Changeset 31804 in vbox

Timestamp:

Aug 19, 2010 9:10:57 PM (14 years ago)

Author:

vboxsync

Message:

VBoxHDD/VDI: Support for increasing the size of a disk, completely untested\!

Location:

trunk/src/VBox/Devices/Storage

Files:

• VDICore.h (modified) (4 diffs)
• VDIHDDCore.cpp (modified) (2 diffs)

trunk/src/VBox/Devices/Storage/VDICore.h

@@ -356 +356 @@
 }
 
-DECLINLINE(unsigned) getImageDataOffset(PVDIHEADER ph)
+DECLINLINE(uint32_t) getImageDataOffset(PVDIHEADER ph)
 {
     switch (GET_MAJOR_HEADER_VERSION(ph))
@@ -366 +366 @@
     AssertFailed();
     return 0;
+}
+
+DECLINLINE(void) setImageDataOffset(PVDIHEADER ph, uint32_t offData)
+{
+    switch (GET_MAJOR_HEADER_VERSION(ph))
+    {
+        case 0: return;
+        case 1: ph->u.v1.offData = offData;
+    }
+    AssertFailed();
 }
 
@@ -398 +408 @@
 }
 
+DECLINLINE(void) setImageDiskSize(PVDIHEADER ph, uint64_t cbDisk)
+{
+    switch (GET_MAJOR_HEADER_VERSION(ph))
+    {
+        case 0: ph->u.v0.cbDisk = cbDisk; return;
+        case 1: ph->u.v1.cbDisk = cbDisk; return;
+    }
+    AssertFailed();
+}
+
 DECLINLINE(unsigned) getImageBlockSize(PVDIHEADER ph)
 {
@@ -430 +450 @@
     return 0;
 }
+
+DECLINLINE(void) setImageBlocks(PVDIHEADER ph, unsigned cBlocks)
+{
+    switch (GET_MAJOR_HEADER_VERSION(ph))
+    {
+        case 0: ph->u.v0.cBlocks = cBlocks; return;
+        case 1: ph->u.v1.cBlocks = cBlocks; return;
+    }
+    AssertFailed();
+}
+
 
 DECLINLINE(unsigned) getImageBlocksAllocated(PVDIHEADER ph)

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

@@ -2513 +2513 @@
                                  uPercentStart + uPercentSpan);
     }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+/** @copydoc VBOXHDDBACKEND::pfnResize */
