Changeset 32573 in vbox for trunk/src/VBox/Devices

Timestamp:

Sep 16, 2010 5:18:03 PM (14 years ago)

Author:

vboxsync

Message:

Storage/Vmdk: implement special purpose backend for proper streamOptimized VMDK export, at the moment only with the functionality needed by cloning. Not really tested.

Location:

trunk/src/VBox/Devices/Storage

Files:

• VBoxHDD.cpp (modified) (2 diffs)
• VmdkHDDCore.cpp (modified) (9 diffs)

trunk/src/VBox/Devices/Storage/VBoxHDD.cpp

@@ -418 +418 @@
 extern VBOXHDDBACKEND g_RawBackend;
 extern VBOXHDDBACKEND g_VmdkBackend;
+extern VBOXHDDBACKEND g_VmdkStreamBackend;
 extern VBOXHDDBACKEND g_VDIBackend;
 extern VBOXHDDBACKEND g_VhdBackend;
@@ -434 +435 @@
     &g_RawBackend,
     &g_VmdkBackend,
+    &g_VmdkStreamBackend,
     &g_VDIBackend,
     &g_VhdBackend,

trunk/src/VBox/Devices/Storage/VmdkHDDCore.cpp

@@ -1206 +1206 @@
     }
     pExtent->pGD = pGD;
-    /* The VMDK 1.1 spec talks about compressed grain directories, but real
-     * life files don't have them. The spec is wrong in creative ways. */
+    /* The VMDK 1.1 spec seems to talk about compressed grain directories,
+     * but in reality they are not compressed. */
     rc = vmdkFileReadSync(pImage, pExtent->pFile,
                           VMDK_SECTOR2BYTE(pExtent->uSectorGD),
@@ -1229 +1229 @@
         }
         pExtent->pRGD = pRGD;
-        /* The VMDK 1.1 spec talks about compressed grain directories, but real
-         * life files don't have them. The spec is wrong in creative ways. */
+        /* The VMDK 1.1 spec seems to talk about compressed grain directories,
+         * but in reality they are not compressed. */
         rc = vmdkFileReadSync(pImage, pExtent->pFile,
                               VMDK_SECTOR2BYTE(pExtent->uSectorRGD),
@@ -1277 +1277 @@
                 goto out;
             }
-            /* The VMDK 1.1 spec talks about compressed grain tables, but real
-             * life files don't have them. The spec is wrong in creative ways. */
+            /* The VMDK 1.1 spec seems to talk about compressed grain tables,
+             * but in reality they are not compressed. */
             rc = vmdkFileReadSync(pImage, pExtent->pFile,
                                   VMDK_SECTOR2BYTE(*pGDTmp),
@@ -1289 +1289 @@
                 goto out;
             }
