Changeset 44400 in vbox for trunk/src/VBox/Storage

Timestamp:

Jan 27, 2013 9:16:10 PM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

83374

Message:

Storage/VD: Further I/O path unification, drop synchronous vdDiscardHelper and use async version for VDDiscardRanges

File:

• trunk/src/VBox/Storage/VD.cpp (modified) (17 diffs)

trunk/src/VBox/Storage/VD.cpp

@@ -39 +39 @@
 #include <iprt/list.h>
 #include <iprt/avl.h>
+#include <iprt/semaphore.h>
 
 #include <VBox/vd-plugin.h>
@@ -260 +261 @@
     /** Pointer to the discard state if any. */
     PVDDISCARDSTATE        pDiscard;
+
+    /** Event semaphore for synchronous I/O. */
+    RTSEMEVENT             hEventSemSyncIo;
+    /** Status code of the last synchronous I/O request. */
+    int                    rcSync;
 };
 
@@ -1233 +1239 @@
 
 /**
- * Discards the given range from the underlying block.
- *
- * @returns VBox status code.
- * @param   pDisk      VD container data.
- * @param   offStart   Where to start discarding.
- * @param   cbDiscard  How many bytes to discard.
- */
-static int vdDiscardRange(PVBOXHDD pDisk, PVDDISCARDSTATE pDiscard, uint64_t offStart, size_t cbDiscard)
-{
-    int rc = VINF_SUCCESS;
-
-    LogFlowFunc(("pDisk=%#p pDiscard=%#p offStart=%llu cbDiscard=%zu\n",
-                 pDisk, pDiscard, offStart, cbDiscard));
-
-    do
-    {
-        size_t cbThisDiscard;
-
-        /* Look for a matching block in the AVL tree first. */
-        PVDDISCARDBLOCK pBlock = (PVDDISCARDBLOCK)RTAvlrU64GetBestFit(pDiscard->pTreeBlocks, offStart, false);
-        if (!pBlock || pBlock->Core.KeyLast < offStart)
-        {
-            void *pbmAllocated = NULL;
-            size_t cbPreAllocated, cbPostAllocated;
-            PVDDISCARDBLOCK pBlockAbove = (PVDDISCARDBLOCK)RTAvlrU64GetBestFit(pDiscard->pTreeBlocks, offStart, true);
-
-            /* Clip range to remain in the current block. */
-            if (pBlockAbove)
-                cbThisDiscard = RT_MIN(cbDiscard, pBlockAbove->Core.KeyLast - offStart + 1);
-            else
-                cbThisDiscard = cbDiscard;
-
-            Assert(!(cbThisDiscard % 512));
-
-            /* No block found, try to discard using the backend first. */
-            VDIOCTX IoCtx;
-
-            vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_DISCARD, 0, 0, NULL,
-                        NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
-            rc = pDisk->pLast->Backend->pfnDiscard(pDisk->pLast->pBackendData,
-                                                        &IoCtx, offStart,
-                                                        cbThisDiscard, &cbPreAllocated,
-                                                        &cbPostAllocated, &cbThisDiscard,
-                                                        &pbmAllocated, 0);
-            if (rc == VERR_VD_DISCARD_ALIGNMENT_NOT_MET)
-            {
-                /* Create new discard block. */
-                pBlock = (PVDDISCARDBLOCK)RTMemAllocZ(sizeof(VDDISCARDBLOCK));
-                if (pBlock)
-                {
-                    pBlock->Core.Key     = offStart - cbPreAllocated;
-                    pBlock->Core.KeyLast = offStart + cbThisDiscard + cbPostAllocated - 1;
-                    pBlock->cbDiscard    = cbPreAllocated + cbThisDiscard + cbPostAllocated;
-                    pBlock->pbmAllocated = pbmAllocated;
-                    bool fInserted = RTAvlrU64Insert(pDiscard->pTreeBlocks, &pBlock->Core);
-                    Assert(fInserted);
-
-                    RTListPrepend(&pDiscard->ListLru, &pBlock->NodeLru);
-                    pDiscard->cbDiscarding += pBlock->cbDiscard;
-                    if (pDiscard->cbDiscarding > VD_DISCARD_REMOVE_THRESHOLD)
-                        rc = vdDiscardRemoveBlocks(pDisk, pDiscard, VD_DISCARD_REMOVE_THRESHOLD);
-                    else
-                        rc = VINF_SUCCESS;
-                }
-                else
-                {
-                    RTMemFree(pbmAllocated);
-                    rc = VERR_NO_MEMORY;
-                }
-            }
-        }
-        else
-        {
-            /* Range lies partly in the block, update allocation bitmap. */
-            int32_t idxStart, idxEnd;
-
-            cbThisDiscard = RT_MIN(cbDiscard, pBlock->Core.KeyLast - offStart + 1);
-
-            AssertPtr(pBlock);
-
-            Assert(!(cbThisDiscard % 512));
-            Assert(!((offStart - pBlock->Core.Key) % 512));
-
-            idxStart = (offStart - pBlock->Core.Key) / 512;
-            idxEnd = idxStart + (cbThisDiscard / 512);
-
-            ASMBitClearRange(pBlock->pbmAllocated, idxStart, idxEnd);
-
-            /* Call the backend to discard the block if it is completely unallocated now. */
-            if (ASMBitFirstSet((volatile void *)pBlock->pbmAllocated, pBlock->cbDiscard / 512) == -1)
-            {
-                VDIOCTX IoCtx;
-                size_t cbPreAllocated, cbPostAllocated, cbActuallyDiscarded;
-
-                vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_DISCARD, 0, 0, NULL,
-                            NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
-                rc = pDisk->pLast->Backend->pfnDiscard(pDisk->pLast->pBackendData,
-                                                            &IoCtx, pBlock->Core.Key,
-                                                            pBlock->cbDiscard, &cbPreAllocated,
-                                                            &cbPostAllocated, &cbActuallyDiscarded,
-                                                            NULL, 0);
-                Assert(rc != VERR_VD_DISCARD_ALIGNMENT_NOT_MET);
-                Assert(!cbPreAllocated);
-                Assert(!cbPostAllocated);
-                Assert(cbActuallyDiscarded == pBlock->cbDiscard || RT_FAILURE(rc));
-
-                /* Remove the block on success. */
-                if (RT_SUCCESS(rc))
-                {
-                    PVDDISCARDBLOCK pBlockRemove = (PVDDISCARDBLOCK)RTAvlrU64RangeRemove(pDiscard->pTreeBlocks, pBlock->Core.Key);
-                    Assert(pBlockRemove == pBlock);
-
-                    pDiscard->cbDiscarding -= pBlock->cbDiscard;
-                    RTListNodeRemove(&pBlock->NodeLru);
-                    RTMemFree(pBlock->pbmAllocated);
-                    RTMemFree(pBlock);
-                }
-            }
-            else
-            {
-                RTListNodeRemove(&pBlock->NodeLru);
-                RTListPrepend(&pDiscard->ListLru, &pBlock->NodeLru);
-                rc = VINF_SUCCESS;
-            }
-        }
-
-        Assert(cbDiscard >= cbThisDiscard);
-
-        cbDiscard -= cbThisDiscard;
-        offStart  += cbThisDiscard;
-    } while (cbDiscard != 0 && RT_SUCCESS(rc));
-
-    LogFlowFunc(("returns rc=%Rrc\n", rc));
-    return rc;
-}
-
-/**
- * Discard helper.
- *
- * @returns VBox status code.
- * @param   pDisk    VD container data.
- * @param   paRanges The array of ranges to discard.
- * @param   cRanges  The number of ranges in the array.
- */
-static int vdDiscardHelper(PVBOXHDD pDisk, PCRTRANGE paRanges, unsigned cRanges)
-{
-    int rc = VINF_SUCCESS;
-    PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
-
-    if (RT_UNLIKELY(!pDiscard))
-    {
-        pDiscard = vdDiscardStateCreate();
-        if (!pDiscard)
-            return VERR_NO_MEMORY;
-
-        pDisk->pDiscard = pDiscard;
-    }
-
-    /* Go over the range array and discard individual blocks. */
-    for (unsigned i = 0; i < cRanges; i++)
-    {
-        rc = vdDiscardRange(pDisk, pDiscard, paRanges[i].offStart, paRanges[i].cbRange);
-        if (RT_FAILURE(rc))
-            break;
-    }
-
-    return rc;
-}
-
-/**
  * Marks the given range as allocated in the image.
  * Required if there are discards in progress and a write to a block which can get discarded
@@ -1500 +1336 @@
                                          void *pvUser1, void *pvUser2,
                                          void *pvAllocation,
-                                         PFNVDIOCTXTRANSFER pfnIoCtxTransfer)
+                                         PFNVDIOCTXTRANSFER pfnIoCtxTransfer,
+                                         uint32_t fFlags)
 {
     PVDIOCTX pIoCtx = NULL;
@@ -1513 +1350 @@
         pIoCtx->cMetaTransfersPending     = 0;
         pIoCtx->fComplete                 = false;
-        pIoCtx->fFlags                    = 0;
+        pIoCtx->fFlags                    = fFlags;
         pIoCtx->pvAllocation              = pvAllocation;
         pIoCtx->pfnIoCtxTransfer          = pfnIoCtxTransfer;
@@ -3998 +3835 @@
 }
 
-/** 
+/**
  * Processes a list of waiting I/O tasks. The disk lock must be held by caller.
  *
@@ -4037 +3874 @@
         pCur = pHead;
         pHead = pHead->pNext;
-        vdIoTaskFree(pDisk, pCur); 
-    }
-}
-
-/** 
+        vdIoTaskFree(pDisk, pCur);
+    }
+}
+
+/**
  * Process any I/O context on the halted list.
  *
@@ -4101 +3938 @@
      * Afterwards comes the list of new I/O contexts.
      */
