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

Timestamp:

Apr 24, 2009 6:19:57 PM (16 years ago)

Author:

vboxsync

Message:

VBoxHDD/generic+VDI: implemented and documented

Location:

trunk/src/VBox/Devices/Storage

Files:

• VBoxHDD-Internal.h (modified) (5 diffs)
• VBoxHDD.cpp (modified) (4 diffs)
• VDIHDDCore.cpp (modified) (8 diffs)

trunk/src/VBox/Devices/Storage/VBoxHDD-Internal.h

@@ -159 +159 @@
      *
      * @returns VBox status code.
-     * @returns VINF_VD_BLOCK_FREE if this image contains no data for this block.
-     * @returns VINF_VD_BLOCK_ZERO if this image contains a zero data block.
-     * @param   pvBackendData   Opaque state data for this image.
-     * @param   off             Offset to start reading from.
+     * @returns VERR_VD_BLOCK_FREE if this image contains no data for this block.
+     * @param   pvBackendData   Opaque state data for this image.
+     * @param   uOffset         Offset to start reading from.
      * @param   pvBuf           Where to store the read bits.
      * @param   cbRead          Number of bytes to read.
      * @param   pcbActuallyRead Pointer to returned number of bytes read.
      */
-    DECLR3CALLBACKMEMBER(int, pfnRead, (void *pvBackendData, uint64_t off, void *pvBuf,
+    DECLR3CALLBACKMEMBER(int, pfnRead, (void *pvBackendData, uint64_t uOffset, void *pvBuf,
                                         size_t cbRead, size_t *pcbActuallyRead));
 
@@ -175 +174 @@
      *
      * @returns VBox status code.
-     * @returns VINF_VD_BLOCK_FREE if this image contains no data for this block and
+     * @returns VERR_VD_BLOCK_FREE if this image contains no data for this block and
      *          this is not a full-block write. The write must be repeated with
      *          the correct amount of prefix/postfix data read from the images below
@@ -182 +181 @@
      *          stack uses different block sizes.
      * @param   pvBackendData   Opaque state data for this image.
-     * @param   off             Offset to start writing to.
+     * @param   uOffset         Offset to start writing to.
      * @param   pvBuf           Where to retrieve the written bits.
      * @param   cbWrite         Number of bytes to write.
      * @param   pcbWriteProcess Pointer to returned number of bytes that could
      *                          be processed. In case the function returned
-     *                          VINF_VD_BLOCK_FREE this is the number of bytes
+     *                          VERR_VD_BLOCK_FREE this is the number of bytes
      *                          that could be written in a full block write,
      *                          when prefixed/postfixed by the appropriate
@@ -198 +197 @@
      *                          of the VD_WRITE_* flags.
      */
-    DECLR3CALLBACKMEMBER(int, pfnWrite, (void *pvBackendData, uint64_t off,
+    DECLR3CALLBACKMEMBER(int, pfnWrite, (void *pvBackendData, uint64_t uOffset,
                                          const void *pvBuf, size_t cbWrite,
                                          size_t *pcbWriteProcess, size_t *pcbPreRead,
@@ -495 +494 @@
      *  VD_CAP_FILE and NULL otherwise. */
     DECLR3CALLBACKMEMBER(int, pfnComposeName, (PVDINTERFACE pConfig, char **pszName));
+
+    /**
+     * Compact the image. The pointer may be NULL, indicating that this
+     * isn't supported yet (for file-based images) or not necessary.
+     *
+     * @returns VBox status code.
+     * @returns VERR_NOT_SUPPORTED if this image cannot be compacted yet.
+     * @param   pvBackendData   Opaque state data for this image.
+     * @param   uPercentStart   Starting value for progress percentage.
+     * @param   uPercentSpan    Span for varying progress percentage.
+     * @param   pVDIfsOperation Pointer to the per-operation VD interface list.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnCompact, (void *pvBackendData,
+                                           unsigned uPercentStart, unsigned uPercentSpan,
+                                           PVDINTERFACE pVDIfsOperation));
 
 } VBOXHDDBACKEND;

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

@@ -119 +119 @@
 
 
+/**
+ * VBox parent read descriptor, used internally for compaction.
+ */
+typedef struct VDPARENTSTATEDESC
+{
+    /** Pointer to disk descriptor. */
+    PVBOXHDD pDisk;
+    /** Pointer to image descriptor. */
+    PVDIMAGE pImage;
+} VDPARENTSTATEDESC, *PVDPARENTSTATEDESC;
+
+
 extern VBOXHDDBACKEND g_RawBackend;
 extern VBOXHDDBACKEND g_VmdkBackend;
@@ -304 +316 @@
 
     return rc;
+}
+
+/**
+ * internal: parent image read wrapper for compacting.
+ */
+static int vdParentRead(void *pvUser, uint64_t uOffset, void *pvBuf,
+                        size_t cbRead)
+{
+    PVDPARENTSTATEDESC pParentState = (PVDPARENTSTATEDESC)pvUser;
+    return vdReadHelper(pParentState->pDisk, pParentState->pImage, uOffset,
+                        pvBuf, cbRead);
 }
 
@@ -2119 +2142 @@
  * @return  VERR_VD_IMAGE_NOT_FOUND if image with specified number was not opened.
  * @return  VERR_VD_IMAGE_READ_ONLY if image is not writable.
- * @return  VERR_NOT_SUPPORTED if this kind of image cannot be compacted.
- * @return  VERR_NOT_IMPLEMENTED if this kind of image can be compacted, but
- *                               the code for this isn't implemented yet.
+ * @return  VERR_NOT_SUPPORTED if this kind of image can be compacted, but
+ *                             the code for this isn't implemented yet.
  * @param   pDisk           Pointer to HDD container.
  * @param   nImage          Image number, counts from 0. 0 is always base image of container.
@@ -2129 +2151 @@
                             PVDINTERFACE pVDIfsOperation)
 {
-    return VERR_NOT_SUPPORTED;
+    int rc;
+    void *pvBuf = NULL;
+    void *pvTmp = NULL;
+
+    LogFlowFunc(("pDisk=%#p nImage=%u pVDIfsOperation=%#p\n",
+                 pDisk, nImage, pVDIfsOperation));
+
+    PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
+                                              VDINTERFACETYPE_PROGRESS);
+    PVDINTERFACEPROGRESS pCbProgress = NULL;
+    if (pIfProgress)
+        pCbProgress = VDGetInterfaceProgress(pIfProgress);
+
+    do {
+        /* Check arguments. */
+        AssertMsgBreakStmt(VALID_PTR(pDisk), ("pDisk=%#p\n", pDisk),
+                           rc = VERR_INVALID_PARAMETER);
+        AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE,
+                  ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
+
+        /* If there is no compact callback for not file based backends then
+         * the backend doesn't need compaction. No need to make much fuss about
+         * this. For file based ones signal this as not yet supported. */
+        if (!pImage->Backend->pfnCompact)
+        {
+            if (pImage->Backend->uBackendCaps & VD_CAP_FILE)
+                rc = VERR_NOT_SUPPORTED;
+            else
+                rc = VINF_SUCCESS;
+            break;
+        }
+
+        /* Insert interface for reading parent state into per-operation list,
+         * if there is a parent image. */
+        VDINTERFACE IfOpParent;
+        VDINTERFACEPARENTSTATE ParentCb;
+        VDPARENTSTATEDESC ParentUser;
+        if (pImage->pPrev)
+        {
+            ParentCb.cbSize = sizeof(ParentCb);
+            ParentCb.enmInterface = VDINTERFACETYPE_PARENTSTATE;
+            ParentCb.pfnParentRead = vdParentRead;
+            ParentUser.pDisk = pDisk;
+            ParentUser.pImage = pImage->pPrev;
+            rc = VDInterfaceAdd(&IfOpParent, "VDCompact_ParentState", VDINTERFACETYPE_PARENTSTATE,
+                                &ParentCb, &ParentUser, &pVDIfsOperation);
+            AssertRC(rc);
+        }
+
+        rc = pImage->Backend->pfnCompact(pImage->pvBackendData,
+                                         0, 99,
+                                         pVDIfsOperation);
+    } while (0);
+
+    if (pvBuf)
+        RTMemTmpFree(pvBuf);
+    if (pvTmp)
+        RTMemTmpFree(pvTmp);
+
+    if (RT_SUCCESS(rc))
+    {
+        if (pCbProgress && pCbProgress->pfnProgress)
+            pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */, 100,
+                                     pIfProgress->pvUser);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
 }
 

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

@@ -1778 +1778 @@
 }
 
-static int vdiGetTimeStamp(void *pvBackendData, PRTTIMESPEC pTimeStamp)
+static int vdiGetTimeStamp(void *pBackendData, PRTTIMESPEC pTimeStamp)
 {
     int rc = VERR_NOT_IMPLEMENTED;
@@ -1785 +1785 @@
 }
 
-static int vdiGetParentTimeStamp(void *pvBackendData, PRTTIMESPEC pTimeStamp)
+static int vdiGetParentTimeStamp(void *pBackendData, PRTTIMESPEC pTimeStamp)
 {
     int rc = VERR_NOT_IMPLEMENTED;
@@ -1792 +1792 @@
 }
 
-static int vdiSetParentTimeStamp(void *pvBackendData, PCRTTIMESPEC pTimeStamp)
+static int vdiSetParentTimeStamp(void *pBackendData, PCRTTIMESPEC pTimeStamp)
 {
     int rc = VERR_NOT_IMPLEMENTED;
@@ -1799 +1799 @@
 }
 
-static int vdiGetParentFilename(void *pvBackendData, char **ppszParentFilename)
+static int vdiGetParentFilename(void *pBackendData, char **ppszParentFilename)
 {
     int rc = VERR_NOT_IMPLEMENTED;
@@ -1806 +1806 @@
 }
 
-static int vdiSetParentFilename(void *pvBackendData, const char *pszParentFilename)
+static int vdiSetParentFilename(void *pBackendData, const char *pszParentFilename)
 {
     int rc = VERR_NOT_IMPLEMENTED;
@@ -1813 +1813 @@
 }
 
-static bool vdiIsAsyncIOSupported(void *pvBackendData)
+static bool vdiIsAsyncIOSupported(void *pBackendData)
 {
     return false;
 }
 
-static int vdiAsyncRead(void *pvBackendData, uint64_t uOffset, size_t cbRead,
+static int vdiAsyncRead(void *pBackendData, uint64_t uOffset, size_t cbRead,
                         PPDMDATASEG paSeg, unsigned cSeg, void *pvUser)
 {
@@ -1826 +1826 @@
 }
 
-static int vdiAsyncWrite(void *pvBackendData, uint64_t uOffset, size_t cbWrite,
+static int vdiAsyncWrite(void *pBackendData, uint64_t uOffset, size_t cbWrite,
                          PPDMDATASEG paSeg, unsigned cSeg, void *pvUser)
 {
     int rc = VERR_NOT_IMPLEMENTED;
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnCompact */
+static int vdiCompact(void *pBackendData, unsigned uPercentStart,
+                      unsigned uPercentSpan, PVDINTERFACE pVDIfsOperation)
+{
+    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
+    int rc = VINF_SUCCESS;
+    void *pvBuf = NULL, *pvTmp = NULL;
+    unsigned *paBlocks2 = NULL;
+
+    int (*pfnParentRead)(void *, uint64_t, void *, size_t) = NULL;
+    void *pvParent = NULL;
+    PVDINTERFACE pIfParentState = VDInterfaceGet(pVDIfsOperation,
+                                                 VDINTERFACETYPE_PARENTSTATE);
+    PVDINTERFACEPARENTSTATE pCbParentState = NULL;
+    if (pIfParentState)
+    {
+        pCbParentState = VDGetInterfaceParentState(pIfParentState);
+        if (pCbParentState)
+            pfnParentRead = pCbParentState->pfnParentRead;
+        pvParent = pIfParentState->pvUser;
+    }
+
+    PFNVMPROGRESS pfnProgress = NULL;
+    void *pvUser = NULL;
+    PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
+                                              VDINTERFACETYPE_PROGRESS);
+    PVDINTERFACEPROGRESS pCbProgress = NULL;
+    if (pIfProgress)
+    {
+        pCbProgress = VDGetInterfaceProgress(pIfProgress);
+        if (pCbProgress)
+            pfnProgress = pCbProgress->pfnProgress;
+        pvUser = pIfProgress->pvUser;
+    }
+
+    do {
+        AssertBreakStmt(pImage, rc = VERR_INVALID_PARAMETER);
+
+        AssertBreakStmt(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
+                        rc = VERR_VD_IMAGE_READ_ONLY);
+
+        unsigned cBlocks;
+        unsigned cBlocksToMove = 0;
+        size_t cbBlock;
+        cBlocks = getImageBlocks(&pImage->Header);
+        cbBlock = getImageBlockSize(&pImage->Header);
+        if (pfnParentRead)
+        {
+            pvBuf = RTMemTmpAlloc(cbBlock);
+            AssertBreakStmt(VALID_PTR(pvBuf), rc = VERR_NO_MEMORY);
+        }
+        pvTmp = RTMemTmpAlloc(cbBlock);
+        AssertBreakStmt(VALID_PTR(pvTmp), rc = VERR_NO_MEMORY);
+
+        uint64_t cbFile;
+        rc = RTFileGetSize(pImage->File, &cbFile);
+        AssertRCBreak(rc);
+        unsigned cBlocksAllocated = (unsigned)((cbFile - pImage->offStartData - pImage->offStartBlockData) >> pImage->uShiftOffset2Index);
+
+        /* Allocate block array for back resolving. */
+        paBlocks2 = (unsigned *)RTMemAlloc(sizeof(unsigned *) * cBlocksAllocated);
+        AssertBreakStmt(VALID_PTR(paBlocks2), rc = VERR_NO_MEMORY);
+        /* Fill out back resolving, check/fix allocation errors before
+         * compacting the image, just to be on the safe side. Update the
+         * image contents straight away, as this enables cancelling. */
+        for (unsigned i = 0; i < cBlocks; i++)
+            paBlocks2[i] = VDI_IMAGE_BLOCK_FREE;
+        rc = VINF_SUCCESS;
+        for (unsigned i = 0; i < cBlocks; i++)
+        {
+            VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
+            if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
+            {
+                if (ptrBlock < cBlocksAllocated)
+                {
+                    if (paBlocks2[ptrBlock] == VDI_IMAGE_BLOCK_FREE)
+                        paBlocks2[ptrBlock] = i;
+                    else
+                    {
+                        LogFunc(("Freed cross-linked block %u in file \"%s\"\n",
+                                 i, pImage->pszFilename));
+                        pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
+                        rc = vdiUpdateBlockInfo(pImage, i);
+                        if (RT_FAILURE(rc))
+                            break;
+                    }
+                }
+                else
+                {
+                    LogFunc(("Freed out of bounds reference for block %u in file \"%s\"\n",
+                             i, pImage->pszFilename));
+                    pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;;
+                    rc = vdiUpdateBlockInfo(pImage, i);
+                    if (RT_FAILURE(rc))
+                        break;
+                }
+            }
+        }
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Find redundant information and update the block pointers
+         * accordingly, creating bubbles. Keep disk up to date, as this
+         * enables cancelling. */
+        for (unsigned i = 0; i < cBlocks; i++)
+        {
+            VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
+            if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
+            {
+                /* Block present in image file, read relevant data. */
+                uint64_t u64Offset = (uint64_t)ptrBlock * pImage->cbTotalBlockData
+                                   + (pImage->offStartData + pImage->offStartBlockData);
+                rc = RTFileReadAt(pImage->File, u64Offset, pvTmp, cbBlock, NULL);
+                if (RT_FAILURE(rc))
+                    break;
+
+                if (ASMBitFirstSet((volatile void *)pvTmp, (uint32_t)cbBlock * 8) == -1)
+                {
+                    pImage->paBlocks[i] = VDI_IMAGE_BLOCK_ZERO;
+                    rc = vdiUpdateBlockInfo(pImage, i);
+                    if (RT_FAILURE(rc))
+                        break;
+                    paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
+                    /* Adjust progress info, one block to be relocated. */
+                    cBlocksToMove++;
+                }
+                else if (pfnParentRead)
+                {
+                    rc = pfnParentRead(pvParent, i * cbBlock, pvBuf, cbBlock);
+                    if (RT_FAILURE(rc))
+                        break;
+                    if (memcmp(pvTmp, pvBuf, cbBlock))
+                    {
+                        pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
+                        rc = vdiUpdateBlockInfo(pImage, i);
+                        if (RT_FAILURE(rc))
+                            break;
+                        paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
+                        /* Adjust progress info, one block to be relocated. */
+                        cBlocksToMove++;
+                    }
+                }
+            }
+
+            if (pCbProgress && pCbProgress->pfnProgress)
+            {
+                rc = pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
+                                              (uint64_t)i * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart,
+                                              pIfProgress->pvUser);
+                if (RT_FAILURE(rc))
+                    break;
+            }
+        }
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Fill bubbles with other data (if available). */
+        unsigned cBlocksMoved = 0;
+        unsigned uBlockUsedPos = cBlocksAllocated;
+        for (unsigned i = 0; i < cBlocksAllocated; i++)
+        {
+            unsigned uBlock = paBlocks2[i];
+            if (uBlock == VDI_IMAGE_BLOCK_FREE)
+            {
+                unsigned uBlockData;
+                do {
+                    uBlockUsedPos--;
+                    uBlockData = paBlocks2[uBlockUsedPos];
+                } while (uBlockUsedPos > i && uBlockData == VDI_IMAGE_BLOCK_FREE);
+                /* Terminate early if there is no block which needs copying. */
+                if (uBlockUsedPos == i)
+                    break;
+                uint64_t u64Offset = (uint64_t)uBlockUsedPos * pImage->cbTotalBlockData
+                                   + (pImage->offStartData + pImage->offStartBlockData);
+                rc = RTFileReadAt(pImage->File, u64Offset, pvTmp, cbBlock, NULL);
+                u64Offset = (uint64_t)i * pImage->cbTotalBlockData
+                          + (pImage->offStartData + pImage->offStartBlockData);
+                rc = RTFileWriteAt(pImage->File, u64Offset, pvTmp, cbBlock, NULL);
+                pImage->paBlocks[uBlockData] = i;
+                setImageBlocksAllocated(&pImage->Header, cBlocksAllocated - cBlocksMoved);
+                rc = vdiUpdateBlockInfo(pImage, uBlockData);
+                if (RT_FAILURE(rc))
+                    break;
+                paBlocks2[i] = uBlockData;
+                paBlocks2[uBlockUsedPos] = VDI_IMAGE_BLOCK_FREE;
+                cBlocksMoved++;
+            }
+
+            if (pCbProgress && pCbProgress->pfnProgress)
+            {
+                rc = pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
+                                              (uint64_t)(cBlocks + cBlocksMoved) * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart,
+                                              pIfProgress->pvUser);
+                if (RT_FAILURE(rc))
+                    break;
+            }
+        }
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Update image header. */
+        setImageBlocksAllocated(&pImage->Header, uBlockUsedPos);
+        vdiUpdateHeader(pImage);
+
+        /* Truncate the image to the proper size to finish compacting. */
+        rc = RTFileSetSize(pImage->File,
+                           (uint64_t)uBlockUsedPos * pImage->cbTotalBlockData
+                           + (pImage->offStartData + pImage->offStartBlockData));
+    } while (0);
+
+    if (paBlocks2)
+        RTMemTmpFree(paBlocks2);
+    if (pvTmp)
+        RTMemTmpFree(pvTmp);
+    if (pvBuf)
+        RTMemTmpFree(pvBuf);
+
+    if (RT_SUCCESS(rc) && pCbProgress && pCbProgress->pfnProgress)
+    {
+        pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
+                                 uPercentStart + uPercentSpan,
+                                 pIfProgress->pvUser);
+    }
+
     LogFlowFunc(("returns %Rrc\n", rc));
     return rc;
@@ -1927 +2155 @@
     genericFileComposeLocation,
     /* pfnComposeName */
-    genericFileComposeName
+    genericFileComposeName,
+    /* pfnCompact */
+    vdiCompact
 };