-            /* The VMDK 1.1 spec talks about compressed grain tables, but real
-             * life files don't have them. The spec is wrong in creative ways. */
+            /* The VMDK 1.1 spec seems to talk about compressed grain tables,
+             * but in reality they are not compressed. */
             rc = vmdkFileReadSync(pImage, pExtent->pFile,
                                   VMDK_SECTOR2BYTE(*pRGDTmp),
@@ -1332 +1332 @@
                 continue;
 
-            /* The VMDK 1.1 spec talks about compressed grain tables, but real
-             * life files don't have them. The spec is wrong in creative ways. */
+            /* The VMDK 1.1 spec seems to talk about compressed grain tables,
+             * but in reality they are not compressed. */
             rc = vmdkFileReadSync(pImage, pExtent->pFile,
                                   VMDK_SECTOR2BYTE(*pGDTmp),
@@ -2868 +2868 @@
         goto out;
     }
-/* disabled the size check again as there are too many too short vmdks out there */
+/* disabled the check as there are too many truncated vmdk images out there */
 #ifdef VBOX_WITH_VMDK_STRICT_SIZE_CHECK
     if (    cbExtentSize != RT_ALIGN_64(cbExtentSize, 512)
@@ -4046 +4046 @@
     if (RT_FAILURE(rc))
         return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not set the image type in '%s'"), pImage->pszFilename);
+    return rc;
+}
+
+/**
+ * Internal. Clear the grain table buffer for real stream optimized writing.
+ */
+static void vmdksClearGT(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 vmdksFlushGT(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;
+
+    uint64_t uFileOffset;
+    rc = vmdkFileGetSize(pImage, pExtent->pFile, &uFileOffset);
+    AssertRC(rc);
+    uFileOffset = RT_ALIGN_64(uFileOffset, 512);
+
+    /* Grain table marker. */
+    /** @todo check me! */
+    uint8_t aMarker[512];
+    memset(aMarker, '\0', sizeof(aMarker));
+    PVMDKMARKER pMarker = (PVMDKMARKER)&aMarker[0];
+    pMarker->cbSize = RT_H2LE_U32(pExtent->cGTEntries * sizeof(uint32_t));
+    pMarker->uType = RT_H2LE_U32(VMDK_MARKER_GT);
+    rc = vmdkFileWriteSync(pImage, pExtent->pFile, uFileOffset,
+                           aMarker, sizeof(aMarker), NULL);
+    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 = vmdkFileWriteSync(pImage, pExtent->pFile, uFileOffset,
+                               &pImage->pGTCache->aGTCache[i].aGTData[0],
+                               VMDK_GT_CACHELINE_SIZE * sizeof(uint32_t),
+                               NULL);
+    }
+    return rc;
+}
+
+/**
+ * Internal. Free all allocated space for representing a real stream optimized
+ * image, and optionally delete the image from disk.
+ */
+static int vmdksFreeImage(PVMDKIMAGE pImage, bool fDelete)
+{
+    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))
+        {
+            /* Check if all extents are clean. */
+            for (unsigned i = 0; i < pImage->cExtents; i++)
+            {
+                Assert(!pImage->pExtents[i].fUncleanShutdown);
+            }
+        }
+
+        /* No need to write any pending data if the file will be deleted. */
+        if (!fDelete && pImage->pExtents)
+        {
+            PVMDKEXTENT pExtent = &pImage->pExtents[0];
+            uint32_t uLastGDEntry = pExtent->uLastGrainWritten / pExtent->cGTEntries;
+            if (uLastGDEntry != pExtent->cGDEntries)
+            {
+                rc = vmdksFlushGT(pImage, pExtent, uLastGDEntry);
+                AssertRC(rc);
+                vmdksClearGT(pImage, pExtent);
+                for (uint32_t i = uLastGDEntry + 1; i < pExtent->cGDEntries; i++)
+                {
+                    rc = vmdksFlushGT(pImage, pExtent, i);
+                    AssertRC(rc);
+                }
+            }
+
+            uint64_t uFileOffset;
+            rc = vmdkFileGetSize(pImage, pExtent->pFile, &uFileOffset);
+            AssertRC(rc);
+            uFileOffset = RT_ALIGN_64(uFileOffset, 512);
+
+            /* Grain directory marker. */
+            /** @todo check me! */
+            uint8_t aMarker[512];
+            memset(aMarker, '\0', sizeof(aMarker));
+            PVMDKMARKER pMarker = (PVMDKMARKER)&aMarker[0];
+            pMarker->cbSize = RT_H2LE_U32(pExtent->cGDEntries * sizeof(uint32_t));
+            pMarker->uType = RT_H2LE_U32(VMDK_MARKER_GD);
+            rc = vmdkFileWriteSync(pImage, pExtent->pFile, uFileOffset,
+                                   aMarker, sizeof(aMarker), NULL);
+            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 = vmdkFileWriteSync(pImage, pExtent->pFile, uFileOffset,
+                                   pExtent->pGD,
+                                   pExtent->cGDEntries * sizeof(uint32_t),
+                                   NULL);
+            AssertRC(rc);
+
+            pExtent->uSectorGD = VMDK_BYTE2SECTOR(uFileOffset);
+            pExtent->uSectorRGD = VMDK_BYTE2SECTOR(uFileOffset);
+            uFileOffset = RT_ALIGN_64(uFileOffset + pExtent->cGDEntries * sizeof(uint32_t), 512);
+
+            /* End of stream marker. */
+            memset(aMarker, '\0', sizeof(aMarker));
+            /** @todo check me! */
+            rc = vmdkFileWriteSync(pImage, pExtent->pFile, uFileOffset,
+                                   aMarker, sizeof(aMarker), NULL);
+            AssertRC(rc);
+
+            uFileOffset += 512;
+            rc = vmdkWriteMetaSparseExtent(pImage, pExtent, uFileOffset);
+            AssertRC(rc);
+        }
+
+        if (pImage->pExtents != NULL)
+        {
+            for (unsigned i = 0 ; i < pImage->cExtents; i++)
+                vmdkFreeExtentData(pImage, &pImage->pExtents[i], fDelete);
+            RTMemFree(pImage->pExtents);
+            pImage->pExtents = NULL;
+        }
+        pImage->cExtents = 0;
+        if (pImage->pFile != NULL)
+            vmdkFileClose(pImage, &pImage->pFile, fDelete);
+        vmdkFileCheckAllClose(pImage);
+
+        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: Create a real stream optimized VMDK using only linear writes.
+ */
+static int vmdksCreateImage(PVMDKIMAGE pImage, uint64_t cbSize,
+                            unsigned uImageFlags, const char *pszComment,
+                            PCVDGEOMETRY pPCHSGeometry,
+                            PCVDGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
+                            PFNVDPROGRESS pfnProgress, void *pvUser,
+                            unsigned uPercentStart, unsigned uPercentSpan)
+{
+    int rc;
+
+    pImage->uImageFlags = uImageFlags;
+
+    /* Try to get error interface. */
+    pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
+    if (pImage->pInterfaceError)
+        pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
+
+    /* Get I/O interface. */
+    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IO);
+    AssertPtrReturn(pImage->pInterfaceIO, VERR_INVALID_PARAMETER);
+    pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
+    AssertPtrReturn(pImage->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
+
+    PVMDKEXTENT pExtent;
+    char *pszBasenameSubstr, *pszBasedirectory, *pszBasename;
+    size_t cbBasenameSubstr;
+
+    rc = vmdkCreateDescriptor(pImage, pImage->pDescData, pImage->cbDescAlloc,
+                              &pImage->Descriptor);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new descriptor in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+
+    rc = vmdkCreateExtents(pImage, 1);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new extent list in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+
+    /* Basename strings needed for constructing the extent names. */
+    pszBasenameSubstr = RTPathFilename(pImage->pszFilename);
+    AssertPtr(pszBasenameSubstr);
+    cbBasenameSubstr = strlen(pszBasenameSubstr) + 1;
+
+    /* No separate descriptor file. */
+    pImage->pFile = NULL;
+
+    /* Set up all extents. */
+    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. */
+    pszBasename = (char *)RTMemTmpAlloc(cbBasenameSubstr);
+    if (!pszBasename)
+    {
+        rc = VERR_NO_MEMORY;
+        goto out;
+    }
+    memcpy(pszBasename, pszBasenameSubstr, cbBasenameSubstr);
+    pExtent->pszBasename = pszBasename;
+
+    pszBasedirectory = RTStrDup(pImage->pszFilename);
+    RTPathStripFilename(pszBasedirectory);
+    char *pszFullname;
+    rc = RTStrAPrintf(&pszFullname, "%s%c%s", pszBasedirectory,
+                      RTPATH_SLASH, pExtent->pszBasename);
+    RTStrFree(pszBasedirectory);
+    if (RT_FAILURE(rc))
+        goto out;
+    pExtent->pszFullname = pszFullname;
+
+    /* Create file for extent. */
+    rc = vmdkFileOpen(pImage, &pExtent->pFile, pExtent->pszFullname,
+                      VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags,
+                                                 true /* fCreate */),
+                      false /* fAsyncIO */);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new file '%s'"), pExtent->pszFullname);
+        goto out;
+    }
+
+    /* 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 acepted. */
+    pExtent->uVersion = 3;
+    pExtent->uCompression = VMDK_COMPRESSION_DEFLATE;
+    pExtent->fFooter = true;
+
+    pExtent->enmAccess = VMDKACCESS_READONLY;
+    pExtent->fUncleanShutdown = true;
+    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,
+                                  RT_MAX(  pExtent->uDescriptorSector
+                                         + pExtent->cDescriptorSectors,
+                                         1),
+                                  false /* fPreAlloc */);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not create new grain directory in '%s'"), pExtent->pszFullname);
+        goto out;
+    }
+
+    rc = vmdkDescBaseSetStr(pImage, &pImage->Descriptor, "createType",
+                            "streamOptimized");
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not set the image type in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+
+    if (pfnProgress)
+        pfnProgress(pvUser, uPercentStart + uPercentSpan * 20 / 100);
+
+    pImage->cbSize = cbSize;
+
+    Assert(pImage->cExtents == 1);
+
+    rc = vmdkDescExtInsert(pImage, &pImage->Descriptor, pExtent->enmAccess,
+                           pExtent->cNominalSectors, pExtent->enmType,
+                           pExtent->pszBasename, pExtent->uSectorOffset);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: could not insert the extent list into descriptor in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+    vmdkDescExtRemoveDummy(pImage, &pImage->Descriptor);
+
+    if (    pPCHSGeometry->cCylinders != 0
+        &&  pPCHSGeometry->cHeads != 0
+        &&  pPCHSGeometry->cSectors != 0)
+    {
+        rc = vmdkDescSetPCHSGeometry(pImage, pPCHSGeometry);
+        if (RT_FAILURE(rc))
+            goto out;
+    }
+    if (    pLCHSGeometry->cCylinders != 0
+        &&  pLCHSGeometry->cHeads != 0
+        &&  pLCHSGeometry->cSectors != 0)
+    {
+        rc = vmdkDescSetLCHSGeometry(pImage, pLCHSGeometry);
+        if (RT_FAILURE(rc))
+            goto out;
+    }
+
+    pImage->LCHSGeometry = *pLCHSGeometry;
+    pImage->PCHSGeometry = *pPCHSGeometry;
+
+    pImage->ImageUuid = *pUuid;
+    rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                            VMDK_DDB_IMAGE_UUID, &pImage->ImageUuid);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing image UUID in new descriptor in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+    RTUuidClear(&pImage->ParentUuid);
+    rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                            VMDK_DDB_PARENT_UUID, &pImage->ParentUuid);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing parent image UUID in new descriptor in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+    RTUuidClear(&pImage->ModificationUuid);
+    rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                            VMDK_DDB_MODIFICATION_UUID,
+                            &pImage->ModificationUuid);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing modification UUID in new descriptor in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+    RTUuidClear(&pImage->ParentModificationUuid);
+    rc = vmdkDescDDBSetUuid(pImage, &pImage->Descriptor,
+                            VMDK_DDB_PARENT_MODIFICATION_UUID,
+                            &pImage->ParentModificationUuid);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error storing parent modification UUID in new descriptor in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+
+    rc = vmdkAllocateGrainTableCache(pImage);
+    if (RT_FAILURE(rc))
+        goto out;
+
+    rc = vmdkSetImageComment(pImage, pszComment);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: cannot set image comment in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+
+    if (pfnProgress)
+        pfnProgress(pvUser, uPercentStart + uPercentSpan * 50 / 100);
+
+    rc = vmdkWriteMetaSparseExtent(pImage, &pImage->pExtents[0], 0);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: cannot write VMDK header in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+
+    if (pfnProgress)
+        pfnProgress(pvUser, uPercentStart + uPercentSpan * 70 / 100);
+
+    rc = vmdkWriteDescriptor(pImage);
+    if (RT_FAILURE(rc))
+    {
+        rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: cannot write VMDK descriptor in '%s'"), pImage->pszFilename);
+        goto out;
+    }
+
+out:
+    if (RT_SUCCESS(rc) && pfnProgress)
+        pfnProgress(pvUser, uPercentStart + uPercentSpan);
+
+    if (RT_FAILURE(rc))
+        vmdksFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
     return rc;
 }