+static int vdiResize(void *pBackendData, uint64_t cbSize,
+                     PCPDMMEDIAGEOMETRY pPCHSGeometry, PCPDMMEDIAGEOMETRY pLCHSGeometry,
+                     unsigned uPercentStart, unsigned uPercentSpan,
+                     PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
+                     PVDINTERFACE pVDIfsOperation)
+{
+    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
+    int rc = VINF_SUCCESS;
+
+    PFNVDPROGRESS 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;
+    }
+
+    /* Making the image smaller is not supported at the moment. */
+    if (cbSize < getImageDiskSize(&pImage->Header) || GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
+        rc = VERR_NOT_SUPPORTED;
+    else if (cbSize > getImageDiskSize(&pImage->Header))
+    {
+        unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header);
+        uint64_t cbNew  = cbSize - getImageDiskSize(&pImage->Header);
+        uint32_t cBlocksNew = cbNew / getImageBlockSize(&pImage->Header);
+        if (cbNew % getImageBlockSize(&pImage->Header))
+            cBlocksNew++;
+        uint32_t cbAdditionalBlockspace = cBlocksNew * sizeof(VDIIMAGEBLOCKPOINTER);
+        uint64_t cbBlockspace = getImageBlocks(&pImage->Header) * sizeof(VDIIMAGEBLOCKPOINTER) + cbAdditionalBlockspace;
+
+        uint64_t offImageDataNew = RT_ALIGN_32(pImage->offStartBlocks + cbBlockspace, VDI_GEOMETRY_SECTOR_SIZE);
+
+        if (   pImage->offStartData != offImageDataNew
+            && getImageBlocksAllocated(&pImage->Header) > 0)
+        {
+            /* Calculate how many sectors nee to be relocated. */
+            uint64_t cbOverlapping = offImageDataNew - pImage->offStartData;
+            unsigned cBlocksReloc = cbOverlapping / getImageBlockSize(&pImage->Header);
+            if (cbOverlapping % getImageBlockSize(&pImage->Header))
+                cBlocksReloc++;
+
+            /* Do the relocation. */
+            LogFlow(("Relocating %u blocks\n", cBlocksReloc));
+
+            /*
+             * Get the blocks we need to relocate first, they are appended to the end
+             * of the image.
+             */
+            void *pvBuf = NULL, *pvZero = NULL;
+            do
+            {
+                uint64_t offBlockCur = pImage->offStartData;
+                VDIIMAGEBLOCKPOINTER uBlock = 0;
+
+                /* Allocate data buffer. */
+                pvBuf = RTMemAllocZ(pImage->cbTotalBlockData);
+                if (!pvBuf)
+                {
+                    rc = VERR_NO_MEMORY;
+                    break;
+                }
+
+                /* Allocate buffer for overwrting with zeroes. */
+                pvZero = RTMemAllocZ(pImage->cbTotalBlockData);
+                if (!pvZero)
+                {
+                    rc = VERR_NO_MEMORY;
+                    break;
+                }
+
+                for (unsigned i = 0; i < cBlocksReloc; i++)
+                {
+                    /* Search the index in the block table. */
+                    for (unsigned idxBlock = 0; idxBlock < cBlocksAllocated; idxBlock++)
+                    {
+                        if (pImage->paBlocks[idxBlock] == uBlock)
+                        {
+                            /* Read data and append to the end of the image. */
+                            rc = vdiFileReadSync(pImage, offBlockCur, pvBuf, pImage->cbTotalBlockData, NULL);
+                            if (RT_FAILURE(rc))
+                                break;
+
+                            uint64_t offBlockAppend;
+                            rc = vdiFileGetSize(pImage, &offBlockAppend);
+                            if (RT_FAILURE(rc))
+                                break;
+
+                            rc = vdiFileWriteSync(pImage, offBlockAppend, pvBuf, pImage->cbTotalBlockData, NULL);
+                            if (RT_FAILURE(rc))
+                                break;
+
+                            /* Zero out the old block area. */
+                            rc = vdiFileWriteSync(pImage, offBlockCur, pvZero, pImage->cbTotalBlockData, NULL);
+                            if (RT_FAILURE(rc))
+                                break;
+
+                            /* Update block counter. */
+                            pImage->paBlocks[idxBlock] = cBlocksAllocated;
+
+                            /*
+                             * Decrease the block number of all other entries in the array.
+                             * They were moved one block to the front.
+                             * Doing it as a separate step iterating over the array again
+                             * because an error while relocating the one block might end up
+                             * in a corrupted image otherwise.
+                             */
+                            for (unsigned idxBlock2 = 0; idxBlock2 < cBlocksAllocated; idxBlock2++)
+                            {
+                                if (   idxBlock2 != idxBlock
+                                    && IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[idxBlock2]))
+                                    pImage->paBlocks[idxBlock2]--;
+                            }
+                        }
+                    }
+
+                    if (RT_FAILURE(rc))
+                        break;
+
+                    uBlock++;
+                    offBlockCur += pImage->cbTotalBlockData;
+                }
+            } while (0);
+
+            if (pvBuf)
+                RTMemFree(pvBuf);
+            if (pvZero)
+                RTMemFree(pvZero);
+        }
+
+        /*
+         * Relocation done, expand the block array and update the header with
+         * the new data.
+         */
+        if (RT_SUCCESS(rc))
+        {
+            PVDIIMAGEBLOCKPOINTER paBlocksNew = (PVDIIMAGEBLOCKPOINTER)RTMemRealloc(pImage->paBlocks, getImageBlocks(&pImage->Header) + cBlocksNew);
+            if (paBlocksNew)
+            {
+                /* Mark the new blocks as unallocated. */
+                for (unsigned idxBlock = getImageBlocks(&pImage->Header); idxBlock < getImageBlocks(&pImage->Header) + cBlocksNew; idxBlock++)
+                    pImage->paBlocks[idxBlock] = VDI_IMAGE_BLOCK_FREE;
+            }
+            else
+                rc = VERR_NO_MEMORY;
+
+            /* Write the block array before updating the rest. */
+            rc = vdiFileWriteSync(pImage, pImage->offStartBlocks, pImage->paBlocks,
+                                  sizeof(VDIIMAGEBLOCKPOINTER) * (getImageBlocks(&pImage->Header) + cBlocksNew),
+                                  NULL);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Update size and new block count. */
+            setImageDiskSize(&pImage->Header, cbSize);
+            setImageBlocks(&pImage->Header, getImageBlocks(&pImage->Header) + cBlocksNew);
+            /* Update geometry. */
+            pImage->PCHSGeometry = *pPCHSGeometry;
+
+            PVDIDISKGEOMETRY pGeometry = getImageLCHSGeometry(&pImage->Header);
+            if (pGeometry)
+            {
+                pGeometry->cCylinders = pLCHSGeometry->cCylinders;
+                pGeometry->cHeads = pLCHSGeometry->cHeads;
+                pGeometry->cSectors = pLCHSGeometry->cSectors;
+                pGeometry->cbSector = VDI_GEOMETRY_SECTOR_SIZE;
+            }
+        }
+
+        /*
+         * We need to update the new offsets for the image data in the out of memory
+         * case too because we relocated the blocks already.
+         */
+        pImage->offStartData = offImageDataNew;
+        setImageDataOffset(&pImage->Header, offImageDataNew);
+
+        /* Update header information in base image file. */
+        vdiFlushImage(pImage);
+    }
+    /* Same size doesn't change the image at all. */
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -2617 +2809 @@
     vdiCompact,
     /* pfnResize */
-    NULL
+    vdiResize
 };