Changeset 38621 in vbox for trunk/src/VBox/Storage/VDI.cpp

Timestamp:

Sep 4, 2011 4:56:56 PM (13 years ago)

Author:

vboxsync

Message:

VD: Initial support to discard unused blocks in an image + support for VDI images

File:

• trunk/src/VBox/Storage/VDI.cpp (modified) (8 diffs)

trunk/src/VBox/Storage/VDI.cpp

@@ -102 +102 @@
         }
 
+        if (pImage->paBlocksRev)
+        {
+            RTMemFree(pImage->paBlocksRev);
+            pImage->paBlocksRev = NULL;
+        }
+
         if (fDelete && pImage->pszFilename)
             vdIfIoIntFileDelete(pImage->pIfIo, pImage->pszFilename);
@@ -703 +709 @@
                                getImageBlocks(&pImage->Header) * sizeof(VDIIMAGEBLOCKPOINTER),
                                NULL);
+
+    if (uOpenFlags & VD_OPEN_FLAGS_DISCARD)
+    {
+        /*
+         * Create the back resolving table for discards.
+         * any error or inconsistency results in a fail because this might
+         * get us into trouble later on.
+         */
+        pImage->paBlocksRev = (unsigned *)RTMemAllocZ(sizeof(unsigned) * getImageBlocks(&pImage->Header));
+        if (pImage->paBlocksRev)
+        {
+            unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header);
+            unsigned cBlocks = getImageBlocks(&pImage->Header);
+
+            for (unsigned i = 0; i < cBlocksAllocated; i++)
+                pImage->paBlocksRev[i] = VDI_IMAGE_BLOCK_FREE;
+
+            for (unsigned i = 0; i < cBlocks; i++)
+            {
+                VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
+                if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
+                {
+                    if (ptrBlock < cBlocksAllocated)
+                    {
+                        if (pImage->paBlocksRev[ptrBlock] == VDI_IMAGE_BLOCK_FREE)
+                            pImage->paBlocksRev[ptrBlock] = i;
+                        else
+                        {
+                            rc = VERR_VD_VDI_INVALID_HEADER;
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        rc = VERR_VD_VDI_INVALID_HEADER;
+                        break;
+                    }
+                }
+            }
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
 
 out:
@@ -1205 +1254 @@
                     goto out;
                 pImage->paBlocks[uBlock] = cBlocksAllocated;
+
+                if (pImage->paBlocksRev)
+                    pImage->paBlocksRev[cBlocksAllocated] = uBlock;
+
                 setImageBlocksAllocated(&pImage->Header, cBlocksAllocated + 1);
 
@@ -1488 +1541 @@
 
     /* 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)))
+    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_DISCARD)))
     {
         rc = VERR_INVALID_PARAMETER;
@@ -2004 +2057 @@
                     goto out;
                 pImage->paBlocks[uBlock] = cBlocksAllocated;
+
+                if (pImage->paBlocksRev)
+                    pImage->paBlocksRev[cBlocksAllocated] = uBlock;
+
                 setImageBlocksAllocated(&pImage->Header, cBlocksAllocated + 1);
 
@@ -2481 +2538 @@
 
 
+/** @copydoc VBOXHDDBACKEND::pfnDiscard */
+static DECLCALLBACK(int) vdiDiscard(void *pBackendData,
+                                    uint64_t uOffset, size_t cbDiscard,
+                                    size_t *pcbPreAllocated,
+                                    size_t *pcbPostAllocated,
+                                    size_t *pcbActuallyDiscarded,
+                                    void   **ppbmAllocationBitmap,
+                                    unsigned fDiscard)
+{
+    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
+    unsigned uBlock;
+    unsigned offDiscard;
+    int rc = VINF_SUCCESS;
+    void *pvBlock = NULL;
+
+    LogFlowFunc(("pBackendData=%#p uOffset=%llu cbDiscard=%zu pcbPreAllocated=%#p pcbPostAllocated=%#p pcbActuallyDiscarded=%#p ppbmAllocationBitmap=%#p fDiscard=%#x\n",
+                 pBackendData, uOffset, cbDiscard, pcbPreAllocated, pcbPostAllocated, pcbActuallyDiscarded, ppbmAllocationBitmap, fDiscard));
+
+    AssertPtr(pImage);
+    Assert(!(uOffset % 512));
+    Assert(!(cbDiscard % 512));
+
+    do
+    {
+        AssertMsgBreakStmt(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
+                           ("Image is opened readonly\n"),
+                           rc = VERR_VD_IMAGE_READ_ONLY);
+
+        AssertMsgBreakStmt(cbDiscard,
+                           ("cbDiscard=%u\n", cbDiscard),
+                           rc = VERR_INVALID_PARAMETER);
+
+        /* Calculate starting block number and offset inside it. */
+        uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
+        offDiscard = (unsigned)uOffset & pImage->uBlockMask;
+
+        /* Clip range to at most the rest of the block. */
+        cbDiscard = RT_MIN(cbDiscard, getImageBlockSize(&pImage->Header) - offDiscard);
+        Assert(!(cbDiscard % 512));
+
+        if (pcbPreAllocated)
+            *pcbPreAllocated = 0;
+
+        if (pcbPostAllocated)
+            *pcbPostAllocated = 0;
+
+        if (IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
+        {
+            uint8_t *pbBlockData;
+            size_t cbPreAllocated, cbPostAllocated;
+
+            cbPreAllocated = offDiscard % getImageBlockSize(&pImage->Header);
+            cbPostAllocated = getImageBlockSize(&pImage->Header) - cbDiscard - cbPreAllocated;
+
+            /* Read the block data. */
+            pvBlock = RTMemAlloc(pImage->cbTotalBlockData);
+            if (!pvBlock)
+            {
+                rc = VERR_NO_MEMORY;
+                break;
+            }
+            pbBlockData = (uint8_t *)pvBlock + pImage->offStartBlockData;
+
+            uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData + pImage->offStartData;
+            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, u64Offset,
+                                       pvBlock, pImage->cbTotalBlockData, NULL);
+            if (RT_FAILURE(rc))
+                break;
+
+            /* Clear data. */
+            memset(pbBlockData + offDiscard , 0, cbDiscard);
+
+            Assert(!(cbDiscard % 4));
+            Assert(cbDiscard * 8 <= UINT32_MAX);
+            if (ASMBitFirstSet((volatile void *)pbBlockData, getImageBlockSize(&pImage->Header) * 8) == -1)
+            {
+                uint64_t cbImage;
+                unsigned idxLastBlock = getImageBlocksAllocated(&pImage->Header) - 1;
+                unsigned uBlockLast = pImage->paBlocksRev[idxLastBlock];
+
+                pImage->paBlocksRev[idxLastBlock] = VDI_IMAGE_BLOCK_FREE;
+
+                /*
+                 * The block is empty, remove it.
+                 * Read the last block of the image first.
+                 */
+                if (idxLastBlock != pImage->paBlocks[uBlock])
+                {
+                    u64Offset = (uint64_t)idxLastBlock * pImage->cbTotalBlockData + pImage->offStartData;
+                    rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, u64Offset,
+                                               pvBlock, pImage->cbTotalBlockData, NULL);
+                    if (RT_FAILURE(rc))
+                        break;
+
+                    /* Write to the now unallocated block. */
+                    u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData + pImage->offStartData;
+                    rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, u64Offset,
+                                                pvBlock, pImage->cbTotalBlockData, NULL);
+                    if (RT_FAILURE(rc))
+                        break;
+
+                    /* Update block and reverse block tables. */
+                    pImage->paBlocks[uBlockLast] = pImage->paBlocks[uBlock];
+                    rc = vdiUpdateBlockInfo(pImage, uBlockLast);
+                    if (RT_FAILURE(rc))
+                        break;
+                }
+
+                pImage->paBlocks[uBlock] = VDI_IMAGE_BLOCK_ZERO;
+
+                /* Update the block pointers. */
+                setImageBlocksAllocated(&pImage->Header, idxLastBlock);
+                rc = vdiUpdateBlockInfo(pImage, uBlock);
+                if (RT_FAILURE(rc))
+                    break;
+
+                /* Set new file size. */
+                rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbImage);
+                if (RT_FAILURE(rc))
+                    break;
+
+                rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, cbImage - pImage->cbTotalBlockData);
+            }
+            else /* if (fDiscard & VD_DISCARD_MARK_UNUSED) */
+            {
+                /* Write changed data to the image. */
+                rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, u64Offset + offDiscard,
+                                            pbBlockData + offDiscard, cbDiscard, NULL);
+            }
+#if 0
+            else
+            {
+                /* Block has data, create allocation bitmap. */
+                *pcbPreAllocated = cbPreAllocated;
+                *pcbPostAllocated = cbPostAllocated;
+                *ppbmAllocationBitmap = vdAllocationBitmapCreate(pvBlock, getImageBlockSize(&pImage->Header));
+                if (RT_UNLIKELY(!*ppbmAllocationBitmap))
+                    rc = VERR_NO_MEMORY;
+                else
+                    rc = VERR_VD_DISCARD_ALIGNMENT_NOT_MET;
+            }
+#endif
+        }
+        /* else: nothing to do. */
+    } while (0);
+
+    if (pcbActuallyDiscarded)
+        *pcbActuallyDiscarded = cbDiscard;
+
+    if (pvBlock)
+        RTMemFree(pvBlock);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
 VBOXHDDBACKEND g_VDIBackend =
 {
@@ -2489 +2702 @@
     /* uBackendCaps */
       VD_CAP_UUID | VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC
-    | VD_CAP_DIFF | VD_CAP_FILE | VD_CAP_ASYNC | VD_CAP_VFS,
+    | VD_CAP_DIFF | VD_CAP_FILE | VD_CAP_ASYNC | VD_CAP_VFS | VD_CAP_DISCARD,
     /* paFileExtensions */
     s_aVdiFileExtensions,
@@ -2577 +2790 @@
     vdiCompact,
     /* pfnResize */
-    vdiResize
+    vdiResize,
+    /* pfnDiscard */
+    vdiDiscard
 };