@@ -5195 +5617 @@
     }
     return pszNewStr;
+}
+
+
+/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
+static int vmdksCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
+                             PVDINTERFACE pVDIfsImage)
+{
+    LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
+    int rc = VINF_SUCCESS;
+
+    if (   !VALID_PTR(pszFilename)
+        || !*pszFilename
+        || strchr(pszFilename, '"'))
+    {
+        rc = VERR_INVALID_PARAMETER;
+        goto out;
+    }
+
+    /* Always return failure, to avoid opening other VMDK files via this
+     * special VMDK streamOptimized format backend. */
+    rc = VERR_NOT_SUPPORTED;
+
+out:
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+/** @copydoc VBOXHDDBACKEND::pfnOpen */
+static int vmdksOpen(const char *pszFilename, unsigned uOpenFlags,
+                     PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
+                     void **ppBackendData)
+{
+    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
+    int rc;
+
+    rc = VERR_NOT_SUPPORTED;
+    LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnCreate */
+static int vmdksCreate(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, 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 ppBackendData=%#p", pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, ppBackendData));
+    int rc;
+    PVMDKIMAGE pImage;
+
+    PFNVDPROGRESS pfnProgress = NULL;
+    void *pvUser = NULL;
+    PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
+                                              VDINTERFACETYPE_PROGRESS);
+    PVDINTERFACEPROGRESS pCbProgress = NULL;
+    if (pIfProgress)
+    {
+        pCbProgress = VDGetInterfaceProgress(pIfProgress);
+        pfnProgress = pCbProgress->pfnProgress;
+        pvUser = pIfProgress->pvUser;
+    }
+
+    /* Check open flags. No flags are supported. */
+    if (uOpenFlags != VD_OPEN_FLAGS_NORMAL)
+    {
+        rc = VERR_INVALID_PARAMETER;
+        goto out;
+    }
+
+    /* Check image flags. No flags are supported. */
+    if (uImageFlags != VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED)
+    {
+        rc = VERR_INVALID_PARAMETER;
+        goto out;
+    }
+
+    /* Check size. Maximum 2TB-64K. */
+    if (   !cbSize
+        || cbSize >= _1T * 2 - _64K)
+    {
+        rc = VERR_VD_INVALID_SIZE;
+        goto out;
+    }
+
+    /* Check remaining arguments. */
+    if (   !VALID_PTR(pszFilename)
+        || !*pszFilename
+        || strchr(pszFilename, '"')
+        || !VALID_PTR(pPCHSGeometry)
+        || !VALID_PTR(pLCHSGeometry))
+    {
+        rc = VERR_INVALID_PARAMETER;
+        goto out;
+    }
+
+    pImage = (PVMDKIMAGE)RTMemAllocZ(sizeof(VMDKIMAGE));
+    if (!pImage)
+    {
+        rc = VERR_NO_MEMORY;
+        goto out;
+    }
+    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 stream optimized images are small, so don't waste
+     * space in the resulting image and allocate a small buffer. */
+    pImage->cbDescAlloc = VMDK_SECTOR2BYTE(4);
+    pImage->pDescData = (char *)RTMemAllocZ(pImage->cbDescAlloc);
+    if (!pImage->pDescData)
+    {
+        rc = VERR_NO_MEMORY;
+        goto out;
+    }
+
+    rc = vmdksCreateImage(pImage, cbSize, uImageFlags, pszComment,
+                          pPCHSGeometry, pLCHSGeometry, pUuid,
+                          pfnProgress, pvUser, uPercentStart, uPercentSpan);
+    if (RT_SUCCESS(rc))
+    {
+        /* Image is always writable. */
+        *ppBackendData = pImage;
+    }
+    else
+    {
+        RTMemFree(pImage->pDescData);
+        RTMemFree(pImage);
+    }
+
+out:
+    LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnClose */
+static int vmdksClose(void *pBackendData, bool fDelete)
+{
+    LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    rc = vmdksFreeImage(pImage, fDelete);
+    RTMemFree(pImage);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnRead */
+static int vmdksRead(void *pBackendData, uint64_t uOffset, void *pvBuf,
+                     size_t cbToRead, size_t *pcbActuallyRead)
+{
+    LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToRead=%zu pcbActuallyRead=%#p\n", pBackendData, uOffset, pvBuf, cbToRead, pcbActuallyRead));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    rc = VERR_NOT_SUPPORTED;
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnWrite */
+static int vmdksWrite(void *pBackendData, uint64_t uOffset, const void *pvBuf,
+                      size_t cbToWrite, size_t *pcbWriteProcess,
+                      size_t *pcbPreRead, size_t *pcbPostRead, unsigned fWrite)
+{
+    LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n", pBackendData, uOffset, pvBuf, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    PVMDKEXTENT pExtent;
+    uint64_t uSector;
+    uint32_t uGrain;
+    uint32_t uGDEntry, uLastGDEntry;
+    uint32_t cbGrain = 0;
+    uint32_t uCacheLine, uCacheEntry;
+    const void *pData = pvBuf;
+    int rc;
+
+    AssertPtr(pImage);
+    Assert(uOffset % 512 == 0);
+    Assert(cbToWrite % 512 == 0);
+
+    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+    {
+        rc = VERR_VD_IMAGE_READ_ONLY;
+        goto out;
+    }
+
+    pExtent = &pImage->pExtents[0];
+    uSector = VMDK_BYTE2SECTOR(uOffset);
+
+    /* 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 (   cbToWrite == 0
+        || (   cbToWrite < VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain)
+            && pImage->cbSize - uOffset >= VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain))
+        || uOffset % VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain)
+        || uOffset + cbToWrite > pImage->cbSize)
+    {
+        rc = VERR_INVALID_PARAMETER;
+        goto out;
+    }
+
+    /* Clip write range to at most the rest of the grain. */
+    cbToWrite = RT_MIN(cbToWrite, VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain - uSector % pExtent->cSectorsPerGrain));
+
+    /* Do not allow to go back. */
+    uGrain = VMDK_BYTE2SECTOR(uOffset) / pExtent->cSectorsPerGrain;
+    uCacheLine = uGrain / VMDK_GT_CACHELINE_SIZE % VMDK_GT_CACHE_SIZE;
+    uCacheEntry = uGrain % VMDK_GT_CACHELINE_SIZE;
+    uGDEntry = uGrain / pExtent->cGTEntries;
+    uLastGDEntry = pExtent->uLastGrainWritten / pExtent->cGTEntries;
+    if (uGrain < pExtent->uLastGrainWritten)
+    {
+        rc = VERR_VD_VMDK_INVALID_WRITE;
+        goto out;
+    }
+
+    if (uGDEntry != uLastGDEntry)
+    {
+        rc = vmdksFlushGT(pImage, pExtent, uLastGDEntry);
+        if (RT_FAILURE(rc))
+            goto out;
+        vmdksClearGT(pImage, pExtent);
+        for (uint32_t i = uLastGDEntry + 1; i < uGDEntry; i++)
+        {
+            rc = vmdksFlushGT(pImage, pExtent, i);
+            if (RT_FAILURE(rc))
+                goto out;
+        }
+    }
+
+    /* Check access permissions as defined in the extent descriptor.
+     * May sound a bit paradoxical, but we created the image with a
+     * readonly extent since the resulting image is kind of "write once". */
+    if (pExtent->enmAccess != VMDKACCESS_READONLY)
+    {
+        rc = VERR_VD_VMDK_INVALID_STATE;
+        goto out;
+    }
+
+    uint64_t uFileOffset;
+    rc = vmdkFileGetSize(pImage, pExtent->pFile, &uFileOffset);
+    if (RT_FAILURE(rc))
+        goto out;
+    if (uFileOffset % 512)
+    {
+        rc = VERR_INTERNAL_ERROR;
+        goto out;
+    }
+
+    /* 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])
+    {
+        rc = VERR_INTERNAL_ERROR;
+        goto out;
+    }
+
+    /* Update grain table entry. */
+    pImage->pGTCache->aGTCache[uCacheLine].aGTData[uCacheEntry] = VMDK_BYTE2SECTOR(uFileOffset);
+
+    if (cbToWrite != VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain))
+    {
+        memcpy(pExtent->pvGrain, pvBuf, cbToWrite);
+        memset((char *)pExtent->pvGrain + cbToWrite, '\0',
+               VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain) - cbToWrite);
+        pData = pExtent->pvGrain;
+    }
+    rc = vmdkFileDeflateSync(pImage, pExtent->pFile, uFileOffset,
+                             pData, VMDK_SECTOR2BYTE(pExtent->cSectorsPerGrain),
+                             VMDK_MARKER_IGNORE, uSector, &cbGrain);
+    if (RT_FAILURE(rc))
+    {
+        pExtent->uGrainSector = 0;
+        pExtent->uLastGrainSector = 0;
+        AssertRC(rc);
+        return vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: cannot write compressed data block in '%s'"), pExtent->pszFullname);
+    }
+    cbGrain = RT_ALIGN(cbGrain, 512);
+    pExtent->uLastGrainSector = VMDK_BYTE2SECTOR(uFileOffset);
+    pExtent->uLastGrainWritten = uGrain;
+    pExtent->cbLastGrainWritten = cbGrain;
+
+    if (pcbWriteProcess)
+        *pcbWriteProcess = cbToWrite;
+
+out:
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnFlush */
+static int vmdksFlush(void *pBackendData)
+{
+    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    AssertPtr(pImage);
+
+    /* Pure dummy operation, closing takes care of everything. */
+    rc = VINF_SUCCESS;
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
+static int vmdksSetPCHSGeometry(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;
+
+    AssertPtr(pImage);
+
+    if (pImage)
+    {
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            rc = VERR_VD_IMAGE_READ_ONLY;
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_NOT_OPENED;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
+static int vmdksSetLCHSGeometry(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;
+
+    AssertPtr(pImage);
+
+    if (pImage)
+    {
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            rc = VERR_VD_IMAGE_READ_ONLY;
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_NOT_OPENED;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
+static int vmdksSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
+{
+    LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc = VINF_SUCCESS;
+
+    /* Image must be opened and the new flags must be the same as before. */
+    if (!pImage || pImage->uOpenFlags != uOpenFlags)
+    {
+        rc = VERR_INVALID_PARAMETER;
+        goto out;
+    }
+
+out:
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnSetComment */
+static int vmdksSetComment(void *pBackendData, const char *pszComment)
+{
+    LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    AssertPtr(pImage);
+
+    if (pImage)
+    {
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            rc = VERR_VD_IMAGE_READ_ONLY;
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_NOT_OPENED;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
+static int vmdksSetUuid(void *pBackendData, PCRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    LogFlowFunc(("%RTuuid\n", pUuid));
+    AssertPtr(pImage);
+
+    if (pImage)
+    {
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            rc = VERR_VD_IMAGE_READ_ONLY;
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_NOT_OPENED;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
+static int vmdksSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    AssertPtr(pImage);
+
+    if (pImage)
+    {
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            rc = VERR_VD_IMAGE_READ_ONLY;
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_NOT_OPENED;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
+static int vmdksSetParentUuid(void *pBackendData, PCRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    AssertPtr(pImage);
+
+    if (pImage)
+    {
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            rc = VERR_VD_IMAGE_READ_ONLY;
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_NOT_OPENED;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
+static int vmdksSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
+{
+    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
+    PVMDKIMAGE pImage = (PVMDKIMAGE)pBackendData;
+    int rc;
+
+    AssertPtr(pImage);
+
+    if (pImage)
+    {
+        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            rc = VERR_VD_IMAGE_READ_ONLY;
+        else
+            rc = VERR_NOT_SUPPORTED;
+    }
+    else
+        rc = VERR_VD_NOT_OPENED;
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
 }
 
@@ -6778 +7700 @@
     return rc;
 }
+
+
+VBOXHDDBACKEND g_VmdkStreamBackend =
+{
+    /* pszBackendName */
+    "VMDKstream",
+    /* cbSize */
+    sizeof(VBOXHDDBACKEND),
+    /* uBackendCaps */
+    VD_CAP_UUID | VD_CAP_CREATE_DYNAMIC | VD_CAP_FILE | VD_CAP_VFS,
+    /* papszFileExtensions */
+    s_apszVmdkFileExtensions,
+    /* paConfigInfo */
+    NULL,
+    /* hPlugin */
+    NIL_RTLDRMOD,
+    /* pfnCheckIfValid */
+    vmdksCheckIfValid,
+    /* pfnOpen */
+    vmdksOpen,
+    /* pfnCreate */
+    vmdksCreate,
+    /* pfnRename */
+    NULL,
+    /* pfnClose */
+    vmdksClose,
+    /* pfnRead */
+    vmdksRead,
+    /* pfnWrite */
+    vmdksWrite,
+    /* pfnFlush */
+    vmdksFlush,
+    /* pfnGetVersion */
+    vmdkGetVersion,
+    /* pfnGetSize */
+    vmdkGetSize,
+    /* pfnGetFileSize */
+    vmdkGetFileSize,
+    /* pfnGetPCHSGeometry */
+    vmdkGetPCHSGeometry,
+    /* pfnSetPCHSGeometry */
+    vmdksSetPCHSGeometry,
+    /* pfnGetLCHSGeometry */
+    vmdkGetLCHSGeometry,
+    /* pfnSetLCHSGeometry */
+    vmdksSetLCHSGeometry,
+    /* pfnGetImageFlags */
+    vmdkGetImageFlags,
+    /* pfnGetOpenFlags */
+    vmdkGetOpenFlags,
+    /* pfnSetOpenFlags */
+    vmdksSetOpenFlags,
+    /* pfnGetComment */
+    vmdkGetComment,
+    /* pfnSetComment */
+    vmdksSetComment,
+    /* pfnGetUuid */
+    vmdkGetUuid,
+    /* pfnSetUuid */
+    vmdksSetUuid,
+    /* pfnGetModificationUuid */
+    vmdkGetModificationUuid,
+    /* pfnSetModificationUuid */
+    vmdksSetModificationUuid,
+    /* pfnGetParentUuid */
+    vmdkGetParentUuid,
+    /* pfnSetParentUuid */
+    vmdksSetParentUuid,
+    /* pfnGetParentModificationUuid */
+    vmdkGetParentModificationUuid,
+    /* pfnSetParentModificationUuid */
+    vmdksSetParentModificationUuid,
+    /* pfnDump */
+    vmdkDump,
+    /* pfnGetTimeStamp */
+    NULL,
+    /* pfnGetParentTimeStamp */
+    NULL,
+    /* pfnSetParentTimeStamp */
+    NULL,
+    /* pfnGetParentFilename */
+    NULL,
+    /* pfnSetParentFilename */
+    NULL,
+    /* pfnIsAsyncIOSupported */
+    NULL,
+    /* pfnAsyncRead */
+    NULL,
+    /* pfnAsyncWrite */
+    NULL,
+    /* pfnAsyncFlush */
+    NULL,
+    /* pfnComposeLocation */
+    genericFileComposeLocation,
+    /* pfnComposeName */
+    genericFileComposeName,
+    /* pfnCompact */
+    NULL,
+    /* pfnResize */
+    NULL
+};