Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 9247 insertions, 0 deletions

diff --git a/src/VBox/Storage/VMDK.cpp b/src/VBox/Storage/VMDK.cpp
new file mode 100644
index 00000000..f5f01ec5
--- /dev/null
+++ b/src/VBox/Storage/VMDK.cpp
@@ -0,0 +1,9247 @@
+/* $Id: VMDK.cpp $ */
+/** @file
+ * VMDK disk image, core code.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_VD_VMDK
+#include <VBox/log.h>           /* before VBox/vd-ifs.h */
+#include <VBox/vd-plugin.h>
+#include <VBox/err.h>
+
+#include <iprt/assert.h>
+#include <iprt/alloc.h>
+#include <iprt/base64.h>
+#include <iprt/ctype.h>
+#include <iprt/crc.h>
+#include <iprt/dvm.h>
+#include <iprt/uuid.h>
+#include <iprt/path.h>
+#include <iprt/rand.h>
+#include <iprt/string.h>
+#include <iprt/sort.h>
+#include <iprt/zip.h>
+#include <iprt/asm.h>
+#ifdef RT_OS_WINDOWS
+# include <iprt/utf16.h>
+# include <iprt/uni.h>
+# include <iprt/uni.h>
+# include <iprt/nt/nt-and-windows.h>
+# include <winioctl.h>
+#endif
+#ifdef RT_OS_LINUX
+# include <errno.h>
+# include <sys/stat.h>
+# include <iprt/dir.h>
+# include <iprt/symlink.h>
+# include <iprt/linux/sysfs.h>
+#endif
+#ifdef RT_OS_FREEBSD
+#include <libgeom.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#endif
+#ifdef RT_OS_SOLARIS
+#include <sys/dkio.h>
+#include <sys/vtoc.h>
+#include <sys/efi_partition.h>
+#include <unistd.h>
+#include <errno.h>
+#endif
+#ifdef RT_OS_DARWIN
+# include <sys/stat.h>
+# include <sys/disk.h>
+# include <errno.h>
+/* The following structure and IOCTLs are defined in znu bsd/sys/disk.h but
+   inside KERNEL ifdefs and thus stripped from the SDK edition of the header.
+   While we could try include the header from the Kernel.framework, it's a lot
+   easier to just add the structure and 4 defines here. */
+typedef struct
+{
+    uint64_t offset;
+    uint64_t length;
+    uint8_t  reserved0128[12];
+    dev_t    dev;
+} dk_physical_extent_t;
+# define DKIOCGETBASE               _IOR( 'd', 73, uint64_t)
+# define DKIOCLOCKPHYSICALEXTENTS   _IO(  'd', 81)
+# define DKIOCGETPHYSICALEXTENT     _IOWR('d', 82, dk_physical_extent_t)
+# define DKIOCUNLOCKPHYSICALEXTENTS _IO(  'd', 83)
+#endif /* RT_OS_DARWIN */
+
+#include "VDBackends.h"
+
+
+/*********************************************************************************************************************************
+*   Constants And Macros, Structures and Typedefs                                                                                *
+*********************************************************************************************************************************/
+
+/** Maximum encoded string size (including NUL) we allow for VMDK images.
+ * Deliberately not set high to avoid running out of descriptor space. */
+#define VMDK_ENCODED_COMMENT_MAX 1024
+
+/** VMDK descriptor DDB entry for PCHS cylinders. */
+#define VMDK_DDB_GEO_PCHS_CYLINDERS "ddb.geometry.cylinders"
+
+/** VMDK descriptor DDB entry for PCHS heads. */
+#define VMDK_DDB_GEO_PCHS_HEADS "ddb.geometry.heads"
+
+/** VMDK descriptor DDB entry for PCHS sectors. */
+#define VMDK_DDB_GEO_PCHS_SECTORS "ddb.geometry.sectors"
+
+/** VMDK descriptor DDB entry for LCHS cylinders. */
+#define VMDK_DDB_GEO_LCHS_CYLINDERS "ddb.geometry.biosCylinders"
+
+/** VMDK descriptor DDB entry for LCHS heads. */
+#define VMDK_DDB_GEO_LCHS_HEADS "ddb.geometry.biosHeads"
+
+/** VMDK descriptor DDB entry for LCHS sectors. */
+#define VMDK_DDB_GEO_LCHS_SECTORS "ddb.geometry.biosSectors"
+
+/** VMDK descriptor DDB entry for image UUID. */
+#define VMDK_DDB_IMAGE_UUID "ddb.uuid.image"
+
+/** VMDK descriptor DDB entry for image modification UUID. */
+#define VMDK_DDB_MODIFICATION_UUID "ddb.uuid.modification"
+
+/** VMDK descriptor DDB entry for parent image UUID. */
+#define VMDK_DDB_PARENT_UUID "ddb.uuid.parent"
+
+/** VMDK descriptor DDB entry for parent image modification UUID. */
+#define VMDK_DDB_PARENT_MODIFICATION_UUID "ddb.uuid.parentmodification"
+
+/** No compression for streamOptimized files. */
+#define VMDK_COMPRESSION_NONE 0
+
+/** Deflate compression for streamOptimized files. */
+#define VMDK_COMPRESSION_DEFLATE 1
+
+/** Marker that the actual GD value is stored in the footer. */
+#define VMDK_GD_AT_END 0xffffffffffffffffULL
+
+/** Marker for end-of-stream in streamOptimized images. */
+#define VMDK_MARKER_EOS 0
+
+/** Marker for grain table block in streamOptimized images. */
+#define VMDK_MARKER_GT 1
+
+/** Marker for grain directory block in streamOptimized images. */
+#define VMDK_MARKER_GD 2
+
+/** Marker for footer in streamOptimized images. */
+#define VMDK_MARKER_FOOTER 3
+
+/** Marker for unknown purpose in streamOptimized images.
+ * Shows up in very recent images created by vSphere, but only sporadically.
+ * They "forgot" to document that one in the VMDK specification. */
+#define VMDK_MARKER_UNSPECIFIED 4
+
+/** Dummy marker for "don't check the marker value". */
+#define VMDK_MARKER_IGNORE 0xffffffffU
+
+/**
+ * Magic number for hosted images created by VMware Workstation 4, VMware
+ * Workstation 5, VMware Server or VMware Player. Not necessarily sparse.
+ */
+#define VMDK_SPARSE_MAGICNUMBER 0x564d444b /* 'V' 'M' 'D' 'K' */
+
+/** VMDK sector size in bytes. */
+#define VMDK_SECTOR_SIZE 512
+/** Max string buffer size for uint64_t with null term */
+#define UINT64_MAX_BUFF_SIZE 21
+/** Grain directory entry size in bytes */
+#define VMDK_GRAIN_DIR_ENTRY_SIZE 4
+/** Grain table size in bytes */
+#define VMDK_GRAIN_TABLE_SIZE 2048
+
+/**
+ * VMDK hosted binary extent header. The "Sparse" is a total misnomer, as
+ * this header is also used for monolithic flat images.
+ */
+#pragma pack(1)
+typedef struct SparseExtentHeader
+{
+    uint32_t    magicNumber;
+    uint32_t    version;
+    uint32_t    flags;
+    uint64_t    capacity;
+    uint64_t    grainSize;
+    uint64_t    descriptorOffset;
+    uint64_t    descriptorSize;
+    uint32_t    numGTEsPerGT;
+    uint64_t    rgdOffset;
+    uint64_t    gdOffset;
+    uint64_t    overHead;
+    bool        uncleanShutdown;
+    char        singleEndLineChar;
+    char        nonEndLineChar;
+    char        doubleEndLineChar1;
+    char        doubleEndLineChar2;
+    uint16_t    compressAlgorithm;
+    uint8_t     pad[433];
+} SparseExtentHeader;
+#pragma pack()
+
+/** The maximum allowed descriptor size in the extent header in sectors. */
+#define VMDK_SPARSE_DESCRIPTOR_SIZE_MAX UINT64_C(20480) /* 10MB */
+
+/** VMDK capacity for a single chunk when 2G splitting is turned on. Should be
+ * divisible by the default grain size (64K) */
+#define VMDK_2G_SPLIT_SIZE (2047 * 1024 * 1024)
+
+/** VMDK streamOptimized file format marker. The type field may or may not
+ * be actually valid, but there's always data to read there. */
+#pragma pack(1)
+typedef struct VMDKMARKER
+{
+    uint64_t uSector;
+    uint32_t cbSize;
+    uint32_t uType;
+} VMDKMARKER, *PVMDKMARKER;
+#pragma pack()
+
+
+/** Convert sector number/size to byte offset/size. */
+#define VMDK_SECTOR2BYTE(u) ((uint64_t)(u) << 9)
+
+/** Convert byte offset/size to sector number/size. */
+#define VMDK_BYTE2SECTOR(u) ((u) >> 9)
+
+/**
+ * VMDK extent type.
+ */
+typedef enum VMDKETYPE
+{
+    /** Hosted sparse extent. */
+    VMDKETYPE_HOSTED_SPARSE = 1,
+    /** Flat extent. */
+    VMDKETYPE_FLAT,
+    /** Zero extent. */
+    VMDKETYPE_ZERO,
+    /** VMFS extent, used by ESX. */
+    VMDKETYPE_VMFS
+} VMDKETYPE, *PVMDKETYPE;
+
+/**
+ * VMDK access type for a extent.
+ */
+typedef enum VMDKACCESS
+{
+    /** No access allowed. */
+    VMDKACCESS_NOACCESS = 0,
+    /** Read-only access. */
+    VMDKACCESS_READONLY,
+    /** Read-write access. */
+    VMDKACCESS_READWRITE
+} VMDKACCESS, *PVMDKACCESS;
+
+/** Forward declaration for PVMDKIMAGE. */
+typedef struct VMDKIMAGE *PVMDKIMAGE;
+
+/**
+ * Extents files entry. Used for opening a particular file only once.
+ */
+typedef struct VMDKFILE
+{
+    /** Pointer to file path. Local copy. */
+    const char      *pszFilename;
+    /** Pointer to base name. Local copy. */
+    const char      *pszBasename;
+    /** File open flags for consistency checking. */
+    unsigned         fOpen;
+    /** Handle for sync/async file abstraction.*/
+    PVDIOSTORAGE     pStorage;
+    /** Reference counter. */
+    unsigned         uReferences;
+    /** Flag whether the file should be deleted on last close. */
+    bool             fDelete;
+    /** Pointer to the image we belong to (for debugging purposes). */
+    PVMDKIMAGE       pImage;
+    /** Pointer to next file descriptor. */
+    struct VMDKFILE *pNext;
+    /** Pointer to the previous file descriptor. */
+    struct VMDKFILE *pPrev;
+} VMDKFILE, *PVMDKFILE;
+
+/**
+ * VMDK extent data structure.
+ */
+typedef struct VMDKEXTENT
+{
+    /** File handle. */
+    PVMDKFILE    pFile;
+    /** Base name of the image extent. */
+    const char  *pszBasename;
+    /** Full name of the image extent. */
+    const char  *pszFullname;
+    /** Number of sectors in this extent. */
+    uint64_t    cSectors;
+    /** Number of sectors per block (grain in VMDK speak). */
+    uint64_t    cSectorsPerGrain;
+    /** Starting sector number of descriptor. */
+    uint64_t    uDescriptorSector;
+    /** Size of descriptor in sectors. */
+    uint64_t    cDescriptorSectors;
+    /** Starting sector number of grain directory. */
+    uint64_t    uSectorGD;
+    /** Starting sector number of redundant grain directory. */
+    uint64_t    uSectorRGD;
+    /** Total number of metadata sectors. */
+    uint64_t    cOverheadSectors;
+    /** Nominal size (i.e. as described by the descriptor) of this extent. */
+    uint64_t    cNominalSectors;
+    /** Sector offset (i.e. as described by the descriptor) of this extent. */
+    uint64_t    uSectorOffset;
+    /** Number of entries in a grain table. */
+    uint32_t    cGTEntries;
+    /** Number of sectors reachable via a grain directory entry. */
+    uint32_t    cSectorsPerGDE;
+    /** Number of entries in the grain directory. */
+    uint32_t    cGDEntries;
+    /** Pointer to the next free sector. Legacy information. Do not use. */
+    uint32_t    uFreeSector;
+    /** Number of this extent in the list of images. */
+    uint32_t    uExtent;
+    /** Pointer to the descriptor (NULL if no descriptor in this extent). */
+    char        *pDescData;
+    /** Pointer to the grain directory. */
+    uint32_t    *pGD;
+    /** Pointer to the redundant grain directory. */
+    uint32_t    *pRGD;
+    /** VMDK version of this extent. 1=1.0/1.1 */
+    uint32_t    uVersion;
+    /** Type of this extent. */
+    VMDKETYPE   enmType;
+    /** Access to this extent. */
+    VMDKACCESS  enmAccess;
+    /** Flag whether this extent is marked as unclean. */
+    bool        fUncleanShutdown;
+    /** Flag whether the metadata in the extent header needs to be updated. */
+    bool        fMetaDirty;
+    /** Flag whether there is a footer in this extent. */
+    bool        fFooter;
+    /** Compression type for this extent. */
+    uint16_t    uCompression;
+    /** Append position for writing new grain. Only for sparse extents. */
+    uint64_t    uAppendPosition;
+    /** Last grain which was accessed. Only for streamOptimized extents. */
+    uint32_t    uLastGrainAccess;
+    /** Starting sector corresponding to the grain buffer. */
+    uint32_t    uGrainSectorAbs;
+    /** Grain number corresponding to the grain buffer. */
+    uint32_t    uGrain;
+    /** Actual size of the compressed data, only valid for reading. */
+    uint32_t    cbGrainStreamRead;
+    /** Size of compressed grain buffer for streamOptimized extents. */
+    size_t      cbCompGrain;
+    /** Compressed grain buffer for streamOptimized extents, with marker. */
+    void        *pvCompGrain;
+    /** Decompressed grain buffer for streamOptimized extents. */
+    void        *pvGrain;
+    /** Reference to the image in which this extent is used. Do not use this
+     * on a regular basis to avoid passing pImage references to functions
+     * explicitly. */
+    struct VMDKIMAGE *pImage;
+} VMDKEXTENT, *PVMDKEXTENT;
+
+/**
+ * Grain table cache size. Allocated per image.
+ */
+#define VMDK_GT_CACHE_SIZE 256
+
+/**
+ * Grain table block size. Smaller than an actual grain table block to allow
+ * more grain table blocks to be cached without having to allocate excessive
+ * amounts of memory for the cache.
+ */
+#define VMDK_GT_CACHELINE_SIZE 128
+
+
+/**
+ * Maximum number of lines in a descriptor file. Not worth the effort of
+ * making it variable. Descriptor files are generally very short (~20 lines),
+ * with the exception of sparse files split in 2G chunks, which need for the
+ * maximum size (almost 2T) exactly 1025 lines for the disk database.
+ */
+#define VMDK_DESCRIPTOR_LINES_MAX   1100U
+
+/**
+ * Parsed descriptor information. Allows easy access and update of the
+ * descriptor (whether separate file or not). Free form text files suck.
+ */
+typedef struct VMDKDESCRIPTOR
+{
+    /** Line number of first entry of the disk descriptor. */
+    unsigned    uFirstDesc;
+    /** Line number of first entry in the extent description. */
+    unsigned    uFirstExtent;
+    /** Line number of first disk database entry. */
+    unsigned    uFirstDDB;
+    /** Total number of lines. */
+    unsigned    cLines;
+    /** Total amount of memory available for the descriptor. */
+    size_t      cbDescAlloc;
+    /** Set if descriptor has been changed and not yet written to disk. */
+    bool        fDirty;
+    /** Array of pointers to the data in the descriptor. */
+    char        *aLines[VMDK_DESCRIPTOR_LINES_MAX];
+    /** Array of line indices pointing to the next non-comment line. */
+    unsigned    aNextLines[VMDK_DESCRIPTOR_LINES_MAX];
+} VMDKDESCRIPTOR, *PVMDKDESCRIPTOR;
+
+
+/**
+ * Cache entry for translating extent/sector to a sector number in that
+ * extent.
+ */
+typedef struct VMDKGTCACHEENTRY
+{
+    /** Extent number for which this entry is valid. */
+    uint32_t    uExtent;
+    /** GT data block number. */
+    uint64_t    uGTBlock;
+    /** Data part of the cache entry. */
+    uint32_t    aGTData[VMDK_GT_CACHELINE_SIZE];
+} VMDKGTCACHEENTRY, *PVMDKGTCACHEENTRY;
+
+/**
+ * Cache data structure for blocks of grain table entries. For now this is a
+ * fixed size direct mapping cache, but this should be adapted to the size of
+ * the sparse image and maybe converted to a set-associative cache. The
+ * implementation below implements a write-through cache with write allocate.
+ */
+typedef struct VMDKGTCACHE
+{
+    /** Cache entries. */
+    VMDKGTCACHEENTRY    aGTCache[VMDK_GT_CACHE_SIZE];
+    /** Number of cache entries (currently unused). */
+    unsigned            cEntries;
+} VMDKGTCACHE, *PVMDKGTCACHE;
+
+/**
+ * Complete VMDK image data structure. Mainly a collection of extents and a few
+ * extra global data fields.
+ */
+typedef struct VMDKIMAGE
+{
+    /** Image name. */
+    const char        *pszFilename;
+    /** Descriptor file if applicable. */
+    PVMDKFILE         pFile;
+
+    /** Pointer to the per-disk VD interface list. */
+    PVDINTERFACE      pVDIfsDisk;
+    /** Pointer to the per-image VD interface list. */
+    PVDINTERFACE      pVDIfsImage;
+
+    /** Error interface. */
+    PVDINTERFACEERROR pIfError;
+    /** I/O interface. */
+    PVDINTERFACEIOINT pIfIo;
+
+
+    /** Pointer to the image extents. */
+    PVMDKEXTENT     pExtents;
+    /** Number of image extents. */
+    unsigned        cExtents;
+    /** Pointer to the files list, for opening a file referenced multiple
+     * times only once (happens mainly with raw partition access). */
+    PVMDKFILE       pFiles;
+
+    /**
+     * Pointer to an array of segment entries for async I/O.
+     * This is an optimization because the task number to submit is not known
+     * and allocating/freeing an array in the read/write functions every time
+     * is too expensive.
+     */
+    PPDMDATASEG     paSegments;
+    /** Entries available in the segments array. */
+    unsigned        cSegments;
+
+    /** Open flags passed by VBoxHD layer. */
+    unsigned        uOpenFlags;
+    /** Image flags defined during creation or determined during open. */
+    unsigned        uImageFlags;
+    /** Total size of the image. */
+    uint64_t        cbSize;
+    /** Physical geometry of this image. */
+    VDGEOMETRY      PCHSGeometry;
+    /** Logical geometry of this image. */
+    VDGEOMETRY      LCHSGeometry;
+    /** Image UUID. */
+    RTUUID          ImageUuid;
+    /** Image modification UUID. */
+    RTUUID          ModificationUuid;
+    /** Parent image UUID. */
+    RTUUID          ParentUuid;
+    /** Parent image modification UUID. */
+    RTUUID          ParentModificationUuid;
+
+    /** Pointer to grain table cache, if this image contains sparse extents. */
+    PVMDKGTCACHE    pGTCache;
+    /** Pointer to the descriptor (NULL if no separate descriptor file). */
+    char            *pDescData;
+    /** Allocation size of the descriptor file. */
+    size_t          cbDescAlloc;
+    /** Parsed descriptor file content. */
+    VMDKDESCRIPTOR  Descriptor;
+    /** The static region list. */
+    VDREGIONLIST    RegionList;
+} VMDKIMAGE;
+
+
+/** State for the input/output callout of the inflate reader/deflate writer. */
+typedef struct VMDKCOMPRESSIO
+{
+    /* Image this operation relates to. */
+    PVMDKIMAGE pImage;
+    /* Current read position. */
+    ssize_t iOffset;
+    /* Size of the compressed grain buffer (available data). */
+    size_t cbCompGrain;
+    /* Pointer to the compressed grain buffer. */
+    void *pvCompGrain;
+} VMDKCOMPRESSIO;
+
+
+/** Tracks async grain allocation. */
+typedef struct VMDKGRAINALLOCASYNC
+{
+    /** Flag whether the allocation failed. */
+    bool        fIoErr;
+    /** Current number of transfers pending.
+     * If reached 0 and there is an error the old state is restored. */
+    unsigned    cIoXfersPending;
+    /** Sector number */
+    uint64_t    uSector;
+    /** Flag whether the grain table needs to be updated. */
+    bool        fGTUpdateNeeded;
+    /** Extent the allocation happens. */
+    PVMDKEXTENT pExtent;
+    /** Position of the new grain, required for the grain table update. */
+    uint64_t    uGrainOffset;
+    /** Grain table sector. */
+    uint64_t    uGTSector;
+    /** Backup grain table sector. */
+    uint64_t    uRGTSector;
+} VMDKGRAINALLOCASYNC, *PVMDKGRAINALLOCASYNC;
+
+/**
+ * State information for vmdkRename() and helpers.
+ */
+typedef struct VMDKRENAMESTATE
+{
+    /** Array of old filenames. */
+    char           **apszOldName;
+    /** Array of new filenames. */
+    char           **apszNewName;
+    /** Array of new lines in the extent descriptor. */
+    char           **apszNewLines;
+    /** Name of the old descriptor file if not a sparse image. */
+    char           *pszOldDescName;
+    /** Flag whether we called vmdkFreeImage(). */
+    bool           fImageFreed;
+    /** Flag whther the descriptor is embedded in the image (sparse) or
+     * in a separate file. */
+    bool           fEmbeddedDesc;
+    /** Number of extents in the image. */
+    unsigned       cExtents;
+    /** New base filename. */
+    char           *pszNewBaseName;
+    /** The old base filename. */
+    char           *pszOldBaseName;
+    /** New full filename. */
+    char           *pszNewFullName;
+    /** Old full filename. */
+    char           *pszOldFullName;
+    /** The old image name. */
+    const char     *pszOldImageName;
+    /** Copy of the original VMDK descriptor. */
+    VMDKDESCRIPTOR DescriptorCopy;
+    /** Copy of the extent state for sparse images. */
+    VMDKEXTENT     ExtentCopy;
+} VMDKRENAMESTATE;
+/** Pointer to a VMDK rename state. */
+typedef VMDKRENAMESTATE *PVMDKRENAMESTATE;
+
+
+/*********************************************************************************************************************************
+*   Static Variables                                                                                                             *
+*********************************************************************************************************************************/
+
+/** NULL-terminated array of supported file extensions. */
+static const VDFILEEXTENSION s_aVmdkFileExtensions[] =
+{
+    {"vmdk", VDTYPE_HDD},
+    {NULL, VDTYPE_INVALID}
+};
+
+/** NULL-terminated array of configuration option. */
+static const VDCONFIGINFO s_aVmdkConfigInfo[] =
+{
+    /* Options for VMDK raw disks */
+    { "RawDrive",                       NULL,                             VDCFGVALUETYPE_STRING,       0 },
+    { "Partitions",                     NULL,                             VDCFGVALUETYPE_STRING,       0 },
+    { "BootSector",                     NULL,                             VDCFGVALUETYPE_BYTES,        0 },
+    { "Relative",                       NULL,                             VDCFGVALUETYPE_INTEGER,      0 },
+
+    /* End of options list */
+    { NULL,                             NULL,                             VDCFGVALUETYPE_INTEGER,      0 }
+};
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+
+static void vmdkFreeStreamBuffers(PVMDKEXTENT pExtent);
+static int vmdkFreeExtentData(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                              bool fDelete);
+
+static int vmdkCreateExtents(PVMDKIMAGE pImage, unsigned cExtents);
+static int vmdkFlushImage(PVMDKIMAGE pImage, PVDIOCTX pIoCtx);
+static int vmdkSetImageComment(PVMDKIMAGE pImage, const char *pszComment);
+static int vmdkFreeImage(PVMDKIMAGE pImage, bool fDelete, bool fFlush);
+
+static DECLCALLBACK(int) vmdkAllocGrainComplete(void *pBackendData, PVDIOCTX pIoCtx,
+                                                void *pvUser, int rcReq);
+
+/**
+ * Internal: open a file (using a file descriptor cache to ensure each file
+ * is only opened once - anything else can cause locking problems).
+ */
+static int vmdkFileOpen(PVMDKIMAGE pImage, PVMDKFILE *ppVmdkFile,
+                        const char *pszBasename, const char *pszFilename, uint32_t fOpen)
+{
+    int rc = VINF_SUCCESS;
+    PVMDKFILE pVmdkFile;
+
+    for (pVmdkFile = pImage->pFiles;
+         pVmdkFile != NULL;
+         pVmdkFile = pVmdkFile->pNext)
+    {
+        if (!strcmp(pszFilename, pVmdkFile->pszFilename))
+        {
+            Assert(fOpen == pVmdkFile->fOpen);
+            pVmdkFile->uReferences++;
+
+            *ppVmdkFile = pVmdkFile;
+
+            return rc;
+        }
+    }
+
+    /* If we get here, there's no matching entry in the cache. */
+    pVmdkFile = (PVMDKFILE)RTMemAllocZ(sizeof(VMDKFILE));
+    if (!pVmdkFile)
+    {
+        *ppVmdkFile = NULL;
+        return VERR_NO_MEMORY;
+    }
+
+    pVmdkFile->pszFilename = RTStrDup(pszFilename);
+    if (!pVmdkFile->pszFilename)
+    {
+        RTMemFree(pVmdkFile);
+        *ppVmdkFile = NULL;
+        return VERR_NO_MEMORY;
+    }
+
+    if (pszBasename)
+    {
+        pVmdkFile->pszBasename = RTStrDup(pszBasename);
+        if (!pVmdkFile->pszBasename)
+        {
+            RTStrFree((char *)(void *)pVmdkFile->pszFilename);
+            RTMemFree(pVmdkFile);
+            *ppVmdkFile = NULL;
+            return VERR_NO_MEMORY;
+        }
+    }
+
+    pVmdkFile->fOpen = fOpen;
+
+    rc = vdIfIoIntFileOpen(pImage->pIfIo, pszFilename, fOpen,
+                           &pVmdkFile->pStorage);
+    if (RT_SUCCESS(rc))
+    {
+        pVmdkFile->uReferences = 1;
+        pVmdkFile->pImage = pImage;
+        pVmdkFile->pNext = pImage->pFiles;
+        if (pImage->pFiles)
+            pImage->pFiles->pPrev = pVmdkFile;
+        pImage->pFiles = pVmdkFile;
+        *ppVmdkFile = pVmdkFile;
+    }
+    else
+    {
+        RTStrFree((char *)(void *)pVmdkFile->pszFilename);
+        RTMemFree(pVmdkFile);
+        *ppVmdkFile = NULL;
+    }
+
+    return rc;
+}
+
+/**
+ * Internal: close a file, updating the file descriptor cache.
+ */
+static int vmdkFileClose(PVMDKIMAGE pImage, PVMDKFILE *ppVmdkFile, bool fDelete)
+{
+    int rc = VINF_SUCCESS;
+    PVMDKFILE pVmdkFile = *ppVmdkFile;
+
+    AssertPtr(pVmdkFile);
+
+    pVmdkFile->fDelete |= fDelete;
+    Assert(pVmdkFile->uReferences);
+    pVmdkFile->uReferences--;
+    if (pVmdkFile->uReferences == 0)
+    {
+        PVMDKFILE pPrev;
+        PVMDKFILE pNext;
+
+        /* Unchain the element from the list. */
+        pPrev = pVmdkFile->pPrev;
+        pNext = pVmdkFile->pNext;
+
+        if (pNext)
+            pNext->pPrev = pPrev;
+        if (pPrev)
+            pPrev->pNext = pNext;
+        else
+            pImage->pFiles = pNext;
+
+        rc = vdIfIoIntFileClose(pImage->pIfIo, pVmdkFile->pStorage);
+
+        bool fFileDel = pVmdkFile->fDelete;
+        if (   pVmdkFile->pszBasename
+            && fFileDel)
+        {
+            const char *pszSuffix = RTPathSuffix(pVmdkFile->pszBasename);
+            if (   RTPathHasPath(pVmdkFile->pszBasename)
+                || !pszSuffix
+                || (   strcmp(pszSuffix, ".vmdk")
+                    && strcmp(pszSuffix, ".bin")
+                    && strcmp(pszSuffix, ".img")))
+                fFileDel = false;
+        }
+
+        if (fFileDel)
+        {
+            int rc2 = vdIfIoIntFileDelete(pImage->pIfIo, pVmdkFile->pszFilename);
+            if (RT_SUCCESS(rc))
+                rc = rc2;
+        }
+        else if (pVmdkFile->fDelete)
+            LogRel(("VMDK: Denying deletion of %s\n", pVmdkFile->pszBasename));
+        RTStrFree((char *)(void *)pVmdkFile->pszFilename);
+        if (pVmdkFile->pszBasename)
+            RTStrFree((char *)(void *)pVmdkFile->pszBasename);
+        RTMemFree(pVmdkFile);
+    }
+
+    *ppVmdkFile = NULL;
+    return rc;
+}
+
+/*#define VMDK_USE_BLOCK_DECOMP_API - test and enable */
+#ifndef VMDK_USE_BLOCK_DECOMP_API
+static DECLCALLBACK(int) vmdkFileInflateHelper(void *pvUser, void *pvBuf, size_t cbBuf, size_t *pcbBuf)
+{
+    VMDKCOMPRESSIO *pInflateState = (VMDKCOMPRESSIO *)pvUser;
+    size_t cbInjected = 0;
+
+    Assert(cbBuf);
+    if (pInflateState->iOffset < 0)
+    {
+        *(uint8_t *)pvBuf = RTZIPTYPE_ZLIB;
+        pvBuf = (uint8_t *)pvBuf + 1;
+        cbBuf--;
+        cbInjected = 1;
+        pInflateState->iOffset = RT_UOFFSETOF(VMDKMARKER, uType);
+    }
+    if (!cbBuf)
+    {
+        if (pcbBuf)
+            *pcbBuf = cbInjected;
+        return VINF_SUCCESS;
+    }
+    cbBuf = RT_MIN(cbBuf, pInflateState->cbCompGrain - pInflateState->iOffset);
+    memcpy(pvBuf,
+           (uint8_t *)pInflateState->pvCompGrain + pInflateState->iOffset,
+           cbBuf);
+    pInflateState->iOffset += cbBuf;
+    Assert(pcbBuf);
+    *pcbBuf = cbBuf + cbInjected;
+    return VINF_SUCCESS;
+}
+#endif
+
+/**
+ * Internal: read from a file and inflate the compressed data,
+ * distinguishing between async and normal operation
+ */
+DECLINLINE(int) vmdkFileInflateSync(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                                    uint64_t uOffset, void *pvBuf,
+                                    size_t cbToRead, const void *pcvMarker,
+                                    uint64_t *puLBA, uint32_t *pcbMarkerData)
+{
+    int rc;
+#ifndef VMDK_USE_BLOCK_DECOMP_API
+    PRTZIPDECOMP pZip = NULL;
+#endif
+    VMDKMARKER *pMarker = (VMDKMARKER *)pExtent->pvCompGrain;
+    size_t cbCompSize, cbActuallyRead;
+
+    if (!pcvMarker)
+    {
+        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                   uOffset, pMarker, RT_UOFFSETOF(VMDKMARKER, uType));
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+    else
+    {
+        memcpy(pMarker, pcvMarker, RT_UOFFSETOF(VMDKMARKER, uType));
+        /* pcvMarker endianness has already been partially transformed, fix it */
+        pMarker->uSector = RT_H2LE_U64(pMarker->uSector);
+        pMarker->cbSize = RT_H2LE_U32(pMarker->cbSize);
+    }
+
+    cbCompSize = RT_LE2H_U32(pMarker->cbSize);
+    if (cbCompSize == 0)
+    {
+        AssertMsgFailed(("VMDK: corrupted marker\n"));
+        return VERR_VD_VMDK_INVALID_FORMAT;
+    }
+
+    /* Sanity check - the expansion ratio should be much less than 2. */
+    Assert(cbCompSize < 2 * cbToRead);
+    if (cbCompSize >= 2 * cbToRead)
+        return VERR_VD_VMDK_INVALID_FORMAT;
+
+    /* Compressed grain marker. Data follows immediately. */
+    rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                               uOffset + RT_UOFFSETOF(VMDKMARKER, uType),
+                                (uint8_t *)pExtent->pvCompGrain
+                              + RT_UOFFSETOF(VMDKMARKER, uType),
+                               RT_ALIGN_Z(  cbCompSize
+                                          + RT_UOFFSETOF(VMDKMARKER, uType),
+                                          512)
+                               - RT_UOFFSETOF(VMDKMARKER, uType));
+
+    if (puLBA)
+        *puLBA = RT_LE2H_U64(pMarker->uSector);
+    if (pcbMarkerData)
+        *pcbMarkerData = RT_ALIGN(  cbCompSize
+                                  + RT_UOFFSETOF(VMDKMARKER, uType),
+                                  512);
+
+#ifdef VMDK_USE_BLOCK_DECOMP_API
+    rc = RTZipBlockDecompress(RTZIPTYPE_ZLIB, 0 /*fFlags*/,
+                              pExtent->pvCompGrain, cbCompSize + RT_UOFFSETOF(VMDKMARKER, uType), NULL,
+                              pvBuf, cbToRead, &cbActuallyRead);
+#else
+    VMDKCOMPRESSIO InflateState;
+    InflateState.pImage = pImage;
+    InflateState.iOffset = -1;
+    InflateState.cbCompGrain = cbCompSize + RT_UOFFSETOF(VMDKMARKER, uType);
+    InflateState.pvCompGrain = pExtent->pvCompGrain;
+
+    rc = RTZipDecompCreate(&pZip, &InflateState, vmdkFileInflateHelper);
+    if (RT_FAILURE(rc))
+        return rc;
+    rc = RTZipDecompress(pZip, pvBuf, cbToRead, &cbActuallyRead);
+    RTZipDecompDestroy(pZip);
+#endif /* !VMDK_USE_BLOCK_DECOMP_API */
+    if (RT_FAILURE(rc))
+    {
+        if (rc == VERR_ZIP_CORRUPTED)
+            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: Compressed image is corrupted '%s'"), pExtent->pszFullname);
+        return rc;
+    }
+    if (cbActuallyRead != cbToRead)
+        rc = VERR_VD_VMDK_INVALID_FORMAT;
+    return rc;
+}
+
+static DECLCALLBACK(int) vmdkFileDeflateHelper(void *pvUser, const void *pvBuf, size_t cbBuf)
+{
+    VMDKCOMPRESSIO *pDeflateState = (VMDKCOMPRESSIO *)pvUser;
+
+    Assert(cbBuf);
+    if (pDeflateState->iOffset < 0)
+    {
+        pvBuf = (const uint8_t *)pvBuf + 1;
+        cbBuf--;
+        pDeflateState->iOffset = RT_UOFFSETOF(VMDKMARKER, uType);
+    }
+    if (!cbBuf)
+        return VINF_SUCCESS;
+    if (pDeflateState->iOffset + cbBuf > pDeflateState->cbCompGrain)
+        return VERR_BUFFER_OVERFLOW;
+    memcpy((uint8_t *)pDeflateState->pvCompGrain + pDeflateState->iOffset,
+           pvBuf, cbBuf);
+    pDeflateState->iOffset += cbBuf;
+    return VINF_SUCCESS;
+}
+
+/**
+ * Internal: deflate the uncompressed data and write to a file,
+ * distinguishing between async and normal operation
+ */
+DECLINLINE(int) vmdkFileDeflateSync(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                                    uint64_t uOffset, const void *pvBuf,
+                                    size_t cbToWrite, uint64_t uLBA,
+                                    uint32_t *pcbMarkerData)
+{
+    int rc;
+    PRTZIPCOMP pZip = NULL;
+    VMDKCOMPRESSIO DeflateState;
+
+    DeflateState.pImage = pImage;
+    DeflateState.iOffset = -1;
+    DeflateState.cbCompGrain = pExtent->cbCompGrain;
+    DeflateState.pvCompGrain = pExtent->pvCompGrain;
+
+    rc = RTZipCompCreate(&pZip, &DeflateState, vmdkFileDeflateHelper,
+                         RTZIPTYPE_ZLIB, RTZIPLEVEL_DEFAULT);
+    if (RT_FAILURE(rc))
+        return rc;
+    rc = RTZipCompress(pZip, pvBuf, cbToWrite);
+    if (RT_SUCCESS(rc))
+        rc = RTZipCompFinish(pZip);
+    RTZipCompDestroy(pZip);
+    if (RT_SUCCESS(rc))
+    {
+        Assert(   DeflateState.iOffset > 0
+               && (size_t)DeflateState.iOffset <= DeflateState.cbCompGrain);
+
+        /* pad with zeroes to get to a full sector size */
+        uint32_t uSize = DeflateState.iOffset;
+        if (uSize % 512)
+        {
+            uint32_t uSizeAlign = RT_ALIGN(uSize, 512);
+            memset((uint8_t *)pExtent->pvCompGrain + uSize, '\0',
+                   uSizeAlign - uSize);
+            uSize = uSizeAlign;
+        }
+
+        if (pcbMarkerData)
+            *pcbMarkerData = uSize;
+
+        /* Compressed grain marker. Data follows immediately. */
+        VMDKMARKER *pMarker = (VMDKMARKER *)pExtent->pvCompGrain;
+        pMarker->uSector = RT_H2LE_U64(uLBA);
+        pMarker->cbSize = RT_H2LE_U32(  DeflateState.iOffset
+                                      - RT_UOFFSETOF(VMDKMARKER, uType));
+        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    uOffset, pMarker, uSize);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+    return rc;
+}
+
+
+/**
+ * Internal: check if all files are closed, prevent leaking resources.
+ */
+static int vmdkFileCheckAllClose(PVMDKIMAGE pImage)
+{
+    int rc = VINF_SUCCESS, rc2;
+    PVMDKFILE pVmdkFile;
+
+    Assert(pImage->pFiles == NULL);
+    for (pVmdkFile = pImage->pFiles;
+         pVmdkFile != NULL;
+         pVmdkFile = pVmdkFile->pNext)
+    {
+        LogRel(("VMDK: leaking reference to file \"%s\"\n",
+                pVmdkFile->pszFilename));
+        pImage->pFiles = pVmdkFile->pNext;
+
+        rc2 = vmdkFileClose(pImage, &pVmdkFile, pVmdkFile->fDelete);
+
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+    }
+    return rc;
+}
+
+/**
+ * Internal: truncate a string (at a UTF8 code point boundary) and encode the
+ * critical non-ASCII characters.
+ */
+static char *vmdkEncodeString(const char *psz)
+{
+    char szEnc[VMDK_ENCODED_COMMENT_MAX + 3];
+    char *pszDst = szEnc;
+
+    AssertPtr(psz);
+
+    for (; *psz; psz = RTStrNextCp(psz))
+    {
+        char *pszDstPrev = pszDst;
+        RTUNICP Cp = RTStrGetCp(psz);
+        if (Cp == '\\')
+        {
+            pszDst = RTStrPutCp(pszDst, Cp);
+            pszDst = RTStrPutCp(pszDst, Cp);
+        }
+        else if (Cp == '\n')
+        {
+            pszDst = RTStrPutCp(pszDst, '\\');
+            pszDst = RTStrPutCp(pszDst, 'n');
+        }
+        else if (Cp == '\r')
+        {
+            pszDst = RTStrPutCp(pszDst, '\\');
+            pszDst = RTStrPutCp(pszDst, 'r');
+        }
+        else
+            pszDst = RTStrPutCp(pszDst, Cp);
+        if (pszDst - szEnc >= VMDK_ENCODED_COMMENT_MAX - 1)
+        {
+            pszDst = pszDstPrev;
+            break;
+        }
+    }
+    *pszDst = '\0';
+    return RTStrDup(szEnc);
+}
+
+/**
+ * Internal: decode a string and store it into the specified string.
+ */
+static int vmdkDecodeString(const char *pszEncoded, char *psz, size_t cb)
+{
+    int rc = VINF_SUCCESS;
+    char szBuf[4];
+
+    if (!cb)
+        return VERR_BUFFER_OVERFLOW;
+
+    AssertPtr(psz);
+
+    for (; *pszEncoded; pszEncoded = RTStrNextCp(pszEncoded))
+    {
+        char *pszDst = szBuf;
+        RTUNICP Cp = RTStrGetCp(pszEncoded);
+        if (Cp == '\\')
+        {
+            pszEncoded = RTStrNextCp(pszEncoded);
+            RTUNICP CpQ = RTStrGetCp(pszEncoded);
+            if (CpQ == 'n')
+                RTStrPutCp(pszDst, '\n');
+            else if (CpQ == 'r')
+                RTStrPutCp(pszDst, '\r');
+            else if (CpQ == '\0')
+            {
+                rc = VERR_VD_VMDK_INVALID_HEADER;
+                break;
+            }
+            else
+                RTStrPutCp(pszDst, CpQ);
+        }
+        else
+            pszDst = RTStrPutCp(pszDst, Cp);
+
+        /* Need to leave space for terminating NUL. */
+        if ((size_t)(pszDst - szBuf) + 1 >= cb)
+        {
+            rc = VERR_BUFFER_OVERFLOW;
+            break;
+        }
+        memcpy(psz, szBuf, pszDst - szBuf);
+        psz += pszDst - szBuf;
+    }
+    *psz = '\0';
+    return rc;
+}
+
+/**
+ * Internal: free all buffers associated with grain directories.
+ */
+static void vmdkFreeGrainDirectory(PVMDKEXTENT pExtent)
+{
+    if (pExtent->pGD)
+    {
+        RTMemFree(pExtent->pGD);
+        pExtent->pGD = NULL;
+    }
+    if (pExtent->pRGD)
+    {
+        RTMemFree(pExtent->pRGD);
+        pExtent->pRGD = NULL;
+    }
+}
+
+/**
+ * Internal: allocate the compressed/uncompressed buffers for streamOptimized
+ * images.
+ */
+static int vmdkAllocStreamBuffers(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
+{
+    int rc = VINF_SUCCESS;
+
+    if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+    {
+        /* streamOptimized extents need a compressed grain buffer, which must
+         * be big enough to hold uncompressible data (which needs ~8 bytes
+         * more than the uncompressed data), the marker and padding. */
+        pExtent->cbCompGrain = RT_ALIGN_Z(  VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain)
+                                          + 8 + sizeof(VMDKMARKER), 512);
+        pExtent->pvCompGrain = RTMemAlloc(pExtent->cbCompGrain);
+        if (RT_LIKELY(pExtent->pvCompGrain))
+        {
+            /* streamOptimized extents need a decompressed grain buffer. */
+            pExtent->pvGrain = RTMemAlloc(VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+            if (!pExtent->pvGrain)
+                rc = VERR_NO_MEMORY;
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    if (RT_FAILURE(rc))
+        vmdkFreeStreamBuffers(pExtent);
+    return rc;
+}
+
+/**
+ * Internal: allocate all buffers associated with grain directories.
+ */
+static int vmdkAllocGrainDirectory(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
+{
+    RT_NOREF1(pImage);
+    int rc = VINF_SUCCESS;
+    size_t cbGD = pExtent->cGDEntries * sizeof(uint32_t);
+
+    pExtent->pGD = (uint32_t *)RTMemAllocZ(cbGD);
+    if (RT_LIKELY(pExtent->pGD))
+    {
+        if (pExtent->uSectorRGD)
+        {
+            pExtent->pRGD = (uint32_t *)RTMemAllocZ(cbGD);
+            if (RT_UNLIKELY(!pExtent->pRGD))
+                rc = VERR_NO_MEMORY;
+        }
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    if (RT_FAILURE(rc))
+        vmdkFreeGrainDirectory(pExtent);
+    return rc;
+}
+
+/**
+ * Converts the grain directory from little to host endianess.
+ *
+ * @param   pGD             The grain directory.
+ * @param   cGDEntries      Number of entries in the grain directory to convert.
+ */
+DECLINLINE(void) vmdkGrainDirectoryConvToHost(uint32_t *pGD, uint32_t cGDEntries)
+{
+    uint32_t *pGDTmp = pGD;
+
+    for (uint32_t i = 0; i < cGDEntries; i++, pGDTmp++)
+        *pGDTmp = RT_LE2H_U32(*pGDTmp);
+}
+
+/**
+ * Read the grain directory and allocated grain tables verifying them against
+ * their back up copies if available.
+ *
+ * @returns VBox status code.
+ * @param   pImage          Image instance data.
+ * @param   pExtent         The VMDK extent.
+ */
+static int vmdkReadGrainDirectory(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
+{
+    int rc = VINF_SUCCESS;
+    size_t cbGD = pExtent->cGDEntries * sizeof(uint32_t);
+
+    AssertReturn((   pExtent->enmType == VMDKETYPE_HOSTED_SPARSE
+                  && pExtent->uSectorGD != VMDK_GD_AT_END
+                  && pExtent->uSectorRGD != VMDK_GD_AT_END), VERR_INTERNAL_ERROR);
+
+    rc = vmdkAllocGrainDirectory(pImage, pExtent);
+    if (RT_SUCCESS(rc))
+    {
+        /* The VMDK 1.1 spec seems to talk about compressed grain directories,
+         * but in reality they are not compressed. */
+        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                   VMDK_SECTOR2BYTE(pExtent->uSectorGD),
+                                   pExtent->pGD, cbGD);
+        if (RT_SUCCESS(rc))
+        {
+            vmdkGrainDirectoryConvToHost(pExtent->pGD, pExtent->cGDEntries);
+
+            if (   pExtent->uSectorRGD
+                && !(pImage->uOpenFlags & VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS))
+            {
+                /* The VMDK 1.1 spec seems to talk about compressed grain directories,
+                 * but in reality they are not compressed. */
+                rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                           VMDK_SECTOR2BYTE(pExtent->uSectorRGD),
+                                           pExtent->pRGD, cbGD);
+                if (RT_SUCCESS(rc))
+                {
+                    vmdkGrainDirectoryConvToHost(pExtent->pRGD, pExtent->cGDEntries);
+
+                    /* Check grain table and redundant grain table for consistency. */
+                    size_t cbGT = pExtent->cGTEntries * sizeof(uint32_t);
+                    size_t cbGTBuffers = cbGT; /* Start with space for one GT. */
+                    size_t cbGTBuffersMax = _1M;
+
+                    uint32_t *pTmpGT1 = (uint32_t *)RTMemAlloc(cbGTBuffers);
+                    uint32_t *pTmpGT2 = (uint32_t *)RTMemAlloc(cbGTBuffers);
+
+                    if (   !pTmpGT1
+                        || !pTmpGT2)
+                        rc = VERR_NO_MEMORY;
+
+                    size_t i = 0;
+                    uint32_t *pGDTmp = pExtent->pGD;
+                    uint32_t *pRGDTmp = pExtent->pRGD;
+
+                    /* Loop through all entries. */
+                    while (i < pExtent->cGDEntries)
+                    {
+                        uint32_t uGTStart = *pGDTmp;
+                        uint32_t uRGTStart = *pRGDTmp;
+                        size_t   cbGTRead = cbGT;
+
+                        /* If no grain table is allocated skip the entry. */
+                        if (*pGDTmp == 0 && *pRGDTmp == 0)
+                        {
+                            i++;
+                            continue;
+                        }
+
+                        if (*pGDTmp == 0 || *pRGDTmp == 0 || *pGDTmp == *pRGDTmp)
+                        {
+                            /* Just one grain directory entry refers to a not yet allocated
+                             * grain table or both grain directory copies refer to the same
+                             * grain table. Not allowed. */
+                            rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                           N_("VMDK: inconsistent references to grain directory in '%s'"), pExtent->pszFullname);
+                            break;
+                        }
+
+                        i++;
+                        pGDTmp++;
+                        pRGDTmp++;
+
+                        /*
+                         * Read a few tables at once if adjacent to decrease the number
+                         * of I/O requests. Read at maximum 1MB at once.
+                         */
+                        while (   i < pExtent->cGDEntries
+                               && cbGTRead < cbGTBuffersMax)
+                        {
+                            /* If no grain table is allocated skip the entry. */
+                            if (*pGDTmp == 0 && *pRGDTmp == 0)
+                            {
+                                i++;
+                                continue;
+                            }
+
+                            if (*pGDTmp == 0 || *pRGDTmp == 0 || *pGDTmp == *pRGDTmp)
+                            {
+                                /* Just one grain directory entry refers to a not yet allocated
+                                 * grain table or both grain directory copies refer to the same
+                                 * grain table. Not allowed. */
+                                rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                               N_("VMDK: inconsistent references to grain directory in '%s'"), pExtent->pszFullname);
+                                break;
+                            }
+
+                            /* Check that the start offsets are adjacent.*/
+                            if (   VMDK_SECTOR2BYTE(uGTStart) + cbGTRead != VMDK_SECTOR2BYTE(*pGDTmp)
+                                || VMDK_SECTOR2BYTE(uRGTStart) + cbGTRead != VMDK_SECTOR2BYTE(*pRGDTmp))
+                                break;
+
+                            i++;
+                            pGDTmp++;
+                            pRGDTmp++;
+                            cbGTRead += cbGT;
+                        }
+
+                        /* Increase buffers if required. */
+                        if (   RT_SUCCESS(rc)
+                            && cbGTBuffers < cbGTRead)
+                        {
+                            uint32_t *pTmp;
+                            pTmp = (uint32_t *)RTMemRealloc(pTmpGT1, cbGTRead);
+                            if (pTmp)
+                            {
+                                pTmpGT1 = pTmp;
+                                pTmp = (uint32_t *)RTMemRealloc(pTmpGT2, cbGTRead);
+                                if (pTmp)
+                                    pTmpGT2 = pTmp;
+                                else
+                                    rc = VERR_NO_MEMORY;
+                            }
+                            else
+                                rc = VERR_NO_MEMORY;
+
+                            if (rc == VERR_NO_MEMORY)
+                            {
+                                /* Reset to the old values. */
+                                rc = VINF_SUCCESS;
+                                i -= cbGTRead / cbGT;
+                                cbGTRead = cbGT;
+
+                                /* Don't try to increase the buffer again in the next run. */
+                                cbGTBuffersMax = cbGTBuffers;
+                            }
+                        }
+
+                        if (RT_SUCCESS(rc))
+                        {
+                           /* The VMDK 1.1 spec seems to talk about compressed grain tables,
+                             * but in reality they are not compressed. */
+                            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                       VMDK_SECTOR2BYTE(uGTStart),
+                                                       pTmpGT1, cbGTRead);
+                            if (RT_FAILURE(rc))
+                            {
+                                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                               N_("VMDK: error reading grain table in '%s'"), pExtent->pszFullname);
+                                break;
+                            }
+                            /* The VMDK 1.1 spec seems to talk about compressed grain tables,
+                             * but in reality they are not compressed. */
+                            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                       VMDK_SECTOR2BYTE(uRGTStart),
+                                                       pTmpGT2, cbGTRead);
+                            if (RT_FAILURE(rc))
+                            {
+                                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                               N_("VMDK: error reading backup grain table in '%s'"), pExtent->pszFullname);
+                                break;
+                            }
+                            if (memcmp(pTmpGT1, pTmpGT2, cbGTRead))
+                            {
+                                rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                               N_("VMDK: inconsistency between grain table and backup grain table in '%s'"), pExtent->pszFullname);
+                                break;
+                            }
+                        }
+                    } /* while (i < pExtent->cGDEntries) */
+
+                    /** @todo figure out what to do for unclean VMDKs. */
+                    if (pTmpGT1)
+                        RTMemFree(pTmpGT1);
+                    if (pTmpGT2)
+                        RTMemFree(pTmpGT2);
+                }
+                else
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                   N_("VMDK: could not read redundant grain directory in '%s'"), pExtent->pszFullname);
+            }
+        }
+        else
+            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                           N_("VMDK: could not read grain directory in '%s': %Rrc"), pExtent->pszFullname, rc);
+    }
+
+    if (RT_FAILURE(rc))
+        vmdkFreeGrainDirectory(pExtent);
+    return rc;
+}
+
+/**
+ * Creates a new grain directory for the given extent at the given start sector.
+ *
+ * @returns VBox status code.
+ * @param   pImage          Image instance data.
+ * @param   pExtent         The VMDK extent.
+ * @param   uStartSector    Where the grain directory should be stored in the image.
+ * @param   fPreAlloc       Flag whether to pre allocate the grain tables at this point.
+ */
+static int vmdkCreateGrainDirectory(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                                    uint64_t uStartSector, bool fPreAlloc)
+{
+    int rc = VINF_SUCCESS;
+    unsigned i;
+    size_t cbGD = pExtent->cGDEntries * sizeof(uint32_t);
+    size_t cbGDRounded = RT_ALIGN_64(cbGD, 512);
+    size_t cbGTRounded;
+    uint64_t cbOverhead;
+
+    if (fPreAlloc)
+    {
+        cbGTRounded = RT_ALIGN_64(pExtent->cGDEntries * pExtent->cGTEntries * sizeof(uint32_t), 512);
+        cbOverhead  = VMDK_SECTOR2BYTE(uStartSector) + cbGDRounded + cbGTRounded;
+    }
+    else
+    {
+        /* Use a dummy start sector for layout computation. */
+        if (uStartSector == VMDK_GD_AT_END)
+            uStartSector = 1;
+        cbGTRounded = 0;
+        cbOverhead = VMDK_SECTOR2BYTE(uStartSector) + cbGDRounded;
+    }
+
+    /* For streamOptimized extents there is only one grain directory,
+     * and for all others take redundant grain directory into account. */
+    if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+    {
+        cbOverhead = RT_ALIGN_64(cbOverhead,
+                                 VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+    }
+    else
+    {
+        cbOverhead += cbGDRounded + cbGTRounded;
+        cbOverhead = RT_ALIGN_64(cbOverhead,
+                                 VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+        rc = vdIfIoIntFileSetSize(pImage->pIfIo, pExtent->pFile->pStorage, cbOverhead);
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        pExtent->uAppendPosition = cbOverhead;
+        pExtent->cOverheadSectors = VMDK_BYTE2SECTOR(cbOverhead);
+
+        if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+        {
+            pExtent->uSectorRGD = 0;
+            pExtent->uSectorGD = uStartSector;
+        }
+        else
+        {
+            pExtent->uSectorRGD = uStartSector;
+            pExtent->uSectorGD = uStartSector + VMDK_BYTE2SECTOR(cbGDRounded + cbGTRounded);
+        }
+
+        rc = vmdkAllocStreamBuffers(pImage, pExtent);
+        if (RT_SUCCESS(rc))
+        {
+            rc = vmdkAllocGrainDirectory(pImage, pExtent);
+            if (   RT_SUCCESS(rc)
+                && fPreAlloc)
+            {
+                uint32_t uGTSectorLE;
+                uint64_t uOffsetSectors;
+
+                if (pExtent->pRGD)
+                {
+                    uOffsetSectors = pExtent->uSectorRGD + VMDK_BYTE2SECTOR(cbGDRounded);
+                    for (i = 0; i < pExtent->cGDEntries; i++)
+                    {
+                        pExtent->pRGD[i] = uOffsetSectors;
+                        uGTSectorLE = RT_H2LE_U64(uOffsetSectors);
+                        /* Write the redundant grain directory entry to disk. */
+                        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                    VMDK_SECTOR2BYTE(pExtent->uSectorRGD) + i * sizeof(uGTSectorLE),
+                                                    &uGTSectorLE, sizeof(uGTSectorLE));
+                        if (RT_FAILURE(rc))
+                        {
+                            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write new redundant grain directory entry in '%s'"), pExtent->pszFullname);
+                            break;
+                        }
+                        uOffsetSectors += VMDK_BYTE2SECTOR(pExtent->cGTEntries * sizeof(uint32_t));
+                    }
+                }
+
+                if (RT_SUCCESS(rc))
+                {
+                    uOffsetSectors = pExtent->uSectorGD + VMDK_BYTE2SECTOR(cbGDRounded);
+                    for (i = 0; i < pExtent->cGDEntries; i++)
+                    {
+                        pExtent->pGD[i] = uOffsetSectors;
+                        uGTSectorLE = RT_H2LE_U64(uOffsetSectors);
+                        /* Write the grain directory entry to disk. */
+                        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                    VMDK_SECTOR2BYTE(pExtent->uSectorGD) + i * sizeof(uGTSectorLE),
+                                                    &uGTSectorLE, sizeof(uGTSectorLE));
+                        if (RT_FAILURE(rc))
+                        {
+                            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write new grain directory entry in '%s'"), pExtent->pszFullname);
+                            break;
+                        }
+                        uOffsetSectors += VMDK_BYTE2SECTOR(pExtent->cGTEntries * sizeof(uint32_t));
+                    }
+                }
+            }
+        }
+    }
+
+    if (RT_FAILURE(rc))
+        vmdkFreeGrainDirectory(pExtent);
+    return rc;
+}
+
+/**
+ * Unquotes the given string returning the result in a separate buffer.
+ *
+ * @returns VBox status code.
+ * @param   pImage          The VMDK image state.
+ * @param   pszStr          The string to unquote.
+ * @param   ppszUnquoted    Where to store the return value, use RTMemTmpFree to
+ *                          free.
+ * @param   ppszNext        Where to store the pointer to any character following
+ *                          the quoted value, optional.
+ */
+static int vmdkStringUnquote(PVMDKIMAGE pImage, const char *pszStr,
+                             char **ppszUnquoted, char **ppszNext)
+{
+    const char *pszStart = pszStr;
+    char *pszQ;
+    char *pszUnquoted;
+
+    /* Skip over whitespace. */
+    while (*pszStr == ' ' || *pszStr == '\t')
+        pszStr++;
+
+    if (*pszStr != '"')
+    {
+        pszQ = (char *)pszStr;
+        while (*pszQ && *pszQ != ' ' && *pszQ != '\t')
+            pszQ++;
+    }
+    else
+    {
+        pszStr++;
+        pszQ = (char *)strchr(pszStr, '"');
+        if (pszQ == NULL)
+            return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrectly quoted value in descriptor in '%s' (raw value %s)"),
+                             pImage->pszFilename, pszStart);
+    }
+
+    pszUnquoted = (char *)RTMemTmpAlloc(pszQ - pszStr + 1);
+    if (!pszUnquoted)
+        return VERR_NO_MEMORY;
+    memcpy(pszUnquoted, pszStr, pszQ - pszStr);
+    pszUnquoted[pszQ - pszStr] = '\0';
+    *ppszUnquoted = pszUnquoted;
+    if (ppszNext)
+        *ppszNext = pszQ + 1;
+    return VINF_SUCCESS;
+}
+
+static int vmdkDescInitStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                           const char *pszLine)
+{
+    char *pEnd = pDescriptor->aLines[pDescriptor->cLines];
+    ssize_t cbDiff = strlen(pszLine) + 1;
+
+    if (    pDescriptor->cLines >= VMDK_DESCRIPTOR_LINES_MAX - 1
+        &&  pEnd - pDescriptor->aLines[0] > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff)
+        return vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
+
+    memcpy(pEnd, pszLine, cbDiff);
+    pDescriptor->cLines++;
+    pDescriptor->aLines[pDescriptor->cLines] = pEnd + cbDiff;
+    pDescriptor->fDirty = true;
+
+    return VINF_SUCCESS;
+}
+
+static bool vmdkDescGetStr(PVMDKDESCRIPTOR pDescriptor, unsigned uStart,
+                           const char *pszKey, const char **ppszValue)
+{
+    size_t cbKey = strlen(pszKey);
+    const char *pszValue;
+
+    while (uStart != 0)
+    {
+        if (!strncmp(pDescriptor->aLines[uStart], pszKey, cbKey))
+        {
+            /* Key matches, check for a '=' (preceded by whitespace). */
+            pszValue = pDescriptor->aLines[uStart] + cbKey;
+            while (*pszValue == ' ' || *pszValue == '\t')
+                pszValue++;
+            if (*pszValue == '=')
+            {
+                *ppszValue = pszValue + 1;
+                break;
+            }
+        }
+        uStart = pDescriptor->aNextLines[uStart];
+    }
+    return !!uStart;
+}
+
+static int vmdkDescSetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                          unsigned uStart,
+                          const char *pszKey, const char *pszValue)
+{
+    char *pszTmp = NULL; /* (MSC naturally cannot figure this isn't used uninitialized) */
+    size_t cbKey = strlen(pszKey);
+    unsigned uLast = 0;
+
+    while (uStart != 0)
+    {
+        if (!strncmp(pDescriptor->aLines[uStart], pszKey, cbKey))
+        {
+            /* Key matches, check for a '=' (preceded by whitespace). */
+            pszTmp = pDescriptor->aLines[uStart] + cbKey;
+            while (*pszTmp == ' ' || *pszTmp == '\t')
+                pszTmp++;
+            if (*pszTmp == '=')
+            {
+                pszTmp++;
+                /** @todo r=bird: Doesn't skipping trailing blanks here just cause unecessary
+                 *        bloat and potentially out of space error? */
+                while (*pszTmp == ' ' || *pszTmp == '\t')
+                    pszTmp++;
+                break;
+            }
+        }
+        if (!pDescriptor->aNextLines[uStart])
+            uLast = uStart;
+        uStart = pDescriptor->aNextLines[uStart];
+    }
+    if (uStart)
+    {
+        if (pszValue)
+        {
+            /* Key already exists, replace existing value. */
+            size_t cbOldVal = strlen(pszTmp);
+            size_t cbNewVal = strlen(pszValue);
+            ssize_t cbDiff = cbNewVal - cbOldVal;
+            /* Check for buffer overflow. */
+            if (  pDescriptor->aLines[pDescriptor->cLines] - pDescriptor->aLines[0]
+                > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff)
+                return vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
+
+            memmove(pszTmp + cbNewVal, pszTmp + cbOldVal,
+                    pDescriptor->aLines[pDescriptor->cLines] - pszTmp - cbOldVal);
+            memcpy(pszTmp, pszValue, cbNewVal + 1);
+            for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
+                pDescriptor->aLines[i] += cbDiff;
+        }
+        else
+        {
+            memmove(pDescriptor->aLines[uStart], pDescriptor->aLines[uStart+1],
+                    pDescriptor->aLines[pDescriptor->cLines] - pDescriptor->aLines[uStart+1] + 1);
+            for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
+            {
+                pDescriptor->aLines[i-1] = pDescriptor->aLines[i];
+                if (pDescriptor->aNextLines[i])
+                    pDescriptor->aNextLines[i-1] = pDescriptor->aNextLines[i] - 1;
+                else
+                    pDescriptor->aNextLines[i-1] = 0;
+            }
+            pDescriptor->cLines--;
+            /* Adjust starting line numbers of following descriptor sections. */
+            if (uStart < pDescriptor->uFirstExtent)
+                pDescriptor->uFirstExtent--;
+            if (uStart < pDescriptor->uFirstDDB)
+                pDescriptor->uFirstDDB--;
+        }
+    }
+    else
+    {
+        /* Key doesn't exist, append after the last entry in this category. */
+        if (!pszValue)
+        {
+            /* Key doesn't exist, and it should be removed. Simply a no-op. */
+            return VINF_SUCCESS;
+        }
+        cbKey = strlen(pszKey);
+        size_t cbValue = strlen(pszValue);
+        ssize_t cbDiff = cbKey + 1 + cbValue + 1;
+        /* Check for buffer overflow. */
+        if (   (pDescriptor->cLines >= VMDK_DESCRIPTOR_LINES_MAX - 1)
+            || (  pDescriptor->aLines[pDescriptor->cLines]
+                - pDescriptor->aLines[0] > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff))
+            return vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
+        for (unsigned i = pDescriptor->cLines + 1; i > uLast + 1; i--)
+        {
+            pDescriptor->aLines[i] = pDescriptor->aLines[i - 1];
+            if (pDescriptor->aNextLines[i - 1])
+                pDescriptor->aNextLines[i] = pDescriptor->aNextLines[i - 1] + 1;
+            else
+                pDescriptor->aNextLines[i] = 0;
+        }
+        uStart = uLast + 1;
+        pDescriptor->aNextLines[uLast] = uStart;
+        pDescriptor->aNextLines[uStart] = 0;
+        pDescriptor->cLines++;
+        pszTmp = pDescriptor->aLines[uStart];
+        memmove(pszTmp + cbDiff, pszTmp,
+                pDescriptor->aLines[pDescriptor->cLines] - pszTmp);
+        memcpy(pDescriptor->aLines[uStart], pszKey, cbKey);
+        pDescriptor->aLines[uStart][cbKey] = '=';
+        memcpy(pDescriptor->aLines[uStart] + cbKey + 1, pszValue, cbValue + 1);
+        for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
+            pDescriptor->aLines[i] += cbDiff;
+
+        /* Adjust starting line numbers of following descriptor sections. */
+        if (uStart <= pDescriptor->uFirstExtent)
+            pDescriptor->uFirstExtent++;
+        if (uStart <= pDescriptor->uFirstDDB)
+            pDescriptor->uFirstDDB++;
+    }
+    pDescriptor->fDirty = true;
+    return VINF_SUCCESS;
+}
+
+static int vmdkDescBaseGetU32(PVMDKDESCRIPTOR pDescriptor, const char *pszKey,
+                              uint32_t *puValue)
+{
+    const char *pszValue;
+
+    if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDesc, pszKey,
+                        &pszValue))
+        return VERR_VD_VMDK_VALUE_NOT_FOUND;
+    return RTStrToUInt32Ex(pszValue, NULL, 10, puValue);
+}
+
+/**
+ * Returns the value of the given key as a string allocating the necessary memory.
+ *
+ * @returns VBox status code.
+ * @retval  VERR_VD_VMDK_VALUE_NOT_FOUND if the value could not be found.
+ * @param   pImage          The VMDK image state.
+ * @param   pDescriptor     The descriptor to fetch the value from.
+ * @param   pszKey          The key to get the value from.
+ * @param   ppszValue       Where to store the return value, use RTMemTmpFree to
+ *                          free.
+ */
+static int vmdkDescBaseGetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                              const char *pszKey, char **ppszValue)
+{
+    const char *pszValue;
+    char *pszValueUnquoted;
+
+    if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDesc, pszKey,
+                        &pszValue))
+        return VERR_VD_VMDK_VALUE_NOT_FOUND;
+    int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
+    if (RT_FAILURE(rc))
+        return rc;
+    *ppszValue = pszValueUnquoted;
+    return rc;
+}
+
+static int vmdkDescBaseSetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                              const char *pszKey, const char *pszValue)
+{
+    char *pszValueQuoted;
+
+    RTStrAPrintf(&pszValueQuoted, "\"%s\"", pszValue);
+    if (!pszValueQuoted)
+        return VERR_NO_STR_MEMORY;
+    int rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc, pszKey,
+                            pszValueQuoted);
+    RTStrFree(pszValueQuoted);
+    return rc;
+}
+
+static void vmdkDescExtRemoveDummy(PVMDKIMAGE pImage,
+                                   PVMDKDESCRIPTOR pDescriptor)
+{
+    RT_NOREF1(pImage);
+    unsigned uEntry = pDescriptor->uFirstExtent;
+    ssize_t cbDiff;
+
+    if (!uEntry)
+        return;
+
+    cbDiff = strlen(pDescriptor->aLines[uEntry]) + 1;
+    /* Move everything including \0 in the entry marking the end of buffer. */
+    memmove(pDescriptor->aLines[uEntry], pDescriptor->aLines[uEntry + 1],
+            pDescriptor->aLines[pDescriptor->cLines] - pDescriptor->aLines[uEntry + 1] + 1);
+    for (unsigned i = uEntry + 1; i <= pDescriptor->cLines; i++)
+    {
+        pDescriptor->aLines[i - 1] = pDescriptor->aLines[i] - cbDiff;
+        if (pDescriptor->aNextLines[i])
+            pDescriptor->aNextLines[i - 1] = pDescriptor->aNextLines[i] - 1;
+        else
+            pDescriptor->aNextLines[i - 1] = 0;
+    }
+    pDescriptor->cLines--;
+    if (pDescriptor->uFirstDDB)
+        pDescriptor->uFirstDDB--;
+
+    return;
+}
+
+static void vmdkDescExtRemoveByLine(PVMDKIMAGE pImage,
+                                   PVMDKDESCRIPTOR pDescriptor, unsigned uLine)
+{
+    RT_NOREF1(pImage);
+    unsigned uEntry = uLine;
+    ssize_t cbDiff;
+    if (!uEntry)
+        return;
+    cbDiff = strlen(pDescriptor->aLines[uEntry]) + 1;
+    /* Move everything including \0 in the entry marking the end of buffer. */
+    memmove(pDescriptor->aLines[uEntry], pDescriptor->aLines[uEntry + 1],
+            pDescriptor->aLines[pDescriptor->cLines] - pDescriptor->aLines[uEntry + 1] + 1);
+    for (unsigned i = uEntry; i <= pDescriptor->cLines; i++)
+    {
+        if (i != uEntry)
+            pDescriptor->aLines[i - 1] = pDescriptor->aLines[i] - cbDiff;
+        if (pDescriptor->aNextLines[i])
+            pDescriptor->aNextLines[i - 1] = pDescriptor->aNextLines[i] - 1;
+        else
+            pDescriptor->aNextLines[i - 1] = 0;
+    }
+    pDescriptor->cLines--;
+    if (pDescriptor->uFirstDDB)
+        pDescriptor->uFirstDDB--;
+    return;
+}
+
+static int vmdkDescExtInsert(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                             VMDKACCESS enmAccess, uint64_t cNominalSectors,
+                             VMDKETYPE enmType, const char *pszBasename,
+                             uint64_t uSectorOffset)
+{
+    static const char *apszAccess[] = { "NOACCESS", "RDONLY", "RW" };
+    static const char *apszType[] = { "", "SPARSE", "FLAT", "ZERO", "VMFS" };
+    char *pszTmp;
+    unsigned uStart = pDescriptor->uFirstExtent, uLast = 0;
+    char szExt[1024];
+    ssize_t cbDiff;
+
+    Assert((unsigned)enmAccess < RT_ELEMENTS(apszAccess));
+    Assert((unsigned)enmType < RT_ELEMENTS(apszType));
+
+    /* Find last entry in extent description. */
+    while (uStart)
+    {
+        if (!pDescriptor->aNextLines[uStart])
+            uLast = uStart;
+        uStart = pDescriptor->aNextLines[uStart];
+    }
+
+    if (enmType == VMDKETYPE_ZERO)
+    {
+        RTStrPrintf(szExt, sizeof(szExt), "%s %llu %s ", apszAccess[enmAccess],
+                    cNominalSectors, apszType[enmType]);
+    }
+    else if (enmType == VMDKETYPE_FLAT)
+    {
+        RTStrPrintf(szExt, sizeof(szExt), "%s %llu %s \"%s\" %llu",
+                    apszAccess[enmAccess], cNominalSectors,
+                    apszType[enmType], pszBasename, uSectorOffset);
+    }
+    else
+    {
+        RTStrPrintf(szExt, sizeof(szExt), "%s %llu %s \"%s\"",
+                    apszAccess[enmAccess], cNominalSectors,
+                    apszType[enmType], pszBasename);
+    }
+    cbDiff = strlen(szExt) + 1;
+
+    /* Check for buffer overflow. */
+    if (   (pDescriptor->cLines >= VMDK_DESCRIPTOR_LINES_MAX - 1)
+        || (  pDescriptor->aLines[pDescriptor->cLines]
+            - pDescriptor->aLines[0] > (ptrdiff_t)pDescriptor->cbDescAlloc - cbDiff))
+    {
+        if ((pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
+            && !(pDescriptor->cLines >= VMDK_DESCRIPTOR_LINES_MAX - 1))
+        {
+            pImage->cbDescAlloc *= 2;
+            pDescriptor->cbDescAlloc *= 2;
+        }
+        else
+            return vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
+    }
+
+    for (unsigned i = pDescriptor->cLines + 1; i > uLast + 1; i--)
+    {
+        pDescriptor->aLines[i] = pDescriptor->aLines[i - 1];
+        if (pDescriptor->aNextLines[i - 1])
+            pDescriptor->aNextLines[i] = pDescriptor->aNextLines[i - 1] + 1;
+        else
+            pDescriptor->aNextLines[i] = 0;
+    }
+    uStart = uLast + 1;
+    pDescriptor->aNextLines[uLast] = uStart;
+    pDescriptor->aNextLines[uStart] = 0;
+    pDescriptor->cLines++;
+    pszTmp = pDescriptor->aLines[uStart];
+    memmove(pszTmp + cbDiff, pszTmp,
+            pDescriptor->aLines[pDescriptor->cLines] - pszTmp);
+    memcpy(pDescriptor->aLines[uStart], szExt, cbDiff);
+    for (unsigned i = uStart + 1; i <= pDescriptor->cLines; i++)
+        pDescriptor->aLines[i] += cbDiff;
+
+    /* Adjust starting line numbers of following descriptor sections. */
+    if (uStart <= pDescriptor->uFirstDDB)
+        pDescriptor->uFirstDDB++;
+
+    pDescriptor->fDirty = true;
+    return VINF_SUCCESS;
+}
+
+/**
+ * Returns the value of the given key from the DDB as a string allocating
+ * the necessary memory.
+ *
+ * @returns VBox status code.
+ * @retval  VERR_VD_VMDK_VALUE_NOT_FOUND if the value could not be found.
+ * @param   pImage          The VMDK image state.
+ * @param   pDescriptor     The descriptor to fetch the value from.
+ * @param   pszKey          The key to get the value from.
+ * @param   ppszValue       Where to store the return value, use RTMemTmpFree to
+ *                          free.
+ */
+static int vmdkDescDDBGetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                             const char *pszKey, char **ppszValue)
+{
+    const char *pszValue;
+    char *pszValueUnquoted;
+
+    if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
+                        &pszValue))
+        return VERR_VD_VMDK_VALUE_NOT_FOUND;
+    int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
+    if (RT_FAILURE(rc))
+        return rc;
+    *ppszValue = pszValueUnquoted;
+    return rc;
+}
+
+static int vmdkDescDDBGetU32(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                             const char *pszKey, uint32_t *puValue)
+{
+    const char *pszValue;
+    char *pszValueUnquoted;
+
+    if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
+                        &pszValue))
+        return VERR_VD_VMDK_VALUE_NOT_FOUND;
+    int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
+    if (RT_FAILURE(rc))
+        return rc;
+    rc = RTStrToUInt32Ex(pszValueUnquoted, NULL, 10, puValue);
+    RTMemTmpFree(pszValueUnquoted);
+    return rc;
+}
+
+static int vmdkDescDDBGetUuid(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                              const char *pszKey, PRTUUID pUuid)
+{
+    const char *pszValue;
+    char *pszValueUnquoted;
+
+    if (!vmdkDescGetStr(pDescriptor, pDescriptor->uFirstDDB, pszKey,
+                        &pszValue))
+        return VERR_VD_VMDK_VALUE_NOT_FOUND;
+    int rc = vmdkStringUnquote(pImage, pszValue, &pszValueUnquoted, NULL);
+    if (RT_FAILURE(rc))
+        return rc;
+    rc = RTUuidFromStr(pUuid, pszValueUnquoted);
+    RTMemTmpFree(pszValueUnquoted);
+    return rc;
+}
+
+static int vmdkDescDDBSetStr(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                             const char *pszKey, const char *pszVal)
+{
+    int rc;
+    char *pszValQuoted;
+
+    if (pszVal)
+    {
+        RTStrAPrintf(&pszValQuoted, "\"%s\"", pszVal);
+        if (!pszValQuoted)
+            return VERR_NO_STR_MEMORY;
+    }
+    else
+        pszValQuoted = NULL;
+    rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
+                        pszValQuoted);
+    if (pszValQuoted)
+        RTStrFree(pszValQuoted);
+    return rc;
+}
+
+static int vmdkDescDDBSetUuid(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                              const char *pszKey, PCRTUUID pUuid)
+{
+    char *pszUuid;
+
+    RTStrAPrintf(&pszUuid, "\"%RTuuid\"", pUuid);
+    if (!pszUuid)
+        return VERR_NO_STR_MEMORY;
+    int rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
+                            pszUuid);
+    RTStrFree(pszUuid);
+    return rc;
+}
+
+static int vmdkDescDDBSetU32(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDescriptor,
+                             const char *pszKey, uint32_t uValue)
+{
+    char *pszValue;
+
+    RTStrAPrintf(&pszValue, "\"%d\"", uValue);
+    if (!pszValue)
+        return VERR_NO_STR_MEMORY;
+    int rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDDB, pszKey,
+                            pszValue);
+    RTStrFree(pszValue);
+    return rc;
+}
+
+/**
+ * Splits the descriptor data into individual lines checking for correct line
+ * endings and descriptor size.
+ *
+ * @returns VBox status code.
+ * @param   pImage          The image instance.
+ * @param   pDesc           The descriptor.
+ * @param   pszTmp          The raw descriptor data from the image.
+ */
+static int vmdkDescSplitLines(PVMDKIMAGE pImage, PVMDKDESCRIPTOR pDesc, char *pszTmp)
+{
+    unsigned cLine = 0;
+    int rc = VINF_SUCCESS;
+
+    while (   RT_SUCCESS(rc)
+           && *pszTmp != '\0')
+    {
+        pDesc->aLines[cLine++] = pszTmp;
+        if (cLine >= VMDK_DESCRIPTOR_LINES_MAX)
+        {
+            vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor too big in '%s'"), pImage->pszFilename);
+            rc = VERR_VD_VMDK_INVALID_HEADER;
+            break;
+        }
+
+        while (*pszTmp != '\0' && *pszTmp != '\n')
+        {
+            if (*pszTmp == '\r')
+            {
+                if (*(pszTmp + 1) != '\n')
+                {
+                    rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: unsupported end of line in descriptor in '%s'"), pImage->pszFilename);
+                    break;
+                }
+                else
+                {
+                    /* Get rid of CR character. */
+                    *pszTmp = '\0';
+                }
+            }
+            pszTmp++;
+        }
+
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Get rid of LF character. */
+        if (*pszTmp == '\n')
+        {
+            *pszTmp = '\0';
+            pszTmp++;
+        }
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        pDesc->cLines = cLine;
+        /* Pointer right after the end of the used part of the buffer. */
+        pDesc->aLines[cLine] = pszTmp;
+    }
+
+    return rc;
+}
+
+static int vmdkPreprocessDescriptor(PVMDKIMAGE pImage, char *pDescData,
+                                    size_t cbDescData, PVMDKDESCRIPTOR pDescriptor)
+{
+    pDescriptor->cbDescAlloc = cbDescData;
+    int rc = vmdkDescSplitLines(pImage, pDescriptor, pDescData);
+    if (RT_SUCCESS(rc))
+    {
+        if (    strcmp(pDescriptor->aLines[0], "# Disk DescriptorFile")
+            &&  strcmp(pDescriptor->aLines[0], "# Disk Descriptor File")
+            &&  strcmp(pDescriptor->aLines[0], "#Disk Descriptor File")
+            &&  strcmp(pDescriptor->aLines[0], "#Disk DescriptorFile"))
+            rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                           N_("VMDK: descriptor does not start as expected in '%s'"), pImage->pszFilename);
+        else
+        {
+            unsigned uLastNonEmptyLine = 0;
+
+            /* Initialize those, because we need to be able to reopen an image. */
+            pDescriptor->uFirstDesc = 0;
+            pDescriptor->uFirstExtent = 0;
+            pDescriptor->uFirstDDB = 0;
+            for (unsigned i = 0; i < pDescriptor->cLines; i++)
+            {
+                if (*pDescriptor->aLines[i] != '#' && *pDescriptor->aLines[i] != '\0')
+                {
+                    if (    !strncmp(pDescriptor->aLines[i], "RW", 2)
+                        ||  !strncmp(pDescriptor->aLines[i], "RDONLY", 6)
+                        ||  !strncmp(pDescriptor->aLines[i], "NOACCESS", 8) )
+                    {
+                        /* An extent descriptor. */
+                        if (!pDescriptor->uFirstDesc || pDescriptor->uFirstDDB)
+                        {
+                            /* Incorrect ordering of entries. */
+                            rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                           N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
+                            break;
+                        }
+                        if (!pDescriptor->uFirstExtent)
+                        {
+                            pDescriptor->uFirstExtent = i;
+                            uLastNonEmptyLine = 0;
+                        }
+                    }
+                    else if (!strncmp(pDescriptor->aLines[i], "ddb.", 4))
+                    {
+                        /* A disk database entry. */
+                        if (!pDescriptor->uFirstDesc || !pDescriptor->uFirstExtent)
+                        {
+                            /* Incorrect ordering of entries. */
+                            rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                           N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
+                            break;
+                        }
+                        if (!pDescriptor->uFirstDDB)
+                        {
+                            pDescriptor->uFirstDDB = i;
+                            uLastNonEmptyLine = 0;
+                        }
+                    }
+                    else
+                    {
+                        /* A normal entry. */
+                        if (pDescriptor->uFirstExtent || pDescriptor->uFirstDDB)
+                        {
+                            /* Incorrect ordering of entries. */
+                            rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                           N_("VMDK: incorrect ordering of entries in descriptor in '%s'"), pImage->pszFilename);
+                            break;
+                        }
+                        if (!pDescriptor->uFirstDesc)
+                        {
+                            pDescriptor->uFirstDesc = i;
+                            uLastNonEmptyLine = 0;
+                        }
+                    }
+                    if (uLastNonEmptyLine)
+                        pDescriptor->aNextLines[uLastNonEmptyLine] = i;
+                    uLastNonEmptyLine = i;
+                }
+            }
+        }
+    }
+
+    return rc;
+}
+
+static int vmdkDescSetPCHSGeometry(PVMDKIMAGE pImage,
+                                   PCVDGEOMETRY pPCHSGeometry)
+{
+    int rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_PCHS_CYLINDERS,
+                           pPCHSGeometry->cCylinders);
+    if (RT_FAILURE(rc))
+        return rc;
+    rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_PCHS_HEADS,
+                           pPCHSGeometry->cHeads);
+    if (RT_FAILURE(rc))
+        return rc;
+    rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_PCHS_SECTORS,
+                           pPCHSGeometry->cSectors);
+    return rc;
+}
+
+static int vmdkDescSetLCHSGeometry(PVMDKIMAGE pImage,
+                                   PCVDGEOMETRY pLCHSGeometry)
+{
+    int rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_LCHS_CYLINDERS,
+                           pLCHSGeometry->cCylinders);
+    if (RT_FAILURE(rc))
+        return rc;
+    rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_LCHS_HEADS,
+
+                           pLCHSGeometry->cHeads);
+    if (RT_FAILURE(rc))
+        return rc;
+    rc = vmdkDescDDBSetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_LCHS_SECTORS,
+                           pLCHSGeometry->cSectors);
+    return rc;
+}
+
+static int vmdkCreateDescriptor(PVMDKIMAGE pImage, char *pDescData,
+                                size_t cbDescData, PVMDKDESCRIPTOR pDescriptor)
+{
+    pDescriptor->uFirstDesc = 0;
+    pDescriptor->uFirstExtent = 0;
+    pDescriptor->uFirstDDB = 0;
+    pDescriptor->cLines = 0;
+    pDescriptor->cbDescAlloc = cbDescData;
+    pDescriptor->fDirty = false;
+    pDescriptor->aLines[pDescriptor->cLines] = pDescData;
+    memset(pDescriptor->aNextLines, '\0', sizeof(pDescriptor->aNextLines));
+
+    int rc = vmdkDescInitStr(pImage, pDescriptor, "# Disk DescriptorFile");
+    if (RT_SUCCESS(rc))
+        rc = vmdkDescInitStr(pImage, pDescriptor, "version=1");
+    if (RT_SUCCESS(rc))
+    {
+        pDescriptor->uFirstDesc = pDescriptor->cLines - 1;
+        rc = vmdkDescInitStr(pImage, pDescriptor, "");
+    }
+    if (RT_SUCCESS(rc))
+        rc = vmdkDescInitStr(pImage, pDescriptor, "# Extent description");
+    if (RT_SUCCESS(rc))
+        rc = vmdkDescInitStr(pImage, pDescriptor, "NOACCESS 0 ZERO ");
+    if (RT_SUCCESS(rc))
+    {
+        pDescriptor->uFirstExtent = pDescriptor->cLines - 1;
+        rc = vmdkDescInitStr(pImage, pDescriptor, "");
+    }
+    if (RT_SUCCESS(rc))
+    {
+        /* The trailing space is created by VMware, too. */
+        rc = vmdkDescInitStr(pImage, pDescriptor, "# The disk Data Base ");
+    }
+    if (RT_SUCCESS(rc))
+        rc = vmdkDescInitStr(pImage, pDescriptor, "#DDB");
+    if (RT_SUCCESS(rc))
+        rc = vmdkDescInitStr(pImage, pDescriptor, "");
+    if (RT_SUCCESS(rc))
+        rc = vmdkDescInitStr(pImage, pDescriptor, "ddb.virtualHWVersion = \"4\"");
+    if (RT_SUCCESS(rc))
+    {
+        pDescriptor->uFirstDDB = pDescriptor->cLines - 1;
+
+        /* Now that the framework is in place, use the normal functions to insert
+         * the remaining keys. */
+        char szBuf[9];
+        RTStrPrintf(szBuf, sizeof(szBuf), "%08x", RTRandU32());
+        rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc,
+                            "CID", szBuf);
+    }
+    if (RT_SUCCESS(rc))
+        rc = vmdkDescSetStr(pImage, pDescriptor, pDescriptor->uFirstDesc,
+                            "parentCID", "ffffffff");
+    if (RT_SUCCESS(rc))
+        rc = vmdkDescDDBSetStr(pImage, pDescriptor, "ddb.adapterType", "ide");
+
+    return rc;
+}
+
+static int vmdkParseDescriptor(PVMDKIMAGE pImage, char *pDescData, size_t cbDescData)
+{
+    int rc;
+    unsigned cExtents;
+    unsigned uLine;
+    unsigned i;
+
+    rc = vmdkPreprocessDescriptor(pImage, pDescData, cbDescData,
+                                  &pImage->Descriptor);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /* Check version, must be 1. */
+    uint32_t uVersion;
+    rc = vmdkDescBaseGetU32(&pImage->Descriptor, "version", &uVersion);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error finding key 'version' in descriptor in '%s'"), pImage->pszFilename);
+    if (uVersion != 1)
+        return vdIfError(pImage->pIfError, VERR_VD_VMDK_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VMDK: unsupported format version in descriptor in '%s'"), pImage->pszFilename);
+
+    /* Get image creation type and determine image flags. */
+    char *pszCreateType = NULL;   /* initialized to make gcc shut up */
+    rc = vmdkDescBaseGetStr(pImage, &pImage->Descriptor, "createType",
+                            &pszCreateType);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot get image type from descriptor in '%s'"), pImage->pszFilename);
+    if (    !strcmp(pszCreateType, "twoGbMaxExtentSparse")
+        ||  !strcmp(pszCreateType, "twoGbMaxExtentFlat"))
+        pImage->uImageFlags |= VD_VMDK_IMAGE_FLAGS_SPLIT_2G;
+    else if (   !strcmp(pszCreateType, "partitionedDevice")
+             || !strcmp(pszCreateType, "fullDevice"))
+        pImage->uImageFlags |= VD_VMDK_IMAGE_FLAGS_RAWDISK;
+    else if (!strcmp(pszCreateType, "streamOptimized"))
+        pImage->uImageFlags |= VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED;
+    else if (!strcmp(pszCreateType, "vmfs"))
+        pImage->uImageFlags |= VD_IMAGE_FLAGS_FIXED | VD_VMDK_IMAGE_FLAGS_ESX;
+    RTMemTmpFree(pszCreateType);
+
+    /* Count the number of extent config entries. */
+    for (uLine = pImage->Descriptor.uFirstExtent, cExtents = 0;
+         uLine != 0;
+         uLine = pImage->Descriptor.aNextLines[uLine], cExtents++)
+        /* nothing */;
+
+    if (!pImage->pDescData && cExtents != 1)
+    {
+        /* Monolithic image, must have only one extent (already opened). */
+        return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: monolithic image may only have one extent in '%s'"), pImage->pszFilename);
+    }
+
+    if (pImage->pDescData)
+    {
+        /* Non-monolithic image, extents need to be allocated. */
+        rc = vmdkCreateExtents(pImage, cExtents);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    for (i = 0, uLine = pImage->Descriptor.uFirstExtent;
+         i < cExtents; i++, uLine = pImage->Descriptor.aNextLines[uLine])
+    {
+        char *pszLine = pImage->Descriptor.aLines[uLine];
+
+        /* Access type of the extent. */
+        if (!strncmp(pszLine, "RW", 2))
+        {
+            pImage->pExtents[i].enmAccess = VMDKACCESS_READWRITE;
+            pszLine += 2;
+        }
+        else if (!strncmp(pszLine, "RDONLY", 6))
+        {
+            pImage->pExtents[i].enmAccess = VMDKACCESS_READONLY;
+            pszLine += 6;
+        }
+        else if (!strncmp(pszLine, "NOACCESS", 8))
+        {
+            pImage->pExtents[i].enmAccess = VMDKACCESS_NOACCESS;
+            pszLine += 8;
+        }
+        else
+            return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
+        if (*pszLine++ != ' ')
+            return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
+
+        /* Nominal size of the extent. */
+        rc = RTStrToUInt64Ex(pszLine, &pszLine, 10,
+                             &pImage->pExtents[i].cNominalSectors);
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
+        if (*pszLine++ != ' ')
+            return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
+
+        /* Type of the extent. */
+        if (!strncmp(pszLine, "SPARSE", 6))
+        {
+            pImage->pExtents[i].enmType = VMDKETYPE_HOSTED_SPARSE;
+            pszLine += 6;
+        }
+        else if (!strncmp(pszLine, "FLAT", 4))
+        {
+            pImage->pExtents[i].enmType = VMDKETYPE_FLAT;
+            pszLine += 4;
+        }
+        else if (!strncmp(pszLine, "ZERO", 4))
+        {
+            pImage->pExtents[i].enmType = VMDKETYPE_ZERO;
+            pszLine += 4;
+        }
+        else if (!strncmp(pszLine, "VMFS", 4))
+        {
+            pImage->pExtents[i].enmType = VMDKETYPE_VMFS;
+            pszLine += 4;
+        }
+        else
+            return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
+
+        if (pImage->pExtents[i].enmType == VMDKETYPE_ZERO)
+        {
+            /* This one has no basename or offset. */
+            if (*pszLine == ' ')
+                pszLine++;
+            if (*pszLine != '\0')
+                return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
+            pImage->pExtents[i].pszBasename = NULL;
+        }
+        else
+        {
+            /* All other extent types have basename and optional offset. */
+            if (*pszLine++ != ' ')
+                return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
+
+            /* Basename of the image. Surrounded by quotes. */
+            char *pszBasename;
+            rc = vmdkStringUnquote(pImage, pszLine, &pszBasename, &pszLine);
+            if (RT_FAILURE(rc))
+                return rc;
+            pImage->pExtents[i].pszBasename = pszBasename;
+            if (*pszLine == ' ')
+            {
+                pszLine++;
+                if (*pszLine != '\0')
+                {
+                    /* Optional offset in extent specified. */
+                    rc = RTStrToUInt64Ex(pszLine, &pszLine, 10,
+                                         &pImage->pExtents[i].uSectorOffset);
+                    if (RT_FAILURE(rc))
+                        return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
+                }
+            }
+
+            if (*pszLine != '\0')
+                return vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: parse error in extent description in '%s'"), pImage->pszFilename);
+        }
+    }
+
+    /* Determine PCHS geometry (autogenerate if necessary). */
+    rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_PCHS_CYLINDERS,
+                           &pImage->PCHSGeometry.cCylinders);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+        pImage->PCHSGeometry.cCylinders = 0;
+    else if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting PCHS geometry from extent description in '%s'"), pImage->pszFilename);
+    rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_PCHS_HEADS,
+                           &pImage->PCHSGeometry.cHeads);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+        pImage->PCHSGeometry.cHeads = 0;
+    else if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting PCHS geometry from extent description in '%s'"), pImage->pszFilename);
+    rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_PCHS_SECTORS,
+                           &pImage->PCHSGeometry.cSectors);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+        pImage->PCHSGeometry.cSectors = 0;
+    else if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting PCHS geometry from extent description in '%s'"), pImage->pszFilename);
+    if (    pImage->PCHSGeometry.cCylinders == 0
+        ||  pImage->PCHSGeometry.cHeads == 0
+        ||  pImage->PCHSGeometry.cHeads > 16
+        ||  pImage->PCHSGeometry.cSectors == 0
+        ||  pImage->PCHSGeometry.cSectors > 63)
+    {
+        /* Mark PCHS geometry as not yet valid (can't do the calculation here
+         * as the total image size isn't known yet). */
+        pImage->PCHSGeometry.cCylinders = 0;
+        pImage->PCHSGeometry.cHeads = 16;
+        pImage->PCHSGeometry.cSectors = 63;
+    }
+
+    /* Determine LCHS geometry (set to 0 if not specified). */
+    rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_LCHS_CYLINDERS,
+                           &pImage->LCHSGeometry.cCylinders);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+        pImage->LCHSGeometry.cCylinders = 0;
+    else if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting LCHS geometry from extent description in '%s'"), pImage->pszFilename);
+    rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_LCHS_HEADS,
+                           &pImage->LCHSGeometry.cHeads);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+        pImage->LCHSGeometry.cHeads = 0;
+    else if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting LCHS geometry from extent description in '%s'"), pImage->pszFilename);
+    rc = vmdkDescDDBGetU32(pImage, &pImage->Descriptor,
+                           VMDK_DDB_GEO_LCHS_SECTORS,
+                           &pImage->LCHSGeometry.cSectors);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+        pImage->LCHSGeometry.cSectors = 0;
+    else if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting LCHS geometry from extent description in '%s'"), pImage->pszFilename);
+    if (    pImage->LCHSGeometry.cCylinders == 0
+        ||  pImage->LCHSGeometry.cHeads == 0
+        ||  pImage->LCHSGeometry.cSectors == 0)
+    {
+        pImage->LCHSGeometry.cCylinders = 0;
+        pImage->LCHSGeometry.cHeads = 0;
+        pImage->LCHSGeometry.cSectors = 0;
+    }
+
+    /* Get image UUID. */
+    rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor, VMDK_DDB_IMAGE_UUID,
+                            &pImage->ImageUuid);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+    {
+        /* Image without UUID. Probably created by VMware and not yet used
+         * by VirtualBox. Can only be added for images opened in read/write
+         * mode, so don't bother producing a sensible UUID otherwise. */
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            RTUuidClear(&pImage->ImageUuid);
+        else
+        {
+            rc = RTUuidCreate(&pImage->ImageUuid);
+            if (RT_FAILURE(rc))
+                return rc;
+            rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                                    VMDK_DDB_IMAGE_UUID, &pImage->ImageUuid);
+            if (RT_FAILURE(rc))
+                return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing image UUID in descriptor in '%s'"), pImage->pszFilename);
+        }
+    }
+    else if (RT_FAILURE(rc))
+        return rc;
+
+    /* Get image modification UUID. */
+    rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor,
+                            VMDK_DDB_MODIFICATION_UUID,
+                            &pImage->ModificationUuid);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+    {
+        /* Image without UUID. Probably created by VMware and not yet used
+         * by VirtualBox. Can only be added for images opened in read/write
+         * mode, so don't bother producing a sensible UUID otherwise. */
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            RTUuidClear(&pImage->ModificationUuid);
+        else
+        {
+            rc = RTUuidCreate(&pImage->ModificationUuid);
+            if (RT_FAILURE(rc))
+                return rc;
+            rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                                    VMDK_DDB_MODIFICATION_UUID,
+                                    &pImage->ModificationUuid);
+            if (RT_FAILURE(rc))
+                return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing image modification UUID in descriptor in '%s'"), pImage->pszFilename);
+        }
+    }
+    else if (RT_FAILURE(rc))
+        return rc;
+
+    /* Get UUID of parent image. */
+    rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor, VMDK_DDB_PARENT_UUID,
+                            &pImage->ParentUuid);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+    {
+        /* Image without UUID. Probably created by VMware and not yet used
+         * by VirtualBox. Can only be added for images opened in read/write
+         * mode, so don't bother producing a sensible UUID otherwise. */
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            RTUuidClear(&pImage->ParentUuid);
+        else
+        {
+            rc = RTUuidClear(&pImage->ParentUuid);
+            if (RT_FAILURE(rc))
+                return rc;
+            rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                                    VMDK_DDB_PARENT_UUID, &pImage->ParentUuid);
+            if (RT_FAILURE(rc))
+                return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing parent UUID in descriptor in '%s'"), pImage->pszFilename);
+        }
+    }
+    else if (RT_FAILURE(rc))
+        return rc;
+
+    /* Get parent image modification UUID. */
+    rc = vmdkDescDDBGetUuid(pImage, &pImage->Descriptor,
+                            VMDK_DDB_PARENT_MODIFICATION_UUID,
+                            &pImage->ParentModificationUuid);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+    {
+        /* Image without UUID. Probably created by VMware and not yet used
+         * by VirtualBox. Can only be added for images opened in read/write
+         * mode, so don't bother producing a sensible UUID otherwise. */
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            RTUuidClear(&pImage->ParentModificationUuid);
+        else
+        {
+            RTUuidClear(&pImage->ParentModificationUuid);
+            rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                                    VMDK_DDB_PARENT_MODIFICATION_UUID,
+                                    &pImage->ParentModificationUuid);
+            if (RT_FAILURE(rc))
+                return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing parent modification UUID in descriptor in '%s'"), pImage->pszFilename);
+        }
+    }
+    else if (RT_FAILURE(rc))
+        return rc;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Internal : Prepares the descriptor to write to the image.
+ */
+static int vmdkDescriptorPrepare(PVMDKIMAGE pImage, uint64_t cbLimit,
+                                 void **ppvData, size_t *pcbData)
+{
+    int rc = VINF_SUCCESS;
+
+    /*
+     * Allocate temporary descriptor buffer.
+     * In case there is no limit allocate a default
+     * and increase if required.
+     */
+    size_t cbDescriptor = cbLimit ? cbLimit : 4 * _1K;
+    char *pszDescriptor = (char *)RTMemAllocZ(cbDescriptor);
+    size_t offDescriptor = 0;
+
+    if (!pszDescriptor)
+        return VERR_NO_MEMORY;
+
+    for (unsigned i = 0; i < pImage->Descriptor.cLines; i++)
+    {
+        const char *psz = pImage->Descriptor.aLines[i];
+        size_t cb = strlen(psz);
+
+        /*
+         * Increase the descriptor if there is no limit and
+         * there is not enough room left for this line.
+         */
+        if (offDescriptor + cb + 1 > cbDescriptor)
+        {
+            if (cbLimit)
+            {
+                rc = vdIfError(pImage->pIfError, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too long in '%s'"), pImage->pszFilename);
+                break;
+            }
+            else
+            {
+                char *pszDescriptorNew = NULL;
+                LogFlow(("Increasing descriptor cache\n"));
+
+                pszDescriptorNew = (char *)RTMemRealloc(pszDescriptor, cbDescriptor + cb + 4 * _1K);
+                if (!pszDescriptorNew)
+                {
+                    rc = VERR_NO_MEMORY;
+                    break;
+                }
+                pszDescriptor = pszDescriptorNew;
+                cbDescriptor += cb + 4 * _1K;
+            }
+        }
+
+        if (cb > 0)
+        {
+            memcpy(pszDescriptor + offDescriptor, psz, cb);
+            offDescriptor += cb;
+        }
+
+        memcpy(pszDescriptor + offDescriptor, "\n", 1);
+        offDescriptor++;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        *ppvData = pszDescriptor;
+        *pcbData = offDescriptor;
+    }
+    else if (pszDescriptor)
+        RTMemFree(pszDescriptor);
+
+    return rc;
+}
+
+/**
+ * Internal: write/update the descriptor part of the image.
+ */
+static int vmdkWriteDescriptor(PVMDKIMAGE pImage, PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    uint64_t cbLimit;
+    uint64_t uOffset;
+    PVMDKFILE pDescFile;
+    void *pvDescriptor = NULL;
+    size_t cbDescriptor;
+
+    if (pImage->pDescData)
+    {
+        /* Separate descriptor file. */
+        uOffset = 0;
+        cbLimit = 0;
+        pDescFile = pImage->pFile;
+    }
+    else
+    {
+        /* Embedded descriptor file. */
+        uOffset = VMDK_SECTOR2BYTE(pImage->pExtents[0].uDescriptorSector);
+        cbLimit = VMDK_SECTOR2BYTE(pImage->pExtents[0].cDescriptorSectors);
+        pDescFile = pImage->pExtents[0].pFile;
+    }
+    /* Bail out if there is no file to write to. */
+    if (pDescFile == NULL)
+        return VERR_INVALID_PARAMETER;
+
+    rc = vmdkDescriptorPrepare(pImage, cbLimit, &pvDescriptor, &cbDescriptor);
+    if (RT_SUCCESS(rc))
+    {
+        rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pDescFile->pStorage,
+                                    uOffset, pvDescriptor,
+                                    cbLimit ? cbLimit : cbDescriptor,
+                                    pIoCtx, NULL, NULL);
+        if (   RT_FAILURE(rc)
+            && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error writing descriptor in '%s'"), pImage->pszFilename);
+    }
+
+    if (RT_SUCCESS(rc) && !cbLimit)
+    {
+        rc = vdIfIoIntFileSetSize(pImage->pIfIo, pDescFile->pStorage, cbDescriptor);
+        if (RT_FAILURE(rc))
+            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error truncating descriptor in '%s'"), pImage->pszFilename);
+    }
+
+    if (RT_SUCCESS(rc))
+        pImage->Descriptor.fDirty = false;
+
+    if (pvDescriptor)
+        RTMemFree(pvDescriptor);
+    return rc;
+
+}
+
+/**
+ * Internal: validate the consistency check values in a binary header.
+ */
+static int vmdkValidateHeader(PVMDKIMAGE pImage, PVMDKEXTENT pExtent, const SparseExtentHeader *pHeader)
+{
+    int rc = VINF_SUCCESS;
+    if (RT_LE2H_U32(pHeader->magicNumber) != VMDK_SPARSE_MAGICNUMBER)
+    {
+        rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: incorrect magic in sparse extent header in '%s'"), pExtent->pszFullname);
+        return rc;
+    }
+    if (RT_LE2H_U32(pHeader->version) != 1 && RT_LE2H_U32(pHeader->version) != 3)
+    {
+        rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VMDK: incorrect version in sparse extent header in '%s', not a VMDK 1.0/1.1 conforming file"), pExtent->pszFullname);
+        return rc;
+    }
+    if (    (RT_LE2H_U32(pHeader->flags) & 1)
+        &&  (   pHeader->singleEndLineChar != '\n'
+             || pHeader->nonEndLineChar != ' '
+             || pHeader->doubleEndLineChar1 != '\r'
+             || pHeader->doubleEndLineChar2 != '\n') )
+    {
+        rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: corrupted by CR/LF translation in '%s'"), pExtent->pszFullname);
+        return rc;
+    }
+    if (RT_LE2H_U64(pHeader->descriptorSize) > VMDK_SPARSE_DESCRIPTOR_SIZE_MAX)
+    {
+        rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor size out of bounds (%llu vs %llu) '%s'"),
+                       pExtent->pszFullname, RT_LE2H_U64(pHeader->descriptorSize), VMDK_SPARSE_DESCRIPTOR_SIZE_MAX);
+        return rc;
+    }
+    return rc;
+}
+
+/**
+ * Internal: read metadata belonging to an extent with binary header, i.e.
+ * as found in monolithic files.
+ */
+static int vmdkReadBinaryMetaExtent(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                                    bool fMagicAlreadyRead)
+{
+    SparseExtentHeader Header;
+    int rc;
+
+    if (!fMagicAlreadyRead)
+        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage, 0,
+                                   &Header, sizeof(Header));
+    else
+    {
+        Header.magicNumber = RT_H2LE_U32(VMDK_SPARSE_MAGICNUMBER);
+        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                   RT_UOFFSETOF(SparseExtentHeader, version),
+                                   &Header.version,
+                                     sizeof(Header)
+                                   - RT_UOFFSETOF(SparseExtentHeader, version));
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        rc = vmdkValidateHeader(pImage, pExtent, &Header);
+        if (RT_SUCCESS(rc))
+        {
+            uint64_t cbFile = 0;
+
+            if (    (RT_LE2H_U32(Header.flags) & RT_BIT(17))
+                &&  RT_LE2H_U64(Header.gdOffset) == VMDK_GD_AT_END)
+                pExtent->fFooter = true;
+
+            if (   !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                || (   pExtent->fFooter
+                    && !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL)))
+            {
+                rc = vdIfIoIntFileGetSize(pImage->pIfIo, pExtent->pFile->pStorage, &cbFile);
+                if (RT_FAILURE(rc))
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot get size of '%s'"), pExtent->pszFullname);
+            }
+
+            if (RT_SUCCESS(rc))
+            {
+                if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+                    pExtent->uAppendPosition = RT_ALIGN_64(cbFile, 512);
+
+                if (   pExtent->fFooter
+                    && (   !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                        || !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL)))
+                {
+                    /* Read the footer, which comes before the end-of-stream marker. */
+                    rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                               cbFile - 2*512, &Header,
+                                               sizeof(Header));
+                    if (RT_FAILURE(rc))
+                    {
+                        vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error reading extent footer in '%s'"), pExtent->pszFullname);
+                        rc = VERR_VD_VMDK_INVALID_HEADER;
+                    }
+
+                    if (RT_SUCCESS(rc))
+                        rc = vmdkValidateHeader(pImage, pExtent, &Header);
+                    /* Prohibit any writes to this extent. */
+                    pExtent->uAppendPosition = 0;
+                }
+
+                if (RT_SUCCESS(rc))
+                {
+                    pExtent->uVersion           = RT_LE2H_U32(Header.version);
+                    pExtent->enmType            = VMDKETYPE_HOSTED_SPARSE; /* Just dummy value, changed later. */
+                    pExtent->cSectors           = RT_LE2H_U64(Header.capacity);
+                    pExtent->cSectorsPerGrain   = RT_LE2H_U64(Header.grainSize);
+                    pExtent->uDescriptorSector  = RT_LE2H_U64(Header.descriptorOffset);
+                    pExtent->cDescriptorSectors = RT_LE2H_U64(Header.descriptorSize);
+                    pExtent->cGTEntries         = RT_LE2H_U32(Header.numGTEsPerGT);
+                    pExtent->cOverheadSectors   = RT_LE2H_U64(Header.overHead);
+                    pExtent->fUncleanShutdown   = !!Header.uncleanShutdown;
+                    pExtent->uCompression       = RT_LE2H_U16(Header.compressAlgorithm);
+                    if (RT_LE2H_U32(Header.flags) & RT_BIT(1))
+                    {
+                        pExtent->uSectorRGD     = RT_LE2H_U64(Header.rgdOffset);
+                        pExtent->uSectorGD      = RT_LE2H_U64(Header.gdOffset);
+                    }
+                    else
+                    {
+                        pExtent->uSectorGD      = RT_LE2H_U64(Header.gdOffset);
+                        pExtent->uSectorRGD     = 0;
+                    }
+
+                    if (pExtent->uDescriptorSector && !pExtent->cDescriptorSectors)
+                        rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                       N_("VMDK: inconsistent embedded descriptor config in '%s'"), pExtent->pszFullname);
+
+                    if (   RT_SUCCESS(rc)
+                        && (   pExtent->uSectorGD == VMDK_GD_AT_END
+                            || pExtent->uSectorRGD == VMDK_GD_AT_END)
+                        && (   !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                            || !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL)))
+                        rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                       N_("VMDK: cannot resolve grain directory offset in '%s'"), pExtent->pszFullname);
+
+                    if (RT_SUCCESS(rc))
+                    {
+                        uint64_t cSectorsPerGDE = pExtent->cGTEntries * pExtent->cSectorsPerGrain;
+                        if (!cSectorsPerGDE || cSectorsPerGDE > UINT32_MAX)
+                            rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                           N_("VMDK: incorrect grain directory size in '%s'"), pExtent->pszFullname);
+                        else
+                        {
+                            pExtent->cSectorsPerGDE = cSectorsPerGDE;
+                            pExtent->cGDEntries = (pExtent->cSectors + cSectorsPerGDE - 1) / cSectorsPerGDE;
+
+                            /* Fix up the number of descriptor sectors, as some flat images have
+                             * really just one, and this causes failures when inserting the UUID
+                             * values and other extra information. */
+                            if (pExtent->cDescriptorSectors != 0 && pExtent->cDescriptorSectors < 4)
+                            {
+                                /* Do it the easy way - just fix it for flat images which have no
+                                 * other complicated metadata which needs space too. */
+                                if (    pExtent->uDescriptorSector + 4 < pExtent->cOverheadSectors
+                                    &&  pExtent->cGTEntries * pExtent->cGDEntries == 0)
+                                    pExtent->cDescriptorSectors = 4;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error reading extent header in '%s'"), pExtent->pszFullname);
+        rc = VERR_VD_VMDK_INVALID_HEADER;
+    }
+
+    if (RT_FAILURE(rc))
+        vmdkFreeExtentData(pImage, pExtent, false);
+
+    return rc;
+}
+
+/**
+ * Internal: read additional metadata belonging to an extent. For those
+ * extents which have no additional metadata just verify the information.
+ */
+static int vmdkReadMetaExtent(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
+{
+    int rc = VINF_SUCCESS;
+
+/* disabled the check as there are too many truncated vmdk images out there */
+#ifdef VBOX_WITH_VMDK_STRICT_SIZE_CHECK
+    uint64_t cbExtentSize;
+    /* The image must be a multiple of a sector in size and contain the data
+     * area (flat images only). If not, it means the image is at least
+     * truncated, or even seriously garbled. */
+    rc = vdIfIoIntFileGetSize(pImage->pIfIo, pExtent->pFile->pStorage, &cbExtentSize);
+    if (RT_FAILURE(rc))
+        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error getting size in '%s'"), pExtent->pszFullname);
+    else if (    cbExtentSize != RT_ALIGN_64(cbExtentSize, 512)
+        &&  (pExtent->enmType != VMDKETYPE_FLAT || pExtent->cNominalSectors + pExtent->uSectorOffset > VMDK_BYTE2SECTOR(cbExtentSize)))
+        rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                       N_("VMDK: file size is not a multiple of 512 in '%s', file is truncated or otherwise garbled"), pExtent->pszFullname);
+#endif /* VBOX_WITH_VMDK_STRICT_SIZE_CHECK */
+    if (   RT_SUCCESS(rc)
+        && pExtent->enmType == VMDKETYPE_HOSTED_SPARSE)
+    {
+        /* The spec says that this must be a power of two and greater than 8,
+         * but probably they meant not less than 8. */
+        if (    (pExtent->cSectorsPerGrain & (pExtent->cSectorsPerGrain - 1))
+            ||  pExtent->cSectorsPerGrain < 8)
+            rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                           N_("VMDK: invalid extent grain size %u in '%s'"), pExtent->cSectorsPerGrain, pExtent->pszFullname);
+        else
+        {
+            /* This code requires that a grain table must hold a power of two multiple
+             * of the number of entries per GT cache entry. */
+            if (    (pExtent->cGTEntries & (pExtent->cGTEntries - 1))
+                ||  pExtent->cGTEntries < VMDK_GT_CACHELINE_SIZE)
+                rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                               N_("VMDK: grain table cache size problem in '%s'"), pExtent->pszFullname);
+            else
+            {
+                rc = vmdkAllocStreamBuffers(pImage, pExtent);
+                if (RT_SUCCESS(rc))
+                {
+                    /* Prohibit any writes to this streamOptimized extent. */
+                    if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+                        pExtent->uAppendPosition = 0;
+
+                    if (   !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+                        || !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                        || !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL))
+                        rc = vmdkReadGrainDirectory(pImage, pExtent);
+                    else
+                    {
+                        pExtent->uGrainSectorAbs = pExtent->cOverheadSectors;
+                        pExtent->cbGrainStreamRead = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    if (RT_FAILURE(rc))
+        vmdkFreeExtentData(pImage, pExtent, false);
+
+    return rc;
+}
+
+/**
+ * Internal: write/update the metadata for a sparse extent.
+ */
+static int vmdkWriteMetaSparseExtent(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                                     uint64_t uOffset, PVDIOCTX pIoCtx)
+{
+    SparseExtentHeader Header;
+
+    memset(&Header, '\0', sizeof(Header));
+    Header.magicNumber = RT_H2LE_U32(VMDK_SPARSE_MAGICNUMBER);
+    Header.version = RT_H2LE_U32(pExtent->uVersion);
+    Header.flags = RT_H2LE_U32(RT_BIT(0));
+    if (pExtent->pRGD)
+        Header.flags |= RT_H2LE_U32(RT_BIT(1));
+    if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+        Header.flags |= RT_H2LE_U32(RT_BIT(16) | RT_BIT(17));
+    Header.capacity = RT_H2LE_U64(pExtent->cSectors);
+    Header.grainSize = RT_H2LE_U64(pExtent->cSectorsPerGrain);
+    Header.descriptorOffset = RT_H2LE_U64(pExtent->uDescriptorSector);
+    Header.descriptorSize = RT_H2LE_U64(pExtent->cDescriptorSectors);
+    Header.numGTEsPerGT = RT_H2LE_U32(pExtent->cGTEntries);
+    if (pExtent->fFooter && uOffset == 0)
+    {
+        if (pExtent->pRGD)
+        {
+            Assert(pExtent->uSectorRGD);
+            Header.rgdOffset = RT_H2LE_U64(VMDK_GD_AT_END);
+            Header.gdOffset = RT_H2LE_U64(VMDK_GD_AT_END);
+        }
+        else
+            Header.gdOffset = RT_H2LE_U64(VMDK_GD_AT_END);
+    }
+    else
+    {
+        if (pExtent->pRGD)
+        {
+            Assert(pExtent->uSectorRGD);
+            Header.rgdOffset = RT_H2LE_U64(pExtent->uSectorRGD);
+            Header.gdOffset = RT_H2LE_U64(pExtent->uSectorGD);
+        }
+        else
+            Header.gdOffset = RT_H2LE_U64(pExtent->uSectorGD);
+    }
+    Header.overHead = RT_H2LE_U64(pExtent->cOverheadSectors);
+    Header.uncleanShutdown = pExtent->fUncleanShutdown;
+    Header.singleEndLineChar = '\n';
+    Header.nonEndLineChar = ' ';
+    Header.doubleEndLineChar1 = '\r';
+    Header.doubleEndLineChar2 = '\n';
+    Header.compressAlgorithm = RT_H2LE_U16(pExtent->uCompression);
+
+    int rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    uOffset, &Header, sizeof(Header),
+                                    pIoCtx, NULL, NULL);
+    if (RT_FAILURE(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
+        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error writing extent header in '%s'"), pExtent->pszFullname);
+    return rc;
+}
+
+/**
+ * Internal: free the buffers used for streamOptimized images.
+ */
+static void vmdkFreeStreamBuffers(PVMDKEXTENT pExtent)
+{
+    if (pExtent->pvCompGrain)
+    {
+        RTMemFree(pExtent->pvCompGrain);
+        pExtent->pvCompGrain = NULL;
+    }
+    if (pExtent->pvGrain)
+    {
+        RTMemFree(pExtent->pvGrain);
+        pExtent->pvGrain = NULL;
+    }
+}
+
+/**
+ * Internal: free the memory used by the extent data structure, optionally
+ * deleting the referenced files.
+ *
+ * @returns VBox status code.
+ * @param   pImage    Pointer to the image instance data.
+ * @param   pExtent   The extent to free.
+ * @param   fDelete   Flag whether to delete the backing storage.
+ */
+static int vmdkFreeExtentData(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                              bool fDelete)
+{
+    int rc = VINF_SUCCESS;
+
+    vmdkFreeGrainDirectory(pExtent);
+    if (pExtent->pDescData)
+    {
+        RTMemFree(pExtent->pDescData);
+        pExtent->pDescData = NULL;
+    }
+    if (pExtent->pFile != NULL)
+    {
+        /* Do not delete raw extents, these have full and base names equal. */
+        rc = vmdkFileClose(pImage, &pExtent->pFile,
+                              fDelete
+                           && pExtent->pszFullname
+                           && pExtent->pszBasename
+                           && strcmp(pExtent->pszFullname, pExtent->pszBasename));
+    }
+    if (pExtent->pszBasename)
+    {
+        RTMemTmpFree((void *)pExtent->pszBasename);
+        pExtent->pszBasename = NULL;
+    }
+    if (pExtent->pszFullname)
+    {
+        RTStrFree((char *)(void *)pExtent->pszFullname);
+        pExtent->pszFullname = NULL;
+    }
+    vmdkFreeStreamBuffers(pExtent);
+
+    return rc;
+}
+
+/**
+ * Internal: allocate grain table cache if necessary for this image.
+ */
+static int vmdkAllocateGrainTableCache(PVMDKIMAGE pImage)
+{
+    PVMDKEXTENT pExtent;
+
+    /* Allocate grain table cache if any sparse extent is present. */
+    for (unsigned i = 0; i < pImage->cExtents; i++)
+    {
+        pExtent = &pImage->pExtents[i];
+        if (pExtent->enmType == VMDKETYPE_HOSTED_SPARSE)
+        {
+            /* Allocate grain table cache. */
+            pImage->pGTCache = (PVMDKGTCACHE)RTMemAllocZ(sizeof(VMDKGTCACHE));
+            if (!pImage->pGTCache)
+                return VERR_NO_MEMORY;
+            for (unsigned j = 0; j < VMDK_GT_CACHE_SIZE; j++)
+            {
+                PVMDKGTCACHEENTRY pGCE = &pImage->pGTCache->aGTCache[j];
+                pGCE->uExtent = UINT32_MAX;
+            }
+            pImage->pGTCache->cEntries = VMDK_GT_CACHE_SIZE;
+            break;
+        }
+    }
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Internal: allocate the given number of extents.
+ */
+static int vmdkCreateExtents(PVMDKIMAGE pImage, unsigned cExtents)
+{
+    int rc = VINF_SUCCESS;
+    PVMDKEXTENT pExtents = (PVMDKEXTENT)RTMemAllocZ(cExtents * sizeof(VMDKEXTENT));
+    if (pExtents)
+    {
+        for (unsigned i = 0; i < cExtents; i++)
+        {
+            pExtents[i].pFile = NULL;
+            pExtents[i].pszBasename = NULL;
+            pExtents[i].pszFullname = NULL;
+            pExtents[i].pGD = NULL;
+            pExtents[i].pRGD = NULL;
+            pExtents[i].pDescData = NULL;
+            pExtents[i].uVersion = 1;
+            pExtents[i].uCompression = VMDK_COMPRESSION_NONE;
+            pExtents[i].uExtent = i;
+            pExtents[i].pImage = pImage;
+        }
+        pImage->pExtents = pExtents;
+        pImage->cExtents = cExtents;
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    return rc;
+}
+
+/**
+ * Internal: Create an additional file backed extent in split images.
+ * Supports split sparse and flat images.
+ *
+ * @returns VBox status code.
+ * @param   pImage              VMDK image instance.
+ * @param   cbSize              Desiried size in bytes of new extent.
+ */
+static int vmdkAddFileBackedExtent(PVMDKIMAGE pImage, uint64_t cbSize)
+{
+    int rc = VINF_SUCCESS;
+    unsigned uImageFlags = pImage->uImageFlags;
+
+    /* Check for unsupported image type. */
+    if ((uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX)
+        || (uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+        || (uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK))
+    {
+        return VERR_NOT_SUPPORTED;
+    }
+
+    /* Allocate array of extents and copy existing extents to it. */
+    PVMDKEXTENT pNewExtents = (PVMDKEXTENT)RTMemAllocZ((pImage->cExtents + 1) * sizeof(VMDKEXTENT));
+    if (!pNewExtents)
+    {
+        return VERR_NO_MEMORY;
+    }
+
+    memcpy(pNewExtents, pImage->pExtents, pImage->cExtents * sizeof(VMDKEXTENT));
+
+    /* Locate newly created extent and populate default metadata. */
+    PVMDKEXTENT pExtent = &pNewExtents[pImage->cExtents];
+
+    pExtent->pFile = NULL;
+    pExtent->pszBasename = NULL;
+    pExtent->pszFullname = NULL;
+    pExtent->pGD = NULL;
+    pExtent->pRGD = NULL;
+    pExtent->pDescData = NULL;
+    pExtent->uVersion = 1;
+    pExtent->uCompression = VMDK_COMPRESSION_NONE;
+    pExtent->uExtent = pImage->cExtents;
+    pExtent->pImage = pImage;
+    pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbSize);
+    pExtent->enmAccess = VMDKACCESS_READWRITE;
+    pExtent->uSectorOffset = 0;
+    pExtent->fMetaDirty = true;
+
+    /* Apply image type specific meta data. */
+    if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
+    {
+        pExtent->enmType = VMDKETYPE_FLAT;
+    }
+    else
+    {
+        uint64_t cSectorsPerGDE, cSectorsPerGD;
+        pExtent->enmType = VMDKETYPE_HOSTED_SPARSE;
+        pExtent->cSectors = VMDK_BYTE2SECTOR(RT_ALIGN_64(cbSize, _64K));
+        pExtent->cSectorsPerGrain = VMDK_BYTE2SECTOR(_64K);
+        pExtent->cGTEntries = 512;
+        cSectorsPerGDE = pExtent->cGTEntries * pExtent->cSectorsPerGrain;
+        pExtent->cSectorsPerGDE = cSectorsPerGDE;
+        pExtent->cGDEntries = (pExtent->cSectors + cSectorsPerGDE - 1) / cSectorsPerGDE;
+        cSectorsPerGD = (pExtent->cGDEntries + (512 / sizeof(uint32_t) - 1)) / (512 / sizeof(uint32_t));
+    }
+
+    /* Allocate and set file name for extent. */
+    char *pszBasenameSubstr = RTPathFilename(pImage->pszFilename);
+    AssertPtr(pszBasenameSubstr);
+
+    char *pszBasenameSuff = RTPathSuffix(pszBasenameSubstr);
+    char *pszBasenameBase = RTStrDup(pszBasenameSubstr);
+    RTPathStripSuffix(pszBasenameBase);
+    char *pszTmp;
+    size_t cbTmp;
+
+    if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
+        RTStrAPrintf(&pszTmp, "%s-f%03d%s", pszBasenameBase,
+                        pExtent->uExtent + 1, pszBasenameSuff);
+    else
+        RTStrAPrintf(&pszTmp, "%s-s%03d%s", pszBasenameBase, pExtent->uExtent + 1,
+                        pszBasenameSuff);
+
+    RTStrFree(pszBasenameBase);
+    if (!pszTmp)
+        return VERR_NO_STR_MEMORY;
+    cbTmp = strlen(pszTmp) + 1;
+    char *pszBasename = (char *)RTMemTmpAlloc(cbTmp);
+    if (!pszBasename)
+    {
+        RTStrFree(pszTmp);
+        return VERR_NO_MEMORY;
+    }
+
+    memcpy(pszBasename, pszTmp, cbTmp);
+    RTStrFree(pszTmp);
+
+    pExtent->pszBasename = pszBasename;
+
+    char *pszBasedirectory = RTStrDup(pImage->pszFilename);
+    if (!pszBasedirectory)
+        return VERR_NO_STR_MEMORY;
+    RTPathStripFilename(pszBasedirectory);
+    char *pszFullname = RTPathJoinA(pszBasedirectory, pExtent->pszBasename);
+    RTStrFree(pszBasedirectory);
+    if (!pszFullname)
+        return VERR_NO_STR_MEMORY;
+    pExtent->pszFullname = pszFullname;
+
+    /* Create file for extent. */
+    rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
+                        VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
+                                                    true /* fCreate */));
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pExtent->pszFullname);
+
+    if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
+    {
+        /* For flat images: Pre allocate file space. */
+        rc = vdIfIoIntFileSetAllocationSize(pImage->pIfIo, pExtent->pFile->pStorage, cbSize,
+                                            0 /* fFlags */, NULL, 0, 0);
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set size of new file '%s'"), pExtent->pszFullname);
+    }
+    else
+    {
+        /* For sparse images: Allocate new grain directories/tables. */
+        /* fPreAlloc should never be false because VMware can't use such images. */
+        rc = vmdkCreateGrainDirectory(pImage, pExtent,
+                                      RT_MAX( pExtent->uDescriptorSector
+                                              + pExtent->cDescriptorSectors,
+                                              1),
+                                      true /* fPreAlloc */);
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new grain directory in '%s'"), pExtent->pszFullname);
+    }
+
+    /* Insert new extent into descriptor file. */
+    rc = vmdkDescExtInsert(pImage, &pImage->Descriptor, pExtent->enmAccess,
+                           pExtent->cNominalSectors, pExtent->enmType,
+                           pExtent->pszBasename, pExtent->uSectorOffset);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not insert the extent list into descriptor in '%s'"), pImage->pszFilename);
+
+    pImage->pExtents = pNewExtents;
+    pImage->cExtents++;
+
+    return rc;
+}
+
+/**
+ * Reads and processes the descriptor embedded in sparse images.
+ *
+ * @returns VBox status code.
+ * @param   pImage         VMDK image instance.
+ * @param   pFile          The sparse file handle.
+ */
+static int vmdkDescriptorReadSparse(PVMDKIMAGE pImage, PVMDKFILE pFile)
+{
+    /* It's a hosted single-extent image. */
+    int rc = vmdkCreateExtents(pImage, 1);
+    if (RT_SUCCESS(rc))
+    {
+        /* The opened file is passed to the extent. No separate descriptor
+         * file, so no need to keep anything open for the image. */
+        PVMDKEXTENT pExtent = &pImage->pExtents[0];
+        pExtent->pFile = pFile;
+        pImage->pFile = NULL;
+        pExtent->pszFullname = RTPathAbsDup(pImage->pszFilename);
+        if (RT_LIKELY(pExtent->pszFullname))
+        {
+            /* As we're dealing with a monolithic image here, there must
+             * be a descriptor embedded in the image file. */
+            rc = vmdkReadBinaryMetaExtent(pImage, pExtent, true /* fMagicAlreadyRead */);
+            if (   RT_SUCCESS(rc)
+                && pExtent->uDescriptorSector
+                && pExtent->cDescriptorSectors)
+            {
+                /* HACK: extend the descriptor if it is unusually small and it fits in
+                 * the unused space after the image header. Allows opening VMDK files
+                 * with extremely small descriptor in read/write mode.
+                 *
+                 * The previous version introduced a possible regression for VMDK stream
+                 * optimized images from VMware which tend to have only a single sector sized
+                 * descriptor. Increasing the descriptor size resulted in adding the various uuid
+                 * entries required to make it work with VBox but for stream optimized images
+                 * the updated binary header wasn't written to the disk creating a mismatch
+                 * between advertised and real descriptor size.
+                 *
+                 * The descriptor size will be increased even if opened readonly now if there
+                 * enough room but the new value will not be written back to the image.
+                 */
+                if (    pExtent->cDescriptorSectors < 3
+                    &&  (int64_t)pExtent->uSectorGD - pExtent->uDescriptorSector >= 4
+                    &&  (!pExtent->uSectorRGD || (int64_t)pExtent->uSectorRGD - pExtent->uDescriptorSector >= 4))
+                {
+                    uint64_t cDescriptorSectorsOld = pExtent->cDescriptorSectors;
+
+                    pExtent->cDescriptorSectors = 4;
+                    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+                    {
+                        /*
+                         * Update the on disk number now to make sure we don't introduce inconsistencies
+                         * in case of stream optimized images from VMware where the descriptor is just
+                         * one sector big (the binary header is not written to disk for complete
+                         * stream optimized images in vmdkFlushImage()).
+                         */
+                        uint64_t u64DescSizeNew = RT_H2LE_U64(pExtent->cDescriptorSectors);
+                        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pFile->pStorage,
+                                                    RT_UOFFSETOF(SparseExtentHeader, descriptorSize),
+                                                    &u64DescSizeNew, sizeof(u64DescSizeNew));
+                        if (RT_FAILURE(rc))
+                        {
+                            LogFlowFunc(("Increasing the descriptor size failed with %Rrc\n", rc));
+                            /* Restore the old size and carry on. */
+                            pExtent->cDescriptorSectors = cDescriptorSectorsOld;
+                        }
+                    }
+                }
+                /* Read the descriptor from the extent. */
+                pExtent->pDescData = (char *)RTMemAllocZ(VMDK_SECTOR2BYTE(pExtent->cDescriptorSectors));
+                if (RT_LIKELY(pExtent->pDescData))
+                {
+                    rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                               VMDK_SECTOR2BYTE(pExtent->uDescriptorSector),
+                                               pExtent->pDescData,
+                                               VMDK_SECTOR2BYTE(pExtent->cDescriptorSectors));
+                    if (RT_SUCCESS(rc))
+                    {
+                        rc = vmdkParseDescriptor(pImage, pExtent->pDescData,
+                                                 VMDK_SECTOR2BYTE(pExtent->cDescriptorSectors));
+                        if (   RT_SUCCESS(rc)
+                            && (   !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+                                || !(pImage->uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO)))
+                        {
+                            rc = vmdkReadMetaExtent(pImage, pExtent);
+                            if (RT_SUCCESS(rc))
+                            {
+                                /* Mark the extent as unclean if opened in read-write mode. */
+                                if (   !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                                    && !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
+                                {
+                                    pExtent->fUncleanShutdown = true;
+                                    pExtent->fMetaDirty = true;
+                                }
+                            }
+                        }
+                        else if (RT_SUCCESS(rc))
+                            rc = VERR_NOT_SUPPORTED;
+                    }
+                    else
+                        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: read error for descriptor in '%s'"), pExtent->pszFullname);
+                }
+                else
+                    rc = VERR_NO_MEMORY;
+            }
+            else if (RT_SUCCESS(rc))
+                rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: monolithic image without descriptor in '%s'"), pImage->pszFilename);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    return rc;
+}
+
+/**
+ * Reads the descriptor from a pure text file.
+ *
+ * @returns VBox status code.
+ * @param   pImage          VMDK image instance.
+ * @param   pFile           The descriptor file handle.
+ */
+static int vmdkDescriptorReadAscii(PVMDKIMAGE pImage, PVMDKFILE pFile)
+{
+    /* Allocate at least 10K, and make sure that there is 5K free space
+     * in case new entries need to be added to the descriptor. Never
+     * allocate more than 128K, because that's no valid descriptor file
+     * and will result in the correct "truncated read" error handling. */
+    uint64_t cbFileSize;
+    int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pFile->pStorage, &cbFileSize);
+    if (   RT_SUCCESS(rc)
+        && cbFileSize >= 50)
+    {
+        uint64_t cbSize = cbFileSize;
+        if (cbSize % VMDK_SECTOR2BYTE(10))
+            cbSize += VMDK_SECTOR2BYTE(20) - cbSize % VMDK_SECTOR2BYTE(10);
+        else
+            cbSize += VMDK_SECTOR2BYTE(10);
+        cbSize = RT_MIN(cbSize, _128K);
+        pImage->cbDescAlloc = RT_MAX(VMDK_SECTOR2BYTE(20), cbSize);
+        pImage->pDescData = (char *)RTMemAllocZ(pImage->cbDescAlloc);
+        if (RT_LIKELY(pImage->pDescData))
+        {
+            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pFile->pStorage, 0, pImage->pDescData,
+                                       RT_MIN(pImage->cbDescAlloc, cbFileSize));
+            if (RT_SUCCESS(rc))
+            {
+#if 0 /** @todo Revisit */
+                cbRead += sizeof(u32Magic);
+                if (cbRead == pImage->cbDescAlloc)
+                {
+                    /* Likely the read is truncated. Better fail a bit too early
+                     * (normally the descriptor is much smaller than our buffer). */
+                    rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: cannot read descriptor in '%s'"), pImage->pszFilename);
+                    goto out;
+                }
+#endif
+                rc = vmdkParseDescriptor(pImage, pImage->pDescData,
+                                         pImage->cbDescAlloc);
+                if (RT_SUCCESS(rc))
+                {
+                    for (unsigned i = 0; i < pImage->cExtents && RT_SUCCESS(rc); i++)
+                    {
+                        PVMDKEXTENT pExtent = &pImage->pExtents[i];
+                        if (pExtent->pszBasename)
+                        {
+                            /* Hack to figure out whether the specified name in the
+                             * extent descriptor is absolute. Doesn't always work, but
+                             * should be good enough for now. */
+                            char *pszFullname;
+                            /** @todo implement proper path absolute check. */
+                            if (pExtent->pszBasename[0] == RTPATH_SLASH)
+                            {
+                                pszFullname = RTStrDup(pExtent->pszBasename);
+                                if (!pszFullname)
+                                {
+                                    rc = VERR_NO_MEMORY;
+                                    break;
+                                }
+                            }
+                            else
+                            {
+                                char *pszDirname = RTStrDup(pImage->pszFilename);
+                                if (!pszDirname)
+                                {
+                                    rc = VERR_NO_MEMORY;
+                                    break;
+                                }
+                                RTPathStripFilename(pszDirname);
+                                pszFullname = RTPathJoinA(pszDirname, pExtent->pszBasename);
+                                RTStrFree(pszDirname);
+                                if (!pszFullname)
+                                {
+                                    rc = VERR_NO_STR_MEMORY;
+                                    break;
+                                }
+                            }
+                            pExtent->pszFullname = pszFullname;
+                        }
+                        else
+                            pExtent->pszFullname = NULL;
+
+                        unsigned uOpenFlags = pImage->uOpenFlags | ((pExtent->enmAccess == VMDKACCESS_READONLY) ? VD_OPEN_FLAGS_READONLY : 0);
+                        switch (pExtent->enmType)
+                        {
+                            case VMDKETYPE_HOSTED_SPARSE:
+                                rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
+                                                  VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */));
+                                if (RT_FAILURE(rc))
+                                {
+                                    /* Do NOT signal an appropriate error here, as the VD
+                                     * layer has the choice of retrying the open if it
+                                     * failed. */
+                                    break;
+                                }
+                                rc = vmdkReadBinaryMetaExtent(pImage, pExtent,
+                                                              false /* fMagicAlreadyRead */);
+                                if (RT_FAILURE(rc))
+                                    break;
+                                rc = vmdkReadMetaExtent(pImage, pExtent);
+                                if (RT_FAILURE(rc))
+                                    break;
+
+                                /* Mark extent as unclean if opened in read-write mode. */
+                                if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+                                {
+                                    pExtent->fUncleanShutdown = true;
+                                    pExtent->fMetaDirty = true;
+                                }
+                                break;
+                            case VMDKETYPE_VMFS:
+                            case VMDKETYPE_FLAT:
+                                rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
+                                                  VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */));
+                                if (RT_FAILURE(rc))
+                                {
+                                    /* Do NOT signal an appropriate error here, as the VD
+                                     * layer has the choice of retrying the open if it
+                                     * failed. */
+                                    break;
+                                }
+                                break;
+                            case VMDKETYPE_ZERO:
+                                /* Nothing to do. */
+                                break;
+                            default:
+                                AssertMsgFailed(("unknown vmdk extent type %d\n", pExtent->enmType));
+                        }
+                    }
+                }
+            }
+            else
+                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: read error for descriptor in '%s'"), pImage->pszFilename);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+    else if (RT_SUCCESS(rc))
+        rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS, N_("VMDK: descriptor in '%s' is too short"), pImage->pszFilename);
+
+    return rc;
+}
+
+/**
+ * Read and process the descriptor based on the image type.
+ *
+ * @returns VBox status code.
+ * @param   pImage    VMDK image instance.
+ * @param   pFile     VMDK file handle.
+ */
+static int vmdkDescriptorRead(PVMDKIMAGE pImage, PVMDKFILE pFile)
+{
+    uint32_t u32Magic;
+
+    /* Read magic (if present). */
+    int rc = vdIfIoIntFileReadSync(pImage->pIfIo, pFile->pStorage, 0,
+                                   &u32Magic, sizeof(u32Magic));
+    if (RT_SUCCESS(rc))
+    {
+        /* Handle the file according to its magic number. */
+        if (RT_LE2H_U32(u32Magic) == VMDK_SPARSE_MAGICNUMBER)
+            rc = vmdkDescriptorReadSparse(pImage, pFile);
+        else
+            rc = vmdkDescriptorReadAscii(pImage, pFile);
+    }
+    else
+    {
+        vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error reading the magic number in '%s'"), pImage->pszFilename);
+        rc = VERR_VD_VMDK_INVALID_HEADER;
+    }
+
+    return rc;
+}
+
+/**
+ * Internal: Open an image, constructing all necessary data structures.
+ */
+static int vmdkOpenImage(PVMDKIMAGE pImage, unsigned uOpenFlags)
+{
+    pImage->uOpenFlags = uOpenFlags;
+    pImage->pIfError   = VDIfErrorGet(pImage->pVDIfsDisk);
+    pImage->pIfIo      = VDIfIoIntGet(pImage->pVDIfsImage);
+    AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
+
+    /*
+     * Open the image.
+     * We don't have to check for asynchronous access because
+     * we only support raw access and the opened file is a description
+     * file were no data is stored.
+     */
+    PVMDKFILE pFile;
+    int rc = vmdkFileOpen(pImage, &pFile, NULL, pImage->pszFilename,
+                          VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */));
+    if (RT_SUCCESS(rc))
+    {
+        pImage->pFile = pFile;
+
+        rc = vmdkDescriptorRead(pImage, pFile);
+        if (RT_SUCCESS(rc))
+        {
+            /* Determine PCHS geometry if not set. */
+            if (pImage->PCHSGeometry.cCylinders == 0)
+            {
+                uint64_t cCylinders =   VMDK_BYTE2SECTOR(pImage->cbSize)
+                                      / pImage->PCHSGeometry.cHeads
+                                      / pImage->PCHSGeometry.cSectors;
+                pImage->PCHSGeometry.cCylinders = (unsigned)RT_MIN(cCylinders, 16383);
+                if (   !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                    && !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
+                {
+                    rc = vmdkDescSetPCHSGeometry(pImage, &pImage->PCHSGeometry);
+                    AssertRC(rc);
+                }
+            }
+
+            /* Update the image metadata now in case has changed. */
+            rc = vmdkFlushImage(pImage, NULL);
+            if (RT_SUCCESS(rc))
+            {
+                /* Figure out a few per-image constants from the extents. */
+                pImage->cbSize = 0;
+                for (unsigned i = 0; i < pImage->cExtents; i++)
+                {
+                    PVMDKEXTENT pExtent = &pImage->pExtents[i];
+                    if (pExtent->enmType == VMDKETYPE_HOSTED_SPARSE)
+                    {
+                        /* Here used to be a check whether the nominal size of an extent
+                         * is a multiple of the grain size. The spec says that this is
+                         * always the case, but unfortunately some files out there in the
+                         * wild violate the spec (e.g. ReactOS 0.3.1). */
+                    }
+                    else if (    pExtent->enmType == VMDKETYPE_FLAT
+                             ||  pExtent->enmType == VMDKETYPE_ZERO)
+                        pImage->uImageFlags |= VD_IMAGE_FLAGS_FIXED;
+
+                    pImage->cbSize += VMDK_SECTOR2BYTE(pExtent->cNominalSectors);
+                }
+
+                if (   !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+                    || !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                    || !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL))
+                    rc = vmdkAllocateGrainTableCache(pImage);
+            }
+        }
+    }
+    /* else: Do NOT signal an appropriate error here, as the VD layer has the
+     *       choice of retrying the open if it failed. */
+
+    if (RT_SUCCESS(rc))
+    {
+        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
+        pImage->RegionList.fFlags   = 0;
+        pImage->RegionList.cRegions = 1;
+
+        pRegion->offRegion            = 0; /* Disk start. */
+        pRegion->cbBlock              = 512;
+        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
+        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
+        pRegion->cbData               = 512;
+        pRegion->cbMetadata           = 0;
+        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
+    }
+    else
+        vmdkFreeImage(pImage, false, false /*fFlush*/); /* Don't try to flush anything if opening failed. */
+    return rc;
+}
+
+/**
+ * Frees a raw descriptor.
+ * @internal
+ */
+static int vmdkRawDescFree(PVDISKRAW pRawDesc)
+{
+    if (!pRawDesc)
+        return VINF_SUCCESS;
+
+    RTStrFree(pRawDesc->pszRawDisk);
+    pRawDesc->pszRawDisk = NULL;
+
+    /* Partitions: */
+    for (unsigned i = 0; i < pRawDesc->cPartDescs; i++)
+    {
+        RTStrFree(pRawDesc->pPartDescs[i].pszRawDevice);
+        pRawDesc->pPartDescs[i].pszRawDevice = NULL;
+
+        RTMemFree(pRawDesc->pPartDescs[i].pvPartitionData);
+        pRawDesc->pPartDescs[i].pvPartitionData = NULL;
+    }
+
+    RTMemFree(pRawDesc->pPartDescs);
+    pRawDesc->pPartDescs = NULL;
+
+    RTMemFree(pRawDesc);
+    return VINF_SUCCESS;
+}
+
+/**
+ * Helper that grows the raw partition descriptor table by @a cToAdd entries,
+ * returning the pointer to the first new entry.
+ * @internal
+ */
+static int vmdkRawDescAppendPartDesc(PVMDKIMAGE pImage, PVDISKRAW pRawDesc, uint32_t cToAdd, PVDISKRAWPARTDESC *ppRet)
+{
+    uint32_t const    cOld = pRawDesc->cPartDescs;
+    uint32_t const    cNew   = cOld + cToAdd;
+    PVDISKRAWPARTDESC paNew = (PVDISKRAWPARTDESC)RTMemReallocZ(pRawDesc->pPartDescs,
+                                                               cOld * sizeof(pRawDesc->pPartDescs[0]),
+                                                               cNew * sizeof(pRawDesc->pPartDescs[0]));
+    if (paNew)
+    {
+        pRawDesc->cPartDescs = cNew;
+        pRawDesc->pPartDescs = paNew;
+
+        *ppRet = &paNew[cOld];
+        return VINF_SUCCESS;
+    }
+    *ppRet = NULL;
+    return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
+                     N_("VMDK: Image path: '%s'. Out of memory growing the partition descriptors (%u -> %u)."),
+                     pImage->pszFilename, cOld, cNew);
+}
+
+/**
+ * @callback_method_impl{FNRTSORTCMP}
+ */
+static DECLCALLBACK(int) vmdkRawDescPartComp(void const *pvElement1, void const *pvElement2, void *pvUser)
+{
+    RT_NOREF(pvUser);
+    int64_t const iDelta = ((PVDISKRAWPARTDESC)pvElement1)->offStartInVDisk - ((PVDISKRAWPARTDESC)pvElement2)->offStartInVDisk;
+    return iDelta < 0 ? -1 : iDelta > 0 ? 1 : 0;
+}
+
+/**
+ * Post processes the partition descriptors.
+ *
+ * Sorts them and check that they don't overlap.
+ */
+static int vmdkRawDescPostProcessPartitions(PVMDKIMAGE pImage, PVDISKRAW pRawDesc, uint64_t cbSize)
+{
+    /*
+     * Sort data areas in ascending order of start.
+     */
+    RTSortShell(pRawDesc->pPartDescs, pRawDesc->cPartDescs, sizeof(pRawDesc->pPartDescs[0]), vmdkRawDescPartComp, NULL);
+
+    /*
+     * Check that we don't have overlapping descriptors.  If we do, that's an
+     * indication that the drive is corrupt or that the RTDvm code is buggy.
+     */
+    VDISKRAWPARTDESC const *paPartDescs = pRawDesc->pPartDescs;
+    for (uint32_t i = 0; i < pRawDesc->cPartDescs; i++)
+    {
+        uint64_t offLast = paPartDescs[i].offStartInVDisk + paPartDescs[i].cbData;
+        if (offLast <= paPartDescs[i].offStartInVDisk)
+            return vdIfError(pImage->pIfError, VERR_FILESYSTEM_CORRUPT /*?*/, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. Bogus partition descriptor #%u (%#RX64 LB %#RX64%s): Wrap around or zero"),
+                             pImage->pszFilename, i, paPartDescs[i].offStartInVDisk, paPartDescs[i].cbData,
+                             paPartDescs[i].pvPartitionData ? " (data)" : "");
+        offLast -= 1;
+
+        if (i + 1 < pRawDesc->cPartDescs && offLast >= paPartDescs[i + 1].offStartInVDisk)
+            return vdIfError(pImage->pIfError, VERR_FILESYSTEM_CORRUPT /*?*/, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. Partition descriptor #%u (%#RX64 LB %#RX64%s) overlaps with the next (%#RX64 LB %#RX64%s)"),
+                             pImage->pszFilename, i, paPartDescs[i].offStartInVDisk, paPartDescs[i].cbData,
+                             paPartDescs[i].pvPartitionData ? " (data)" : "", paPartDescs[i + 1].offStartInVDisk,
+                             paPartDescs[i + 1].cbData, paPartDescs[i + 1].pvPartitionData ? " (data)" : "");
+        if (offLast >= cbSize)
+            return vdIfError(pImage->pIfError, VERR_FILESYSTEM_CORRUPT /*?*/, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. Partition descriptor #%u (%#RX64 LB %#RX64%s) goes beyond the end of the drive (%#RX64)"),
+                             pImage->pszFilename, i, paPartDescs[i].offStartInVDisk, paPartDescs[i].cbData,
+                             paPartDescs[i].pvPartitionData ? " (data)" : "", cbSize);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+#ifdef RT_OS_LINUX
+/**
+ * Searches the dir specified in @a pszBlockDevDir for subdirectories with a
+ * 'dev' file matching @a uDevToLocate.
+ *
+ * This is used both
+ *
+ * @returns IPRT status code, errors have been reported properly.
+ * @param   pImage          For error reporting.
+ * @param   pszBlockDevDir  Input: Path to the directory search under.
+ *                          Output: Path to the directory containing information
+ *                          for @a uDevToLocate.
+ * @param   cbBlockDevDir   The size of the buffer @a pszBlockDevDir points to.
+ * @param   uDevToLocate    The device number of the block device info dir to
+ *                          locate.
+ * @param   pszDevToLocate  For error reporting.
+ */
+static int vmdkFindSysBlockDevPath(PVMDKIMAGE pImage, char *pszBlockDevDir, size_t cbBlockDevDir,
+                                   dev_t uDevToLocate, const char *pszDevToLocate)
+{
+    size_t const cchDir = RTPathEnsureTrailingSeparator(pszBlockDevDir, cbBlockDevDir);
+    AssertReturn(cchDir > 0, VERR_BUFFER_OVERFLOW);
+
+    RTDIR hDir = NIL_RTDIR;
+    int rc = RTDirOpen(&hDir, pszBlockDevDir);
+    if (RT_SUCCESS(rc))
+    {
+        for (;;)
+        {
+            RTDIRENTRY Entry;
+            rc = RTDirRead(hDir, &Entry, NULL);
+            if (RT_SUCCESS(rc))
+            {
+                /* We're interested in directories and symlinks. */
+                if (   Entry.enmType == RTDIRENTRYTYPE_DIRECTORY
+                    || Entry.enmType == RTDIRENTRYTYPE_SYMLINK
+                    || Entry.enmType == RTDIRENTRYTYPE_UNKNOWN)
+                {
+                    rc = RTStrCopy(&pszBlockDevDir[cchDir], cbBlockDevDir - cchDir, Entry.szName);
+                    AssertContinue(RT_SUCCESS(rc)); /* should not happen! */
+
+                    dev_t uThisDevNo = ~uDevToLocate;
+                    rc = RTLinuxSysFsReadDevNumFile(&uThisDevNo, "%s/dev", pszBlockDevDir);
+                    if (RT_SUCCESS(rc) && uThisDevNo == uDevToLocate)
+                        break;
+                }
+            }
+            else
+            {
+                pszBlockDevDir[cchDir] = '\0';
+                if (rc == VERR_NO_MORE_FILES)
+                    rc = vdIfError(pImage->pIfError, VERR_NOT_FOUND, RT_SRC_POS,
+                                   N_("VMDK: Image path: '%s'. Failed to locate device corresponding to '%s' under '%s'"),
+                                   pImage->pszFilename, pszDevToLocate, pszBlockDevDir);
+                else
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                   N_("VMDK: Image path: '%s'. RTDirRead failed enumerating '%s': %Rrc"),
+                                   pImage->pszFilename, pszBlockDevDir, rc);
+                break;
+            }
+        }
+        RTDirClose(hDir);
+    }
+    else
+        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. Failed to open dir '%s' for listing: %Rrc"),
+                       pImage->pszFilename, pszBlockDevDir, rc);
+    return rc;
+}
+#endif /* RT_OS_LINUX */
+
+#ifdef RT_OS_FREEBSD
+
+
+/**
+ * Reads the config data from the provider and returns offset and size
+ *
+ * @return IPRT status code
+ * @param pProvider   GEOM provider representing partition
+ * @param pcbOffset   Placeholder for the offset of the partition
+ * @param pcbSize     Placeholder for the size of the partition
+ */
+static int vmdkReadPartitionsParamsFromProvider(gprovider *pProvider, uint64_t *pcbOffset, uint64_t *pcbSize)
+{
+    gconfig *pConfEntry;
+    int rc = VERR_NOT_FOUND;
+
+    /*
+     * Required parameters are located in the list containing key/value pairs.
+     * Both key and value are in text form. Manuals tells nothing about the fact
+     * that the both parameters should be present in the list. Thus, there are
+     * cases when only one parameter is presented. To handle such cases we treat
+     * absent params as zero allowing the caller decide the case is either correct
+     * or an error.
+     */
+    uint64_t cbOffset = 0;
+    uint64_t cbSize = 0;
+    LIST_FOREACH(pConfEntry, &pProvider->lg_config, lg_config)
+    {
+        if (RTStrCmp(pConfEntry->lg_name, "offset") == 0)
+        {
+            cbOffset = RTStrToUInt64(pConfEntry->lg_val);
+            rc = VINF_SUCCESS;
+        }
+        else if (RTStrCmp(pConfEntry->lg_name, "length") == 0)
+        {
+            cbSize = RTStrToUInt64(pConfEntry->lg_val);
+            rc = VINF_SUCCESS;
+        }
+    }
+    if (RT_SUCCESS(rc))
+    {
+        *pcbOffset = cbOffset;
+        *pcbSize = cbSize;
+    }
+    return rc;
+}
+
+
+/**
+ * Searches the partition specified by name and calculates its size and absolute offset.
+ *
+ * @return IPRT status code.
+ * @param pParentClass       Class containing pParentGeom
+ * @param pszParentGeomName  Name of the parent geom where we are looking for provider
+ * @param pszProviderName    Name of the provider we are looking for
+ * @param pcbAbsoluteOffset  Placeholder for the absolute offset of the partition, i.e. offset from the beginning of the disk
+ * @param psbSize            Placeholder for the size of the partition.
+ */
+static int vmdkFindPartitionParamsByName(gclass *pParentClass, const char *pszParentGeomName, const char *pszProviderName,
+                                         uint64_t *pcbAbsoluteOffset, uint64_t *pcbSize)
+{
+    AssertReturn(pParentClass,       VERR_INVALID_PARAMETER);
+    AssertReturn(pszParentGeomName,  VERR_INVALID_PARAMETER);
+    AssertReturn(pszProviderName,    VERR_INVALID_PARAMETER);
+    AssertReturn(pcbAbsoluteOffset,  VERR_INVALID_PARAMETER);
+    AssertReturn(pcbSize,            VERR_INVALID_PARAMETER);
+
+    ggeom *pParentGeom;
+    int rc = VERR_NOT_FOUND;
+    LIST_FOREACH(pParentGeom, &pParentClass->lg_geom, lg_geom)
+    {
+        if (RTStrCmp(pParentGeom->lg_name, pszParentGeomName) == 0)
+        {
+            rc = VINF_SUCCESS;
+            break;
+        }
+    }
+    if (RT_FAILURE(rc))
+        return rc;
+
+    gprovider *pProvider;
+    /*
+     * First, go over providers without handling EBR or BSDLabel
+     * partitions for case when looking provider is child
+     * of the givng geom, to reduce searching time
+     */
+    LIST_FOREACH(pProvider, &pParentGeom->lg_provider, lg_provider)
+    {
+        if (RTStrCmp(pProvider->lg_name, pszProviderName) == 0)
+            return vmdkReadPartitionsParamsFromProvider(pProvider, pcbAbsoluteOffset, pcbSize);
+    }
+
+    /*
+     * No provider found. Go over the parent geom again
+     * and make recursions if geom represents EBR or BSDLabel.
+     * In this case given parent geom contains only EBR or BSDLabel
+     * partition itself and their own partitions are in the separate
+     * geoms. Also, partition offsets are relative to geom, so
+     * we have to add offset from child provider with parent geoms
+     * provider
+     */
+
+    LIST_FOREACH(pProvider, &pParentGeom->lg_provider, lg_provider)
+    {
+        uint64_t cbOffset = 0;
+        uint64_t cbSize = 0;
+        rc = vmdkReadPartitionsParamsFromProvider(pProvider, &cbOffset, &cbSize);
+        if (RT_FAILURE(rc))
+            return rc;
+
+        uint64_t cbProviderOffset = 0;
+        uint64_t cbProviderSize = 0;
+        rc = vmdkFindPartitionParamsByName(pParentClass, pProvider->lg_name, pszProviderName, &cbProviderOffset, &cbProviderSize);
+        if (RT_SUCCESS(rc))
+        {
+            *pcbAbsoluteOffset = cbOffset + cbProviderOffset;
+            *pcbSize = cbProviderSize;
+            return rc;
+        }
+    }
+
+    return VERR_NOT_FOUND;
+}
+#endif
+
+
+/**
+ * Attempts to verify the raw partition path.
+ *
+ * We don't want to trust RTDvm and the partition device node morphing blindly.
+ */
+static int vmdkRawDescVerifyPartitionPath(PVMDKIMAGE pImage, PVDISKRAWPARTDESC pPartDesc, uint32_t idxPartition,
+                                          const char *pszRawDrive, RTFILE hRawDrive, uint32_t cbSector, RTDVMVOLUME hVol)
+{
+    RT_NOREF(pImage, pPartDesc, idxPartition, pszRawDrive, hRawDrive, cbSector, hVol);
+
+    /*
+     * Try open the raw partition device.
+     */
+    RTFILE hRawPart = NIL_RTFILE;
+    int rc = RTFileOpen(&hRawPart, pPartDesc->pszRawDevice, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                         N_("VMDK: Image path: '%s'. Failed to open partition #%u on '%s' via '%s' (%Rrc)"),
+                         pImage->pszFilename, idxPartition, pszRawDrive, pPartDesc->pszRawDevice, rc);
+
+    /*
+     * Compare the partition UUID if we can get it.
+     */
+#ifdef RT_OS_WINDOWS
+    DWORD cbReturned;
+
+    /* 1. Get the device numbers for both handles, they should have the same disk. */
+    STORAGE_DEVICE_NUMBER DevNum1;
+    RT_ZERO(DevNum1);
+    if (!DeviceIoControl((HANDLE)RTFileToNative(hRawDrive), IOCTL_STORAGE_GET_DEVICE_NUMBER,
+                         NULL /*pvInBuffer*/, 0 /*cbInBuffer*/, &DevNum1, sizeof(DevNum1), &cbReturned, NULL /*pOverlapped*/))
+        rc = vdIfError(pImage->pIfError, RTErrConvertFromWin32(GetLastError()), RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. IOCTL_STORAGE_GET_DEVICE_NUMBER failed on '%s': %u"),
+                       pImage->pszFilename, pszRawDrive, GetLastError());
+
+    STORAGE_DEVICE_NUMBER DevNum2;
+    RT_ZERO(DevNum2);
+    if (!DeviceIoControl((HANDLE)RTFileToNative(hRawPart), IOCTL_STORAGE_GET_DEVICE_NUMBER,
+                         NULL /*pvInBuffer*/, 0 /*cbInBuffer*/, &DevNum2, sizeof(DevNum2), &cbReturned, NULL /*pOverlapped*/))
+        rc = vdIfError(pImage->pIfError, RTErrConvertFromWin32(GetLastError()), RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. IOCTL_STORAGE_GET_DEVICE_NUMBER failed on '%s': %u"),
+                       pImage->pszFilename, pPartDesc->pszRawDevice, GetLastError());
+    if (   RT_SUCCESS(rc)
+        && (   DevNum1.DeviceNumber != DevNum2.DeviceNumber
+            || DevNum1.DeviceType   != DevNum2.DeviceType))
+        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s' (%#x != %#x || %#x != %#x)"),
+                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive,
+                       DevNum1.DeviceNumber, DevNum2.DeviceNumber, DevNum1.DeviceType, DevNum2.DeviceType);
+    if (RT_SUCCESS(rc))
+    {
+        /* Get the partitions from the raw drive and match up with the volume info
+           from RTDvm.  The partition number is found in DevNum2. */
+        DWORD cbNeeded = 0;
+        if (   DeviceIoControl((HANDLE)RTFileToNative(hRawDrive), IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
+                               NULL /*pvInBuffer*/, 0 /*cbInBuffer*/, NULL, 0, &cbNeeded, NULL /*pOverlapped*/)
+            || cbNeeded < RT_UOFFSETOF_DYN(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry[1]))
+            cbNeeded = RT_UOFFSETOF_DYN(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry[64]);
+        cbNeeded += sizeof(PARTITION_INFORMATION_EX) * 2; /* just in case */
+        DRIVE_LAYOUT_INFORMATION_EX *pLayout = (DRIVE_LAYOUT_INFORMATION_EX *)RTMemTmpAllocZ(cbNeeded);
+        if (pLayout)
+        {
+            cbReturned = 0;
+            if (DeviceIoControl((HANDLE)RTFileToNative(hRawDrive), IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
+                                NULL /*pvInBuffer*/, 0 /*cbInBuffer*/, pLayout, cbNeeded, &cbReturned, NULL /*pOverlapped*/))
+            {
+                /* Find the entry with the given partition number (it's not an index, array contains empty MBR entries ++). */
+                unsigned iEntry = 0;
+                while (   iEntry < pLayout->PartitionCount
+                       && pLayout->PartitionEntry[iEntry].PartitionNumber != DevNum2.PartitionNumber)
+                    iEntry++;
+                if (iEntry < pLayout->PartitionCount)
+                {
+                    /* Compare the basics */
+                    PARTITION_INFORMATION_EX const * const pLayoutEntry = &pLayout->PartitionEntry[iEntry];
+                    if (pLayoutEntry->StartingOffset.QuadPart != (int64_t)pPartDesc->offStartInVDisk)
+                        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': StartingOffset %RU64, expected %RU64"),
+                                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive,
+                                       pLayoutEntry->StartingOffset.QuadPart, pPartDesc->offStartInVDisk);
+                    else if (pLayoutEntry->PartitionLength.QuadPart != (int64_t)pPartDesc->cbData)
+                        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': PartitionLength %RU64, expected %RU64"),
+                                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive,
+                                       pLayoutEntry->PartitionLength.QuadPart, pPartDesc->cbData);
+                    /** @todo We could compare the MBR type, GPT type and ID. */
+                    RT_NOREF(hVol);
+                }
+                else
+                    rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                   N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': PartitionCount (%#x vs %#x)"),
+                                   pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive,
+                                   DevNum2.PartitionNumber, pLayout->PartitionCount);
+# ifndef LOG_ENABLED
+                if (RT_FAILURE(rc))
+# endif
+                {
+                    LogRel(("VMDK: Windows reports %u partitions for '%s':\n", pLayout->PartitionCount, pszRawDrive));
+                    PARTITION_INFORMATION_EX const *pEntry = &pLayout->PartitionEntry[0];
+                    for (DWORD i = 0; i < pLayout->PartitionCount; i++, pEntry++)
+                    {
+                        LogRel(("VMDK: #%u/%u: %016RU64 LB %016RU64 style=%d rewrite=%d",
+                                i, pEntry->PartitionNumber, pEntry->StartingOffset.QuadPart, pEntry->PartitionLength.QuadPart,
+                                pEntry->PartitionStyle, pEntry->RewritePartition));
+                        if (pEntry->PartitionStyle == PARTITION_STYLE_MBR)
+                            LogRel((" type=%#x boot=%d rec=%d hidden=%u\n", pEntry->Mbr.PartitionType, pEntry->Mbr.BootIndicator,
+                                    pEntry->Mbr.RecognizedPartition, pEntry->Mbr.HiddenSectors));
+                        else if (pEntry->PartitionStyle == PARTITION_STYLE_GPT)
+                            LogRel((" type=%RTuuid id=%RTuuid aatrib=%RX64 name=%.36ls\n", &pEntry->Gpt.PartitionType,
+                                    &pEntry->Gpt.PartitionId, pEntry->Gpt.Attributes, &pEntry->Gpt.Name[0]));
+                        else
+                            LogRel(("\n"));
+                    }
+                    LogRel(("VMDK: Looked for partition #%u (%u, '%s') at %RU64 LB %RU64\n", DevNum2.PartitionNumber,
+                            idxPartition, pPartDesc->pszRawDevice, pPartDesc->offStartInVDisk, pPartDesc->cbData));
+               }
+            }
+            else
+                rc = vdIfError(pImage->pIfError, RTErrConvertFromWin32(GetLastError()), RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'. IOCTL_DISK_GET_DRIVE_LAYOUT_EX failed on '%s': %u (cb %u, cbRet %u)"),
+                               pImage->pszFilename, pPartDesc->pszRawDevice, GetLastError(), cbNeeded, cbReturned);
+            RTMemTmpFree(pLayout);
+        }
+        else
+            rc = VERR_NO_TMP_MEMORY;
+    }
+
+#elif defined(RT_OS_LINUX)
+    RT_NOREF(hVol);
+
+    /* Stat the two devices first to get their device numbers.  (We probably
+       could make some assumptions here about the major & minor number assignments
+       for legacy nodes, but it doesn't hold up for nvme, so we'll skip that.) */
+    struct stat StDrive, StPart;
+    if (fstat((int)RTFileToNative(hRawDrive), &StDrive) != 0)
+        rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. fstat failed on '%s': %d"), pImage->pszFilename, pszRawDrive, errno);
+    else if (fstat((int)RTFileToNative(hRawPart), &StPart) != 0)
+        rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. fstat failed on '%s': %d"), pImage->pszFilename, pPartDesc->pszRawDevice, errno);
+    else
+    {
+        /* Scan the directories immediately under /sys/block/ for one with a
+           'dev' file matching the drive's device number: */
+        char szSysPath[RTPATH_MAX];
+        rc = RTLinuxConstructPath(szSysPath, sizeof(szSysPath), "block/");
+        AssertRCReturn(rc, rc); /* this shall not fail */
+        if (RTDirExists(szSysPath))
+        {
+            rc = vmdkFindSysBlockDevPath(pImage, szSysPath, sizeof(szSysPath), StDrive.st_rdev, pszRawDrive);
+
+            /* Now, scan the directories under that again for a partition device
+               matching the hRawPart device's number: */
+            if (RT_SUCCESS(rc))
+                rc = vmdkFindSysBlockDevPath(pImage, szSysPath, sizeof(szSysPath), StPart.st_rdev, pPartDesc->pszRawDevice);
+
+            /* Having found the /sys/block/device/partition/ path, we can finally
+               read the partition attributes and compare with hVol. */
+            if (RT_SUCCESS(rc))
+            {
+                /* partition number: */
+                int64_t iLnxPartition = 0;
+                rc = RTLinuxSysFsReadIntFile(10, &iLnxPartition, "%s/partition", szSysPath);
+                if (RT_SUCCESS(rc) && iLnxPartition != idxPartition)
+                    rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                   N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': Partition number %RI64, expected %RU32"),
+                                   pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, iLnxPartition, idxPartition);
+                /* else: ignore failure? */
+
+                /* start offset: */
+                uint32_t const cbLnxSector = 512; /* It's hardcoded in the Linux kernel */
+                if (RT_SUCCESS(rc))
+                {
+                    int64_t offLnxStart = -1;
+                    rc = RTLinuxSysFsReadIntFile(10, &offLnxStart, "%s/start", szSysPath);
+                    offLnxStart *= cbLnxSector;
+                    if (RT_SUCCESS(rc) && offLnxStart != (int64_t)pPartDesc->offStartInVDisk)
+                        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': Start offset %RI64, expected %RU64"),
+                                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, offLnxStart, pPartDesc->offStartInVDisk);
+                    /* else: ignore failure? */
+                }
+
+                /* the size: */
+                if (RT_SUCCESS(rc))
+                {
+                    int64_t cbLnxData = -1;
+                    rc = RTLinuxSysFsReadIntFile(10, &cbLnxData, "%s/size", szSysPath);
+                    cbLnxData *= cbLnxSector;
+                    if (RT_SUCCESS(rc) && cbLnxData != (int64_t)pPartDesc->cbData)
+                        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': Size %RI64, expected %RU64"),
+                                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, cbLnxData, pPartDesc->cbData);
+                    /* else: ignore failure? */
+                }
+            }
+        }
+        /* else: We've got nothing to work on, so only do content comparison. */
+    }
+
+#elif defined(RT_OS_FREEBSD)
+    char szDriveDevName[256];
+    char* pszDevName = fdevname_r(RTFileToNative(hRawDrive), szDriveDevName, 256);
+    if (pszDevName == NULL)
+        rc = vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. '%s' is not a drive path"), pImage->pszFilename, pszRawDrive);
+    char szPartDevName[256];
+    if (RT_SUCCESS(rc))
+    {
+        pszDevName = fdevname_r(RTFileToNative(hRawPart), szPartDevName, 256);
+        if (pszDevName == NULL)
+            rc = vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                           N_("VMDK: Image path: '%s'. '%s' is not a partition path"), pImage->pszFilename, pPartDesc->pszRawDevice);
+    }
+    if (RT_SUCCESS(rc))
+    {
+        gmesh geomMesh;
+        int err = geom_gettree(&geomMesh);
+        if (err == 0)
+        {
+            /* Find root class containg partitions info */
+            gclass* pPartClass;
+            LIST_FOREACH(pPartClass, &geomMesh.lg_class, lg_class)
+            {
+                if (RTStrCmp(pPartClass->lg_name, "PART") == 0)
+                    break;
+            }
+            if (pPartClass == NULL || RTStrCmp(pPartClass->lg_name, "PART") != 0)
+                rc = vdIfError(pImage->pIfError, VERR_GENERAL_FAILURE, RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'. 'PART' class not found in the GEOM tree"), pImage->pszFilename);
+
+
+            if (RT_SUCCESS(rc))
+            {
+                /* Find provider representing partition device */
+                uint64_t cbOffset;
+                uint64_t cbSize;
+                rc = vmdkFindPartitionParamsByName(pPartClass, szDriveDevName, szPartDevName, &cbOffset, &cbSize);
+                if (RT_SUCCESS(rc))
+                {
+                    if (cbOffset != pPartDesc->offStartInVDisk)
+                        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': Start offset %RU64, expected %RU64"),
+                                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, cbOffset, pPartDesc->offStartInVDisk);
+                    if (cbSize != pPartDesc->cbData)
+                        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': Size %RU64, expected %RU64"),
+                                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, cbSize, pPartDesc->cbData);
+                }
+                else
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                   N_("VMDK: Image path: '%s'. Error getting geom provider for the partition '%s' of the drive '%s' in the GEOM tree: %Rrc"),
+                                   pImage->pszFilename, pPartDesc->pszRawDevice, pszRawDrive, rc);
+            }
+
+            geom_deletetree(&geomMesh);
+        }
+        else
+            rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(err), RT_SRC_POS,
+                           N_("VMDK: Image path: '%s'. geom_gettree failed: %d"), pImage->pszFilename, err);
+    }
+
+#elif defined(RT_OS_SOLARIS)
+    RT_NOREF(hVol);
+
+    dk_cinfo dkiDriveInfo;
+    dk_cinfo dkiPartInfo;
+    if (ioctl(RTFileToNative(hRawDrive), DKIOCINFO, (caddr_t)&dkiDriveInfo) == -1)
+        rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. DKIOCINFO failed on '%s': %d"), pImage->pszFilename, pszRawDrive, errno);
+    else if (ioctl(RTFileToNative(hRawPart), DKIOCINFO, (caddr_t)&dkiPartInfo) == -1)
+        rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. DKIOCINFO failed on '%s': %d"), pImage->pszFilename, pszRawDrive, errno);
+    else if (  dkiDriveInfo.dki_ctype != dkiPartInfo.dki_ctype
+            || dkiDriveInfo.dki_cnum  != dkiPartInfo.dki_cnum
+            || dkiDriveInfo.dki_addr  != dkiPartInfo.dki_addr
+            || dkiDriveInfo.dki_unit  != dkiPartInfo.dki_unit
+            || dkiDriveInfo.dki_slave != dkiPartInfo.dki_slave)
+        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s' (%#x != %#x || %#x != %#x || %#x != %#x || %#x != %#x || %#x != %#x)"),
+                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive,
+                       dkiDriveInfo.dki_ctype, dkiPartInfo.dki_ctype, dkiDriveInfo.dki_cnum, dkiPartInfo.dki_cnum,
+                       dkiDriveInfo.dki_addr, dkiPartInfo.dki_addr, dkiDriveInfo.dki_unit, dkiPartInfo.dki_unit,
+                       dkiDriveInfo.dki_slave, dkiPartInfo.dki_slave);
+    else
+    {
+        uint64_t cbOffset = 0;
+        uint64_t cbSize = 0;
+        dk_gpt *pEfi = NULL;
+        int idxEfiPart = efi_alloc_and_read(RTFileToNative(hRawPart), &pEfi);
+        if (idxEfiPart >= 0)
+        {
+            if ((uint32_t)dkiPartInfo.dki_partition + 1 == idxPartition)
+            {
+                cbOffset = pEfi->efi_parts[idxEfiPart].p_start * pEfi->efi_lbasize;
+                cbSize   = pEfi->efi_parts[idxEfiPart].p_size  * pEfi->efi_lbasize;
+            }
+            else
+                rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'. Partition #%u number ('%s') verification failed on '%s' (%#x != %#x)"),
+                               pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive,
+                               idxPartition, (uint32_t)dkiPartInfo.dki_partition + 1);
+            efi_free(pEfi);
+        }
+        else
+        {
+            /*
+             * Manual says the efi_alloc_and_read returns VT_EINVAL if no EFI partition table found.
+             * Actually, the function returns any error, e.g. VT_ERROR. Thus, we are not sure, is it
+             * real error or just no EFI table found. Therefore, let's try to obtain partition info
+             * using another way. If there is an error, it returns errno which will be handled below.
+             */
+
+            uint32_t numPartition = (uint32_t)dkiPartInfo.dki_partition;
+            if (numPartition > NDKMAP)
+                numPartition -= NDKMAP;
+            if (numPartition != idxPartition)
+                rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'. Partition #%u number ('%s') verification failed on '%s' (%#x != %#x)"),
+                               pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive,
+                               idxPartition, numPartition);
+            else
+            {
+                dk_minfo_ext mediaInfo;
+                if (ioctl(RTFileToNative(hRawPart), DKIOCGMEDIAINFOEXT, (caddr_t)&mediaInfo) == -1)
+                    rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                                   N_("VMDK: Image path: '%s'. Partition #%u number ('%s') verification failed on '%s'. Can not obtain partition info: %d"),
+                                   pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, errno);
+                else
+                {
+                    extpart_info extPartInfo;
+                    if (ioctl(RTFileToNative(hRawPart), DKIOCEXTPARTINFO, (caddr_t)&extPartInfo) != -1)
+                    {
+                        cbOffset = (uint64_t)extPartInfo.p_start * mediaInfo.dki_lbsize;
+                        cbSize   = (uint64_t)extPartInfo.p_length * mediaInfo.dki_lbsize;
+                    }
+                    else
+                        rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Partition #%u number ('%s') verification failed on '%s'. Can not obtain partition info: %d"),
+                                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, errno);
+                }
+            }
+        }
+        if (RT_SUCCESS(rc) && cbOffset != pPartDesc->offStartInVDisk)
+            rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                           N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': Start offset %RI64, expected %RU64"),
+                           pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, cbOffset, pPartDesc->offStartInVDisk);
+
+        if (RT_SUCCESS(rc) && cbSize != pPartDesc->cbData)
+            rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                           N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': Size %RI64, expected %RU64"),
+                           pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, cbSize, pPartDesc->cbData);
+    }
+
+#elif defined(RT_OS_DARWIN)
+    /* Stat the drive get its device number. */
+    struct stat StDrive;
+    if (fstat((int)RTFileToNative(hRawDrive), &StDrive) != 0)
+        rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. fstat failed on '%s' (errno=%d)"), pImage->pszFilename, pszRawDrive, errno);
+    else
+    {
+        if (ioctl(RTFileToNative(hRawPart), DKIOCLOCKPHYSICALEXTENTS, NULL) == -1)
+            rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                           N_("VMDK: Image path: '%s'. Partition #%u number ('%s') verification failed on '%s': Unable to lock the partition (errno=%d)"),
+                           pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, errno);
+        else
+        {
+            uint32_t cbBlockSize = 0;
+            uint64_t cbOffset = 0;
+            uint64_t cbSize = 0;
+            if (ioctl(RTFileToNative(hRawPart), DKIOCGETBLOCKSIZE, (caddr_t)&cbBlockSize) == -1)
+                rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'. Partition #%u number ('%s') verification failed on '%s': Unable to obtain the sector size of the partition (errno=%d)"),
+                               pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, errno);
+            else if (ioctl(RTFileToNative(hRawPart), DKIOCGETBASE, (caddr_t)&cbOffset) == -1)
+                rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'. Partition #%u number ('%s') verification failed on '%s': Unable to obtain the start offset of the partition (errno=%d)"),
+                               pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, errno);
+            else if (ioctl(RTFileToNative(hRawPart), DKIOCGETBLOCKCOUNT, (caddr_t)&cbSize) == -1)
+                rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'. Partition #%u number ('%s') verification failed on '%s': Unable to obtain the size of the partition (errno=%d)"),
+                               pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, errno);
+            else
+            {
+                cbSize *= (uint64_t)cbBlockSize;
+                dk_physical_extent_t dkPartExtent = {0};
+                dkPartExtent.offset = 0;
+                dkPartExtent.length = cbSize;
+                if (ioctl(RTFileToNative(hRawPart), DKIOCGETPHYSICALEXTENT, (caddr_t)&dkPartExtent) == -1)
+                    rc = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                                   N_("VMDK: Image path: '%s'. Partition #%u number ('%s') verification failed on '%s': Unable to obtain partition info (errno=%d)"),
+                                   pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, errno);
+                else
+                {
+                    if (dkPartExtent.dev != StDrive.st_rdev)
+                        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': Drive does not contain the partition"),
+                                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive);
+                    else if (cbOffset != pPartDesc->offStartInVDisk)
+                        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': Start offset %RU64, expected %RU64"),
+                                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, cbOffset, pPartDesc->offStartInVDisk);
+                    else if (cbSize != pPartDesc->cbData)
+                        rc = vdIfError(pImage->pIfError, VERR_MISMATCH, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s': Size %RU64, expected %RU64"),
+                                       pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, cbSize, pPartDesc->cbData);
+                }
+            }
+
+            if (ioctl(RTFileToNative(hRawPart), DKIOCUNLOCKPHYSICALEXTENTS, NULL) == -1)
+            {
+                int rc2 = vdIfError(pImage->pIfError, RTErrConvertFromErrno(errno), RT_SRC_POS,
+                                    N_("VMDK: Image path: '%s'. Partition #%u number ('%s') verification failed on '%s': Unable to unlock the partition (errno=%d)"),
+                                    pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, errno);
+                if (RT_SUCCESS(rc))
+                    rc = rc2;
+            }
+        }
+    }
+
+#else
+    RT_NOREF(hVol); /* PORTME */
+    rc = VERR_NOT_SUPPORTED;
+#endif
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Compare the first 32 sectors of the partition.
+         *
+         * This might not be conclusive, but for partitions formatted with the more
+         * common file systems it should be as they have a superblock copy at or near
+         * the start of the partition (fat, fat32, ntfs, and ext4 does at least).
+         */
+        size_t const cbToCompare = (size_t)RT_MIN(pPartDesc->cbData / cbSector, 32) * cbSector;
+        uint8_t *pbSector1 = (uint8_t *)RTMemTmpAlloc(cbToCompare * 2);
+        if (pbSector1 != NULL)
+        {
+            uint8_t *pbSector2 = pbSector1 + cbToCompare;
+
+            /* Do the comparing, we repeat if it fails and the data might be volatile. */
+            uint64_t uPrevCrc1 = 0;
+            uint64_t uPrevCrc2 = 0;
+            uint32_t cStable   = 0;
+            for (unsigned iTry = 0; iTry < 256; iTry++)
+            {
+                rc = RTFileReadAt(hRawDrive, pPartDesc->offStartInVDisk, pbSector1, cbToCompare, NULL);
+                if (RT_SUCCESS(rc))
+                {
+                    rc = RTFileReadAt(hRawPart, pPartDesc->offStartInDevice, pbSector2, cbToCompare, NULL);
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (memcmp(pbSector1, pbSector2, cbToCompare) != 0)
+                        {
+                            rc = VERR_MISMATCH;
+
+                            /* Do data stability checks before repeating: */
+                            uint64_t const uCrc1 = RTCrc64(pbSector1, cbToCompare);
+                            uint64_t const uCrc2 = RTCrc64(pbSector2, cbToCompare);
+                            if (   uPrevCrc1 != uCrc1
+                                || uPrevCrc2 != uCrc2)
+                                cStable = 0;
+                            else if (++cStable > 4)
+                                break;
+                            uPrevCrc1 = uCrc1;
+                            uPrevCrc2 = uCrc2;
+                            continue;
+                        }
+                        rc = VINF_SUCCESS;
+                    }
+                    else
+                        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Error reading %zu bytes from '%s' at offset %RU64 (%Rrc)"),
+                                       pImage->pszFilename, cbToCompare, pPartDesc->pszRawDevice, pPartDesc->offStartInDevice, rc);
+                }
+                else
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                   N_("VMDK: Image path: '%s'. Error reading %zu bytes from '%s' at offset %RU64 (%Rrc)"),
+                                   pImage->pszFilename, cbToCompare, pszRawDrive, pPartDesc->offStartInVDisk, rc);
+                break;
+            }
+            if (rc == VERR_MISMATCH)
+            {
+                /* Find the first mismatching bytes: */
+                size_t offMissmatch = 0;
+                while (offMissmatch < cbToCompare && pbSector1[offMissmatch] == pbSector2[offMissmatch])
+                    offMissmatch++;
+                int cbSample = (int)RT_MIN(cbToCompare - offMissmatch, 16);
+
+                if (cStable > 0)
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                   N_("VMDK: Image path: '%s'. Partition #%u path ('%s') verification failed on '%s' (cStable=%d @%#zx: %.*Rhxs vs %.*Rhxs)"),
+                                   pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive, cStable,
+                                   offMissmatch, cbSample, &pbSector1[offMissmatch], cbSample, &pbSector2[offMissmatch]);
+                else
+                {
+                    LogRel(("VMDK: Image path: '%s'. Partition #%u path ('%s') verification undecided on '%s' because of unstable data! (@%#zx: %.*Rhxs vs %.*Rhxs)\n",
+                            pImage->pszFilename, idxPartition, pPartDesc->pszRawDevice, pszRawDrive,
+                            offMissmatch, cbSample, &pbSector1[offMissmatch], cbSample, &pbSector2[offMissmatch]));
+                    rc = -rc;
+                }
+            }
+
+            RTMemTmpFree(pbSector1);
+        }
+        else
+            rc = vdIfError(pImage->pIfError, VERR_NO_TMP_MEMORY, RT_SRC_POS,
+                           N_("VMDK: Image path: '%s'. Failed to allocate %zu bytes for a temporary read buffer\n"),
+                           pImage->pszFilename, cbToCompare * 2);
+    }
+    RTFileClose(hRawPart);
+    return rc;
+}
+
+#ifdef RT_OS_WINDOWS
+/**
+ * Construct the device name for the given partition number.
+ */
+static int vmdkRawDescWinMakePartitionName(PVMDKIMAGE pImage, const char *pszRawDrive, RTFILE hRawDrive, uint32_t idxPartition,
+                                           char **ppszRawPartition)
+{
+    int                   rc         = VINF_SUCCESS;
+    DWORD                 cbReturned = 0;
+    STORAGE_DEVICE_NUMBER DevNum;
+    RT_ZERO(DevNum);
+    if (DeviceIoControl((HANDLE)RTFileToNative(hRawDrive), IOCTL_STORAGE_GET_DEVICE_NUMBER,
+                        NULL /*pvInBuffer*/, 0 /*cbInBuffer*/, &DevNum, sizeof(DevNum), &cbReturned, NULL /*pOverlapped*/))
+        RTStrAPrintf(ppszRawPartition, "\\\\.\\Harddisk%uPartition%u", DevNum.DeviceNumber, idxPartition);
+    else
+        rc = vdIfError(pImage->pIfError, RTErrConvertFromWin32(GetLastError()), RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. IOCTL_STORAGE_GET_DEVICE_NUMBER failed on '%s': %u"),
+                       pImage->pszFilename, pszRawDrive, GetLastError());
+    return rc;
+}
+#endif /* RT_OS_WINDOWS */
+
+/**
+ * Worker for vmdkMakeRawDescriptor that adds partition descriptors when the
+ * 'Partitions' configuration value is present.
+ *
+ * @returns VBox status code, error message has been set on failure.
+ *
+ * @note    Caller is assumed to clean up @a pRawDesc and release
+ *          @a *phVolToRelease.
+ * @internal
+ */
+static int vmdkRawDescDoPartitions(PVMDKIMAGE pImage, RTDVM hVolMgr, PVDISKRAW pRawDesc,
+                                   RTFILE hRawDrive, const char *pszRawDrive, uint32_t cbSector,
+                                   uint32_t fPartitions, uint32_t fPartitionsReadOnly, bool fRelative,
+                                   PRTDVMVOLUME phVolToRelease)
+{
+    *phVolToRelease = NIL_RTDVMVOLUME;
+
+    /* Check sanity/understanding. */
+    Assert(fPartitions);
+    Assert((fPartitions & fPartitionsReadOnly) == fPartitionsReadOnly); /* RO should be a sub-set */
+
+    /*
+     * Allocate on descriptor for each volume up front.
+     */
+    uint32_t const cVolumes = RTDvmMapGetValidVolumes(hVolMgr);
+
+    PVDISKRAWPARTDESC paPartDescs = NULL;
+    int rc = vmdkRawDescAppendPartDesc(pImage, pRawDesc, cVolumes, &paPartDescs);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Enumerate the partitions (volumes) on the disk and create descriptors for each of them.
+     */
+    uint32_t    fPartitionsLeft = fPartitions;
+    RTDVMVOLUME hVol            = NIL_RTDVMVOLUME; /* the current volume, needed for getting the next. */
+    for (uint32_t i = 0; i < cVolumes; i++)
+    {
+        /*
+         * Get the next/first volume and release the current.
+         */
+        RTDVMVOLUME hVolNext = NIL_RTDVMVOLUME;
+        if (i == 0)
+            rc = RTDvmMapQueryFirstVolume(hVolMgr, &hVolNext);
+        else
+            rc = RTDvmMapQueryNextVolume(hVolMgr, hVol, &hVolNext);
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. Volume enumeration failed at volume #%u on '%s' (%Rrc)"),
+                             pImage->pszFilename, i, pszRawDrive, rc);
+        uint32_t cRefs = RTDvmVolumeRelease(hVol);
+        Assert(cRefs != UINT32_MAX); RT_NOREF(cRefs);
+        *phVolToRelease = hVol = hVolNext;
+
+        /*
+         * Depending on the fPartitions selector and associated read-only mask,
+         * the guest either gets read-write or read-only access (bits set)
+         * or no access (selector bit clear, access directed to the VMDK).
+         */
+        paPartDescs[i].cbData = RTDvmVolumeGetSize(hVol);
+
+        uint64_t offVolumeEndIgnored = 0;
+        rc = RTDvmVolumeQueryRange(hVol, &paPartDescs[i].offStartInVDisk, &offVolumeEndIgnored);
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. Failed to get location of volume #%u on '%s' (%Rrc)"),
+                             pImage->pszFilename, i, pszRawDrive, rc);
+        Assert(paPartDescs[i].cbData == offVolumeEndIgnored + 1 - paPartDescs[i].offStartInVDisk);
+
+        /* Note! The index must match IHostDrivePartition::number. */
+        uint32_t idxPartition = RTDvmVolumeGetIndex(hVol, RTDVMVOLIDX_HOST);
+        if (   idxPartition < 32
+            && (fPartitions & RT_BIT_32(idxPartition)))
+        {
+            fPartitionsLeft &= ~RT_BIT_32(idxPartition);
+            if (fPartitionsReadOnly & RT_BIT_32(idxPartition))
+                paPartDescs[i].uFlags |= VDISKRAW_READONLY;
+
+            if (!fRelative)
+            {
+                /*
+                 * Accessing the drive thru the main device node (pRawDesc->pszRawDisk).
+                 */
+                paPartDescs[i].offStartInDevice = paPartDescs[i].offStartInVDisk;
+                paPartDescs[i].pszRawDevice     = RTStrDup(pszRawDrive);
+                AssertPtrReturn(paPartDescs[i].pszRawDevice, VERR_NO_STR_MEMORY);
+            }
+            else
+            {
+                /*
+                 * Relative means access the partition data via the device node for that
+                 * partition, allowing the sysadmin/OS to allow a user access to individual
+                 * partitions without necessarily being able to compromise the host OS.
+                 * Obviously, the creation of the VMDK requires read access to the main
+                 * device node for the drive, but that's a one-time thing and can be done
+                 * by the sysadmin.   Here data starts at offset zero in the device node.
+                 */
+                paPartDescs[i].offStartInDevice = 0;
+
+#if defined(RT_OS_DARWIN) || defined(RT_OS_FREEBSD)
+                /* /dev/rdisk1 -> /dev/rdisk1s2 (s=slice) */
+                RTStrAPrintf(&paPartDescs[i].pszRawDevice, "%ss%u", pszRawDrive, idxPartition);
+#elif defined(RT_OS_LINUX)
+                /* Two naming schemes here: /dev/nvme0n1 -> /dev/nvme0n1p1;  /dev/sda -> /dev/sda1 */
+                RTStrAPrintf(&paPartDescs[i].pszRawDevice,
+                             RT_C_IS_DIGIT(pszRawDrive[strlen(pszRawDrive) - 1]) ? "%sp%u" : "%s%u", pszRawDrive, idxPartition);
+#elif defined(RT_OS_WINDOWS)
+                rc = vmdkRawDescWinMakePartitionName(pImage, pszRawDrive, hRawDrive, idxPartition, &paPartDescs[i].pszRawDevice);
+                AssertRCReturn(rc, rc);
+#elif defined(RT_OS_SOLARIS)
+                if (pRawDesc->enmPartitioningType == VDISKPARTTYPE_MBR)
+                {
+                    /*
+                     * MBR partitions have device nodes in form /dev/(r)dsk/cXtYdZpK
+                     * where X is the controller,
+                     *       Y is target (SCSI device number),
+                     *       Z is disk number,
+                     *       K is partition number,
+                     *         where p0 is the whole disk
+                     *               p1-pN are the partitions of the disk
+                     */
+                    const char *pszRawDrivePath = pszRawDrive;
+                    char szDrivePath[RTPATH_MAX];
+                    size_t cbRawDrive = strlen(pszRawDrive);
+                    if (  cbRawDrive > 1 && strcmp(&pszRawDrive[cbRawDrive - 2], "p0") == 0)
+                    {
+                        memcpy(szDrivePath, pszRawDrive, cbRawDrive - 2);
+                        szDrivePath[cbRawDrive - 2] = '\0';
+                        pszRawDrivePath = szDrivePath;
+                    }
+                    RTStrAPrintf(&paPartDescs[i].pszRawDevice, "%sp%u", pszRawDrivePath, idxPartition);
+                }
+                else /* GPT */
+                {
+                    /*
+                     * GPT partitions have device nodes in form /dev/(r)dsk/cXtYdZsK
+                     * where X is the controller,
+                     *       Y is target (SCSI device number),
+                     *       Z is disk number,
+                     *       K is partition number, zero based. Can be only from 0 to 6.
+                     *         Thus, only partitions numbered 0 through 6 have device nodes.
+                     */
+                    if (idxPartition > 7)
+                        return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                                         N_("VMDK: Image path: '%s'. the partition #%u on '%s' has no device node and can not be specified with 'Relative' property"),
+                                         pImage->pszFilename, idxPartition, pszRawDrive);
+                    RTStrAPrintf(&paPartDescs[i].pszRawDevice, "%ss%u", pszRawDrive, idxPartition - 1);
+                }
+#else
+                AssertFailedReturn(VERR_INTERNAL_ERROR_4); /* The option parsing code should have prevented this - PORTME */
+#endif
+                AssertPtrReturn(paPartDescs[i].pszRawDevice, VERR_NO_STR_MEMORY);
+
+                rc = vmdkRawDescVerifyPartitionPath(pImage, &paPartDescs[i], idxPartition, pszRawDrive, hRawDrive, cbSector, hVol);
+                AssertRCReturn(rc, rc);
+            }
+        }
+        else
+        {
+            /* Not accessible to the guest. */
+            paPartDescs[i].offStartInDevice = 0;
+            paPartDescs[i].pszRawDevice     = NULL;
+        }
+    } /* for each volume */
+
+    RTDvmVolumeRelease(hVol);
+    *phVolToRelease = NIL_RTDVMVOLUME;
+
+    /*
+     * Check that we found all the partitions the user selected.
+     */
+    if (fPartitionsLeft)
+    {
+        char   szLeft[3 * sizeof(fPartitions) * 8];
+        size_t cchLeft = 0;
+        for (unsigned i = 0; i < sizeof(fPartitions) * 8; i++)
+            if (fPartitionsLeft & RT_BIT_32(i))
+                cchLeft += RTStrPrintf(&szLeft[cchLeft], sizeof(szLeft) - cchLeft, cchLeft ? "%u" : ",%u", i);
+        return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. Not all the specified partitions for drive '%s' was found: %s"),
+                             pImage->pszFilename, pszRawDrive, szLeft);
+    }
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Worker for vmdkMakeRawDescriptor that adds partition descriptors with copies
+ * of the partition tables and associated padding areas when the 'Partitions'
+ * configuration value is present.
+ *
+ * The guest is not allowed access to the partition tables, however it needs
+ * them to be able to access the drive.  So, create descriptors for each of the
+ * tables and attach the current disk content.  vmdkCreateRawImage() will later
+ * write the content to the VMDK.  Any changes the guest later makes to the
+ * partition tables will then go to the VMDK copy, rather than the host drive.
+ *
+ * @returns VBox status code, error message has been set on failure.
+ *
+ * @note    Caller is assumed to clean up @a pRawDesc
+ * @internal
+ */
+static int vmdkRawDescDoCopyPartitionTables(PVMDKIMAGE pImage, RTDVM hVolMgr, PVDISKRAW pRawDesc,
+                                            const char *pszRawDrive, RTFILE hRawDrive, void *pvBootSector, size_t cbBootSector)
+{
+    /*
+     * Query the locations.
+     */
+    /* Determin how many locations there are: */
+    size_t cLocations = 0;
+    int rc = RTDvmMapQueryTableLocations(hVolMgr, RTDVMMAPQTABLOC_F_INCLUDE_LEGACY, NULL, 0, &cLocations);
+    if (rc != VERR_BUFFER_OVERFLOW)
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                         N_("VMDK: Image path: '%s'. RTDvmMapQueryTableLocations failed on '%s' (%Rrc)"),
+                         pImage->pszFilename, pszRawDrive, rc);
+    AssertReturn(cLocations > 0 && cLocations < _16M, VERR_INTERNAL_ERROR_5);
+
+    /* We can allocate the partition descriptors here to save an intentation level. */
+    PVDISKRAWPARTDESC paPartDescs = NULL;
+    rc = vmdkRawDescAppendPartDesc(pImage, pRawDesc, (uint32_t)cLocations, &paPartDescs);
+    AssertRCReturn(rc, rc);
+
+    /* Allocate the result table and repeat the location table query: */
+    PRTDVMTABLELOCATION paLocations = (PRTDVMTABLELOCATION)RTMemAllocZ(sizeof(paLocations[0]) * cLocations);
+    if (!paLocations)
+        return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("VMDK: Image path: '%s'. Failed to allocate %zu bytes"),
+                         pImage->pszFilename, sizeof(paLocations[0]) * cLocations);
+    rc = RTDvmMapQueryTableLocations(hVolMgr, RTDVMMAPQTABLOC_F_INCLUDE_LEGACY, paLocations, cLocations, NULL);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Translate them into descriptors.
+         *
+         * We restrict the amount of partition alignment padding to 4MiB as more
+         * will just be a waste of space.  The use case for including the padding
+         * are older boot loaders and boot manager (including one by a team member)
+         * that put data and code in the 62 sectors between the MBR and the first
+         * partition (total of 63).  Later CHS was abandond and partition started
+         * being aligned on power of two sector boundraries (typically 64KiB or
+         * 1MiB depending on the media size).
+         */
+        for (size_t i = 0; i < cLocations && RT_SUCCESS(rc); i++)
+        {
+            Assert(paLocations[i].cb > 0);
+            if (paLocations[i].cb <= _64M)
+            {
+                /* Create the partition descriptor entry: */
+                //paPartDescs[i].pszRawDevice      = NULL;
+                //paPartDescs[i].offStartInDevice  = 0;
+                //paPartDescs[i].uFlags            = 0;
+                paPartDescs[i].offStartInVDisk   = paLocations[i].off;
+                paPartDescs[i].cbData            = paLocations[i].cb;
+                if (paPartDescs[i].cbData < _4M)
+                    paPartDescs[i].cbData = RT_MIN(paPartDescs[i].cbData + paLocations[i].cbPadding, _4M);
+                paPartDescs[i].pvPartitionData = RTMemAllocZ((size_t)paPartDescs[i].cbData);
+                if (paPartDescs[i].pvPartitionData)
+                {
+                    /* Read the content from the drive: */
+                    rc = RTFileReadAt(hRawDrive, paPartDescs[i].offStartInVDisk, paPartDescs[i].pvPartitionData,
+                                      (size_t)paPartDescs[i].cbData, NULL);
+                    if (RT_SUCCESS(rc))
+                    {
+                        /* Do we have custom boot sector code? */
+                        if (pvBootSector && cbBootSector && paPartDescs[i].offStartInVDisk == 0)
+                        {
+                            /* Note! Old code used to quietly drop the bootsector if it was considered too big.
+                                     Instead we fail as we weren't able to do what the user requested us to do.
+                                     Better if the user knows than starts questioning why the guest isn't
+                                     booting as expected. */
+                            if (cbBootSector <= paPartDescs[i].cbData)
+                                memcpy(paPartDescs[i].pvPartitionData, pvBootSector, cbBootSector);
+                            else
+                                rc = vdIfError(pImage->pIfError, VERR_TOO_MUCH_DATA, RT_SRC_POS,
+                                               N_("VMDK: Image path: '%s'. The custom boot sector is too big: %zu bytes, %RU64 bytes available"),
+                                               pImage->pszFilename, cbBootSector, paPartDescs[i].cbData);
+                        }
+                    }
+                    else
+                        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                       N_("VMDK: Image path: '%s'. Failed to read partition at off %RU64 length %zu from '%s' (%Rrc)"),
+                                       pImage->pszFilename, paPartDescs[i].offStartInVDisk,
+                                       (size_t)paPartDescs[i].cbData, pszRawDrive, rc);
+                }
+                else
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                   N_("VMDK: Image path: '%s'. Failed to allocate %zu bytes for copying the partition table at off %RU64"),
+                                      pImage->pszFilename, (size_t)paPartDescs[i].cbData, paPartDescs[i].offStartInVDisk);
+            }
+            else
+                rc = vdIfError(pImage->pIfError, VERR_TOO_MUCH_DATA, RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'. Partition table #%u at offset %RU64 in '%s' is to big: %RU64 bytes"),
+                                  pImage->pszFilename, i, paLocations[i].off, pszRawDrive, paLocations[i].cb);
+        }
+    }
+    else
+        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. RTDvmMapQueryTableLocations failed on '%s' (%Rrc)"),
+                          pImage->pszFilename, pszRawDrive, rc);
+    RTMemFree(paLocations);
+    return rc;
+}
+
+/**
+ * Opens the volume manager for the raw drive when in selected-partition mode.
+ *
+ * @param   pImage      The VMDK image (for errors).
+ * @param   hRawDrive   The raw drive handle.
+ * @param   pszRawDrive The raw drive device path (for errors).
+ * @param   cbSector    The sector size.
+ * @param   phVolMgr    Where to return the handle to the volume manager on
+ *                      success.
+ * @returns VBox status code, errors have been reported.
+ * @internal
+ */
+static int vmdkRawDescOpenVolMgr(PVMDKIMAGE pImage, RTFILE hRawDrive, const char *pszRawDrive, uint32_t cbSector, PRTDVM phVolMgr)
+{
+    *phVolMgr = NIL_RTDVM;
+
+    RTVFSFILE hVfsFile = NIL_RTVFSFILE;
+    int rc = RTVfsFileFromRTFile(hRawDrive, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE, true /*fLeaveOpen*/, &hVfsFile);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                         N_("VMDK: Image path: '%s'.  RTVfsFileFromRTFile failed for '%s' handle (%Rrc)"),
+                         pImage->pszFilename, pszRawDrive, rc);
+
+    RTDVM hVolMgr = NIL_RTDVM;
+    rc = RTDvmCreate(&hVolMgr, hVfsFile, cbSector, 0 /*fFlags*/);
+
+    RTVfsFileRelease(hVfsFile);
+
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                         N_("VMDK: Image path: '%s'. Failed to create volume manager instance for '%s' (%Rrc)"),
+                         pImage->pszFilename, pszRawDrive, rc);
+
+    rc = RTDvmMapOpen(hVolMgr);
+    if (RT_SUCCESS(rc))
+    {
+        *phVolMgr = hVolMgr;
+        return VINF_SUCCESS;
+    }
+    RTDvmRelease(hVolMgr);
+    return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: Image path: '%s'. RTDvmMapOpen failed for '%s' (%Rrc)"),
+                     pImage->pszFilename, pszRawDrive, rc);
+}
+
+/**
+ * Opens the raw drive device and get the sizes for it.
+ *
+ * @param   pImage          The image (for error reporting).
+ * @param   pszRawDrive     The device/whatever to open.
+ * @param   phRawDrive      Where to return the file handle.
+ * @param   pcbRawDrive     Where to return the size.
+ * @param   pcbSector       Where to return the sector size.
+ * @returns IPRT status code, errors have been reported.
+ * @internal
+ */
+static int vmkdRawDescOpenDevice(PVMDKIMAGE pImage, const char *pszRawDrive,
+                                 PRTFILE phRawDrive, uint64_t *pcbRawDrive, uint32_t *pcbSector)
+{
+    /*
+     * Open the device for the raw drive.
+     */
+    RTFILE hRawDrive = NIL_RTFILE;
+    int rc = RTFileOpen(&hRawDrive, pszRawDrive, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                         N_("VMDK: Image path: '%s'. Failed to open the raw drive '%s' for reading (%Rrc)"),
+                         pImage->pszFilename, pszRawDrive, rc);
+
+    /*
+     * Get the sector size.
+     */
+    uint32_t cbSector = 0;
+    rc = RTFileQuerySectorSize(hRawDrive, &cbSector);
+    if (RT_SUCCESS(rc))
+    {
+        /* sanity checks */
+        if (   cbSector >= 512
+            && cbSector <= _64K
+            && RT_IS_POWER_OF_TWO(cbSector))
+        {
+            /*
+             * Get the size.
+             */
+            uint64_t cbRawDrive = 0;
+            rc = RTFileQuerySize(hRawDrive, &cbRawDrive);
+            if (RT_SUCCESS(rc))
+            {
+                /* Check whether cbSize is actually sensible. */
+                if (cbRawDrive > cbSector && (cbRawDrive % cbSector) == 0)
+                {
+                    *phRawDrive  = hRawDrive;
+                    *pcbRawDrive = cbRawDrive;
+                    *pcbSector   = cbSector;
+                    return VINF_SUCCESS;
+                }
+                rc = vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'.  Got a bogus size for the raw drive '%s': %RU64 (sector size %u)"),
+                               pImage->pszFilename, pszRawDrive, cbRawDrive, cbSector);
+            }
+            else
+                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'. Failed to query size of the drive '%s' (%Rrc)"),
+                               pImage->pszFilename, pszRawDrive, rc);
+        }
+        else
+            rc = vdIfError(pImage->pIfError, VERR_OUT_OF_RANGE, RT_SRC_POS,
+                           N_("VMDK: Image path: '%s'. Unsupported sector size for '%s': %u (%#x)"),
+                           pImage->pszFilename, pszRawDrive, cbSector, cbSector);
+    }
+    else
+        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                       N_("VMDK: Image path: '%s'. Failed to get the sector size for '%s' (%Rrc)"),
+                       pImage->pszFilename, pszRawDrive, rc);
+    RTFileClose(hRawDrive);
+    return rc;
+}
+
+/**
+ * Reads the raw disk configuration, leaving initalization and cleanup to the
+ * caller (regardless of return status).
+ *
+ * @returns VBox status code, errors properly reported.
+ * @internal
+ */
+static int vmdkRawDescParseConfig(PVMDKIMAGE pImage, char **ppszRawDrive,
+                                  uint32_t *pfPartitions, uint32_t *pfPartitionsReadOnly,
+                                  void **ppvBootSector, size_t *pcbBootSector, bool *pfRelative,
+                                  char **ppszFreeMe)
+{
+    PVDINTERFACECONFIG pImgCfg = VDIfConfigGet(pImage->pVDIfsImage);
+    if (!pImgCfg)
+        return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                         N_("VMDK: Image path: '%s'. Getting config interface failed"), pImage->pszFilename);
+
+    /*
+     * RawDrive = path
+     */
+    int rc = VDCFGQueryStringAlloc(pImgCfg, "RawDrive", ppszRawDrive);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                         N_("VMDK: Image path: '%s'. Getting 'RawDrive' configuration failed (%Rrc)"), pImage->pszFilename, rc);
+    AssertPtrReturn(*ppszRawDrive, VERR_INTERNAL_ERROR_3);
+
+    /*
+     * Partitions=n[r][,...]
+     */
+    uint32_t const cMaxPartitionBits = sizeof(*pfPartitions) * 8 /* ASSUMES 8 bits per char */;
+    *pfPartitions = *pfPartitionsReadOnly = 0;
+
+    rc = VDCFGQueryStringAlloc(pImgCfg, "Partitions", ppszFreeMe);
+    if (RT_SUCCESS(rc))
+    {
+        char *psz = *ppszFreeMe;
+        while (*psz != '\0')
+        {
+            char *pszNext;
+            uint32_t u32;
+            rc = RTStrToUInt32Ex(psz, &pszNext, 0, &u32);
+            if (rc == VWRN_NUMBER_TOO_BIG || rc == VWRN_NEGATIVE_UNSIGNED)
+                rc = -rc;
+            if (RT_FAILURE(rc))
+                return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                                 N_("VMDK: Image path: '%s'. Parsing 'Partitions' config value failed. Incorrect value (%Rrc): %s"),
+                                 pImage->pszFilename, rc, psz);
+            if (u32 >= cMaxPartitionBits)
+                return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                                 N_("VMDK: Image path: '%s'. 'Partitions' config sub-value out of range: %RU32, max %RU32"),
+                                 pImage->pszFilename, u32, cMaxPartitionBits);
+            *pfPartitions |= RT_BIT_32(u32);
+            psz = pszNext;
+            if (*psz == 'r')
+            {
+                *pfPartitionsReadOnly |= RT_BIT_32(u32);
+                psz++;
+            }
+            if (*psz == ',')
+                psz++;
+            else if (*psz != '\0')
+                return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                                 N_("VMDK: Image path: '%s'. Malformed 'Partitions' config value, expected separator: %s"),
+                                 pImage->pszFilename, psz);
+        }
+
+        RTStrFree(*ppszFreeMe);
+        *ppszFreeMe = NULL;
+    }
+    else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                         N_("VMDK: Image path: '%s'. Getting 'Partitions' configuration failed (%Rrc)"), pImage->pszFilename, rc);
+
+    /*
+     * BootSector=base64
+     */
+    rc = VDCFGQueryStringAlloc(pImgCfg, "BootSector", ppszFreeMe);
+    if (RT_SUCCESS(rc))
+    {
+        ssize_t cbBootSector = RTBase64DecodedSize(*ppszFreeMe, NULL);
+        if (cbBootSector < 0)
+            return vdIfError(pImage->pIfError, VERR_INVALID_BASE64_ENCODING, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. BASE64 decoding failed on the custom bootsector for '%s'"),
+                             pImage->pszFilename, *ppszRawDrive);
+        if (cbBootSector == 0)
+            return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. Custom bootsector for '%s' is zero bytes big"),
+                             pImage->pszFilename, *ppszRawDrive);
+        if (cbBootSector > _4M) /* this is just a preliminary max */
+            return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. Custom bootsector for '%s' is way too big: %zu bytes, max 4MB"),
+                             pImage->pszFilename, *ppszRawDrive, cbBootSector);
+
+        /* Refuse the boot sector if whole-drive.  This used to be done quietly,
+           however, bird disagrees and thinks the user should be told that what
+           he/she/it tries to do isn't possible.  There should be less head
+           scratching this way when the guest doesn't do the expected thing. */
+        if (!*pfPartitions)
+            return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. Custom bootsector for '%s' is not supported for whole-drive configurations, only when selecting partitions"),
+                             pImage->pszFilename, *ppszRawDrive);
+
+        *pcbBootSector = (size_t)cbBootSector;
+        *ppvBootSector = RTMemAlloc((size_t)cbBootSector);
+        if (!*ppvBootSector)
+            return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. Failed to allocate %zd bytes for the custom bootsector for '%s'"),
+                             pImage->pszFilename, cbBootSector, *ppszRawDrive);
+
+        rc = RTBase64Decode(*ppszFreeMe, *ppvBootSector, cbBootSector, NULL /*pcbActual*/, NULL /*ppszEnd*/);
+        if (RT_FAILURE(rc))
+            return  vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
+                              N_("VMDK: Image path: '%s'. Base64 decoding of the custom boot sector for '%s' failed (%Rrc)"),
+                              pImage->pszFilename, *ppszRawDrive, rc);
+
+        RTStrFree(*ppszFreeMe);
+        *ppszFreeMe = NULL;
+    }
+    else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                         N_("VMDK: Image path: '%s'. Getting 'BootSector' configuration failed (%Rrc)"), pImage->pszFilename, rc);
+
+    /*
+     * Relative=0/1
+     */
+    *pfRelative = false;
+    rc = VDCFGQueryBool(pImgCfg, "Relative", pfRelative);
+    if (RT_SUCCESS(rc))
+    {
+        if (!*pfPartitions && *pfRelative != false)
+            return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. The 'Relative' option is not supported for whole-drive configurations, only when selecting partitions"),
+                             pImage->pszFilename);
+#if !defined(RT_OS_DARWIN) && !defined(RT_OS_LINUX) && !defined(RT_OS_FREEBSD) && !defined(RT_OS_WINDOWS) && !defined(RT_OS_SOLARIS) /* PORTME */
+        if (*pfRelative == true)
+            return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                             N_("VMDK: Image path: '%s'. The 'Relative' option is not supported on this host OS"),
+                             pImage->pszFilename);
+#endif
+    }
+    else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                         N_("VMDK: Image path: '%s'. Getting 'Relative' configuration failed (%Rrc)"), pImage->pszFilename, rc);
+    else
+#ifdef RT_OS_DARWIN /* different default on macOS, see ticketref:1461 (comment 20). */
+        *pfRelative = true;
+#else
+        *pfRelative = false;
+#endif
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Creates a raw drive (nee disk) descriptor.
+ *
+ * This was originally done in VBoxInternalManage.cpp, but was copied (not move)
+ * here much later.  That's one of the reasons why we produce a descriptor just
+ * like it does, rather than mixing directly into the vmdkCreateRawImage code.
+ *
+ * @returns VBox status code.
+ * @param   pImage      The image.
+ * @param   ppRaw       Where to return the raw drive descriptor.  Caller must
+ *                      free it using vmdkRawDescFree regardless of the status
+ *                      code.
+ * @internal
+ */
+static int vmdkMakeRawDescriptor(PVMDKIMAGE pImage, PVDISKRAW *ppRaw)
+{
+    /* Make sure it's NULL. */
+    *ppRaw = NULL;
+
+    /*
+     * Read the configuration.
+     */
+    char       *pszRawDrive         = NULL;
+    uint32_t    fPartitions         = 0;    /* zero if whole-drive */
+    uint32_t    fPartitionsReadOnly = 0;    /* (subset of fPartitions) */
+    void       *pvBootSector        = NULL;
+    size_t      cbBootSector        = 0;
+    bool        fRelative           = false;
+    char       *pszFreeMe           = NULL; /* lazy bird cleanup. */
+    int rc = vmdkRawDescParseConfig(pImage, &pszRawDrive, &fPartitions, &fPartitionsReadOnly,
+                                    &pvBootSector, &cbBootSector, &fRelative, &pszFreeMe);
+    RTStrFree(pszFreeMe);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Open the device, getting the sector size and drive size.
+         */
+        uint64_t  cbSize    = 0;
+        uint32_t  cbSector  = 0;
+        RTFILE    hRawDrive = NIL_RTFILE;
+        rc = vmkdRawDescOpenDevice(pImage, pszRawDrive, &hRawDrive, &cbSize, &cbSector);
+        if (RT_SUCCESS(rc))
+        {
+            pImage->cbSize = cbSize;
+            /*
+             * Create the raw-drive descriptor
+             */
+            PVDISKRAW pRawDesc = (PVDISKRAW)RTMemAllocZ(sizeof(*pRawDesc));
+            if (pRawDesc)
+            {
+                pRawDesc->szSignature[0] = 'R';
+                pRawDesc->szSignature[1] = 'A';
+                pRawDesc->szSignature[2] = 'W';
+                //pRawDesc->szSignature[3] = '\0';
+                if (!fPartitions)
+                {
+                    /*
+                     * It's simple for when doing the whole drive.
+                     */
+                    pRawDesc->uFlags = VDISKRAW_DISK;
+                    rc = RTStrDupEx(&pRawDesc->pszRawDisk, pszRawDrive);
+                }
+                else
+                {
+                    /*
+                     * In selected partitions mode we've got a lot more work ahead of us.
+                     */
+                    pRawDesc->uFlags = VDISKRAW_NORMAL;
+                    //pRawDesc->pszRawDisk = NULL;
+                    //pRawDesc->cPartDescs = 0;
+                    //pRawDesc->pPartDescs = NULL;
+
+                    /* We need to parse the partition map to complete the descriptor: */
+                    RTDVM hVolMgr = NIL_RTDVM;
+                    rc = vmdkRawDescOpenVolMgr(pImage, hRawDrive, pszRawDrive, cbSector, &hVolMgr);
+                    if (RT_SUCCESS(rc))
+                    {
+                        RTDVMFORMATTYPE enmFormatType = RTDvmMapGetFormatType(hVolMgr);
+                        if (   enmFormatType == RTDVMFORMATTYPE_MBR
+                            || enmFormatType == RTDVMFORMATTYPE_GPT)
+                        {
+                            pRawDesc->enmPartitioningType = enmFormatType == RTDVMFORMATTYPE_MBR
+                                                          ? VDISKPARTTYPE_MBR : VDISKPARTTYPE_GPT;
+
+                            /* Add copies of the partition tables:  */
+                            rc = vmdkRawDescDoCopyPartitionTables(pImage, hVolMgr, pRawDesc, pszRawDrive, hRawDrive,
+                                                                  pvBootSector, cbBootSector);
+                            if (RT_SUCCESS(rc))
+                            {
+                                /* Add descriptors for the partitions/volumes, indicating which
+                                   should be accessible and how to access them: */
+                                RTDVMVOLUME hVolRelease = NIL_RTDVMVOLUME;
+                                rc = vmdkRawDescDoPartitions(pImage, hVolMgr, pRawDesc, hRawDrive, pszRawDrive, cbSector,
+                                                             fPartitions, fPartitionsReadOnly, fRelative, &hVolRelease);
+                                RTDvmVolumeRelease(hVolRelease);
+
+                                /* Finally, sort the partition and check consistency (overlaps, etc): */
+                                if (RT_SUCCESS(rc))
+                                    rc = vmdkRawDescPostProcessPartitions(pImage, pRawDesc, cbSize);
+                            }
+                        }
+                        else
+                            rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
+                                           N_("VMDK: Image path: '%s'. Unsupported partitioning for the disk '%s': %s"),
+                                           pImage->pszFilename, pszRawDrive, RTDvmMapGetFormatType(hVolMgr));
+                        RTDvmRelease(hVolMgr);
+                    }
+                }
+                if (RT_SUCCESS(rc))
+                {
+                    /*
+                     * We succeeded.
+                     */
+                    *ppRaw = pRawDesc;
+                    Log(("vmdkMakeRawDescriptor: fFlags=%#x enmPartitioningType=%d cPartDescs=%u pszRawDisk=%s\n",
+                         pRawDesc->uFlags, pRawDesc->enmPartitioningType, pRawDesc->cPartDescs, pRawDesc->pszRawDisk));
+                    if (pRawDesc->cPartDescs)
+                    {
+                        Log(("#      VMDK offset         Length  Device offset  PartDataPtr  Device\n"));
+                        for (uint32_t i = 0; i < pRawDesc->cPartDescs; i++)
+                            Log(("%2u  %14RU64 %14RU64 %14RU64 %#18p %s\n", i, pRawDesc->pPartDescs[i].offStartInVDisk,
+                                 pRawDesc->pPartDescs[i].cbData, pRawDesc->pPartDescs[i].offStartInDevice,
+                                 pRawDesc->pPartDescs[i].pvPartitionData, pRawDesc->pPartDescs[i].pszRawDevice));
+                    }
+                }
+                else
+                    vmdkRawDescFree(pRawDesc);
+            }
+            else
+                rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
+                               N_("VMDK: Image path: '%s'. Failed to allocate %u bytes for the raw drive descriptor"),
+                               pImage->pszFilename, sizeof(*pRawDesc));
+            RTFileClose(hRawDrive);
+        }
+    }
+    RTStrFree(pszRawDrive);
+    RTMemFree(pvBootSector);
+    return rc;
+}
+
+/**
+ * Internal: create VMDK images for raw disk/partition access.
+ */
+static int vmdkCreateRawImage(PVMDKIMAGE pImage, const PVDISKRAW pRaw,
+                              uint64_t cbSize)
+{
+    int rc = VINF_SUCCESS;
+    PVMDKEXTENT pExtent;
+
+    if (pRaw->uFlags & VDISKRAW_DISK)
+    {
+        /* Full raw disk access. This requires setting up a descriptor
+         * file and open the (flat) raw disk. */
+        rc = vmdkCreateExtents(pImage, 1);
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
+        pExtent = &pImage->pExtents[0];
+        /* Create raw disk descriptor file. */
+        rc = vmdkFileOpen(pImage, &pImage->pFile, NULL, pImage->pszFilename,
+                          VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
+                                                     true /* fCreate */));
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pImage->pszFilename);
+
+        /* Set up basename for extent description. Cannot use StrDup. */
+        size_t cbBasename = strlen(pRaw->pszRawDisk) + 1;
+        char *pszBasename = (char *)RTMemTmpAlloc(cbBasename);
+        if (!pszBasename)
+            return VERR_NO_MEMORY;
+        memcpy(pszBasename, pRaw->pszRawDisk, cbBasename);
+        pExtent->pszBasename = pszBasename;
+        /* For raw disks the full name is identical to the base name. */
+        pExtent->pszFullname = RTStrDup(pszBasename);
+        if (!pExtent->pszFullname)
+            return VERR_NO_MEMORY;
+        pExtent->enmType = VMDKETYPE_FLAT;
+        pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbSize);
+        pExtent->uSectorOffset = 0;
+        pExtent->enmAccess = (pRaw->uFlags & VDISKRAW_READONLY) ? VMDKACCESS_READONLY : VMDKACCESS_READWRITE;
+        pExtent->fMetaDirty = false;
+
+        /* Open flat image, the raw disk. */
+        rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
+                          VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags | ((pExtent->enmAccess == VMDKACCESS_READONLY) ? VD_OPEN_FLAGS_READONLY : 0),
+                                                     false /* fCreate */));
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not open raw disk file '%s'"), pExtent->pszFullname);
+    }
+    else
+    {
+        /* Raw partition access. This requires setting up a descriptor
+         * file, write the partition information to a flat extent and
+         * open all the (flat) raw disk partitions. */
+
+        /* First pass over the partition data areas to determine how many
+         * extents we need. One data area can require up to 2 extents, as
+         * it might be necessary to skip over unpartitioned space. */
+        unsigned cExtents = 0;
+        uint64_t uStart = 0;
+        for (unsigned i = 0; i < pRaw->cPartDescs; i++)
+        {
+            PVDISKRAWPARTDESC pPart = &pRaw->pPartDescs[i];
+            if (uStart > pPart->offStartInVDisk)
+                return vdIfError(pImage->pIfError, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                                 N_("VMDK: incorrect partition data area ordering set up by the caller in '%s'"), pImage->pszFilename);
+
+            if (uStart < pPart->offStartInVDisk)
+                cExtents++;
+            uStart = pPart->offStartInVDisk + pPart->cbData;
+            cExtents++;
+        }
+        /* Another extent for filling up the rest of the image. */
+        if (uStart != cbSize)
+            cExtents++;
+
+        rc = vmdkCreateExtents(pImage, cExtents);
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
+
+        /* Create raw partition descriptor file. */
+        rc = vmdkFileOpen(pImage, &pImage->pFile, NULL, pImage->pszFilename,
+                          VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
+                                                     true /* fCreate */));
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pImage->pszFilename);
+
+        /* Create base filename for the partition table extent. */
+        /** @todo remove fixed buffer without creating memory leaks. */
+        char pszPartition[1024];
+        const char *pszBase = RTPathFilename(pImage->pszFilename);
+        const char *pszSuff = RTPathSuffix(pszBase);
+        if (pszSuff == NULL)
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: invalid filename '%s'"), pImage->pszFilename);
+        char *pszBaseBase = RTStrDup(pszBase);
+        if (!pszBaseBase)
+            return VERR_NO_MEMORY;
+        RTPathStripSuffix(pszBaseBase);
+        RTStrPrintf(pszPartition, sizeof(pszPartition), "%s-pt%s",
+                    pszBaseBase, pszSuff);
+        RTStrFree(pszBaseBase);
+
+        /* Second pass over the partitions, now define all extents. */
+        uint64_t uPartOffset = 0;
+        cExtents = 0;
+        uStart = 0;
+        for (unsigned i = 0; i < pRaw->cPartDescs; i++)
+        {
+            PVDISKRAWPARTDESC pPart = &pRaw->pPartDescs[i];
+            pExtent = &pImage->pExtents[cExtents++];
+
+            if (uStart < pPart->offStartInVDisk)
+            {
+                pExtent->pszBasename = NULL;
+                pExtent->pszFullname = NULL;
+                pExtent->enmType = VMDKETYPE_ZERO;
+                pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->offStartInVDisk - uStart);
+                pExtent->uSectorOffset = 0;
+                pExtent->enmAccess = VMDKACCESS_READWRITE;
+                pExtent->fMetaDirty = false;
+                /* go to next extent */
+                pExtent = &pImage->pExtents[cExtents++];
+            }
+            uStart = pPart->offStartInVDisk + pPart->cbData;
+
+            if (pPart->pvPartitionData)
+            {
+                /* Set up basename for extent description. Can't use StrDup. */
+                size_t cbBasename = strlen(pszPartition) + 1;
+                char *pszBasename = (char *)RTMemTmpAlloc(cbBasename);
+                if (!pszBasename)
+                    return VERR_NO_MEMORY;
+                memcpy(pszBasename, pszPartition, cbBasename);
+                pExtent->pszBasename = pszBasename;
+
+                /* Set up full name for partition extent. */
+                char *pszDirname = RTStrDup(pImage->pszFilename);
+                if (!pszDirname)
+                    return VERR_NO_STR_MEMORY;
+                RTPathStripFilename(pszDirname);
+                char *pszFullname = RTPathJoinA(pszDirname, pExtent->pszBasename);
+                RTStrFree(pszDirname);
+                if (!pszFullname)
+                    return VERR_NO_STR_MEMORY;
+                pExtent->pszFullname = pszFullname;
+                pExtent->enmType = VMDKETYPE_FLAT;
+                pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->cbData);
+                pExtent->uSectorOffset = uPartOffset;
+                pExtent->enmAccess = VMDKACCESS_READWRITE;
+                pExtent->fMetaDirty = false;
+
+                /* Create partition table flat image. */
+                rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
+                                  VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags | ((pExtent->enmAccess == VMDKACCESS_READONLY) ? VD_OPEN_FLAGS_READONLY : 0),
+                                                             true /* fCreate */));
+                if (RT_FAILURE(rc))
+                    return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new partition data file '%s'"), pExtent->pszFullname);
+                rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                            VMDK_SECTOR2BYTE(uPartOffset),
+                                            pPart->pvPartitionData,
+                                            pPart->cbData);
+                if (RT_FAILURE(rc))
+                    return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not write partition data to '%s'"), pExtent->pszFullname);
+                uPartOffset += VMDK_BYTE2SECTOR(pPart->cbData);
+            }
+            else
+            {
+                if (pPart->pszRawDevice)
+                {
+                    /* Set up basename for extent descr. Can't use StrDup. */
+                    size_t cbBasename = strlen(pPart->pszRawDevice) + 1;
+                    char *pszBasename = (char *)RTMemTmpAlloc(cbBasename);
+                    if (!pszBasename)
+                        return VERR_NO_MEMORY;
+                    memcpy(pszBasename, pPart->pszRawDevice, cbBasename);
+                    pExtent->pszBasename = pszBasename;
+                    /* For raw disks full name is identical to base name. */
+                    pExtent->pszFullname = RTStrDup(pszBasename);
+                    if (!pExtent->pszFullname)
+                        return VERR_NO_MEMORY;
+                    pExtent->enmType = VMDKETYPE_FLAT;
+                    pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->cbData);
+                    pExtent->uSectorOffset = VMDK_BYTE2SECTOR(pPart->offStartInDevice);
+                    pExtent->enmAccess = (pPart->uFlags & VDISKRAW_READONLY) ? VMDKACCESS_READONLY : VMDKACCESS_READWRITE;
+                    pExtent->fMetaDirty = false;
+
+                    /* Open flat image, the raw partition. */
+                    rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
+                                      VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags | ((pExtent->enmAccess == VMDKACCESS_READONLY) ? VD_OPEN_FLAGS_READONLY : 0),
+                                                                 false /* fCreate */));
+                    if (RT_FAILURE(rc))
+                        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not open raw partition file '%s'"), pExtent->pszFullname);
+                }
+                else
+                {
+                    pExtent->pszBasename = NULL;
+                    pExtent->pszFullname = NULL;
+                    pExtent->enmType = VMDKETYPE_ZERO;
+                    pExtent->cNominalSectors = VMDK_BYTE2SECTOR(pPart->cbData);
+                    pExtent->uSectorOffset = 0;
+                    pExtent->enmAccess = VMDKACCESS_READWRITE;
+                    pExtent->fMetaDirty = false;
+                }
+            }
+        }
+        /* Another extent for filling up the rest of the image. */
+        if (uStart != cbSize)
+        {
+            pExtent = &pImage->pExtents[cExtents++];
+            pExtent->pszBasename = NULL;
+            pExtent->pszFullname = NULL;
+            pExtent->enmType = VMDKETYPE_ZERO;
+            pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbSize - uStart);
+            pExtent->uSectorOffset = 0;
+            pExtent->enmAccess = VMDKACCESS_READWRITE;
+            pExtent->fMetaDirty = false;
+        }
+    }
+
+    rc = vmdkDescBaseSetStr(pImage, &pImage->Descriptor, "createType",
+                            (pRaw->uFlags & VDISKRAW_DISK) ?
+                            "fullDevice" : "partitionedDevice");
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set the image type in '%s'"), pImage->pszFilename);
+    return rc;
+}
+
+/**
+ * Internal: create a regular (i.e. file-backed) VMDK image.
+ */
+static int vmdkCreateRegularImage(PVMDKIMAGE pImage, uint64_t cbSize,
+                                  unsigned uImageFlags, PVDINTERFACEPROGRESS pIfProgress,
+                                  unsigned uPercentStart, unsigned uPercentSpan)
+{
+    int rc = VINF_SUCCESS;
+    unsigned cExtents = 1;
+    uint64_t cbOffset = 0;
+    uint64_t cbRemaining = cbSize;
+
+    if (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
+    {
+        cExtents = cbSize / VMDK_2G_SPLIT_SIZE;
+        /* Do proper extent computation: need one smaller extent if the total
+         * size isn't evenly divisible by the split size. */
+        if (cbSize % VMDK_2G_SPLIT_SIZE)
+            cExtents++;
+    }
+    rc = vmdkCreateExtents(pImage, cExtents);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
+
+    /* Basename strings needed for constructing the extent names. */
+    char *pszBasenameSubstr = RTPathFilename(pImage->pszFilename);
+    AssertPtr(pszBasenameSubstr);
+    size_t cbBasenameSubstr = strlen(pszBasenameSubstr) + 1;
+
+    /* Create separate descriptor file if necessary. */
+    if (cExtents != 1 || (uImageFlags & VD_IMAGE_FLAGS_FIXED))
+    {
+        rc = vmdkFileOpen(pImage, &pImage->pFile, NULL, pImage->pszFilename,
+                          VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
+                                                     true /* fCreate */));
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new sparse descriptor file '%s'"), pImage->pszFilename);
+    }
+    else
+        pImage->pFile = NULL;
+
+    /* Set up all extents. */
+    for (unsigned i = 0; i < cExtents; i++)
+    {
+        PVMDKEXTENT pExtent = &pImage->pExtents[i];
+        uint64_t cbExtent = cbRemaining;
+
+        /* Set up fullname/basename for extent description. Cannot use StrDup
+         * for basename, as it is not guaranteed that the memory can be freed
+         * with RTMemTmpFree, which must be used as in other code paths
+         * StrDup is not usable. */
+        if (cExtents == 1 && !(uImageFlags & VD_IMAGE_FLAGS_FIXED))
+        {
+            char *pszBasename = (char *)RTMemTmpAlloc(cbBasenameSubstr);
+            if (!pszBasename)
+                return VERR_NO_MEMORY;
+            memcpy(pszBasename, pszBasenameSubstr, cbBasenameSubstr);
+            pExtent->pszBasename = pszBasename;
+        }
+        else
+        {
+            char *pszBasenameSuff = RTPathSuffix(pszBasenameSubstr);
+            char *pszBasenameBase = RTStrDup(pszBasenameSubstr);
+            RTPathStripSuffix(pszBasenameBase);
+            char *pszTmp;
+            size_t cbTmp;
+            if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
+            {
+                if (cExtents == 1)
+                    RTStrAPrintf(&pszTmp, "%s-flat%s", pszBasenameBase,
+                                 pszBasenameSuff);
+                else
+                    RTStrAPrintf(&pszTmp, "%s-f%03d%s", pszBasenameBase,
+                                 i+1, pszBasenameSuff);
+            }
+            else
+                RTStrAPrintf(&pszTmp, "%s-s%03d%s", pszBasenameBase, i+1,
+                             pszBasenameSuff);
+            RTStrFree(pszBasenameBase);
+            if (!pszTmp)
+                return VERR_NO_STR_MEMORY;
+            cbTmp = strlen(pszTmp) + 1;
+            char *pszBasename = (char *)RTMemTmpAlloc(cbTmp);
+            if (!pszBasename)
+            {
+                RTStrFree(pszTmp);
+                return VERR_NO_MEMORY;
+            }
+            memcpy(pszBasename, pszTmp, cbTmp);
+            RTStrFree(pszTmp);
+            pExtent->pszBasename = pszBasename;
+            if (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
+                cbExtent = RT_MIN(cbRemaining, VMDK_2G_SPLIT_SIZE);
+        }
+        char *pszBasedirectory = RTStrDup(pImage->pszFilename);
+        if (!pszBasedirectory)
+            return VERR_NO_STR_MEMORY;
+        RTPathStripFilename(pszBasedirectory);
+        char *pszFullname = RTPathJoinA(pszBasedirectory, pExtent->pszBasename);
+        RTStrFree(pszBasedirectory);
+        if (!pszFullname)
+            return VERR_NO_STR_MEMORY;
+        pExtent->pszFullname = pszFullname;
+
+        /* Create file for extent. */
+        rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
+                          VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
+                                                     true /* fCreate */));
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pExtent->pszFullname);
+        if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
+        {
+            rc = vdIfIoIntFileSetAllocationSize(pImage->pIfIo, pExtent->pFile->pStorage, cbExtent,
+                                                0 /* fFlags */, pIfProgress,
+                                                uPercentStart + cbOffset * uPercentSpan / cbSize,
+                                                cbExtent * uPercentSpan / cbSize);
+            if (RT_FAILURE(rc))
+                return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set size of new file '%s'"), pExtent->pszFullname);
+        }
+
+        /* Place descriptor file information (where integrated). */
+        if (cExtents == 1 && !(uImageFlags & VD_IMAGE_FLAGS_FIXED))
+        {
+            pExtent->uDescriptorSector = 1;
+            pExtent->cDescriptorSectors = VMDK_BYTE2SECTOR(pImage->cbDescAlloc);
+            /* The descriptor is part of the (only) extent. */
+            pExtent->pDescData = pImage->pDescData;
+            pImage->pDescData = NULL;
+        }
+
+        if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
+        {
+            uint64_t cSectorsPerGDE, cSectorsPerGD;
+            pExtent->enmType = VMDKETYPE_HOSTED_SPARSE;
+            pExtent->cSectors = VMDK_BYTE2SECTOR(RT_ALIGN_64(cbExtent, _64K));
+            pExtent->cSectorsPerGrain = VMDK_BYTE2SECTOR(_64K);
+            pExtent->cGTEntries = 512;
+            cSectorsPerGDE = pExtent->cGTEntries * pExtent->cSectorsPerGrain;
+            pExtent->cSectorsPerGDE = cSectorsPerGDE;
+            pExtent->cGDEntries = (pExtent->cSectors + cSectorsPerGDE - 1) / cSectorsPerGDE;
+            cSectorsPerGD = (pExtent->cGDEntries + (512 / sizeof(uint32_t) - 1)) / (512 / sizeof(uint32_t));
+            if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+            {
+                /* The spec says version is 1 for all VMDKs, but the vast
+                 * majority of streamOptimized VMDKs actually contain
+                 * version 3 - so go with the majority. Both are accepted. */
+                pExtent->uVersion = 3;
+                pExtent->uCompression = VMDK_COMPRESSION_DEFLATE;
+            }
+        }
+        else
+        {
+            if (uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX)
+                pExtent->enmType = VMDKETYPE_VMFS;
+            else
+                pExtent->enmType = VMDKETYPE_FLAT;
+        }
+
+        pExtent->enmAccess = VMDKACCESS_READWRITE;
+        pExtent->fUncleanShutdown = true;
+        pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbExtent);
+        pExtent->uSectorOffset = 0;
+        pExtent->fMetaDirty = true;
+
+        if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
+        {
+            /* fPreAlloc should never be false because VMware can't use such images. */
+            rc = vmdkCreateGrainDirectory(pImage, pExtent,
+                                          RT_MAX(  pExtent->uDescriptorSector
+                                                 + pExtent->cDescriptorSectors,
+                                                 1),
+                                          true /* fPreAlloc */);
+            if (RT_FAILURE(rc))
+                return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new grain directory in '%s'"), pExtent->pszFullname);
+        }
+
+        cbOffset += cbExtent;
+
+        if (RT_SUCCESS(rc))
+            vdIfProgress(pIfProgress, uPercentStart + cbOffset * uPercentSpan / cbSize);
+
+        cbRemaining -= cbExtent;
+    }
+
+    if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX)
+    {
+        /* VirtualBox doesn't care, but VMWare ESX freaks out if the wrong
+         * controller type is set in an image. */
+        rc = vmdkDescDDBSetStr(pImage, &pImage->Descriptor, "ddb.adapterType", "lsilogic");
+        if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set controller type to lsilogic in '%s'"), pImage->pszFilename);
+    }
+
+    const char *pszDescType = NULL;
+    if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
+    {
+        if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX)
+            pszDescType = "vmfs";
+        else
+            pszDescType =   (cExtents == 1)
+                          ? "monolithicFlat" : "twoGbMaxExtentFlat";
+    }
+    else
+    {
+        if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+            pszDescType = "streamOptimized";
+        else
+        {
+            pszDescType =   (cExtents == 1)
+                          ? "monolithicSparse" : "twoGbMaxExtentSparse";
+        }
+    }
+    rc = vmdkDescBaseSetStr(pImage, &pImage->Descriptor, "createType",
+                            pszDescType);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set the image type in '%s'"), pImage->pszFilename);
+    return rc;
+}
+
+/**
+ * Internal: Create a real stream optimized VMDK using only linear writes.
+ */
+static int vmdkCreateStreamImage(PVMDKIMAGE pImage, uint64_t cbSize)
+{
+    int rc = vmdkCreateExtents(pImage, 1);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
+
+    /* Basename strings needed for constructing the extent names. */
+    const char *pszBasenameSubstr = RTPathFilename(pImage->pszFilename);
+    AssertPtr(pszBasenameSubstr);
+    size_t cbBasenameSubstr = strlen(pszBasenameSubstr) + 1;
+
+    /* No separate descriptor file. */
+    pImage->pFile = NULL;
+
+    /* Set up all extents. */
+    PVMDKEXTENT pExtent = &pImage->pExtents[0];
+
+    /* Set up fullname/basename for extent description. Cannot use StrDup
+     * for basename, as it is not guaranteed that the memory can be freed
+     * with RTMemTmpFree, which must be used as in other code paths
+     * StrDup is not usable. */
+    char *pszBasename = (char *)RTMemTmpAlloc(cbBasenameSubstr);
+    if (!pszBasename)
+        return VERR_NO_MEMORY;
+    memcpy(pszBasename, pszBasenameSubstr, cbBasenameSubstr);
+    pExtent->pszBasename = pszBasename;
+
+    char *pszBasedirectory = RTStrDup(pImage->pszFilename);
+    RTPathStripFilename(pszBasedirectory);
+    char *pszFullname = RTPathJoinA(pszBasedirectory, pExtent->pszBasename);
+    RTStrFree(pszBasedirectory);
+    if (!pszFullname)
+        return VERR_NO_STR_MEMORY;
+    pExtent->pszFullname = pszFullname;
+
+    /* Create file for extent. Make it write only, no reading allowed. */
+    rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszBasename, pExtent->pszFullname,
+                        VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
+                                                   true /* fCreate */)
+                      & ~RTFILE_O_READ);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pExtent->pszFullname);
+
+    /* Place descriptor file information. */
+    pExtent->uDescriptorSector = 1;
+    pExtent->cDescriptorSectors = VMDK_BYTE2SECTOR(pImage->cbDescAlloc);
+    /* The descriptor is part of the (only) extent. */
+    pExtent->pDescData = pImage->pDescData;
+    pImage->pDescData = NULL;
+
+    uint64_t cSectorsPerGDE, cSectorsPerGD;
+    pExtent->enmType = VMDKETYPE_HOSTED_SPARSE;
+    pExtent->cSectors = VMDK_BYTE2SECTOR(RT_ALIGN_64(cbSize, _64K));
+    pExtent->cSectorsPerGrain = VMDK_BYTE2SECTOR(_64K);
+    pExtent->cGTEntries = 512;
+    cSectorsPerGDE = pExtent->cGTEntries * pExtent->cSectorsPerGrain;
+    pExtent->cSectorsPerGDE = cSectorsPerGDE;
+    pExtent->cGDEntries = (pExtent->cSectors + cSectorsPerGDE - 1) / cSectorsPerGDE;
+    cSectorsPerGD = (pExtent->cGDEntries + (512 / sizeof(uint32_t) - 1)) / (512 / sizeof(uint32_t));
+
+    /* The spec says version is 1 for all VMDKs, but the vast
+     * majority of streamOptimized VMDKs actually contain
+     * version 3 - so go with the majority. Both are accepted. */
+    pExtent->uVersion = 3;
+    pExtent->uCompression = VMDK_COMPRESSION_DEFLATE;
+    pExtent->fFooter = true;
+
+    pExtent->enmAccess = VMDKACCESS_READONLY;
+    pExtent->fUncleanShutdown = false;
+    pExtent->cNominalSectors = VMDK_BYTE2SECTOR(cbSize);
+    pExtent->uSectorOffset = 0;
+    pExtent->fMetaDirty = true;
+
+    /* Create grain directory, without preallocating it straight away. It will
+     * be constructed on the fly when writing out the data and written when
+     * closing the image. The end effect is that the full grain directory is
+     * allocated, which is a requirement of the VMDK specs. */
+    rc = vmdkCreateGrainDirectory(pImage, pExtent, VMDK_GD_AT_END,
+                                  false /* fPreAlloc */);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new grain directory in '%s'"), pExtent->pszFullname);
+
+    rc = vmdkDescBaseSetStr(pImage, &pImage->Descriptor, "createType",
+                            "streamOptimized");
+    if (RT_FAILURE(rc))
+        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set the image type in '%s'"), pImage->pszFilename);
+
+    return rc;
+}
+
+/**
+ * Initializes the UUID fields in the DDB.
+ *
+ * @returns VBox status code.
+ * @param   pImage          The VMDK image instance.
+ */
+static int vmdkCreateImageDdbUuidsInit(PVMDKIMAGE pImage)
+{
+    int rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor, VMDK_DDB_IMAGE_UUID, &pImage->ImageUuid);
+    if (RT_SUCCESS(rc))
+    {
+        rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor, VMDK_DDB_PARENT_UUID, &pImage->ParentUuid);
+        if (RT_SUCCESS(rc))
+        {
+            rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor, VMDK_DDB_MODIFICATION_UUID,
+                                    &pImage->ModificationUuid);
+            if (RT_SUCCESS(rc))
+            {
+                rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor, VMDK_DDB_PARENT_MODIFICATION_UUID,
+                                        &pImage->ParentModificationUuid);
+                if (RT_FAILURE(rc))
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                                   N_("VMDK: error storing parent modification UUID in new descriptor in '%s'"), pImage->pszFilename);
+            }
+            else
+                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                               N_("VMDK: error storing modification UUID in new descriptor in '%s'"), pImage->pszFilename);
+        }
+        else
+            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                           N_("VMDK: error storing parent image UUID in new descriptor in '%s'"), pImage->pszFilename);
+    }
+    else
+        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                       N_("VMDK: error storing image UUID in new descriptor in '%s'"), pImage->pszFilename);
+
+    return rc;
+}
+
+/**
+ * Internal: The actual code for creating any VMDK variant currently in
+ * existence on hosted environments.
+ */
+static int vmdkCreateImage(PVMDKIMAGE pImage, uint64_t cbSize,
+                           unsigned uImageFlags, const char *pszComment,
+                           PCVDGEOMETRY pPCHSGeometry,
+                           PCVDGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
+                           PVDINTERFACEPROGRESS pIfProgress,
+                           unsigned uPercentStart, unsigned uPercentSpan)
+{
+    pImage->uImageFlags = uImageFlags;
+
+    pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
+    pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
+    AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
+
+    int rc = vmdkCreateDescriptor(pImage, pImage->pDescData, pImage->cbDescAlloc,
+                                  &pImage->Descriptor);
+    if (RT_SUCCESS(rc))
+    {
+        if (uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK)
+        {
+            /* Raw disk image (includes raw partition). */
+            PVDISKRAW pRaw = NULL;
+            rc = vmdkMakeRawDescriptor(pImage, &pRaw);
+            if (RT_FAILURE(rc))
+                return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create raw descriptor for '%s'"),
+                    pImage->pszFilename);
+            if (!cbSize)
+                cbSize = pImage->cbSize;
+
+            rc = vmdkCreateRawImage(pImage, pRaw, cbSize);
+            vmdkRawDescFree(pRaw);
+        }
+        else if (uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+        {
+            /* Stream optimized sparse image (monolithic). */
+            rc = vmdkCreateStreamImage(pImage, cbSize);
+        }
+        else
+        {
+            /* Regular fixed or sparse image (monolithic or split). */
+            rc = vmdkCreateRegularImage(pImage, cbSize, uImageFlags,
+                                        pIfProgress, uPercentStart,
+                                        uPercentSpan * 95 / 100);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            vdIfProgress(pIfProgress, uPercentStart + uPercentSpan * 98 / 100);
+
+            pImage->cbSize = cbSize;
+
+            for (unsigned i = 0; i < pImage->cExtents; i++)
+            {
+                PVMDKEXTENT pExtent = &pImage->pExtents[i];
+
+                rc = vmdkDescExtInsert(pImage, &pImage->Descriptor, pExtent->enmAccess,
+                                       pExtent->cNominalSectors, pExtent->enmType,
+                                       pExtent->pszBasename, pExtent->uSectorOffset);
+                if (RT_FAILURE(rc))
+                {
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not insert the extent list into descriptor in '%s'"), pImage->pszFilename);
+                    break;
+                }
+            }
+
+            if (RT_SUCCESS(rc))
+                vmdkDescExtRemoveDummy(pImage, &pImage->Descriptor);
+
+            pImage->LCHSGeometry = *pLCHSGeometry;
+            pImage->PCHSGeometry = *pPCHSGeometry;
+
+            if (RT_SUCCESS(rc))
+            {
+                if (   pPCHSGeometry->cCylinders != 0
+                    && pPCHSGeometry->cHeads != 0
+                    && pPCHSGeometry->cSectors != 0)
+                    rc = vmdkDescSetPCHSGeometry(pImage, pPCHSGeometry);
+                else if (uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK)
+                {
+                    VDGEOMETRY RawDiskPCHSGeometry;
+                    RawDiskPCHSGeometry.cCylinders = (uint32_t)RT_MIN(pImage->cbSize / 512 / 16 / 63, 16383);
+                    RawDiskPCHSGeometry.cHeads = 16;
+                    RawDiskPCHSGeometry.cSectors = 63;
+                    rc = vmdkDescSetPCHSGeometry(pImage, &RawDiskPCHSGeometry);
+                }
+            }
+
+            if (   RT_SUCCESS(rc)
+                && pLCHSGeometry->cCylinders != 0
+                && pLCHSGeometry->cHeads != 0
+                && pLCHSGeometry->cSectors != 0)
+                rc = vmdkDescSetLCHSGeometry(pImage, pLCHSGeometry);
+
+            pImage->ImageUuid = *pUuid;
+            RTUuidClear(&pImage->ParentUuid);
+            RTUuidClear(&pImage->ModificationUuid);
+            RTUuidClear(&pImage->ParentModificationUuid);
+
+            if (RT_SUCCESS(rc))
+                rc = vmdkCreateImageDdbUuidsInit(pImage);
+
+            if (RT_SUCCESS(rc))
+                rc = vmdkAllocateGrainTableCache(pImage);
+
+            if (RT_SUCCESS(rc))
+            {
+                rc = vmdkSetImageComment(pImage, pszComment);
+                if (RT_FAILURE(rc))
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot set image comment in '%s'"), pImage->pszFilename);
+            }
+
+            if (RT_SUCCESS(rc))
+            {
+                vdIfProgress(pIfProgress, uPercentStart + uPercentSpan * 99 / 100);
+
+                if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+                {
+                    /* streamOptimized is a bit special, we cannot trigger the flush
+                     * until all data has been written. So we write the necessary
+                     * information explicitly. */
+                    pImage->pExtents[0].cDescriptorSectors = VMDK_BYTE2SECTOR(RT_ALIGN_64(  pImage->Descriptor.aLines[pImage->Descriptor.cLines]
+                                                                                          - pImage->Descriptor.aLines[0], 512));
+                    rc = vmdkWriteMetaSparseExtent(pImage, &pImage->pExtents[0], 0, NULL);
+                    if (RT_SUCCESS(rc))
+                    {
+                        rc = vmdkWriteDescriptor(pImage, NULL);
+                        if (RT_FAILURE(rc))
+                            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write VMDK descriptor in '%s'"), pImage->pszFilename);
+                    }
+                    else
+                        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write VMDK header in '%s'"), pImage->pszFilename);
+                }
+                else
+                    rc = vmdkFlushImage(pImage, NULL);
+            }
+        }
+    }
+    else
+        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not create new descriptor in '%s'"), pImage->pszFilename);
+
+
+    if (RT_SUCCESS(rc))
+    {
+        PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
+        pImage->RegionList.fFlags   = 0;
+        pImage->RegionList.cRegions = 1;
+
+        pRegion->offRegion            = 0; /* Disk start. */
+        pRegion->cbBlock              = 512;
+        pRegion->enmDataForm          = VDREGIONDATAFORM_RAW;
+        pRegion->enmMetadataForm      = VDREGIONMETADATAFORM_NONE;
+        pRegion->cbData               = 512;
+        pRegion->cbMetadata           = 0;
+        pRegion->cRegionBlocksOrBytes = pImage->cbSize;
+
+        vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
+    }
+    else
+        vmdkFreeImage(pImage, rc != VERR_ALREADY_EXISTS, false /*fFlush*/);
+    return rc;
+}
+
+/**
+ * Internal: Update image comment.
+ */
+static int vmdkSetImageComment(PVMDKIMAGE pImage, const char *pszComment)
+{
+    char *pszCommentEncoded = NULL;
+    if (pszComment)
+    {
+        pszCommentEncoded = vmdkEncodeString(pszComment);
+        if (!pszCommentEncoded)
+            return VERR_NO_MEMORY;
+    }
+
+    int rc = vmdkDescDDBSetStr(pImage, &pImage->Descriptor,
+                               "ddb.comment", pszCommentEncoded);
+    if (pszCommentEncoded)
+        RTStrFree(pszCommentEncoded);
+    if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing image comment in descriptor in '%s'"), pImage->pszFilename);
+    return VINF_SUCCESS;
+}
+
+/**
+ * Internal. Clear the grain table buffer for real stream optimized writing.
+ */
+static void vmdkStreamClearGT(PVMDKIMAGE pImage, PVMDKEXTENT pExtent)
+{
+    uint32_t cCacheLines = RT_ALIGN(pExtent->cGTEntries, VMDK_GT_CACHELINE_SIZE) / VMDK_GT_CACHELINE_SIZE;
+    for (uint32_t i = 0; i < cCacheLines; i++)
+        memset(&pImage->pGTCache->aGTCache[i].aGTData[0], '\0',
+               VMDK_GT_CACHELINE_SIZE * sizeof(uint32_t));
+}
+
+/**
+ * Internal. Flush the grain table buffer for real stream optimized writing.
+ */
+static int vmdkStreamFlushGT(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                             uint32_t uGDEntry)
+{
+    int rc = VINF_SUCCESS;
+    uint32_t cCacheLines = RT_ALIGN(pExtent->cGTEntries, VMDK_GT_CACHELINE_SIZE) / VMDK_GT_CACHELINE_SIZE;
+
+    /* VMware does not write out completely empty grain tables in the case
+     * of streamOptimized images, which according to my interpretation of
+     * the VMDK 1.1 spec is bending the rules. Since they do it and we can
+     * handle it without problems do it the same way and save some bytes. */
+    bool fAllZero = true;
+    for (uint32_t i = 0; i < cCacheLines; i++)
+    {
+        /* Convert the grain table to little endian in place, as it will not
+         * be used at all after this function has been called. */
+        uint32_t *pGTTmp = &pImage->pGTCache->aGTCache[i].aGTData[0];
+        for (uint32_t j = 0; j < VMDK_GT_CACHELINE_SIZE; j++, pGTTmp++)
+            if (*pGTTmp)
+            {
+                fAllZero = false;
+                break;
+            }
+        if (!fAllZero)
+            break;
+    }
+    if (fAllZero)
+        return VINF_SUCCESS;
+
+    uint64_t uFileOffset = pExtent->uAppendPosition;
+    if (!uFileOffset)
+        return VERR_INTERNAL_ERROR;
+    /* Align to sector, as the previous write could have been any size. */
+    uFileOffset = RT_ALIGN_64(uFileOffset, 512);
+
+    /* Grain table marker. */
+    uint8_t aMarker[512];
+    PVMDKMARKER pMarker = (PVMDKMARKER)&aMarker[0];
+    memset(pMarker, '\0', sizeof(aMarker));
+    pMarker->uSector = RT_H2LE_U64(VMDK_BYTE2SECTOR((uint64_t)pExtent->cGTEntries * sizeof(uint32_t)));
+    pMarker->uType = RT_H2LE_U32(VMDK_MARKER_GT);
+    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage, uFileOffset,
+                                aMarker, sizeof(aMarker));
+    AssertRC(rc);
+    uFileOffset += 512;
+
+    if (!pExtent->pGD || pExtent->pGD[uGDEntry])
+        return VERR_INTERNAL_ERROR;
+
+    pExtent->pGD[uGDEntry] = VMDK_BYTE2SECTOR(uFileOffset);
+
+    for (uint32_t i = 0; i < cCacheLines; i++)
+    {
+        /* Convert the grain table to little endian in place, as it will not
+         * be used at all after this function has been called. */
+        uint32_t *pGTTmp = &pImage->pGTCache->aGTCache[i].aGTData[0];
+        for (uint32_t j = 0; j < VMDK_GT_CACHELINE_SIZE; j++, pGTTmp++)
+            *pGTTmp = RT_H2LE_U32(*pGTTmp);
+
+        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage, uFileOffset,
+                                    &pImage->pGTCache->aGTCache[i].aGTData[0],
+                                    VMDK_GT_CACHELINE_SIZE * sizeof(uint32_t));
+        uFileOffset += VMDK_GT_CACHELINE_SIZE * sizeof(uint32_t);
+        if (RT_FAILURE(rc))
+            break;
+    }
+    Assert(!(uFileOffset % 512));
+    pExtent->uAppendPosition = RT_ALIGN_64(uFileOffset, 512);
+    return rc;
+}
+
+/**
+ * Internal. Free all allocated space for representing an image, and optionally
+ * delete the image from disk.
+ */
+static int vmdkFreeImage(PVMDKIMAGE pImage, bool fDelete, bool fFlush)
+{
+    int rc = VINF_SUCCESS;
+
+    /* Freeing a never allocated image (e.g. because the open failed) is
+     * not signalled as an error. After all nothing bad happens. */
+    if (pImage)
+    {
+        if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+        {
+            if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+            {
+                /* Check if all extents are clean. */
+                for (unsigned i = 0; i < pImage->cExtents; i++)
+                {
+                    Assert(!pImage->pExtents[i].fUncleanShutdown);
+                }
+            }
+            else
+            {
+                /* Mark all extents as clean. */
+                for (unsigned i = 0; i < pImage->cExtents; i++)
+                {
+                    if (   pImage->pExtents[i].enmType == VMDKETYPE_HOSTED_SPARSE
+                        && pImage->pExtents[i].fUncleanShutdown)
+                    {
+                        pImage->pExtents[i].fUncleanShutdown = false;
+                        pImage->pExtents[i].fMetaDirty = true;
+                    }
+
+                    /* From now on it's not safe to append any more data. */
+                    pImage->pExtents[i].uAppendPosition = 0;
+                }
+            }
+        }
+
+        if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+        {
+            /* No need to write any pending data if the file will be deleted
+             * or if the new file wasn't successfully created. */
+            if (   !fDelete && pImage->pExtents
+                && pImage->pExtents[0].cGTEntries
+                && pImage->pExtents[0].uAppendPosition)
+            {
+                PVMDKEXTENT pExtent = &pImage->pExtents[0];
+                uint32_t uLastGDEntry = pExtent->uLastGrainAccess / pExtent->cGTEntries;
+                rc = vmdkStreamFlushGT(pImage, pExtent, uLastGDEntry);
+                AssertRC(rc);
+                vmdkStreamClearGT(pImage, pExtent);
+                for (uint32_t i = uLastGDEntry + 1; i < pExtent->cGDEntries; i++)
+                {
+                    rc = vmdkStreamFlushGT(pImage, pExtent, i);
+                    AssertRC(rc);
+                }
+
+                uint64_t uFileOffset = pExtent->uAppendPosition;
+                if (!uFileOffset)
+                    return VERR_INTERNAL_ERROR;
+                uFileOffset = RT_ALIGN_64(uFileOffset, 512);
+
+                /* From now on it's not safe to append any more data. */
+                pExtent->uAppendPosition = 0;
+
+                /* Grain directory marker. */
+                uint8_t aMarker[512];
+                PVMDKMARKER pMarker = (PVMDKMARKER)&aMarker[0];
+                memset(pMarker, '\0', sizeof(aMarker));
+                pMarker->uSector = VMDK_BYTE2SECTOR(RT_ALIGN_64(RT_H2LE_U64((uint64_t)pExtent->cGDEntries * sizeof(uint32_t)), 512));
+                pMarker->uType = RT_H2LE_U32(VMDK_MARKER_GD);
+                rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage, uFileOffset,
+                                            aMarker, sizeof(aMarker));
+                AssertRC(rc);
+                uFileOffset += 512;
+
+                /* Write grain directory in little endian style. The array will
+                 * not be used after this, so convert in place. */
+                uint32_t *pGDTmp = pExtent->pGD;
+                for (uint32_t i = 0; i < pExtent->cGDEntries; i++, pGDTmp++)
+                    *pGDTmp = RT_H2LE_U32(*pGDTmp);
+                rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                            uFileOffset, pExtent->pGD,
+                                            pExtent->cGDEntries * sizeof(uint32_t));
+                AssertRC(rc);
+
+                pExtent->uSectorGD = VMDK_BYTE2SECTOR(uFileOffset);
+                pExtent->uSectorRGD = VMDK_BYTE2SECTOR(uFileOffset);
+                uFileOffset = RT_ALIGN_64(  uFileOffset
+                                          + pExtent->cGDEntries * sizeof(uint32_t),
+                                          512);
+
+                /* Footer marker. */
+                memset(pMarker, '\0', sizeof(aMarker));
+                pMarker->uSector = VMDK_BYTE2SECTOR(512);
+                pMarker->uType = RT_H2LE_U32(VMDK_MARKER_FOOTER);
+                rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                            uFileOffset, aMarker, sizeof(aMarker));
+                AssertRC(rc);
+
+                uFileOffset += 512;
+                rc = vmdkWriteMetaSparseExtent(pImage, pExtent, uFileOffset, NULL);
+                AssertRC(rc);
+
+                uFileOffset += 512;
+                /* End-of-stream marker. */
+                memset(pMarker, '\0', sizeof(aMarker));
+                rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                            uFileOffset, aMarker, sizeof(aMarker));
+                AssertRC(rc);
+            }
+        }
+        else if (!fDelete && fFlush)
+            vmdkFlushImage(pImage, NULL);
+
+        if (pImage->pExtents != NULL)
+        {
+            for (unsigned i = 0 ; i < pImage->cExtents; i++)
+            {
+                int rc2 = vmdkFreeExtentData(pImage, &pImage->pExtents[i], fDelete);
+                if (RT_SUCCESS(rc))
+                    rc = rc2; /* Propogate any error when closing the file. */
+            }
+            RTMemFree(pImage->pExtents);
+            pImage->pExtents = NULL;
+        }
+        pImage->cExtents = 0;
+        if (pImage->pFile != NULL)
+        {
+            int rc2 = vmdkFileClose(pImage, &pImage->pFile, fDelete);
+            if (RT_SUCCESS(rc))
+                rc = rc2; /* Propogate any error when closing the file. */
+        }
+        int rc2 = vmdkFileCheckAllClose(pImage);
+        if (RT_SUCCESS(rc))
+            rc = rc2; /* Propogate any error when closing the file. */
+
+        if (pImage->pGTCache)
+        {
+            RTMemFree(pImage->pGTCache);
+            pImage->pGTCache = NULL;
+        }
+        if (pImage->pDescData)
+        {
+            RTMemFree(pImage->pDescData);
+            pImage->pDescData = NULL;
+        }
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/**
+ * Internal. Flush image data (and metadata) to disk.
+ */
+static int vmdkFlushImage(PVMDKIMAGE pImage, PVDIOCTX pIoCtx)
+{
+    PVMDKEXTENT pExtent;
+    int rc = VINF_SUCCESS;
+
+    /* Update descriptor if changed. */
+    if (pImage->Descriptor.fDirty)
+        rc = vmdkWriteDescriptor(pImage, pIoCtx);
+
+    if (RT_SUCCESS(rc))
+    {
+        for (unsigned i = 0; i < pImage->cExtents; i++)
+        {
+            pExtent = &pImage->pExtents[i];
+            if (pExtent->pFile != NULL && pExtent->fMetaDirty)
+            {
+                switch (pExtent->enmType)
+                {
+                    case VMDKETYPE_HOSTED_SPARSE:
+                        if (!pExtent->fFooter)
+                            rc = vmdkWriteMetaSparseExtent(pImage, pExtent, 0, pIoCtx);
+                        else
+                        {
+                            uint64_t uFileOffset = pExtent->uAppendPosition;
+                            /* Simply skip writing anything if the streamOptimized
+                             * image hasn't been just created. */
+                            if (!uFileOffset)
+                                break;
+                            uFileOffset = RT_ALIGN_64(uFileOffset, 512);
+                            rc = vmdkWriteMetaSparseExtent(pImage, pExtent,
+                                                           uFileOffset, pIoCtx);
+                        }
+                        break;
+                    case VMDKETYPE_VMFS:
+                    case VMDKETYPE_FLAT:
+                        /* Nothing to do. */
+                        break;
+                    case VMDKETYPE_ZERO:
+                    default:
+                        AssertMsgFailed(("extent with type %d marked as dirty\n",
+                                         pExtent->enmType));
+                        break;
+                }
+            }
+
+            if (RT_FAILURE(rc))
+                break;
+
+            switch (pExtent->enmType)
+            {
+                case VMDKETYPE_HOSTED_SPARSE:
+                case VMDKETYPE_VMFS:
+                case VMDKETYPE_FLAT:
+                    /** @todo implement proper path absolute check. */
+                    if (   pExtent->pFile != NULL
+                        && !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                        && !(pExtent->pszBasename[0] == RTPATH_SLASH))
+                        rc = vdIfIoIntFileFlush(pImage->pIfIo, pExtent->pFile->pStorage, pIoCtx,
+                                                NULL, NULL);
+                    break;
+                case VMDKETYPE_ZERO:
+                    /* No need to do anything for this extent. */
+                    break;
+                default:
+                    AssertMsgFailed(("unknown extent type %d\n", pExtent->enmType));
+                    break;
+            }
+        }
+    }
+
+    return rc;
+}
+
+/**
+ * Internal. Find extent corresponding to the sector number in the disk.
+ */
+static int vmdkFindExtent(PVMDKIMAGE pImage, uint64_t offSector,
+                          PVMDKEXTENT *ppExtent, uint64_t *puSectorInExtent)
+{
+    PVMDKEXTENT pExtent = NULL;
+    int rc = VINF_SUCCESS;
+
+    for (unsigned i = 0; i < pImage->cExtents; i++)
+    {
+        if (offSector < pImage->pExtents[i].cNominalSectors)
+        {
+            pExtent = &pImage->pExtents[i];
+            *puSectorInExtent = offSector + pImage->pExtents[i].uSectorOffset;
+            break;
+        }
+        offSector -= pImage->pExtents[i].cNominalSectors;
+    }
+
+    if (pExtent)
+        *ppExtent = pExtent;
+    else
+        rc = VERR_IO_SECTOR_NOT_FOUND;
+
+    return rc;
+}
+
+/**
+ * Internal. Hash function for placing the grain table hash entries.
+ */
+static uint32_t vmdkGTCacheHash(PVMDKGTCACHE pCache, uint64_t uSector,
+                                unsigned uExtent)
+{
+    /** @todo this hash function is quite simple, maybe use a better one which
+     * scrambles the bits better. */
+    return (uSector + uExtent) % pCache->cEntries;
+}
+
+/**
+ * Internal. Get sector number in the extent file from the relative sector
+ * number in the extent.
+ */
+static int vmdkGetSector(PVMDKIMAGE pImage, PVDIOCTX pIoCtx,
+                         PVMDKEXTENT pExtent, uint64_t uSector,
+                         uint64_t *puExtentSector)
+{
+    PVMDKGTCACHE pCache = pImage->pGTCache;
+    uint64_t uGDIndex, uGTSector, uGTBlock;
+    uint32_t uGTHash, uGTBlockIndex;
+    PVMDKGTCACHEENTRY pGTCacheEntry;
+    uint32_t aGTDataTmp[VMDK_GT_CACHELINE_SIZE];
+    int rc;
+
+    /* For newly created and readonly/sequentially opened streamOptimized
+     * images this must be a no-op, as the grain directory is not there. */
+    if (   (   pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED
+            && pExtent->uAppendPosition)
+        || (   pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED
+            && pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY
+            && pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL))
+    {
+        *puExtentSector = 0;
+        return VINF_SUCCESS;
+    }
+
+    uGDIndex = uSector / pExtent->cSectorsPerGDE;
+    if (uGDIndex >= pExtent->cGDEntries)
+        return VERR_OUT_OF_RANGE;
+    uGTSector = pExtent->pGD[uGDIndex];
+    if (!uGTSector)
+    {
+        /* There is no grain table referenced by this grain directory
+         * entry. So there is absolutely no data in this area. */
+        *puExtentSector = 0;
+        return VINF_SUCCESS;
+    }
+
+    uGTBlock = uSector / (pExtent->cSectorsPerGrain * VMDK_GT_CACHELINE_SIZE);
+    uGTHash = vmdkGTCacheHash(pCache, uGTBlock, pExtent->uExtent);
+    pGTCacheEntry = &pCache->aGTCache[uGTHash];
+    if (    pGTCacheEntry->uExtent != pExtent->uExtent
+        ||  pGTCacheEntry->uGTBlock != uGTBlock)
+    {
+        /* Cache miss, fetch data from disk. */
+        PVDMETAXFER pMetaXfer;
+        rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pExtent->pFile->pStorage,
+                                   VMDK_SECTOR2BYTE(uGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
+                                   aGTDataTmp, sizeof(aGTDataTmp), pIoCtx, &pMetaXfer, NULL, NULL);
+        if (RT_FAILURE(rc))
+            return rc;
+        /* We can release the metadata transfer immediately. */
+        vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
+        pGTCacheEntry->uExtent = pExtent->uExtent;
+        pGTCacheEntry->uGTBlock = uGTBlock;
+        for (unsigned i = 0; i < VMDK_GT_CACHELINE_SIZE; i++)
+            pGTCacheEntry->aGTData[i] = RT_LE2H_U32(aGTDataTmp[i]);
+    }
+    uGTBlockIndex = (uSector / pExtent->cSectorsPerGrain) % VMDK_GT_CACHELINE_SIZE;
+    uint32_t uGrainSector = pGTCacheEntry->aGTData[uGTBlockIndex];
+    if (uGrainSector)
+        *puExtentSector = uGrainSector + uSector % pExtent->cSectorsPerGrain;
+    else
+        *puExtentSector = 0;
+    return VINF_SUCCESS;
+}
+
+/**
+ * Internal. Writes the grain and also if necessary the grain tables.
+ * Uses the grain table cache as a true grain table.
+ */
+static int vmdkStreamAllocGrain(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                                uint64_t uSector, PVDIOCTX pIoCtx,
+                                uint64_t cbWrite)
+{
+    uint32_t uGrain;
+    uint32_t uGDEntry, uLastGDEntry;
+    uint32_t cbGrain = 0;
+    uint32_t uCacheLine, uCacheEntry;
+    const void *pData;
+    int rc;
+
+    /* Very strict requirements: always write at least one full grain, with
+     * proper alignment. Everything else would require reading of already
+     * written data, which we don't support for obvious reasons. The only
+     * exception is the last grain, and only if the image size specifies
+     * that only some portion holds data. In any case the write must be
+     * within the image limits, no "overshoot" allowed. */
+    if (   cbWrite == 0
+        || (   cbWrite < VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain)
+            && pExtent->cNominalSectors - uSector >= pExtent->cSectorsPerGrain)
+        || uSector % pExtent->cSectorsPerGrain
+        || uSector + VMDK_BYTE2SECTOR(cbWrite) > pExtent->cNominalSectors)
+        return VERR_INVALID_PARAMETER;
+
+    /* Clip write range to at most the rest of the grain. */
+    cbWrite = RT_MIN(cbWrite, VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain - uSector % pExtent->cSectorsPerGrain));
+
+    /* Do not allow to go back. */
+    uGrain = uSector / pExtent->cSectorsPerGrain;
+    uCacheLine = uGrain % pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE;
+    uCacheEntry = uGrain % VMDK_GT_CACHELINE_SIZE;
+    uGDEntry = uGrain / pExtent->cGTEntries;
+    uLastGDEntry = pExtent->uLastGrainAccess / pExtent->cGTEntries;
+    if (uGrain < pExtent->uLastGrainAccess)
+        return VERR_VD_VMDK_INVALID_WRITE;
+
+    /* Zero byte write optimization. Since we don't tell VBoxHDD that we need
+     * to allocate something, we also need to detect the situation ourself. */
+    if (   !(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_ZEROES)
+        && vdIfIoIntIoCtxIsZero(pImage->pIfIo, pIoCtx, cbWrite, true /* fAdvance */))
+        return VINF_SUCCESS;
+
+    if (uGDEntry != uLastGDEntry)
+    {
+        rc = vmdkStreamFlushGT(pImage, pExtent, uLastGDEntry);
+        if (RT_FAILURE(rc))
+            return rc;
+        vmdkStreamClearGT(pImage, pExtent);
+        for (uint32_t i = uLastGDEntry + 1; i < uGDEntry; i++)
+        {
+            rc = vmdkStreamFlushGT(pImage, pExtent, i);
+            if (RT_FAILURE(rc))
+                return rc;
+        }
+    }
+
+    uint64_t uFileOffset;
+    uFileOffset = pExtent->uAppendPosition;
+    if (!uFileOffset)
+        return VERR_INTERNAL_ERROR;
+    /* Align to sector, as the previous write could have been any size. */
+    uFileOffset = RT_ALIGN_64(uFileOffset, 512);
+
+    /* Paranoia check: extent type, grain table buffer presence and
+     * grain table buffer space. Also grain table entry must be clear. */
+    if (   pExtent->enmType != VMDKETYPE_HOSTED_SPARSE
+        || !pImage->pGTCache
+        || pExtent->cGTEntries > VMDK_GT_CACHE_SIZE * VMDK_GT_CACHELINE_SIZE
+        || pImage->pGTCache->aGTCache[uCacheLine].aGTData[uCacheEntry])
+        return VERR_INTERNAL_ERROR;
+
+    /* Update grain table entry. */
+    pImage->pGTCache->aGTCache[uCacheLine].aGTData[uCacheEntry] = VMDK_BYTE2SECTOR(uFileOffset);
+
+    if (cbWrite != VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain))
+    {
+        vdIfIoIntIoCtxCopyFrom(pImage->pIfIo, pIoCtx, pExtent->pvGrain, cbWrite);
+        memset((char *)pExtent->pvGrain + cbWrite, '\0',
+               VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain) - cbWrite);
+        pData = pExtent->pvGrain;
+    }
+    else
+    {
+        RTSGSEG Segment;
+        unsigned cSegments = 1;
+        size_t cbSeg = 0;
+
+        cbSeg = vdIfIoIntIoCtxSegArrayCreate(pImage->pIfIo, pIoCtx, &Segment,
+                                             &cSegments, VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+        Assert(cbSeg == VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+        pData = Segment.pvSeg;
+    }
+    rc = vmdkFileDeflateSync(pImage, pExtent, uFileOffset, pData,
+                             VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain),
+                             uSector, &cbGrain);
+    if (RT_FAILURE(rc))
+    {
+        pExtent->uGrainSectorAbs = 0;
+        AssertRC(rc);
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write compressed data block in '%s'"), pExtent->pszFullname);
+    }
+    pExtent->uLastGrainAccess = uGrain;
+    pExtent->uAppendPosition += cbGrain;
+
+    return rc;
+}
+
+/**
+ * Internal: Updates the grain table during grain allocation.
+ */
+static int vmdkAllocGrainGTUpdate(PVMDKIMAGE pImage, PVMDKEXTENT pExtent, PVDIOCTX pIoCtx,
+                                  PVMDKGRAINALLOCASYNC pGrainAlloc)
+{
+    int rc = VINF_SUCCESS;
+    PVMDKGTCACHE pCache = pImage->pGTCache;
+    uint32_t aGTDataTmp[VMDK_GT_CACHELINE_SIZE];
+    uint32_t uGTHash, uGTBlockIndex;
+    uint64_t uGTSector, uRGTSector, uGTBlock;
+    uint64_t uSector = pGrainAlloc->uSector;
+    PVMDKGTCACHEENTRY pGTCacheEntry;
+
+    LogFlowFunc(("pImage=%#p pExtent=%#p pCache=%#p pIoCtx=%#p pGrainAlloc=%#p\n",
+                 pImage, pExtent, pCache, pIoCtx, pGrainAlloc));
+
+    uGTSector = pGrainAlloc->uGTSector;
+    uRGTSector = pGrainAlloc->uRGTSector;
+    LogFlow(("uGTSector=%llu uRGTSector=%llu\n", uGTSector, uRGTSector));
+
+    /* Update the grain table (and the cache). */
+    uGTBlock = uSector / (pExtent->cSectorsPerGrain * VMDK_GT_CACHELINE_SIZE);
+    uGTHash = vmdkGTCacheHash(pCache, uGTBlock, pExtent->uExtent);
+    pGTCacheEntry = &pCache->aGTCache[uGTHash];
+    if (    pGTCacheEntry->uExtent != pExtent->uExtent
+        ||  pGTCacheEntry->uGTBlock != uGTBlock)
+    {
+        /* Cache miss, fetch data from disk. */
+        LogFlow(("Cache miss, fetch data from disk\n"));
+        PVDMETAXFER pMetaXfer = NULL;
+        rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pExtent->pFile->pStorage,
+                                   VMDK_SECTOR2BYTE(uGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
+                                   aGTDataTmp, sizeof(aGTDataTmp), pIoCtx,
+                                   &pMetaXfer, vmdkAllocGrainComplete, pGrainAlloc);
+        if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        {
+            pGrainAlloc->cIoXfersPending++;
+            pGrainAlloc->fGTUpdateNeeded = true;
+            /* Leave early, we will be called  again after the read completed. */
+            LogFlowFunc(("Metadata read in progress, leaving\n"));
+            return rc;
+        }
+        else if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot read allocated grain table entry in '%s'"), pExtent->pszFullname);
+        vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
+        pGTCacheEntry->uExtent = pExtent->uExtent;
+        pGTCacheEntry->uGTBlock = uGTBlock;
+        for (unsigned i = 0; i < VMDK_GT_CACHELINE_SIZE; i++)
+            pGTCacheEntry->aGTData[i] = RT_LE2H_U32(aGTDataTmp[i]);
+    }
+    else
+    {
+        /* Cache hit. Convert grain table block back to disk format, otherwise
+         * the code below will write garbage for all but the updated entry. */
+        for (unsigned i = 0; i < VMDK_GT_CACHELINE_SIZE; i++)
+            aGTDataTmp[i] = RT_H2LE_U32(pGTCacheEntry->aGTData[i]);
+    }
+    pGrainAlloc->fGTUpdateNeeded = false;
+    uGTBlockIndex = (uSector / pExtent->cSectorsPerGrain) % VMDK_GT_CACHELINE_SIZE;
+    aGTDataTmp[uGTBlockIndex] = RT_H2LE_U32(VMDK_BYTE2SECTOR(pGrainAlloc->uGrainOffset));
+    pGTCacheEntry->aGTData[uGTBlockIndex] = VMDK_BYTE2SECTOR(pGrainAlloc->uGrainOffset);
+    /* Update grain table on disk. */
+    rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
+                                VMDK_SECTOR2BYTE(uGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
+                                aGTDataTmp, sizeof(aGTDataTmp), pIoCtx,
+                                vmdkAllocGrainComplete, pGrainAlloc);
+    if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        pGrainAlloc->cIoXfersPending++;
+    else if (RT_FAILURE(rc))
+        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write updated grain table in '%s'"), pExtent->pszFullname);
+    if (pExtent->pRGD)
+    {
+        /* Update backup grain table on disk. */
+        rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    VMDK_SECTOR2BYTE(uRGTSector) + (uGTBlock % (pExtent->cGTEntries / VMDK_GT_CACHELINE_SIZE)) * sizeof(aGTDataTmp),
+                                    aGTDataTmp, sizeof(aGTDataTmp), pIoCtx,
+                                    vmdkAllocGrainComplete, pGrainAlloc);
+        if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+            pGrainAlloc->cIoXfersPending++;
+        else if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write updated backup grain table in '%s'"), pExtent->pszFullname);
+    }
+
+    LogFlowFunc(("leaving rc=%Rrc\n", rc));
+    return rc;
+}
+
+/**
+ * Internal - complete the grain allocation by updating disk grain table if required.
+ */
+static DECLCALLBACK(int) vmdkAllocGrainComplete(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
+{
+    RT_NOREF1(rcReq);
+    int rc = VINF_SUCCESS;
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    PVMDKGRAINALLOCASYNC pGrainAlloc = (PVMDKGRAINALLOCASYNC)pvUser;
+
+    LogFlowFunc(("pBackendData=%#p pIoCtx=%#p pvUser=%#p rcReq=%Rrc\n",
+                 pBackendData, pIoCtx, pvUser, rcReq));
+
+    pGrainAlloc->cIoXfersPending--;
+    if (!pGrainAlloc->cIoXfersPending && pGrainAlloc->fGTUpdateNeeded)
+        rc = vmdkAllocGrainGTUpdate(pImage, pGrainAlloc->pExtent, pIoCtx, pGrainAlloc);
+
+    if (!pGrainAlloc->cIoXfersPending)
+    {
+        /* Grain allocation completed. */
+        RTMemFree(pGrainAlloc);
+    }
+
+    LogFlowFunc(("Leaving rc=%Rrc\n", rc));
+    return rc;
+}
+
+/**
+ * Internal. Allocates a new grain table (if necessary).
+ */
+static int vmdkAllocGrain(PVMDKIMAGE pImage, PVMDKEXTENT pExtent, PVDIOCTX pIoCtx,
+                          uint64_t uSector, uint64_t cbWrite)
+{
+    PVMDKGTCACHE pCache = pImage->pGTCache; NOREF(pCache);
+    uint64_t uGDIndex, uGTSector, uRGTSector;
+    uint64_t uFileOffset;
+    PVMDKGRAINALLOCASYNC pGrainAlloc = NULL;
+    int rc;
+
+    LogFlowFunc(("pCache=%#p pExtent=%#p pIoCtx=%#p uSector=%llu cbWrite=%llu\n",
+                 pCache, pExtent, pIoCtx, uSector, cbWrite));
+
+    pGrainAlloc = (PVMDKGRAINALLOCASYNC)RTMemAllocZ(sizeof(VMDKGRAINALLOCASYNC));
+    if (!pGrainAlloc)
+        return VERR_NO_MEMORY;
+
+    pGrainAlloc->pExtent = pExtent;
+    pGrainAlloc->uSector = uSector;
+
+    uGDIndex = uSector / pExtent->cSectorsPerGDE;
+    if (uGDIndex >= pExtent->cGDEntries)
+    {
+        RTMemFree(pGrainAlloc);
+        return VERR_OUT_OF_RANGE;
+    }
+    uGTSector = pExtent->pGD[uGDIndex];
+    if (pExtent->pRGD)
+        uRGTSector = pExtent->pRGD[uGDIndex];
+    else
+        uRGTSector = 0; /**< avoid compiler warning */
+    if (!uGTSector)
+    {
+        LogFlow(("Allocating new grain table\n"));
+
+        /* There is no grain table referenced by this grain directory
+         * entry. So there is absolutely no data in this area. Allocate
+         * a new grain table and put the reference to it in the GDs. */
+        uFileOffset = pExtent->uAppendPosition;
+        if (!uFileOffset)
+        {
+            RTMemFree(pGrainAlloc);
+            return VERR_INTERNAL_ERROR;
+        }
+        Assert(!(uFileOffset % 512));
+
+        uFileOffset = RT_ALIGN_64(uFileOffset, 512);
+        uGTSector = VMDK_BYTE2SECTOR(uFileOffset);
+
+        /* Normally the grain table is preallocated for hosted sparse extents
+         * that support more than 32 bit sector numbers. So this shouldn't
+         * ever happen on a valid extent. */
+        if (uGTSector > UINT32_MAX)
+        {
+            RTMemFree(pGrainAlloc);
+            return VERR_VD_VMDK_INVALID_HEADER;
+        }
+
+        /* Write grain table by writing the required number of grain table
+         * cache chunks. Allocate memory dynamically here or we flood the
+         * metadata cache with very small entries. */
+        size_t cbGTDataTmp = pExtent->cGTEntries * sizeof(uint32_t);
+        uint32_t *paGTDataTmp = (uint32_t *)RTMemTmpAllocZ(cbGTDataTmp);
+
+        if (!paGTDataTmp)
+        {
+            RTMemFree(pGrainAlloc);
+            return VERR_NO_MEMORY;
+        }
+
+        memset(paGTDataTmp, '\0', cbGTDataTmp);
+        rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    VMDK_SECTOR2BYTE(uGTSector),
+                                    paGTDataTmp, cbGTDataTmp, pIoCtx,
+                                    vmdkAllocGrainComplete, pGrainAlloc);
+        if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+            pGrainAlloc->cIoXfersPending++;
+        else if (RT_FAILURE(rc))
+        {
+            RTMemTmpFree(paGTDataTmp);
+            RTMemFree(pGrainAlloc);
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write grain table allocation in '%s'"), pExtent->pszFullname);
+        }
+        pExtent->uAppendPosition = RT_ALIGN_64(  pExtent->uAppendPosition
+                                               + cbGTDataTmp, 512);
+
+        if (pExtent->pRGD)
+        {
+            AssertReturn(!uRGTSector, VERR_VD_VMDK_INVALID_HEADER);
+            uFileOffset = pExtent->uAppendPosition;
+            if (!uFileOffset)
+                return VERR_INTERNAL_ERROR;
+            Assert(!(uFileOffset % 512));
+            uRGTSector = VMDK_BYTE2SECTOR(uFileOffset);
+
+            /* Normally the redundant grain table is preallocated for hosted
+             * sparse extents that support more than 32 bit sector numbers. So
+             * this shouldn't ever happen on a valid extent. */
+            if (uRGTSector > UINT32_MAX)
+            {
+                RTMemTmpFree(paGTDataTmp);
+                return VERR_VD_VMDK_INVALID_HEADER;
+            }
+
+            /* Write grain table by writing the required number of grain table
+             * cache chunks. Allocate memory dynamically here or we flood the
+             * metadata cache with very small entries. */
+            rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
+                                        VMDK_SECTOR2BYTE(uRGTSector),
+                                        paGTDataTmp, cbGTDataTmp, pIoCtx,
+                                        vmdkAllocGrainComplete, pGrainAlloc);
+            if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+                pGrainAlloc->cIoXfersPending++;
+            else if (RT_FAILURE(rc))
+            {
+                RTMemTmpFree(paGTDataTmp);
+                return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write backup grain table allocation in '%s'"), pExtent->pszFullname);
+            }
+
+            pExtent->uAppendPosition = pExtent->uAppendPosition + cbGTDataTmp;
+        }
+
+        RTMemTmpFree(paGTDataTmp);
+
+        /* Update the grain directory on disk (doing it before writing the
+         * grain table will result in a garbled extent if the operation is
+         * aborted for some reason. Otherwise the worst that can happen is
+         * some unused sectors in the extent. */
+        uint32_t uGTSectorLE = RT_H2LE_U64(uGTSector);
+        rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    VMDK_SECTOR2BYTE(pExtent->uSectorGD) + uGDIndex * sizeof(uGTSectorLE),
+                                    &uGTSectorLE, sizeof(uGTSectorLE), pIoCtx,
+                                    vmdkAllocGrainComplete, pGrainAlloc);
+        if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+            pGrainAlloc->cIoXfersPending++;
+        else if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write grain directory entry in '%s'"), pExtent->pszFullname);
+        if (pExtent->pRGD)
+        {
+            uint32_t uRGTSectorLE = RT_H2LE_U64(uRGTSector);
+            rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pExtent->pFile->pStorage,
+                                        VMDK_SECTOR2BYTE(pExtent->uSectorRGD) + uGDIndex * sizeof(uGTSectorLE),
+                                        &uRGTSectorLE, sizeof(uRGTSectorLE), pIoCtx,
+                                        vmdkAllocGrainComplete, pGrainAlloc);
+            if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+                pGrainAlloc->cIoXfersPending++;
+            else if (RT_FAILURE(rc))
+                return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write backup grain directory entry in '%s'"), pExtent->pszFullname);
+        }
+
+        /* As the final step update the in-memory copy of the GDs. */
+        pExtent->pGD[uGDIndex] = uGTSector;
+        if (pExtent->pRGD)
+            pExtent->pRGD[uGDIndex] = uRGTSector;
+    }
+
+    LogFlow(("uGTSector=%llu uRGTSector=%llu\n", uGTSector, uRGTSector));
+    pGrainAlloc->uGTSector = uGTSector;
+    pGrainAlloc->uRGTSector = uRGTSector;
+
+    uFileOffset = pExtent->uAppendPosition;
+    if (!uFileOffset)
+        return VERR_INTERNAL_ERROR;
+    Assert(!(uFileOffset % 512));
+
+    pGrainAlloc->uGrainOffset = uFileOffset;
+
+    if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+    {
+        AssertMsgReturn(vdIfIoIntIoCtxIsSynchronous(pImage->pIfIo, pIoCtx),
+                        ("Accesses to stream optimized images must be synchronous\n"),
+                        VERR_INVALID_STATE);
+
+        if (cbWrite != VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain))
+            return vdIfError(pImage->pIfError, VERR_INTERNAL_ERROR, RT_SRC_POS, N_("VMDK: not enough data for a compressed data block in '%s'"), pExtent->pszFullname);
+
+        /* Invalidate cache, just in case some code incorrectly allows mixing
+         * of reads and writes. Normally shouldn't be needed. */
+        pExtent->uGrainSectorAbs = 0;
+
+        /* Write compressed data block and the markers. */
+        uint32_t cbGrain = 0;
+        size_t cbSeg = 0;
+        RTSGSEG Segment;
+        unsigned cSegments = 1;
+
+        cbSeg = vdIfIoIntIoCtxSegArrayCreate(pImage->pIfIo, pIoCtx, &Segment,
+                                             &cSegments, cbWrite);
+        Assert(cbSeg == cbWrite);
+
+        rc = vmdkFileDeflateSync(pImage, pExtent, uFileOffset,
+                                 Segment.pvSeg, cbWrite, uSector, &cbGrain);
+        if (RT_FAILURE(rc))
+        {
+            AssertRC(rc);
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write allocated compressed data block in '%s'"), pExtent->pszFullname);
+        }
+        pExtent->uLastGrainAccess = uSector / pExtent->cSectorsPerGrain;
+        pExtent->uAppendPosition += cbGrain;
+    }
+    else
+    {
+        /* Write the data. Always a full grain, or we're in big trouble. */
+        rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    uFileOffset, pIoCtx, cbWrite,
+                                    vmdkAllocGrainComplete, pGrainAlloc);
+        if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+            pGrainAlloc->cIoXfersPending++;
+        else if (RT_FAILURE(rc))
+            return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: cannot write allocated data block in '%s'"), pExtent->pszFullname);
+
+        pExtent->uAppendPosition += cbWrite;
+    }
+
+    rc = vmdkAllocGrainGTUpdate(pImage, pExtent, pIoCtx, pGrainAlloc);
+
+    if (!pGrainAlloc->cIoXfersPending)
+    {
+        /* Grain allocation completed. */
+        RTMemFree(pGrainAlloc);
+    }
+
+    LogFlowFunc(("leaving rc=%Rrc\n", rc));
+
+    return rc;
+}
+
+/**
+ * Internal. Reads the contents by sequentially going over the compressed
+ * grains (hoping that they are in sequence).
+ */
+static int vmdkStreamReadSequential(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                                    uint64_t uSector, PVDIOCTX pIoCtx,
+                                    uint64_t cbRead)
+{
+    int rc;
+
+    LogFlowFunc(("pImage=%#p pExtent=%#p uSector=%llu pIoCtx=%#p cbRead=%llu\n",
+                 pImage, pExtent, uSector, pIoCtx, cbRead));
+
+    AssertMsgReturn(vdIfIoIntIoCtxIsSynchronous(pImage->pIfIo, pIoCtx),
+                    ("Async I/O not supported for sequential stream optimized images\n"),
+                    VERR_INVALID_STATE);
+
+    /* Do not allow to go back. */
+    uint32_t uGrain = uSector / pExtent->cSectorsPerGrain;
+    if (uGrain < pExtent->uLastGrainAccess)
+        return VERR_VD_VMDK_INVALID_STATE;
+    pExtent->uLastGrainAccess = uGrain;
+
+    /* After a previous error do not attempt to recover, as it would need
+     * seeking (in the general case backwards which is forbidden). */
+    if (!pExtent->uGrainSectorAbs)
+        return VERR_VD_VMDK_INVALID_STATE;
+
+    /* Check if we need to read something from the image or if what we have
+     * in the buffer is good to fulfill the request. */
+    if (!pExtent->cbGrainStreamRead || uGrain > pExtent->uGrain)
+    {
+        uint32_t uGrainSectorAbs =   pExtent->uGrainSectorAbs
+                                   + VMDK_BYTE2SECTOR(pExtent->cbGrainStreamRead);
+
+        /* Get the marker from the next data block - and skip everything which
+         * is not a compressed grain. If it's a compressed grain which is for
+         * the requested sector (or after), read it. */
+        VMDKMARKER Marker;
+        do
+        {
+            RT_ZERO(Marker);
+            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                       VMDK_SECTOR2BYTE(uGrainSectorAbs),
+                                       &Marker, RT_UOFFSETOF(VMDKMARKER, uType));
+            if (RT_FAILURE(rc))
+                return rc;
+            Marker.uSector = RT_LE2H_U64(Marker.uSector);
+            Marker.cbSize = RT_LE2H_U32(Marker.cbSize);
+
+            if (Marker.cbSize == 0)
+            {
+                /* A marker for something else than a compressed grain. */
+                rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                             VMDK_SECTOR2BYTE(uGrainSectorAbs)
+                                           + RT_UOFFSETOF(VMDKMARKER, uType),
+                                           &Marker.uType, sizeof(Marker.uType));
+                if (RT_FAILURE(rc))
+                    return rc;
+                Marker.uType = RT_LE2H_U32(Marker.uType);
+                switch (Marker.uType)
+                {
+                    case VMDK_MARKER_EOS:
+                        uGrainSectorAbs++;
+                        /* Read (or mostly skip) to the end of file. Uses the
+                         * Marker (LBA sector) as it is unused anyway. This
+                         * makes sure that really everything is read in the
+                         * success case. If this read fails it means the image
+                         * is truncated, but this is harmless so ignore. */
+                        vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                VMDK_SECTOR2BYTE(uGrainSectorAbs)
+                                              + 511,
+                                              &Marker.uSector, 1);
+                        break;
+                    case VMDK_MARKER_GT:
+                        uGrainSectorAbs += 1 + VMDK_BYTE2SECTOR(pExtent->cGTEntries * sizeof(uint32_t));
+                        break;
+                    case VMDK_MARKER_GD:
+                        uGrainSectorAbs += 1 + VMDK_BYTE2SECTOR(RT_ALIGN(pExtent->cGDEntries * sizeof(uint32_t), 512));
+                        break;
+                    case VMDK_MARKER_FOOTER:
+                        uGrainSectorAbs += 2;
+                        break;
+                    case VMDK_MARKER_UNSPECIFIED:
+                        /* Skip over the contents of the unspecified marker
+                         * type 4 which exists in some vSphere created files. */
+                        /** @todo figure out what the payload means. */
+                        uGrainSectorAbs += 1;
+                        break;
+                    default:
+                        AssertMsgFailed(("VMDK: corrupted marker, type=%#x\n", Marker.uType));
+                        pExtent->uGrainSectorAbs = 0;
+                        return VERR_VD_VMDK_INVALID_STATE;
+                }
+                pExtent->cbGrainStreamRead = 0;
+            }
+            else
+            {
+                /* A compressed grain marker. If it is at/after what we're
+                 * interested in read and decompress data. */
+                if (uSector > Marker.uSector + pExtent->cSectorsPerGrain)
+                {
+                    uGrainSectorAbs += VMDK_BYTE2SECTOR(RT_ALIGN(Marker.cbSize + RT_UOFFSETOF(VMDKMARKER, uType), 512));
+                    continue;
+                }
+                uint64_t uLBA = 0;
+                uint32_t cbGrainStreamRead = 0;
+                rc = vmdkFileInflateSync(pImage, pExtent,
+                                         VMDK_SECTOR2BYTE(uGrainSectorAbs),
+                                         pExtent->pvGrain,
+                                         VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain),
+                                         &Marker, &uLBA, &cbGrainStreamRead);
+                if (RT_FAILURE(rc))
+                {
+                    pExtent->uGrainSectorAbs = 0;
+                    return rc;
+                }
+                if (   pExtent->uGrain
+                    && uLBA / pExtent->cSectorsPerGrain <= pExtent->uGrain)
+                {
+                    pExtent->uGrainSectorAbs = 0;
+                    return VERR_VD_VMDK_INVALID_STATE;
+                }
+                pExtent->uGrain = uLBA / pExtent->cSectorsPerGrain;
+                pExtent->cbGrainStreamRead = cbGrainStreamRead;
+                break;
+            }
+        } while (Marker.uType != VMDK_MARKER_EOS);
+
+        pExtent->uGrainSectorAbs = uGrainSectorAbs;
+
+        if (!pExtent->cbGrainStreamRead && Marker.uType == VMDK_MARKER_EOS)
+        {
+            pExtent->uGrain = UINT32_MAX;
+            /* Must set a non-zero value for pExtent->cbGrainStreamRead or
+             * the next read would try to get more data, and we're at EOF. */
+            pExtent->cbGrainStreamRead = 1;
+        }
+    }
+
+    if (pExtent->uGrain > uSector / pExtent->cSectorsPerGrain)
+    {
+        /* The next data block we have is not for this area, so just return
+         * that there is no data. */
+        LogFlowFunc(("returns VERR_VD_BLOCK_FREE\n"));
+        return VERR_VD_BLOCK_FREE;
+    }
+
+    uint32_t uSectorInGrain = uSector % pExtent->cSectorsPerGrain;
+    vdIfIoIntIoCtxCopyTo(pImage->pIfIo, pIoCtx,
+                         (uint8_t *)pExtent->pvGrain + VMDK_SECTOR2BYTE(uSectorInGrain),
+                         cbRead);
+    LogFlowFunc(("returns VINF_SUCCESS\n"));
+    return VINF_SUCCESS;
+}
+
+/**
+ * Replaces a fragment of a string with the specified string.
+ *
+ * @returns Pointer to the allocated UTF-8 string.
+ * @param   pszWhere        UTF-8 string to search in.
+ * @param   pszWhat         UTF-8 string to search for.
+ * @param   pszByWhat       UTF-8 string to replace the found string with.
+ *
+ * @note    r=bird: This is only used by vmdkRenameWorker().  The first use is
+ *          for updating the base name in the descriptor, the second is for
+ *          generating new filenames for extents.  This code borked when
+ *          RTPathAbs started correcting the driver letter case on windows,
+ *          when strstr failed because the pExtent->pszFullname was not
+ *          subjected to RTPathAbs but while pExtent->pszFullname was.  I fixed
+ *          this by apply RTPathAbs to the places it wasn't applied.
+ *
+ *          However, this highlights some undocumented ASSUMPTIONS as well as
+ *          terrible short commings of the approach.
+ *
+ *          Given the right filename, it may also screw up the descriptor.  Take
+ *          the descriptor text 'RW 2048 SPARSE "Test0.vmdk"' for instance,
+ *          we'll be asked to replace "Test0" with something, no problem.  No,
+ *          imagine 'RW 2048 SPARSE "SPARSE.vmdk"', 'RW 2048 SPARSE "RW.vmdk"'
+ *          or 'RW 2048 SPARSE "2048.vmdk"', and the strstr approach falls on
+ *          its bum.  The descriptor string must be parsed and reconstructed,
+ *          the lazy strstr approach doesn't cut it.
+ *
+ *          I'm also curious as to what would be the correct escaping of '"' in
+ *          the file name and how that is supposed to be handled, because it
+ *          needs to be or such names must be rejected in several places (maybe
+ *          they are, I didn't check).
+ *
+ *          When this function is used to replace the start of a path, I think
+ *          the assumption from the prep/setup code is that we kind of knows
+ *          what we're working on (I could be wrong).  However, using strstr
+ *          instead of strncmp/RTStrNICmp makes no sense and isn't future proof.
+ *          Especially on unix systems, weird stuff could happen if someone
+ *          unwittingly tinkers with the prep/setup code.  What should really be
+ *          done here is using a new RTPathStartEx function that (via flags)
+ *          allows matching partial final component and returns the length of
+ *          what it matched up (in case it skipped slashes and '.' components).
+ *
+ */
+static char *vmdkStrReplace(const char *pszWhere, const char *pszWhat,
+                            const char *pszByWhat)
+{
+    AssertPtr(pszWhere);
+    AssertPtr(pszWhat);
+    AssertPtr(pszByWhat);
+    const char *pszFoundStr = strstr(pszWhere, pszWhat);
+    if (!pszFoundStr)
+    {
+        LogFlowFunc(("Failed to find '%s' in '%s'!\n", pszWhat, pszWhere));
+        return NULL;
+    }
+    size_t cbFinal = strlen(pszWhere) + 1 + strlen(pszByWhat) - strlen(pszWhat);
+    char *pszNewStr = RTStrAlloc(cbFinal);
+    if (pszNewStr)
+    {
+        char *pszTmp = pszNewStr;
+        memcpy(pszTmp, pszWhere, pszFoundStr - pszWhere);
+        pszTmp += pszFoundStr - pszWhere;
+        memcpy(pszTmp, pszByWhat, strlen(pszByWhat));
+        pszTmp += strlen(pszByWhat);
+        strcpy(pszTmp, pszFoundStr + strlen(pszWhat));
+    }
+    return pszNewStr;
+}
+
+
+/** @copydoc VDIMAGEBACKEND::pfnProbe */
+static DECLCALLBACK(int) vmdkProbe(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
+                                   PVDINTERFACE pVDIfsImage, VDTYPE enmDesiredType, VDTYPE *penmType)
+{
+    RT_NOREF(enmDesiredType);
+    LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p penmType=%#p\n",
+                 pszFilename, pVDIfsDisk, pVDIfsImage, penmType));
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+
+    int rc = VINF_SUCCESS;
+    PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
+    if (RT_LIKELY(pImage))
+    {
+        pImage->pszFilename = pszFilename;
+        pImage->pFile = NULL;
+        pImage->pExtents = NULL;
+        pImage->pFiles = NULL;
+        pImage->pGTCache = NULL;
+        pImage->pDescData = NULL;
+        pImage->pVDIfsDisk = pVDIfsDisk;
+        pImage->pVDIfsImage = pVDIfsImage;
+        /** @todo speed up this test open (VD_OPEN_FLAGS_INFO) by skipping as
+         * much as possible in vmdkOpenImage. */
+        rc = vmdkOpenImage(pImage, VD_OPEN_FLAGS_INFO | VD_OPEN_FLAGS_READONLY);
+        vmdkFreeImage(pImage, false, false /*fFlush*/);
+        RTMemFree(pImage);
+
+        if (RT_SUCCESS(rc))
+            *penmType = VDTYPE_HDD;
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnOpen */
+static DECLCALLBACK(int) vmdkOpen(const char *pszFilename, unsigned uOpenFlags,
+                                  PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
+                                  VDTYPE enmType, void **ppBackendData)
+{
+    RT_NOREF1(enmType); /**< @todo r=klaus make use of the type info. */
+
+    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p enmType=%u ppBackendData=%#p\n",
+                 pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, enmType, ppBackendData));
+    int rc;
+
+    /* Check open flags. All valid flags are supported. */
+    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+
+
+    PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
+    if (RT_LIKELY(pImage))
+    {
+        pImage->pszFilename = pszFilename;
+        pImage->pFile = NULL;
+        pImage->pExtents = NULL;
+        pImage->pFiles = NULL;
+        pImage->pGTCache = NULL;
+        pImage->pDescData = NULL;
+        pImage->pVDIfsDisk = pVDIfsDisk;
+        pImage->pVDIfsImage = pVDIfsImage;
+
+        rc = vmdkOpenImage(pImage, uOpenFlags);
+        if (RT_SUCCESS(rc))
+            *ppBackendData = pImage;
+        else
+            RTMemFree(pImage);
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnCreate */
+static DECLCALLBACK(int) vmdkCreate(const char *pszFilename, uint64_t cbSize,
+                                    unsigned uImageFlags, const char *pszComment,
+                                    PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
+                                    PCRTUUID pUuid, unsigned uOpenFlags,
+                                    unsigned uPercentStart, unsigned uPercentSpan,
+                                    PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
+                                    PVDINTERFACE pVDIfsOperation, VDTYPE enmType,
+                                    void **ppBackendData)
+{
+    LogFlowFunc(("pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" pPCHSGeometry=%#p pLCHSGeometry=%#p Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p enmType=%u ppBackendData=%#p\n",
+                 pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData));
+    int rc;
+
+    /* Check the VD container type and image flags. */
+    if (   enmType != VDTYPE_HDD
+        || (uImageFlags & ~VD_VMDK_IMAGE_FLAGS_MASK) != 0)
+        return VERR_VD_INVALID_TYPE;
+
+    /* Check size. Maximum 256TB-64K for sparse images, otherwise unlimited. */
+    if (   !(uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK)
+        && (   !cbSize
+            || (!(uImageFlags & VD_IMAGE_FLAGS_FIXED) && cbSize >= _1T * 256 - _64K)))
+        return VERR_VD_INVALID_SIZE;
+
+    /* Check image flags for invalid combinations. */
+    if (   (uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+        && (uImageFlags & ~(VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED | VD_IMAGE_FLAGS_DIFF)))
+        return VERR_INVALID_PARAMETER;
+
+    /* Check open flags. All valid flags are supported. */
+    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
+    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
+    AssertReturn(!(   uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX
+                   && !(uImageFlags & VD_IMAGE_FLAGS_FIXED)),
+                 VERR_INVALID_PARAMETER);
+
+    PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
+    if (RT_LIKELY(pImage))
+    {
+        PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
+
+        pImage->pszFilename = pszFilename;
+        pImage->pFile = NULL;
+        pImage->pExtents = NULL;
+        pImage->pFiles = NULL;
+        pImage->pGTCache = NULL;
+        pImage->pDescData = NULL;
+        pImage->pVDIfsDisk = pVDIfsDisk;
+        pImage->pVDIfsImage = pVDIfsImage;
+        /* Descriptors for split images can be pretty large, especially if the
+         * filename is long. So prepare for the worst, and allocate quite some
+         * memory for the descriptor in this case. */
+        if (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
+            pImage->cbDescAlloc = VMDK_SECTOR2BYTE(200);
+        else
+            pImage->cbDescAlloc = VMDK_SECTOR2BYTE(20);
+        pImage->pDescData = (char *)RTMemAllocZ(pImage->cbDescAlloc);
+        if (RT_LIKELY(pImage->pDescData))
+        {
+            rc = vmdkCreateImage(pImage, cbSize, uImageFlags, pszComment,
+                                 pPCHSGeometry, pLCHSGeometry, pUuid,
+                                 pIfProgress, uPercentStart, uPercentSpan);
+            if (RT_SUCCESS(rc))
+            {
+                /* So far the image is opened in read/write mode. Make sure the
+                 * image is opened in read-only mode if the caller requested that. */
+                if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                {
+                    vmdkFreeImage(pImage, false, true /*fFlush*/);
+                    rc = vmdkOpenImage(pImage, uOpenFlags);
+                }
+
+                if (RT_SUCCESS(rc))
+                    *ppBackendData = pImage;
+            }
+
+            if (RT_FAILURE(rc))
+                RTMemFree(pImage->pDescData);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+
+        if (RT_FAILURE(rc))
+            RTMemFree(pImage);
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
+    return rc;
+}
+
+/**
+ * Prepares the state for renaming a VMDK image, setting up the state and allocating
+ * memory.
+ *
+ * @returns VBox status code.
+ * @param   pImage          VMDK image instance.
+ * @param   pRenameState    The state to initialize.
+ * @param   pszFilename     The new filename.
+ */
+static int vmdkRenameStatePrepare(PVMDKIMAGE pImage, PVMDKRENAMESTATE pRenameState, const char *pszFilename)
+{
+    AssertReturn(RTPathFilename(pszFilename) != NULL, VERR_INVALID_PARAMETER);
+
+    int rc = VINF_SUCCESS;
+
+    memset(&pRenameState->DescriptorCopy, 0, sizeof(pRenameState->DescriptorCopy));
+
+    /*
+     * Allocate an array to store both old and new names of renamed files
+     * in case we have to roll back the changes. Arrays are initialized
+     * with zeros. We actually save stuff when and if we change it.
+     */
+    pRenameState->cExtents     = pImage->cExtents;
+    pRenameState->apszOldName  = (char **)RTMemTmpAllocZ((pRenameState->cExtents + 1) * sizeof(char *));
+    pRenameState->apszNewName  = (char **)RTMemTmpAllocZ((pRenameState->cExtents + 1) * sizeof(char *));
+    pRenameState->apszNewLines = (char **)RTMemTmpAllocZ(pRenameState->cExtents * sizeof(char *));
+    if (   pRenameState->apszOldName
+        && pRenameState->apszNewName
+        && pRenameState->apszNewLines)
+    {
+        /* Save the descriptor size and position. */
+        if (pImage->pDescData)
+        {
+            /* Separate descriptor file. */
+            pRenameState->fEmbeddedDesc = false;
+        }
+        else
+        {
+            /* Embedded descriptor file. */
+            pRenameState->ExtentCopy = pImage->pExtents[0];
+            pRenameState->fEmbeddedDesc = true;
+        }
+
+        /* Save the descriptor content. */
+        pRenameState->DescriptorCopy.cLines = pImage->Descriptor.cLines;
+        for (unsigned i = 0; i < pRenameState->DescriptorCopy.cLines; i++)
+        {
+            pRenameState->DescriptorCopy.aLines[i] = RTStrDup(pImage->Descriptor.aLines[i]);
+            if (!pRenameState->DescriptorCopy.aLines[i])
+            {
+                rc = VERR_NO_MEMORY;
+                break;
+            }
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Prepare both old and new base names used for string replacement. */
+            pRenameState->pszNewBaseName = RTStrDup(RTPathFilename(pszFilename));
+            AssertReturn(pRenameState->pszNewBaseName, VERR_NO_STR_MEMORY);
+            RTPathStripSuffix(pRenameState->pszNewBaseName);
+
+            pRenameState->pszOldBaseName = RTStrDup(RTPathFilename(pImage->pszFilename));
+            AssertReturn(pRenameState->pszOldBaseName, VERR_NO_STR_MEMORY);
+            RTPathStripSuffix(pRenameState->pszOldBaseName);
+
+            /* Prepare both old and new full names used for string replacement.
+               Note! Must abspath the stuff here, so the strstr weirdness later in
+                     the renaming process get a match against abspath'ed extent paths.
+                     See RTPathAbsDup call in vmdkDescriptorReadSparse(). */
+            pRenameState->pszNewFullName = RTPathAbsDup(pszFilename);
+            AssertReturn(pRenameState->pszNewFullName, VERR_NO_STR_MEMORY);
+            RTPathStripSuffix(pRenameState->pszNewFullName);
+
+            pRenameState->pszOldFullName = RTPathAbsDup(pImage->pszFilename);
+            AssertReturn(pRenameState->pszOldFullName, VERR_NO_STR_MEMORY);
+            RTPathStripSuffix(pRenameState->pszOldFullName);
+
+            /* Save the old name for easy access to the old descriptor file. */
+            pRenameState->pszOldDescName = RTStrDup(pImage->pszFilename);
+            AssertReturn(pRenameState->pszOldDescName, VERR_NO_STR_MEMORY);
+
+            /* Save old image name. */
+            pRenameState->pszOldImageName = pImage->pszFilename;
+        }
+    }
+    else
+        rc = VERR_NO_TMP_MEMORY;
+
+    return rc;
+}
+
+/**
+ * Destroys the given rename state, freeing all allocated memory.
+ *
+ * @param   pRenameState    The rename state to destroy.
+ */
+static void vmdkRenameStateDestroy(PVMDKRENAMESTATE pRenameState)
+{
+    for (unsigned i = 0; i < pRenameState->DescriptorCopy.cLines; i++)
+        if (pRenameState->DescriptorCopy.aLines[i])
+            RTStrFree(pRenameState->DescriptorCopy.aLines[i]);
+    if (pRenameState->apszOldName)
+    {
+        for (unsigned i = 0; i <= pRenameState->cExtents; i++)
+            if (pRenameState->apszOldName[i])
+                RTStrFree(pRenameState->apszOldName[i]);
+        RTMemTmpFree(pRenameState->apszOldName);
+    }
+    if (pRenameState->apszNewName)
+    {
+        for (unsigned i = 0; i <= pRenameState->cExtents; i++)
+            if (pRenameState->apszNewName[i])
+                RTStrFree(pRenameState->apszNewName[i]);
+        RTMemTmpFree(pRenameState->apszNewName);
+    }
+    if (pRenameState->apszNewLines)
+    {
+        for (unsigned i = 0; i < pRenameState->cExtents; i++)
+            if (pRenameState->apszNewLines[i])
+                RTStrFree(pRenameState->apszNewLines[i]);
+        RTMemTmpFree(pRenameState->apszNewLines);
+    }
+    if (pRenameState->pszOldDescName)
+        RTStrFree(pRenameState->pszOldDescName);
+    if (pRenameState->pszOldBaseName)
+        RTStrFree(pRenameState->pszOldBaseName);
+    if (pRenameState->pszNewBaseName)
+        RTStrFree(pRenameState->pszNewBaseName);
+    if (pRenameState->pszOldFullName)
+        RTStrFree(pRenameState->pszOldFullName);
+    if (pRenameState->pszNewFullName)
+        RTStrFree(pRenameState->pszNewFullName);
+}
+
+/**
+ * Rolls back the rename operation to the original state.
+ *
+ * @returns VBox status code.
+ * @param   pImage          VMDK image instance.
+ * @param   pRenameState    The rename state.
+ */
+static int vmdkRenameRollback(PVMDKIMAGE pImage, PVMDKRENAMESTATE pRenameState)
+{
+    int rc = VINF_SUCCESS;
+
+    if (!pRenameState->fImageFreed)
+    {
+        /*
+         * Some extents may have been closed, close the rest. We will
+         * re-open the whole thing later.
+         */
+        vmdkFreeImage(pImage, false, true /*fFlush*/);
+    }
+
+    /* Rename files back. */
+    for (unsigned i = 0; i <= pRenameState->cExtents; i++)
+    {
+        if (pRenameState->apszOldName[i])
+        {
+            rc = vdIfIoIntFileMove(pImage->pIfIo, pRenameState->apszNewName[i], pRenameState->apszOldName[i], 0);
+            AssertRC(rc);
+        }
+    }
+    /* Restore the old descriptor. */
+    PVMDKFILE pFile;
+    rc = vmdkFileOpen(pImage, &pFile, NULL, pRenameState->pszOldDescName,
+                      VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_NORMAL,
+                                                 false /* fCreate */));
+    AssertRC(rc);
+    if (pRenameState->fEmbeddedDesc)
+    {
+        pRenameState->ExtentCopy.pFile = pFile;
+        pImage->pExtents = &pRenameState->ExtentCopy;
+    }
+    else
+    {
+        /* Shouldn't be null for separate descriptor.
+         * There will be no access to the actual content.
+         */
+        pImage->pDescData = pRenameState->pszOldDescName;
+        pImage->pFile = pFile;
+    }
+    pImage->Descriptor = pRenameState->DescriptorCopy;
+    vmdkWriteDescriptor(pImage, NULL);
+    vmdkFileClose(pImage, &pFile, false);
+    /* Get rid of the stuff we implanted. */
+    pImage->pExtents = NULL;
+    pImage->pFile = NULL;
+    pImage->pDescData = NULL;
+    /* Re-open the image back. */
+    pImage->pszFilename = pRenameState->pszOldImageName;
+    rc = vmdkOpenImage(pImage, pImage->uOpenFlags);
+
+    return rc;
+}
+
+/**
+ * Rename worker doing the real work.
+ *
+ * @returns VBox status code.
+ * @param   pImage          VMDK image instance.
+ * @param   pRenameState    The rename state.
+ * @param   pszFilename     The new filename.
+ */
+static int vmdkRenameWorker(PVMDKIMAGE pImage, PVMDKRENAMESTATE pRenameState, const char *pszFilename)
+{
+    int rc = VINF_SUCCESS;
+    unsigned i, line;
+
+    /* Update the descriptor with modified extent names. */
+    for (i = 0, line = pImage->Descriptor.uFirstExtent;
+        i < pRenameState->cExtents;
+        i++, line = pImage->Descriptor.aNextLines[line])
+    {
+        /* Update the descriptor. */
+        pRenameState->apszNewLines[i] = vmdkStrReplace(pImage->Descriptor.aLines[line],
+                                                       pRenameState->pszOldBaseName,
+                                                       pRenameState->pszNewBaseName);
+        if (!pRenameState->apszNewLines[i])
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+        pImage->Descriptor.aLines[line] = pRenameState->apszNewLines[i];
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        /* Make sure the descriptor gets written back. */
+        pImage->Descriptor.fDirty = true;
+        /* Flush the descriptor now, in case it is embedded. */
+        vmdkFlushImage(pImage, NULL);
+
+        /* Close and rename/move extents. */
+        for (i = 0; i < pRenameState->cExtents; i++)
+        {
+            PVMDKEXTENT pExtent = &pImage->pExtents[i];
+            /* Compose new name for the extent. */
+            pRenameState->apszNewName[i] = vmdkStrReplace(pExtent->pszFullname,
+                                                          pRenameState->pszOldFullName,
+                                                          pRenameState->pszNewFullName);
+            if (!pRenameState->apszNewName[i])
+            {
+                rc = VERR_NO_MEMORY;
+                break;
+            }
+            /* Close the extent file. */
+            rc = vmdkFileClose(pImage, &pExtent->pFile, false);
+            if (RT_FAILURE(rc))
+                break;;
+
+            /* Rename the extent file. */
+            rc = vdIfIoIntFileMove(pImage->pIfIo, pExtent->pszFullname, pRenameState->apszNewName[i], 0);
+            if (RT_FAILURE(rc))
+                break;
+            /* Remember the old name. */
+            pRenameState->apszOldName[i] = RTStrDup(pExtent->pszFullname);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Release all old stuff. */
+            rc = vmdkFreeImage(pImage, false, true /*fFlush*/);
+            if (RT_SUCCESS(rc))
+            {
+                pRenameState->fImageFreed = true;
+
+                /* Last elements of new/old name arrays are intended for
+                 * storing descriptor's names.
+                 */
+                pRenameState->apszNewName[pRenameState->cExtents] = RTStrDup(pszFilename);
+                /* Rename the descriptor file if it's separate. */
+                if (!pRenameState->fEmbeddedDesc)
+                {
+                    rc = vdIfIoIntFileMove(pImage->pIfIo, pImage->pszFilename, pRenameState->apszNewName[pRenameState->cExtents], 0);
+                    if (RT_SUCCESS(rc))
+                    {
+                        /* Save old name only if we may need to change it back. */
+                        pRenameState->apszOldName[pRenameState->cExtents] = RTStrDup(pszFilename);
+                    }
+                }
+
+                /* Update pImage with the new information. */
+                pImage->pszFilename = pszFilename;
+
+                /* Open the new image. */
+                rc = vmdkOpenImage(pImage, pImage->uOpenFlags);
+            }
+        }
+    }
+
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnRename */
+static DECLCALLBACK(int) vmdkRename(void *pBackendData, const char *pszFilename)
+{
+    LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
+
+    PVMDKIMAGE  pImage  = (PVMDKIMAGE)pBackendData;
+    VMDKRENAMESTATE RenameState;
+
+    memset(&RenameState, 0, sizeof(RenameState));
+
+    /* Check arguments. */
+    AssertPtrReturn(pImage, VERR_INVALID_POINTER);
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+    AssertReturn(!(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK), VERR_INVALID_PARAMETER);
+
+    int rc = vmdkRenameStatePrepare(pImage, &RenameState, pszFilename);
+    if (RT_SUCCESS(rc))
+    {
+        /* --- Up to this point we have not done any damage yet. --- */
+
+        rc = vmdkRenameWorker(pImage, &RenameState, pszFilename);
+        /* Roll back all changes in case of failure. */
+        if (RT_FAILURE(rc))
+        {
+            int rrc = vmdkRenameRollback(pImage, &RenameState);
+            AssertRC(rrc);
+        }
+    }
+
+    vmdkRenameStateDestroy(&RenameState);
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnClose */
+static DECLCALLBACK(int) vmdkClose(void *pBackendData, bool fDelete)
+{
+    LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    int rc = vmdkFreeImage(pImage, fDelete, true /*fFlush*/);
+    RTMemFree(pImage);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnRead */
+static DECLCALLBACK(int) vmdkRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
+                                  PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
+{
+    LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
+                 pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    AssertPtr(pImage);
+    Assert(uOffset % 512 == 0);
+    Assert(cbToRead % 512 == 0);
+    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
+    AssertReturn(cbToRead, VERR_INVALID_PARAMETER);
+    AssertReturn(uOffset + cbToRead <= pImage->cbSize, VERR_INVALID_PARAMETER);
+
+    /* Find the extent and check access permissions as defined in the extent descriptor. */
+    PVMDKEXTENT pExtent;
+    uint64_t uSectorExtentRel;
+    int rc = vmdkFindExtent(pImage, VMDK_BYTE2SECTOR(uOffset),
+                            &pExtent, &uSectorExtentRel);
+    if (   RT_SUCCESS(rc)
+        && pExtent->enmAccess != VMDKACCESS_NOACCESS)
+    {
+        /* Clip read range to remain in this extent. */
+        cbToRead = RT_MIN(cbToRead, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
+
+        /* Handle the read according to the current extent type. */
+        switch (pExtent->enmType)
+        {
+            case VMDKETYPE_HOSTED_SPARSE:
+            {
+                uint64_t uSectorExtentAbs;
+
+                rc = vmdkGetSector(pImage, pIoCtx, pExtent, uSectorExtentRel, &uSectorExtentAbs);
+                if (RT_FAILURE(rc))
+                    break;
+                /* Clip read range to at most the rest of the grain. */
+                cbToRead = RT_MIN(cbToRead, VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain - uSectorExtentRel % pExtent->cSectorsPerGrain));
+                Assert(!(cbToRead % 512));
+                if (uSectorExtentAbs == 0)
+                {
+                    if (   !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+                        || !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                        || !(pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL))
+                        rc = VERR_VD_BLOCK_FREE;
+                    else
+                        rc = vmdkStreamReadSequential(pImage, pExtent,
+                                                      uSectorExtentRel,
+                                                      pIoCtx, cbToRead);
+                }
+                else
+                {
+                    if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+                    {
+                        AssertMsg(vdIfIoIntIoCtxIsSynchronous(pImage->pIfIo, pIoCtx),
+                                  ("Async I/O is not supported for stream optimized VMDK's\n"));
+
+                        uint32_t uSectorInGrain = uSectorExtentRel % pExtent->cSectorsPerGrain;
+                        uSectorExtentAbs -= uSectorInGrain;
+                        if (pExtent->uGrainSectorAbs != uSectorExtentAbs)
+                        {
+                            uint64_t uLBA = 0; /* gcc maybe uninitialized */
+                            rc = vmdkFileInflateSync(pImage, pExtent,
+                                                     VMDK_SECTOR2BYTE(uSectorExtentAbs),
+                                                     pExtent->pvGrain,
+                                                     VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain),
+                                                     NULL, &uLBA, NULL);
+                            if (RT_FAILURE(rc))
+                            {
+                                pExtent->uGrainSectorAbs = 0;
+                                break;
+                            }
+                            pExtent->uGrainSectorAbs = uSectorExtentAbs;
+                            pExtent->uGrain = uSectorExtentRel / pExtent->cSectorsPerGrain;
+                            Assert(uLBA == uSectorExtentRel);
+                        }
+                        vdIfIoIntIoCtxCopyTo(pImage->pIfIo, pIoCtx,
+                                               (uint8_t *)pExtent->pvGrain
+                                             + VMDK_SECTOR2BYTE(uSectorInGrain),
+                                             cbToRead);
+                    }
+                    else
+                        rc = vdIfIoIntFileReadUser(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                   VMDK_SECTOR2BYTE(uSectorExtentAbs),
+                                                   pIoCtx, cbToRead);
+                }
+                break;
+            }
+            case VMDKETYPE_VMFS:
+            case VMDKETYPE_FLAT:
+                rc = vdIfIoIntFileReadUser(pImage->pIfIo, pExtent->pFile->pStorage,
+                                           VMDK_SECTOR2BYTE(uSectorExtentRel),
+                                           pIoCtx, cbToRead);
+                break;
+            case VMDKETYPE_ZERO:
+            {
+                size_t cbSet;
+
+                cbSet = vdIfIoIntIoCtxSet(pImage->pIfIo, pIoCtx, 0, cbToRead);
+                Assert(cbSet == cbToRead);
+                break;
+            }
+        }
+        if (pcbActuallyRead)
+            *pcbActuallyRead = cbToRead;
+    }
+    else if (RT_SUCCESS(rc))
+        rc = VERR_VD_VMDK_INVALID_STATE;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnWrite */
+static DECLCALLBACK(int) vmdkWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
+                                   PVDIOCTX pIoCtx, size_t *pcbWriteProcess, size_t *pcbPreRead,
+                                   size_t *pcbPostRead, unsigned fWrite)
+{
+    LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
+                 pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    AssertPtr(pImage);
+    Assert(uOffset % 512 == 0);
+    Assert(cbToWrite % 512 == 0);
+    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
+    AssertReturn(cbToWrite, VERR_INVALID_PARAMETER);
+
+    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+    {
+        PVMDKEXTENT pExtent;
+        uint64_t uSectorExtentRel;
+        uint64_t uSectorExtentAbs;
+
+        /* No size check here, will do that later when the extent is located.
+         * There are sparse images out there which according to the spec are
+         * invalid, because the total size is not a multiple of the grain size.
+         * Also for sparse images which are stitched together in odd ways (not at
+         * grain boundaries, and with the nominal size not being a multiple of the
+         * grain size), this would prevent writing to the last grain. */
+
+        rc = vmdkFindExtent(pImage, VMDK_BYTE2SECTOR(uOffset),
+                            &pExtent, &uSectorExtentRel);
+        if (RT_SUCCESS(rc))
+        {
+            if (   pExtent->enmAccess != VMDKACCESS_READWRITE
+                && (   !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+                    && !pImage->pExtents[0].uAppendPosition
+                    && pExtent->enmAccess != VMDKACCESS_READONLY))
+                rc = VERR_VD_VMDK_INVALID_STATE;
+            else
+            {
+                /* Handle the write according to the current extent type. */
+                switch (pExtent->enmType)
+                {
+                    case VMDKETYPE_HOSTED_SPARSE:
+                        rc = vmdkGetSector(pImage, pIoCtx, pExtent, uSectorExtentRel, &uSectorExtentAbs);
+                        if (RT_SUCCESS(rc))
+                        {
+                            if (    pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED
+                                &&  uSectorExtentRel < (uint64_t)pExtent->uLastGrainAccess * pExtent->cSectorsPerGrain)
+                                rc = VERR_VD_VMDK_INVALID_WRITE;
+                            else
+                            {
+                                /* Clip write range to at most the rest of the grain. */
+                                cbToWrite = RT_MIN(cbToWrite,
+                                                   VMDK_SECTOR2BYTE(  pExtent->cSectorsPerGrain
+                                                                    - uSectorExtentRel % pExtent->cSectorsPerGrain));
+                                if (uSectorExtentAbs == 0)
+                                {
+                                    if (!(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
+                                    {
+                                        if (cbToWrite == VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain))
+                                        {
+                                            /* Full block write to a previously unallocated block.
+                                             * Check if the caller wants to avoid the automatic alloc. */
+                                            if (!(fWrite & VD_WRITE_NO_ALLOC))
+                                            {
+                                                /* Allocate GT and find out where to store the grain. */
+                                                rc = vmdkAllocGrain(pImage, pExtent, pIoCtx,
+                                                                    uSectorExtentRel, cbToWrite);
+                                            }
+                                            else
+                                                rc = VERR_VD_BLOCK_FREE;
+                                            *pcbPreRead = 0;
+                                            *pcbPostRead = 0;
+                                        }
+                                        else
+                                        {
+                                            /* Clip write range to remain in this extent. */
+                                            cbToWrite = RT_MIN(cbToWrite,
+                                                               VMDK_SECTOR2BYTE(  pExtent->uSectorOffset
+                                                                                + pExtent->cNominalSectors - uSectorExtentRel));
+                                            *pcbPreRead = VMDK_SECTOR2BYTE(uSectorExtentRel % pExtent->cSectorsPerGrain);
+                                            *pcbPostRead = VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain) - cbToWrite - *pcbPreRead;
+                                            rc = VERR_VD_BLOCK_FREE;
+                                        }
+                                    }
+                                    else
+                                        rc = vmdkStreamAllocGrain(pImage, pExtent, uSectorExtentRel,
+                                                                  pIoCtx, cbToWrite);
+                                }
+                                else
+                                {
+                                    if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+                                    {
+                                        /* A partial write to a streamOptimized image is simply
+                                         * invalid. It requires rewriting already compressed data
+                                         * which is somewhere between expensive and impossible. */
+                                        rc = VERR_VD_VMDK_INVALID_STATE;
+                                        pExtent->uGrainSectorAbs = 0;
+                                        AssertRC(rc);
+                                    }
+                                    else
+                                    {
+                                        Assert(!(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED));
+                                        rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                                    VMDK_SECTOR2BYTE(uSectorExtentAbs),
+                                                                    pIoCtx, cbToWrite, NULL, NULL);
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case VMDKETYPE_VMFS:
+                    case VMDKETYPE_FLAT:
+                        /* Clip write range to remain in this extent. */
+                        cbToWrite = RT_MIN(cbToWrite, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
+                        rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                    VMDK_SECTOR2BYTE(uSectorExtentRel),
+                                                    pIoCtx, cbToWrite, NULL, NULL);
+                        break;
+                    case VMDKETYPE_ZERO:
+                        /* Clip write range to remain in this extent. */
+                        cbToWrite = RT_MIN(cbToWrite, VMDK_SECTOR2BYTE(pExtent->uSectorOffset + pExtent->cNominalSectors - uSectorExtentRel));
+                        break;
+                }
+            }
+
+            if (pcbWriteProcess)
+                *pcbWriteProcess = cbToWrite;
+        }
+    }
+    else
+        rc = VERR_VD_IMAGE_READ_ONLY;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnFlush */
+static DECLCALLBACK(int) vmdkFlush(void *pBackendData, PVDIOCTX pIoCtx)
+{
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    return vmdkFlushImage(pImage, pIoCtx);
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetVersion */
+static DECLCALLBACK(unsigned) vmdkGetVersion(void *pBackendData)
+{
+    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    AssertPtrReturn(pImage, 0);
+
+    return VMDK_IMAGE_VERSION;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
+static DECLCALLBACK(uint64_t) vmdkGetFileSize(void *pBackendData)
+{
+    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    uint64_t cb = 0;
+
+    AssertPtrReturn(pImage, 0);
+
+    if (pImage->pFile != NULL)
+    {
+        uint64_t cbFile;
+        int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pFile->pStorage, &cbFile);
+        if (RT_SUCCESS(rc))
+            cb += cbFile;
+    }
+    for (unsigned i = 0; i < pImage->cExtents; i++)
+    {
+        if (pImage->pExtents[i].pFile != NULL)
+        {
+            uint64_t cbFile;
+            int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pExtents[i].pFile->pStorage, &cbFile);
+            if (RT_SUCCESS(rc))
+                cb += cbFile;
+        }
+    }
+
+    LogFlowFunc(("returns %lld\n", cb));
+    return cb;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetPCHSGeometry */
+static DECLCALLBACK(int) vmdkGetPCHSGeometry(void *pBackendData, PVDGEOMETRY pPCHSGeometry)
+{
+    LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc = VINF_SUCCESS;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    if (pImage->PCHSGeometry.cCylinders)
+        *pPCHSGeometry = pImage->PCHSGeometry;
+    else
+        rc = VERR_VD_GEOMETRY_NOT_SET;
+
+    LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnSetPCHSGeometry */
+static DECLCALLBACK(int) vmdkSetPCHSGeometry(void *pBackendData, PCVDGEOMETRY pPCHSGeometry)
+{
+    LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
+                 pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc = VINF_SUCCESS;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+    {
+        if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
+        {
+            rc = vmdkDescSetPCHSGeometry(pImage, pPCHSGeometry);
+            if (RT_SUCCESS(rc))
+                pImage->PCHSGeometry = *pPCHSGeometry;
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_IMAGE_READ_ONLY;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetLCHSGeometry */
+static DECLCALLBACK(int) vmdkGetLCHSGeometry(void *pBackendData, PVDGEOMETRY pLCHSGeometry)
+{
+    LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc = VINF_SUCCESS;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    if (pImage->LCHSGeometry.cCylinders)
+        *pLCHSGeometry = pImage->LCHSGeometry;
+    else
+        rc = VERR_VD_GEOMETRY_NOT_SET;
+
+    LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnSetLCHSGeometry */
+static DECLCALLBACK(int) vmdkSetLCHSGeometry(void *pBackendData, PCVDGEOMETRY pLCHSGeometry)
+{
+    LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n",
+                 pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc = VINF_SUCCESS;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+    {
+        if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
+        {
+            rc = vmdkDescSetLCHSGeometry(pImage, pLCHSGeometry);
+            if (RT_SUCCESS(rc))
+                pImage->LCHSGeometry = *pLCHSGeometry;
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_IMAGE_READ_ONLY;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
+static DECLCALLBACK(int) vmdkQueryRegions(void *pBackendData, PCVDREGIONLIST *ppRegionList)
+{
+    LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
+    PVMDKIMAGE pThis = (PVMDKIMAGE)pBackendData;
+
+    AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
+
+    *ppRegionList = &pThis->RegionList;
+    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
+    return VINF_SUCCESS;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
+static DECLCALLBACK(void) vmdkRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
+{
+    RT_NOREF1(pRegionList);
+    LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
+    PVMDKIMAGE pThis = (PVMDKIMAGE)pBackendData;
+    AssertPtr(pThis); RT_NOREF(pThis);
+
+    /* Nothing to do here. */
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetImageFlags */
+static DECLCALLBACK(unsigned) vmdkGetImageFlags(void *pBackendData)
+{
+    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    AssertPtrReturn(pImage, 0);
+
+    LogFlowFunc(("returns %#x\n", pImage->uImageFlags));
+    return pImage->uImageFlags;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetOpenFlags */
+static DECLCALLBACK(unsigned) vmdkGetOpenFlags(void *pBackendData)
+{
+    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    AssertPtrReturn(pImage, 0);
+
+    LogFlowFunc(("returns %#x\n", pImage->uOpenFlags));
+    return pImage->uOpenFlags;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnSetOpenFlags */
+static DECLCALLBACK(int) vmdkSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
+{
+    LogFlowFunc(("pBackendData=%#p uOpenFlags=%#x\n", pBackendData, uOpenFlags));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    /* Image must be opened and the new flags must be valid. */
+    if (!pImage || (uOpenFlags & ~(  VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO
+                                   | VD_OPEN_FLAGS_ASYNC_IO | VD_OPEN_FLAGS_SHAREABLE
+                                   | VD_OPEN_FLAGS_SEQUENTIAL | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
+        rc = VERR_INVALID_PARAMETER;
+    else
+    {
+        /* StreamOptimized images need special treatment: reopen is prohibited. */
+        if (pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+        {
+            if (pImage->uOpenFlags == uOpenFlags)
+                rc = VINF_SUCCESS;
+            else
+                rc = VERR_INVALID_PARAMETER;
+        }
+        else
+        {
+            /* Implement this operation via reopening the image. */
+            vmdkFreeImage(pImage, false, true /*fFlush*/);
+            rc = vmdkOpenImage(pImage, uOpenFlags);
+        }
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetComment */
+static DECLCALLBACK(int) vmdkGetComment(void *pBackendData, char *pszComment, size_t cbComment)
+{
+    LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    char *pszCommentEncoded = NULL;
+    int rc = vmdkDescDDBGetStr(pImage, &pImage->Descriptor,
+                               "ddb.comment", &pszCommentEncoded);
+    if (rc == VERR_VD_VMDK_VALUE_NOT_FOUND)
+    {
+        pszCommentEncoded = NULL;
+        rc = VINF_SUCCESS;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        if (pszComment && pszCommentEncoded)
+            rc = vmdkDecodeString(pszCommentEncoded, pszComment, cbComment);
+        else if (pszComment)
+                *pszComment = '\0';
+
+        if (pszCommentEncoded)
+            RTMemTmpFree(pszCommentEncoded);
+    }
+
+    LogFlowFunc(("returns %Rrc comment='%s'\n", rc, pszComment));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnSetComment */
+static DECLCALLBACK(int) vmdkSetComment(void *pBackendData, const char *pszComment)
+{
+    LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+    {
+        if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
+            rc = vmdkSetImageComment(pImage, pszComment);
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_IMAGE_READ_ONLY;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetUuid */
+static DECLCALLBACK(int) vmdkGetUuid(void *pBackendData, PRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    *pUuid = pImage->ImageUuid;
+
+    LogFlowFunc(("returns %Rrc (%RTuuid)\n", VINF_SUCCESS, pUuid));
+    return VINF_SUCCESS;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnSetUuid */
+static DECLCALLBACK(int) vmdkSetUuid(void *pBackendData, PCRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc = VINF_SUCCESS;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+    {
+        if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
+        {
+            pImage->ImageUuid = *pUuid;
+            rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                                    VMDK_DDB_IMAGE_UUID, pUuid);
+            if (RT_FAILURE(rc))
+                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                               N_("VMDK: error storing image UUID in descriptor in '%s'"), pImage->pszFilename);
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_IMAGE_READ_ONLY;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetModificationUuid */
+static DECLCALLBACK(int) vmdkGetModificationUuid(void *pBackendData, PRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    *pUuid = pImage->ModificationUuid;
+
+    LogFlowFunc(("returns %Rrc (%RTuuid)\n", VINF_SUCCESS, pUuid));
+    return VINF_SUCCESS;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnSetModificationUuid */
+static DECLCALLBACK(int) vmdkSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc = VINF_SUCCESS;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+    {
+        if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
+        {
+            /* Only touch the modification uuid if it changed. */
+            if (RTUuidCompare(&pImage->ModificationUuid, pUuid))
+            {
+                pImage->ModificationUuid = *pUuid;
+                rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                                        VMDK_DDB_MODIFICATION_UUID, pUuid);
+                if (RT_FAILURE(rc))
+                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing modification UUID in descriptor in '%s'"), pImage->pszFilename);
+            }
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_IMAGE_READ_ONLY;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetParentUuid */
+static DECLCALLBACK(int) vmdkGetParentUuid(void *pBackendData, PRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    *pUuid = pImage->ParentUuid;
+
+    LogFlowFunc(("returns %Rrc (%RTuuid)\n", VINF_SUCCESS, pUuid));
+    return VINF_SUCCESS;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnSetParentUuid */
+static DECLCALLBACK(int) vmdkSetParentUuid(void *pBackendData, PCRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc = VINF_SUCCESS;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+    {
+        if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
+        {
+            pImage->ParentUuid = *pUuid;
+            rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                                    VMDK_DDB_PARENT_UUID, pUuid);
+            if (RT_FAILURE(rc))
+                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
+                               N_("VMDK: error storing parent image UUID in descriptor in '%s'"), pImage->pszFilename);
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_IMAGE_READ_ONLY;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnGetParentModificationUuid */
+static DECLCALLBACK(int) vmdkGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    *pUuid = pImage->ParentModificationUuid;
+
+    LogFlowFunc(("returns %Rrc (%RTuuid)\n", VINF_SUCCESS, pUuid));
+    return VINF_SUCCESS;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnSetParentModificationUuid */
+static DECLCALLBACK(int) vmdkSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc = VINF_SUCCESS;
+
+    AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
+
+    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
+    {
+        if (!(pImage->uOpenFlags & VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED))
+        {
+            pImage->ParentModificationUuid = *pUuid;
+            rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                                    VMDK_DDB_PARENT_MODIFICATION_UUID, pUuid);
+            if (RT_FAILURE(rc))
+                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: error storing parent image UUID in descriptor in '%s'"), pImage->pszFilename);
+        }
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_IMAGE_READ_ONLY;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnDump */
+static DECLCALLBACK(void) vmdkDump(void *pBackendData)
+{
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+
+    AssertPtrReturnVoid(pImage);
+    vdIfErrorMessage(pImage->pIfError, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%llu\n",
+                     pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
+                     pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
+                     VMDK_BYTE2SECTOR(pImage->cbSize));
+    vdIfErrorMessage(pImage->pIfError, "Header: uuidCreation={%RTuuid}\n", &pImage->ImageUuid);
+    vdIfErrorMessage(pImage->pIfError, "Header: uuidModification={%RTuuid}\n", &pImage->ModificationUuid);
+    vdIfErrorMessage(pImage->pIfError, "Header: uuidParent={%RTuuid}\n", &pImage->ParentUuid);
+    vdIfErrorMessage(pImage->pIfError, "Header: uuidParentModification={%RTuuid}\n", &pImage->ParentModificationUuid);
+}
+
+
+/**
+ * Returns the size, in bytes, of the sparse extent overhead for
+ * the number of desired total sectors and based on the current
+ * sectors of the extent.
+ *
+ * @returns uint64_t size of new overhead in bytes.
+ * @param   pExtent         VMDK extent instance.
+ * @param   cSectorsNew     Number of desired total sectors.
+ */
+static uint64_t vmdkGetNewOverhead(PVMDKEXTENT pExtent, uint64_t cSectorsNew)
+{
+    uint64_t cNewDirEntries = cSectorsNew / pExtent->cSectorsPerGDE;
+    if (cSectorsNew % pExtent->cSectorsPerGDE)
+        cNewDirEntries++;
+
+    size_t cbNewGD = cNewDirEntries * sizeof(uint32_t);
+    uint64_t cbNewDirSize = RT_ALIGN_64(cbNewGD, 512);
+    uint64_t cbNewAllTablesSize = RT_ALIGN_64(cNewDirEntries * pExtent->cGTEntries * sizeof(uint32_t), 512);
+    uint64_t cbNewOverhead = RT_ALIGN_Z(RT_MAX(pExtent->uDescriptorSector
+                                                + pExtent->cDescriptorSectors, 1)
+                                                + cbNewDirSize + cbNewAllTablesSize, 512);
+    cbNewOverhead += cbNewDirSize + cbNewAllTablesSize;
+    cbNewOverhead = RT_ALIGN_64(cbNewOverhead,
+                                VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+
+    return cbNewOverhead;
+}
+
+/**
+ * Internal: Replaces the size (in sectors) of an extent in the descriptor file.
+ *
+ * @returns VBox status code.
+ * @param   pImage              VMDK image instance.
+ * @param   pExtent             VMDK extent instance.
+ * @param   uLine               Line number of descriptor to change.
+ * @param   cSectorsOld         Existing number of sectors.
+ * @param   cSectorsNew         New number of sectors.
+ */
+static int vmdkReplaceExtentSize(PVMDKIMAGE pImage, PVMDKEXTENT pExtent, unsigned uLine, uint64_t cSectorsOld,
+                                 uint64_t cSectorsNew)
+{
+    char szOldExtentSectors[UINT64_MAX_BUFF_SIZE];
+    char szNewExtentSectors[UINT64_MAX_BUFF_SIZE];
+
+    ssize_t cbWritten = RTStrPrintf2(szOldExtentSectors, sizeof(szOldExtentSectors), "%llu", cSectorsOld);
+    if (cbWritten <= 0 || cbWritten > (ssize_t)sizeof(szOldExtentSectors))
+        return VERR_BUFFER_OVERFLOW;
+
+    cbWritten = RTStrPrintf2(szNewExtentSectors, sizeof(szNewExtentSectors), "%llu", cSectorsNew);
+    if (cbWritten <= 0 || cbWritten > (ssize_t)sizeof(szNewExtentSectors))
+        return VERR_BUFFER_OVERFLOW;
+
+    char *pszNewExtentLine = vmdkStrReplace(pImage->Descriptor.aLines[uLine],
+                                            szOldExtentSectors,
+                                            szNewExtentSectors);
+
+    if (RT_UNLIKELY(!pszNewExtentLine))
+        return VERR_INVALID_PARAMETER;
+
+    vmdkDescExtRemoveByLine(pImage, &pImage->Descriptor, uLine);
+    vmdkDescExtInsert(pImage, &pImage->Descriptor,
+                      pExtent->enmAccess, cSectorsNew,
+                      pExtent->enmType, pExtent->pszBasename, pExtent->uSectorOffset);
+
+    RTStrFree(pszNewExtentLine);
+    pszNewExtentLine = NULL;
+
+    pImage->Descriptor.fDirty = true;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Moves sectors down to make room for new overhead.
+ * Used for sparse extent resize.
+ *
+ * @returns VBox status code.
+ * @param   pImage          VMDK image instance.
+ * @param   pExtent         VMDK extent instance.
+ * @param   cSectorsNew     Number of sectors after resize.
+ */
+static int vmdkRelocateSectorsForSparseResize(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                                              uint64_t cSectorsNew)
+{
+    int rc = VINF_SUCCESS;
+
+    uint64_t cbNewOverhead = vmdkGetNewOverhead(pExtent, cSectorsNew);
+
+    uint64_t cNewOverheadSectors = VMDK_BYTE2SECTOR(cbNewOverhead);
+    uint64_t cOverheadSectorDiff = cNewOverheadSectors - pExtent->cOverheadSectors;
+
+    uint64_t cbFile = 0;
+    rc = vdIfIoIntFileGetSize(pImage->pIfIo, pExtent->pFile->pStorage, &cbFile);
+
+    uint64_t uNewAppendPosition;
+
+    /* Calculate how many sectors need to be relocated. */
+    unsigned cSectorsReloc = cOverheadSectorDiff;
+    if (cbNewOverhead % VMDK_SECTOR_SIZE)
+        cSectorsReloc++;
+
+    if (cSectorsReloc < pExtent->cSectors)
+        uNewAppendPosition = RT_ALIGN_Z(cbFile + VMDK_SECTOR2BYTE(cOverheadSectorDiff), 512);
+    else
+        uNewAppendPosition = cbFile;
+
+    /*
+    * Get the blocks we need to relocate first, they are appended to the end
+    * of the image.
+    */
+    void *pvBuf = NULL, *pvZero = NULL;
+    do
+    {
+        /* Allocate data buffer. */
+        pvBuf = RTMemAllocZ(VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+        if (!pvBuf)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        /* Allocate buffer for overwriting with zeroes. */
+        pvZero = RTMemAllocZ(VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+        if (!pvZero)
+        {
+            RTMemFree(pvBuf);
+            pvBuf = NULL;
+
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        uint32_t *aGTDataTmp = (uint32_t *)RTMemAllocZ(sizeof(uint32_t) * pExtent->cGTEntries);
+        if(!aGTDataTmp)
+        {
+            RTMemFree(pvBuf);
+            pvBuf = NULL;
+
+            RTMemFree(pvZero);
+            pvZero = NULL;
+
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        uint32_t *aRGTDataTmp = (uint32_t *)RTMemAllocZ(sizeof(uint32_t) * pExtent->cGTEntries);
+        if(!aRGTDataTmp)
+        {
+            RTMemFree(pvBuf);
+            pvBuf = NULL;
+
+            RTMemFree(pvZero);
+            pvZero = NULL;
+
+            RTMemFree(aGTDataTmp);
+            aGTDataTmp = NULL;
+
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        /* Search for overlap sector in the grain table. */
+        for (uint32_t idxGD = 0; idxGD < pExtent->cGDEntries; idxGD++)
+        {
+            uint64_t uGTSector = pExtent->pGD[idxGD];
+            uint64_t uRGTSector = pExtent->pRGD[idxGD];
+
+            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                        VMDK_SECTOR2BYTE(uGTSector),
+                                        aGTDataTmp, sizeof(uint32_t) * pExtent->cGTEntries);
+
+            if (RT_FAILURE(rc))
+                break;
+
+            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                        VMDK_SECTOR2BYTE(uRGTSector),
+                                        aRGTDataTmp, sizeof(uint32_t) * pExtent->cGTEntries);
+
+            if (RT_FAILURE(rc))
+                break;
+
+            for (uint32_t idxGT = 0; idxGT < pExtent->cGTEntries; idxGT++)
+            {
+                uint64_t aGTEntryLE = RT_LE2H_U64(aGTDataTmp[idxGT]);
+                uint64_t aRGTEntryLE = RT_LE2H_U64(aRGTDataTmp[idxGT]);
+
+                /**
+                 * Check if grain table is valid. If not dump out with an error.
+                 * Shoudln't ever get here (given other checks) but good sanity check.
+                */
+                if (aGTEntryLE != aRGTEntryLE)
+                {
+                    rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                    N_("VMDK: inconsistent references within grain table in '%s'"), pExtent->pszFullname);
+                    break;
+                }
+
+                if (aGTEntryLE < cNewOverheadSectors
+                    && aGTEntryLE != 0)
+                {
+                    /* Read data and append grain to the end of the image. */
+                    rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                VMDK_SECTOR2BYTE(aGTEntryLE), pvBuf,
+                                                VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+                    if (RT_FAILURE(rc))
+                        break;
+
+                    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                uNewAppendPosition, pvBuf,
+                                                VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+                    if (RT_FAILURE(rc))
+                        break;
+
+                    /* Zero out the old block area. */
+                    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                VMDK_SECTOR2BYTE(aGTEntryLE), pvZero,
+                                                VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain));
+                    if (RT_FAILURE(rc))
+                        break;
+
+                    /* Write updated grain tables to file */
+                    aGTDataTmp[idxGT] = VMDK_BYTE2SECTOR(uNewAppendPosition);
+                    aRGTDataTmp[idxGT] = VMDK_BYTE2SECTOR(uNewAppendPosition);
+
+                    if (memcmp(aGTDataTmp, aRGTDataTmp, sizeof(uint32_t) * pExtent->cGTEntries))
+                    {
+                        rc = vdIfError(pImage->pIfError, VERR_VD_VMDK_INVALID_HEADER, RT_SRC_POS,
+                                    N_("VMDK: inconsistency between grain table and backup grain table in '%s'"), pExtent->pszFullname);
+                        break;
+                    }
+
+                    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                VMDK_SECTOR2BYTE(uGTSector),
+                                                aGTDataTmp, sizeof(uint32_t) * pExtent->cGTEntries);
+
+                    if (RT_FAILURE(rc))
+                        break;
+
+                    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                VMDK_SECTOR2BYTE(uRGTSector),
+                                                aRGTDataTmp, sizeof(uint32_t) * pExtent->cGTEntries);
+
+                    break;
+                }
+            }
+        }
+
+        RTMemFree(aGTDataTmp);
+        aGTDataTmp = NULL;
+
+        RTMemFree(aRGTDataTmp);
+        aRGTDataTmp = NULL;
+
+        if (RT_FAILURE(rc))
+            break;
+
+        uNewAppendPosition += VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain);
+    } while (0);
+
+    if (pvBuf)
+    {
+        RTMemFree(pvBuf);
+        pvBuf = NULL;
+    }
+
+    if (pvZero)
+    {
+        RTMemFree(pvZero);
+        pvZero = NULL;
+    }
+
+    // Update append position for extent
+    pExtent->uAppendPosition = uNewAppendPosition;
+
+    return rc;
+}
+
+/**
+ * Resizes meta/overhead for sparse extent resize.
+ *
+ * @returns VBox status code.
+ * @param   pImage          VMDK image instance.
+ * @param   pExtent         VMDK extent instance.
+ * @param   cSectorsNew     Number of sectors after resize.
+ */
+static int vmdkResizeSparseMeta(PVMDKIMAGE pImage, PVMDKEXTENT pExtent,
+                                uint64_t cSectorsNew)
+{
+    int rc = VINF_SUCCESS;
+    uint32_t cOldGDEntries = pExtent->cGDEntries;
+
+    uint64_t cNewDirEntries = cSectorsNew / pExtent->cSectorsPerGDE;
+    if (cSectorsNew % pExtent->cSectorsPerGDE)
+        cNewDirEntries++;
+
+    size_t cbNewGD = cNewDirEntries * sizeof(uint32_t);
+
+    uint64_t cbNewDirSize = RT_ALIGN_64(cbNewGD, 512);
+    uint64_t cbCurrDirSize = RT_ALIGN_64(pExtent->cGDEntries * VMDK_GRAIN_DIR_ENTRY_SIZE, 512);
+    uint64_t cDirSectorDiff = VMDK_BYTE2SECTOR(cbNewDirSize - cbCurrDirSize);
+
+    uint64_t cbNewAllTablesSize = RT_ALIGN_64(cNewDirEntries * pExtent->cGTEntries * sizeof(uint32_t), 512);
+    uint64_t cbCurrAllTablesSize = RT_ALIGN_64(pExtent->cGDEntries * VMDK_GRAIN_TABLE_SIZE, 512);
+    uint64_t cTableSectorDiff = VMDK_BYTE2SECTOR(cbNewAllTablesSize - cbCurrAllTablesSize);
+
+    uint64_t cbNewOverhead = vmdkGetNewOverhead(pExtent, cSectorsNew);
+    uint64_t cNewOverheadSectors = VMDK_BYTE2SECTOR(cbNewOverhead);
+    uint64_t cOverheadSectorDiff = cNewOverheadSectors - pExtent->cOverheadSectors;
+
+    /*
+    * Get the blocks we need to relocate first, they are appended to the end
+    * of the image.
+    */
+    void *pvBuf = NULL, *pvZero = NULL;
+
+    do
+    {
+        /* Allocate data buffer. */
+        pvBuf = RTMemAllocZ(VMDK_GRAIN_TABLE_SIZE);
+        if (!pvBuf)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        /* Allocate buffer for overwriting with zeroes. */
+        pvZero = RTMemAllocZ(VMDK_GRAIN_TABLE_SIZE);
+        if (!pvZero)
+        {
+            RTMemFree(pvBuf);
+            pvBuf = NULL;
+
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        uint32_t uGTStart = VMDK_SECTOR2BYTE(pExtent->uSectorGD) + (cOldGDEntries * VMDK_GRAIN_DIR_ENTRY_SIZE);
+
+        // points to last element in the grain table
+        uint32_t uGTTail = uGTStart + (pExtent->cGDEntries * VMDK_GRAIN_TABLE_SIZE) - VMDK_GRAIN_TABLE_SIZE;
+        uint32_t cbGTOff = RT_ALIGN_Z(VMDK_SECTOR2BYTE(cDirSectorDiff + cTableSectorDiff + cDirSectorDiff), 512);
+
+        for (int i = pExtent->cGDEntries - 1; i >= 0; i--)
+        {
+            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                        uGTTail, pvBuf,
+                                        VMDK_GRAIN_TABLE_SIZE);
+            if (RT_FAILURE(rc))
+                break;
+
+            rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                        RT_ALIGN_Z(uGTTail + cbGTOff, 512), pvBuf,
+                                        VMDK_GRAIN_TABLE_SIZE);
+            if (RT_FAILURE(rc))
+                break;
+
+            // This overshoots when i == 0, but we don't need it anymore.
+            uGTTail -= VMDK_GRAIN_TABLE_SIZE;
+        }
+
+
+        /* Find the end of the grain directory and start bumping everything down. Update locations of GT entries. */
+        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    VMDK_SECTOR2BYTE(pExtent->uSectorGD), pvBuf,
+                                    pExtent->cGDEntries * VMDK_GRAIN_DIR_ENTRY_SIZE);
+        if (RT_FAILURE(rc))
+            break;
+
+        int * tmpBuf = (int *)pvBuf;
+
+        for (uint32_t i = 0; i < pExtent->cGDEntries; i++)
+        {
+            tmpBuf[i] = tmpBuf[i] + VMDK_BYTE2SECTOR(cbGTOff);
+            pExtent->pGD[i] = pExtent->pGD[i] + VMDK_BYTE2SECTOR(cbGTOff);
+        }
+
+        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    RT_ALIGN_Z(VMDK_SECTOR2BYTE(pExtent->uSectorGD + cTableSectorDiff + cDirSectorDiff), 512), pvBuf,
+                                    pExtent->cGDEntries * VMDK_GRAIN_DIR_ENTRY_SIZE);
+        if (RT_FAILURE(rc))
+            break;
+
+        pExtent->uSectorGD = pExtent->uSectorGD + cDirSectorDiff + cTableSectorDiff;
+
+        /* Repeat both steps with the redundant grain table/directory. */
+
+        uint32_t uRGTStart = VMDK_SECTOR2BYTE(pExtent->uSectorRGD) + (cOldGDEntries * VMDK_GRAIN_DIR_ENTRY_SIZE);
+
+        // points to last element in the grain table
+        uint32_t uRGTTail = uRGTStart + (pExtent->cGDEntries * VMDK_GRAIN_TABLE_SIZE) - VMDK_GRAIN_TABLE_SIZE;
+        uint32_t cbRGTOff = RT_ALIGN_Z(VMDK_SECTOR2BYTE(cDirSectorDiff), 512);
+
+        for (int i = pExtent->cGDEntries - 1; i >= 0; i--)
+        {
+            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                        uRGTTail, pvBuf,
+                                        VMDK_GRAIN_TABLE_SIZE);
+            if (RT_FAILURE(rc))
+                break;
+
+            rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                        RT_ALIGN_Z(uRGTTail + cbRGTOff, 512), pvBuf,
+                                        VMDK_GRAIN_TABLE_SIZE);
+            if (RT_FAILURE(rc))
+                break;
+
+            // This overshoots when i == 0, but we don't need it anymore.
+            uRGTTail -= VMDK_GRAIN_TABLE_SIZE;
+        }
+
+        /* Update locations of GT entries. */
+        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    VMDK_SECTOR2BYTE(pExtent->uSectorRGD), pvBuf,
+                                    pExtent->cGDEntries * VMDK_GRAIN_DIR_ENTRY_SIZE);
+        if (RT_FAILURE(rc))
+            break;
+
+        tmpBuf = (int *)pvBuf;
+
+        for (uint32_t i = 0; i < pExtent->cGDEntries; i++)
+        {
+            tmpBuf[i] = tmpBuf[i] + cDirSectorDiff;
+            pExtent->pRGD[i] = pExtent->pRGD[i] + cDirSectorDiff;
+        }
+
+        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    VMDK_SECTOR2BYTE(pExtent->uSectorRGD), pvBuf,
+                                    pExtent->cGDEntries * VMDK_GRAIN_DIR_ENTRY_SIZE);
+        if (RT_FAILURE(rc))
+            break;
+
+        pExtent->uSectorRGD = pExtent->uSectorRGD;
+        pExtent->cOverheadSectors += cOverheadSectorDiff;
+
+    } while (0);
+
+    if (pvBuf)
+    {
+        RTMemFree(pvBuf);
+        pvBuf = NULL;
+    }
+
+    if (pvZero)
+    {
+        RTMemFree(pvZero);
+        pvZero = NULL;
+    }
+
+    pExtent->cGDEntries = cNewDirEntries;
+
+    /* Allocate buffer for overwriting with zeroes. */
+    pvZero = RTMemAllocZ(VMDK_GRAIN_TABLE_SIZE);
+    if (!pvZero)
+        return VERR_NO_MEMORY;
+
+    // Allocate additional grain dir
+    pExtent->pGD = (uint32_t *) RTMemReallocZ(pExtent->pGD, pExtent->cGDEntries * sizeof(uint32_t), cbNewGD);
+    if (RT_LIKELY(pExtent->pGD))
+    {
+        if (pExtent->uSectorRGD)
+        {
+            pExtent->pRGD = (uint32_t *)RTMemReallocZ(pExtent->pRGD, pExtent->cGDEntries * sizeof(uint32_t), cbNewGD);
+            if (RT_UNLIKELY(!pExtent->pRGD))
+                rc = VERR_NO_MEMORY;
+        }
+    }
+    else
+        return VERR_NO_MEMORY;
+
+
+    uint32_t uTmpDirVal = pExtent->pGD[cOldGDEntries - 1] + VMDK_GRAIN_DIR_ENTRY_SIZE;
+    for (uint32_t i = cOldGDEntries; i < pExtent->cGDEntries; i++)
+    {
+        pExtent->pGD[i] = uTmpDirVal;
+
+        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    VMDK_SECTOR2BYTE(uTmpDirVal), pvZero,
+                                    VMDK_GRAIN_TABLE_SIZE);
+
+        if (RT_FAILURE(rc))
+            return rc;
+
+        uTmpDirVal += VMDK_GRAIN_DIR_ENTRY_SIZE;
+    }
+
+    uint32_t uRTmpDirVal = pExtent->pRGD[cOldGDEntries - 1] + VMDK_GRAIN_DIR_ENTRY_SIZE;
+    for (uint32_t i = cOldGDEntries; i < pExtent->cGDEntries; i++)
+    {
+        pExtent->pRGD[i] = uRTmpDirVal;
+
+        rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                    VMDK_SECTOR2BYTE(uRTmpDirVal), pvZero,
+                                    VMDK_GRAIN_TABLE_SIZE);
+
+        if (RT_FAILURE(rc))
+            return rc;
+
+        uRTmpDirVal += VMDK_GRAIN_DIR_ENTRY_SIZE;
+    }
+
+    RTMemFree(pvZero);
+    pvZero = NULL;
+
+    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                VMDK_SECTOR2BYTE(pExtent->uSectorGD), pExtent->pGD,
+                                pExtent->cGDEntries * VMDK_GRAIN_DIR_ENTRY_SIZE);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pExtent->pFile->pStorage,
+                                VMDK_SECTOR2BYTE(pExtent->uSectorRGD), pExtent->pRGD,
+                                pExtent->cGDEntries * VMDK_GRAIN_DIR_ENTRY_SIZE);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    rc = vmdkReplaceExtentSize(pImage, pExtent, pImage->Descriptor.uFirstExtent + pExtent->uExtent,
+                                pExtent->cNominalSectors, cSectorsNew);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    return rc;
+}
+
+/** @copydoc VDIMAGEBACKEND::pfnResize */
+static DECLCALLBACK(int) vmdkResize(void *pBackendData, uint64_t cbSize,
+                                   PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
+                                   unsigned uPercentStart, unsigned uPercentSpan,
+                                   PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
+                                   PVDINTERFACE pVDIfsOperation)
+{
+    RT_NOREF5(uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation);
+
+    // Establish variables and objects needed
+    int rc = VINF_SUCCESS;
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    unsigned uImageFlags = pImage->uImageFlags;
+    PVMDKEXTENT pExtent = &pImage->pExtents[0];
+    pExtent->fMetaDirty = true;
+
+    uint64_t cSectorsNew = cbSize / VMDK_SECTOR_SIZE;   /** < New number of sectors in the image after the resize */
+    if (cbSize % VMDK_SECTOR_SIZE)
+        cSectorsNew++;
+
+    uint64_t cSectorsOld = pImage->cbSize / VMDK_SECTOR_SIZE; /** < Number of sectors before the resize. Only for FLAT images. */
+    if (pImage->cbSize % VMDK_SECTOR_SIZE)
+        cSectorsOld++;
+    unsigned cExtents = pImage->cExtents;
+
+    /* Check size is within min/max bounds. */
+    if ( !(uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK)
+        && (   !cbSize
+            || (!(uImageFlags & VD_IMAGE_FLAGS_FIXED) && cbSize >= _1T * 256 - _64K)) )
+        return VERR_VD_INVALID_SIZE;
+
+    /*
+     * Making the image smaller is not supported at the moment.
+     */
+    /** @todo implement making the image smaller, it is the responsibility of
+     * the user to know what they're doing. */
+    if (cbSize < pImage->cbSize)
+        rc = VERR_VD_SHRINK_NOT_SUPPORTED;
+    else if (cbSize > pImage->cbSize)
+    {
+        /**
+         * monolithicFlat. FIXED flag and not split up into 2 GB parts.
+         */
+        if ((uImageFlags & VD_IMAGE_FLAGS_FIXED) && !(uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G))
+        {
+            /** Required space in bytes for the extent after the resize. */
+            uint64_t cbSectorSpaceNew = cSectorsNew * VMDK_SECTOR_SIZE;
+            pExtent = &pImage->pExtents[0];
+
+            rc = vdIfIoIntFileSetAllocationSize(pImage->pIfIo, pExtent->pFile->pStorage, cbSectorSpaceNew,
+                                                0 /* fFlags */, NULL,
+                                                uPercentStart, uPercentSpan);
+            if (RT_FAILURE(rc))
+                return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set size of new file '%s'"), pExtent->pszFullname);
+
+            rc = vmdkReplaceExtentSize(pImage, pExtent, pImage->Descriptor.uFirstExtent, cSectorsOld, cSectorsNew);
+            if (RT_FAILURE(rc))
+                return rc;
+        }
+
+        /**
+         * twoGbMaxExtentFlat. FIXED flag and SPLIT into 2 GB parts.
+         */
+        if ((uImageFlags & VD_IMAGE_FLAGS_FIXED) && (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G))
+        {
+            /* Check to see how much space remains in last extent */
+            bool fSpaceAvailible = false;
+            uint64_t cLastExtentRemSectors = cSectorsOld % VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE);
+            if (cLastExtentRemSectors)
+                fSpaceAvailible = true;
+
+            uint64_t cSectorsNeeded = cSectorsNew - cSectorsOld;
+
+            /** Space remaining in current last extent file that we don't need to create another one. */
+            if (fSpaceAvailible && cSectorsNeeded + cLastExtentRemSectors <= VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE))
+            {
+                pExtent = &pImage->pExtents[cExtents - 1];
+                rc = vdIfIoIntFileSetAllocationSize(pImage->pIfIo, pExtent->pFile->pStorage,
+                                                    VMDK_SECTOR2BYTE(cSectorsNeeded + cLastExtentRemSectors),
+                                                    0 /* fFlags */, NULL, uPercentStart, uPercentSpan);
+                if (RT_FAILURE(rc))
+                    return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set size of new file '%s'"), pExtent->pszFullname);
+
+                rc = vmdkReplaceExtentSize(pImage, pExtent, pImage->Descriptor.uFirstExtent + cExtents - 1,
+                                           pExtent->cNominalSectors, cSectorsNeeded + cLastExtentRemSectors);
+                if (RT_FAILURE(rc))
+                    return rc;
+            }
+            //** Need more extent files to handle all the requested space. */
+            else
+            {
+                if (fSpaceAvailible)
+                {
+                    pExtent = &pImage->pExtents[cExtents - 1];
+                    rc = vdIfIoIntFileSetAllocationSize(pImage->pIfIo, pExtent->pFile->pStorage, VMDK_2G_SPLIT_SIZE,
+                                                        0 /* fFlags */, NULL,
+                                                        uPercentStart, uPercentSpan);
+                    if (RT_FAILURE(rc))
+                        return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VMDK: could not set size of new file '%s'"), pExtent->pszFullname);
+
+                    cSectorsNeeded = cSectorsNeeded - VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE) + cLastExtentRemSectors;
+
+                    rc = vmdkReplaceExtentSize(pImage, pExtent, pImage->Descriptor.uFirstExtent + cExtents - 1,
+                                               pExtent->cNominalSectors, VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE));
+                    if (RT_FAILURE(rc))
+                        return rc;
+                }
+
+                unsigned cNewExtents = VMDK_SECTOR2BYTE(cSectorsNeeded) / VMDK_2G_SPLIT_SIZE;
+                if (cNewExtents % VMDK_2G_SPLIT_SIZE || cNewExtents < VMDK_2G_SPLIT_SIZE)
+                    cNewExtents++;
+
+                for (unsigned i = cExtents;
+                     i < cExtents + cNewExtents && cSectorsNeeded >= VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE);
+                     i++)
+                {
+                    rc = vmdkAddFileBackedExtent(pImage, VMDK_2G_SPLIT_SIZE);
+                    if (RT_FAILURE(rc))
+                        return rc;
+
+                    pExtent = &pImage->pExtents[i];
+
+                    pExtent->cSectors = VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE);
+                    cSectorsNeeded -= VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE);
+                }
+
+                if (cSectorsNeeded)
+                {
+                    rc = vmdkAddFileBackedExtent(pImage, VMDK_SECTOR2BYTE(cSectorsNeeded));
+                    if (RT_FAILURE(rc))
+                        return rc;
+                }
+            }
+        }
+
+        /**
+         * monolithicSparse.
+         */
+        if (pExtent->enmType == VMDKETYPE_HOSTED_SPARSE && !(uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G))
+        {
+            // 1. Calculate sectors needed for new overhead.
+
+            uint64_t cbNewOverhead = vmdkGetNewOverhead(pExtent, cSectorsNew);
+            uint64_t cNewOverheadSectors = VMDK_BYTE2SECTOR(cbNewOverhead);
+            uint64_t cOverheadSectorDiff = cNewOverheadSectors - pExtent->cOverheadSectors;
+
+            // 2. Relocate sectors to make room for new GD/GT, update entries in GD/GT
+            if (cOverheadSectorDiff > 0)
+            {
+                if (pExtent->cSectors > 0)
+                {
+                    /* Do the relocation. */
+                    LogFlow(("Relocating VMDK sectors\n"));
+                    rc = vmdkRelocateSectorsForSparseResize(pImage, pExtent, cSectorsNew);
+                    if (RT_FAILURE(rc))
+                        return rc;
+
+                    rc = vmdkFlushImage(pImage, NULL);
+                    if (RT_FAILURE(rc))
+                        return rc;
+                }
+
+                rc = vmdkResizeSparseMeta(pImage, pExtent, cSectorsNew);
+                if (RT_FAILURE(rc))
+                    return rc;
+            }
+        }
+
+        /**
+         * twoGbSparseExtent
+         */
+        if (pExtent->enmType == VMDKETYPE_HOSTED_SPARSE && (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G))
+        {
+            /* Check to see how much space remains in last extent */
+            bool fSpaceAvailible = false;
+            uint64_t cLastExtentRemSectors = cSectorsOld % VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE);
+            if (cLastExtentRemSectors)
+                fSpaceAvailible = true;
+
+            uint64_t cSectorsNeeded = cSectorsNew - cSectorsOld;
+
+            if (fSpaceAvailible && cSectorsNeeded + cLastExtentRemSectors <= VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE))
+            {
+                pExtent = &pImage->pExtents[cExtents - 1];
+                rc = vmdkRelocateSectorsForSparseResize(pImage, pExtent, cSectorsNeeded + cLastExtentRemSectors);
+                if (RT_FAILURE(rc))
+                    return rc;
+
+                rc = vmdkFlushImage(pImage, NULL);
+                if (RT_FAILURE(rc))
+                    return rc;
+
+                rc = vmdkResizeSparseMeta(pImage, pExtent, cSectorsNeeded + cLastExtentRemSectors);
+                if (RT_FAILURE(rc))
+                    return rc;
+            }
+            else
+            {
+                if (fSpaceAvailible)
+                {
+                    pExtent = &pImage->pExtents[cExtents - 1];
+                    rc = vmdkRelocateSectorsForSparseResize(pImage, pExtent, VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE));
+                    if (RT_FAILURE(rc))
+                        return rc;
+
+                    rc = vmdkFlushImage(pImage, NULL);
+                    if (RT_FAILURE(rc))
+                        return rc;
+
+                    rc = vmdkResizeSparseMeta(pImage, pExtent, VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE));
+                    if (RT_FAILURE(rc))
+                        return rc;
+
+                    cSectorsNeeded = cSectorsNeeded - VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE) + cLastExtentRemSectors;
+                }
+
+                unsigned cNewExtents = VMDK_SECTOR2BYTE(cSectorsNeeded) / VMDK_2G_SPLIT_SIZE;
+                if (cNewExtents % VMDK_2G_SPLIT_SIZE || cNewExtents < VMDK_2G_SPLIT_SIZE)
+                    cNewExtents++;
+
+                for (unsigned i = cExtents;
+                     i < cExtents + cNewExtents && cSectorsNeeded >= VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE);
+                     i++)
+                {
+                    rc = vmdkAddFileBackedExtent(pImage, VMDK_2G_SPLIT_SIZE);
+                    if (RT_FAILURE(rc))
+                        return rc;
+
+                    pExtent = &pImage->pExtents[i];
+
+                    rc = vmdkFlushImage(pImage, NULL);
+                    if (RT_FAILURE(rc))
+                        return rc;
+
+                    pExtent->cSectors = VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE);
+                    cSectorsNeeded -= VMDK_BYTE2SECTOR(VMDK_2G_SPLIT_SIZE);
+                }
+
+                if (cSectorsNeeded)
+                {
+                    rc = vmdkAddFileBackedExtent(pImage, VMDK_SECTOR2BYTE(cSectorsNeeded));
+                    if (RT_FAILURE(rc))
+                        return rc;
+
+                    pExtent = &pImage->pExtents[pImage->cExtents];
+
+                    rc = vmdkFlushImage(pImage, NULL);
+                    if (RT_FAILURE(rc))
+                        return rc;
+                }
+            }
+        }
+
+        /* Successful resize. Update metadata */
+        if (RT_SUCCESS(rc))
+        {
+            /* Update size and new block count. */
+            pImage->cbSize = cbSize;
+            pExtent->cNominalSectors = cSectorsNew;
+            pExtent->cSectors = cSectorsNew;
+
+            /* Update geometry. */
+            pImage->PCHSGeometry = *pPCHSGeometry;
+            pImage->LCHSGeometry = *pLCHSGeometry;
+        }
+
+        /* Update header information in base image file. */
+        pImage->Descriptor.fDirty = true;
+        rc = vmdkWriteDescriptor(pImage, NULL);
+
+        if (RT_SUCCESS(rc))
+            rc = vmdkFlushImage(pImage, NULL);
+    }
+    /* Same size doesn't change the image at all. */
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+const VDIMAGEBACKEND g_VmdkBackend =
+{
+    /* u32Version */
+    VD_IMGBACKEND_VERSION,
+    /* pszBackendName */
+    "VMDK",
+    /* uBackendCaps */
+      VD_CAP_UUID | VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC
+    | VD_CAP_CREATE_SPLIT_2G | VD_CAP_DIFF | VD_CAP_FILE | VD_CAP_ASYNC
+    | VD_CAP_VFS | VD_CAP_PREFERRED,
+    /* paFileExtensions */
+    s_aVmdkFileExtensions,
+    /* paConfigInfo */
+    s_aVmdkConfigInfo,
+    /* pfnProbe */
+    vmdkProbe,
+    /* pfnOpen */
+    vmdkOpen,
+    /* pfnCreate */
+    vmdkCreate,
+    /* pfnRename */
+    vmdkRename,
+    /* pfnClose */
+    vmdkClose,
+    /* pfnRead */
+    vmdkRead,
+    /* pfnWrite */
+    vmdkWrite,
+    /* pfnFlush */
+    vmdkFlush,
+    /* pfnDiscard */
+    NULL,
+    /* pfnGetVersion */
+    vmdkGetVersion,
+    /* pfnGetFileSize */
+    vmdkGetFileSize,
+    /* pfnGetPCHSGeometry */
+    vmdkGetPCHSGeometry,
+    /* pfnSetPCHSGeometry */
+    vmdkSetPCHSGeometry,
+    /* pfnGetLCHSGeometry */
+    vmdkGetLCHSGeometry,
+    /* pfnSetLCHSGeometry */
+    vmdkSetLCHSGeometry,
+    /* pfnQueryRegions */
+    vmdkQueryRegions,
+    /* pfnRegionListRelease */
+    vmdkRegionListRelease,
+    /* pfnGetImageFlags */
+    vmdkGetImageFlags,
+    /* pfnGetOpenFlags */
+    vmdkGetOpenFlags,
+    /* pfnSetOpenFlags */
+    vmdkSetOpenFlags,
+    /* pfnGetComment */
+    vmdkGetComment,
+    /* pfnSetComment */
+    vmdkSetComment,
+    /* pfnGetUuid */
+    vmdkGetUuid,
+    /* pfnSetUuid */
+    vmdkSetUuid,
+    /* pfnGetModificationUuid */
+    vmdkGetModificationUuid,
+    /* pfnSetModificationUuid */
+    vmdkSetModificationUuid,
+    /* pfnGetParentUuid */
+    vmdkGetParentUuid,
+    /* pfnSetParentUuid */
+    vmdkSetParentUuid,
+    /* pfnGetParentModificationUuid */
+    vmdkGetParentModificationUuid,
+    /* pfnSetParentModificationUuid */
+    vmdkSetParentModificationUuid,
+    /* pfnDump */
+    vmdkDump,
+    /* pfnGetTimestamp */
+    NULL,
+    /* pfnGetParentTimestamp */
+    NULL,
+    /* pfnSetParentTimestamp */
+    NULL,
+    /* pfnGetParentFilename */
+    NULL,
+    /* pfnSetParentFilename */
+    NULL,
+    /* pfnComposeLocation */
+    genericFileComposeLocation,
+    /* pfnComposeName */
+    genericFileComposeName,
+    /* pfnCompact */
+    NULL,
+    /* pfnResize */
+    vmdkResize,
+    /* pfnRepair */
+    NULL,
+    /* pfnTraverseMetadata */
+    NULL,
+    /* u32VersionEnd */
+    VD_IMGBACKEND_VERSION
+};