-
     vdIoTaskProcessWaitingList(pDisk);
     vdIoCtxProcessHaltedList(pDisk);
@@ -4157 +3993 @@
     if (ASMAtomicCmpXchgBool(&pDisk->fLocked, true, false))
     {
-        /* Disk locked, process the list. */
-        vdIoTaskProcessWaitingList(pDisk);
-
-        /* Release disk lock. */
+        /* Release disk lock, it will take care of processing all lists. */
         vdDiskUnlock(pDisk, NULL);
     }
@@ -5219 +5052 @@
 
 /**
+ * Internally used completion handler for synchronous I/O contexts.
+ */
+static DECLCALLBACK(void) vdIoCtxSyncComplete(void *pvUser1, void *pvUser2, int rcReq)
+{
+    PVBOXHDD pDisk = (PVBOXHDD)pvUser1;
+
+    pDisk->rcSync = rcReq;
+    RTSemEventSignal(pDisk->hEventSemSyncIo);
+}
+
+/**
  * Initializes HDD backends.
  *
@@ -5411 +5255 @@
             pDisk->pIoCtxHead              = NULL;
             pDisk->fLocked                 = false;
+            pDisk->hEventSemSyncIo         = NIL_RTSEMEVENT;
+            pDisk->hMemCacheIoCtx          = NIL_RTMEMCACHE;
+            pDisk->hMemCacheIoTask         = NIL_RTMEMCACHE;
+
+            rc = RTSemEventCreate(&pDisk->hEventSemSyncIo);
+            if (RT_FAILURE(rc))
+                break;
 
             /* Create the I/O ctx cache */
@@ -5416 +5267 @@
                                   NULL, NULL, NULL, 0);
             if (RT_FAILURE(rc))
-            {
-                RTMemFree(pDisk);
                 break;
-            }
 
             /* Create the I/O task cache */
@@ -5425 +5273 @@
                                   NULL, NULL, NULL, 0);
             if (RT_FAILURE(rc))
-            {
-                RTMemCacheDestroy(pDisk->hMemCacheIoCtx);
-                RTMemFree(pDisk);
                 break;
-            }
 
             pDisk->pInterfaceError      = VDIfErrorGet(pVDIfsDisk);
@@ -5442 +5286 @@
         }
     } while (0);
+
+    if (   RT_FAILURE(rc)
+        && pDisk)
+    {
+        if (pDisk->hEventSemSyncIo != NIL_RTSEMEVENT)
+            RTSemEventDestroy(pDisk->hEventSemSyncIo);
+        if (pDisk->hMemCacheIoCtx != NIL_RTMEMCACHE)
+            RTMemCacheDestroy(pDisk->hMemCacheIoCtx);
+        if (pDisk->hMemCacheIoTask != NIL_RTMEMCACHE)
+            RTMemCacheDestroy(pDisk->hMemCacheIoTask);
+    }
 
     LogFlowFunc(("returns %Rrc (pDisk=%#p)\n", rc, pDisk));
@@ -5468 +5323 @@
         RTMemCacheDestroy(pDisk->hMemCacheIoCtx);
         RTMemCacheDestroy(pDisk->hMemCacheIoTask);
+        RTSemEventDestroy(pDisk->hEventSemSyncIo);
         RTMemFree(pDisk);
     } while (0);
@@ -9667 +9523 @@
                            rc = VERR_NOT_SUPPORTED);
 
-        vdSetModifiedFlag(pDisk);
-        rc = vdDiscardHelper(pDisk, paRanges, cRanges);
+        PVDIOCTX pIoCtx = vdIoCtxDiscardAlloc(pDisk, paRanges, cRanges,
+                                              vdIoCtxSyncComplete, pDisk, NULL, NULL,
+                                              vdDiscardHelperAsync,
+                                              VDIOCTX_FLAGS_SYNC);
+        if (!pIoCtx)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        rc = vdIoCtxProcessTryLockDefer(pIoCtx);
+        if (rc == VINF_VD_ASYNC_IO_FINISHED)
+            rc = VINF_SUCCESS;
+
+        if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        {
+            rc = RTSemEventWait(pDisk->hEventSemSyncIo, RT_INDEFINITE_WAIT);
+            AssertRC(rc);
+
+            rc = pDisk->rcSync;
+        }
+        else /* Success or error. */
+            vdIoCtxFree(pDisk, pIoCtx);
     } while (0);
 
@@ -9904 +9781 @@
         pIoCtx = vdIoCtxDiscardAlloc(pDisk, paRanges, cRanges,
                                      pfnComplete, pvUser1, pvUser2, NULL,
-                                     vdDiscardHelperAsync);
+                                     vdDiscardHelperAsync,
+                                     0 /* fFlags */);
         if (!pIoCtx)
         {