Changeset 28902 in vbox

Timestamp:

Apr 29, 2010 2:54:08 PM (15 years ago)

Author:

vboxsync

Message:

DiskIntegrity: Add possibility to check for hanging requests

File:

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

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

@@ -29 +29 @@
 #include <iprt/message.h>
 #include <iprt/sg.h>
+#include <iprt/time.h>
+#include <iprt/semaphore.h>
 
 #include "Builtins.h"
@@ -54 +56 @@
     /** User argument */
     void     *pvUser;
+    /** Slot in the array. */
+    unsigned  iSlot;
 } DRVDISKAIOREQ, *PDRVDISKAIOREQ;
 
@@ -87 +91 @@
 
 /**
+ * Active requests list entry.
+ */
+typedef struct DRVDISKAIOREQACTIVE
+{
+    /** Pointer to the request. */
+    volatile PDRVDISKAIOREQ pIoReq;
+    /** Start timestamp. */
+    uint64_t  tsStart;
+} DRVDISKAIOREQACTIVE, *PDRVDISKAIOREQACTIVE;
+
+/**
  * Disk integrity driver instance data.
  *
@@ -112 +127 @@
     PDMIMEDIAASYNCPORT      IMediaAsyncPort;
 
+    /** Flag whether consistency checks are enabled. */
+    bool                    fCheckConsistency;
     /** AVL tree containing the disk blocks to check. */
     PAVLRFOFFTREE           pTreeSegments;
+
+    /** Flag whether async request tracing is enabled. */
+    bool                    fTraceRequests;
+    /** Interval the thread should check for expired requests (milliseconds). */
+    uint32_t                uCheckIntervalMs;
+    /** Expire timeout for a request (milliseconds). */
+    uint32_t                uExpireIntervalMs;
+    /** Thread which checks for lost requests. */
+    RTTHREAD                hThread;
+    /** Event semaphore */
+    RTSEMEVENT              SemEvent;
+    /** Flag whether the thread should run. */
+    bool                    fRunning;
+    /** Array containing active requests. */
+    DRVDISKAIOREQACTIVE     apReqActive[128];
+    /** Next free slot in the array */
+    volatile unsigned       iNextFreeSlot;
 } DRVDISKINTEGRITY, *PDRVDISKINTEGRITY;
 
@@ -354 +388 @@
 }
 
+/**
+ * Adds a request to the active list.
+ *
+ * @returns nothing.
+ * @param   pThis    The driver instance data.
+ * @param   pIoReq   The request to add.
+ */
+static void drvdiskintIoReqAdd(PDRVDISKINTEGRITY pThis, PDRVDISKAIOREQ pIoReq)
+{
+    PDRVDISKAIOREQACTIVE pReqActive = &pThis->apReqActive[pThis->iNextFreeSlot];
+
+    Assert(!pReqActive->pIoReq);
+    pReqActive->tsStart = RTTimeSystemMilliTS();
+    pReqActive->pIoReq  = pIoReq;
+    pIoReq->iSlot = pThis->iNextFreeSlot;
+
+    /* Search for the next one. */
+    pThis->iNextFreeSlot++;
+    while (pThis->apReqActive[pThis->iNextFreeSlot].pIoReq)
+        pThis->iNextFreeSlot = pThis->iNextFreeSlot++ % RT_ELEMENTS(pThis->apReqActive);
+}
+
+/**
+ * Removes a request from the active list.
+ *
+ * @returns nothing.
+ * @param   pThis    The driver instance data.
+ * @param   pIoReq   The request to remove.
+ */
+static void drvdiskintIoReqRemove(PDRVDISKINTEGRITY pThis, PDRVDISKAIOREQ pIoReq)
+{
+    PDRVDISKAIOREQACTIVE pReqActive = &pThis->apReqActive[pIoReq->iSlot];
+
+    Assert(pReqActive->pIoReq == pIoReq);
+
+    ASMAtomicXchgPtr((void * volatile *)&pReqActive->pIoReq, NULL);
+}
+
+/**
+ * Thread checking for expired requests.
+ *
+ * @returns IPRT status code.
+ * @param   pThread    Thread handle.
+ * @param   pvUser     Opaque user data.
+ */
+static int drvdiskIntIoReqExpiredCheck(RTTHREAD pThread, void *pvUser)
+{
+    PDRVDISKINTEGRITY pThis = (PDRVDISKINTEGRITY)pvUser;
+
+    while (pThis->fRunning)
+    {
+        int rc = RTSemEventWait(pThis->SemEvent, pThis->uCheckIntervalMs);
+
+        if (!pThis->fRunning)
+            break;
+
+        Assert(rc == VERR_TIMEOUT);
+
+        /* Get current timestamp for comparison. */
+        uint64_t tsCurr = RTTimeSystemMilliTS();
+
+        /* Go through the array and check for expired requests. */
+        for (unsigned i = 0; i < RT_ELEMENTS(pThis->apReqActive); i++)
+        {
+            PDRVDISKAIOREQACTIVE pReqActive = &pThis->apReqActive[i];
+            PDRVDISKAIOREQ pIoReq = (PDRVDISKAIOREQ)ASMAtomicReadPtr((void * volatile *)&pReqActive->pIoReq);
+
+            if (   pIoReq
+                && (tsCurr - pReqActive->tsStart) >= pThis->uExpireIntervalMs)
+            {
+                RTMsgError("Request %#p expired (active for %llu ms already)\n",
+                           pIoReq, tsCurr - pReqActive->tsStart);
+                RTAssertDebugBreak();
+            }
+        }
+    }
+
+    return VINF_SUCCESS;
+}
+
 /* -=-=-=-=- IMedia -=-=-=-=- */
 
@@ -374 +488 @@
         return rc;
 
-    /* Verify the read. */
-    RTSGSEG Seg;
-    Seg.cbSeg = cbRead;
-    Seg.pvSeg = pvBuf;
-    return drvdiskintReadVerify(pThis, &Seg, 1, off, cbRead);
+    if (pThis->fCheckConsistency)
+    {
+        /* Verify the read. */
+        RTSGSEG Seg;
+        Seg.cbSeg = cbRead;
+        Seg.pvSeg = pvBuf;
+        rc = drvdiskintReadVerify(pThis, &Seg, 1, off, cbRead);
+    }
+
+    return rc;
 }
 
@@ -391 +510 @@
         return rc;
 
-    /* Record the write. */
-    RTSGSEG Seg;
-    Seg.cbSeg = cbWrite;
-    Seg.pvSeg = (void *)pvBuf;
-    return drvdiskintWriteRecord(pThis, &Seg, 1, off, cbWrite);
+    if (pThis->fCheckConsistency)
+    {
+        /* Record the write. */
+        RTSGSEG Seg;
+        Seg.cbSeg = cbWrite;
+        Seg.pvSeg = (void *)pvBuf;
+        rc = drvdiskintWriteRecord(pThis, &Seg, 1, off, cbWrite);
+    }
+
+    return rc;
 }
 
@@ -408 +532 @@
     AssertPtr(pIoReq);
 
+    if (pThis->fTraceRequests)
+        drvdiskintIoReqAdd(pThis, pIoReq);
+
     int rc = pThis->pDrvMediaAsync->pfnStartRead(pThis->pDrvMediaAsync, uOffset, paSeg, cSeg,
                                                  cbRead, pIoReq);
@@ -413 +540 @@
     {
         /* Verify the read now. */
-        int rc2 = drvdiskintReadVerify(pThis, paSeg, cSeg, uOffset, cbRead);
-        AssertRC(rc2);
+        if (pThis->fCheckConsistency)
+        {
+            int rc2 = drvdiskintReadVerify(pThis, paSeg, cSeg, uOffset, cbRead);
+            AssertRC(rc2);
+        }
+
+        if (pThis->fTraceRequests)
+            drvdiskintIoReqRemove(pThis, pIoReq);
         RTMemFree(pIoReq);
     }
@@ -434 +567 @@
     AssertPtr(pIoReq);
 
+    if (pThis->fTraceRequests)
+        drvdiskintIoReqAdd(pThis, pIoReq);
+
     int rc = pThis->pDrvMediaAsync->pfnStartWrite(pThis->pDrvMediaAsync, uOffset, paSeg, cSeg,
                                                   cbWrite, pIoReq);
@@ -439 +575 @@
     {
         /* Verify the read now. */
-        int rc2 = drvdiskintWriteRecord(pThis, paSeg, cSeg, uOffset, cbWrite);
-        AssertRC(rc2);
+        if  (pThis->fCheckConsistency)
+        {
+            int rc2 = drvdiskintWriteRecord(pThis, paSeg, cSeg, uOffset, cbWrite);
+            AssertRC(rc2);
+        }
+
+        if (pThis->fTraceRequests)
+            drvdiskintIoReqRemove(pThis, pIoReq);
+
         RTMemFree(pIoReq);
     }
@@ -523 +666 @@
     LogFlowFunc(("pIoReq=%#p\n", pIoReq));
 
-    if (RT_SUCCESS(rcReq))
+    /* Remove from the active list. */
+    if (pThis->fTraceRequests)
+        drvdiskintIoReqRemove(pThis, pIoReq);
+
+    if (RT_SUCCESS(rcReq) && pThis->fCheckConsistency)
     {
         if (pIoReq->fRead)
@@ -580 +727 @@
         RTMemFree(pThis->pTreeSegments);
     }
+
+    if (pThis->fTraceRequests)
+    {
+        pThis->fRunning = false;
+        RTSemEventSignal(pThis->SemEvent);
+        RTSemEventDestroy(pThis->SemEvent);
+    }
 }
 
@@ -589 +743 @@
 static DECLCALLBACK(int) drvdiskintConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
 {
+    int rc = VINF_SUCCESS;
     PDRVDISKINTEGRITY pThis = PDMINS_2_DATA(pDrvIns, PDRVDISKINTEGRITY);
     LogFlow(("drvdiskintConstruct: iInstance=%d\n", pDrvIns->iInstance));
@@ -596 +751 @@
      * Validate configuration.
      */
-    if (!CFGMR3AreValuesValid(pCfg, ""))
+    if (!CFGMR3AreValuesValid(pCfg, "CheckConsistency\0"
+                                    "TraceRequests\0"
+                                    "CheckIntervalMs\0"
+                                    "ExpireIntervalMs\0"))
         return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
+
+    rc = CFGMR3QueryBoolDef(pCfg, "CheckConsistency", &pThis->fCheckConsistency, false);
+    AssertRC(rc);
+    rc = CFGMR3QueryBoolDef(pCfg, "TraceRequests", &pThis->fTraceRequests, false);
+    AssertRC(rc);
+    rc = CFGMR3QueryU32Def(pCfg, "CheckIntervalMs", &pThis->uCheckIntervalMs, 5000); /* 5 seconds */
+    AssertRC(rc);
+    rc = CFGMR3QueryU32Def(pCfg, "ExpireIntervalMs", &pThis->uExpireIntervalMs, 20000); /* 20 seconds */
+    AssertRC(rc);
 
     /*
@@ -630 +797 @@
      */
     PPDMIBASE pBase;
-    int rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBase);
+    rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBase);
     if (RT_FAILURE(rc))
         return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
-                                   N_("Failed to attach driver below us! %Rrf"), rc);
+                                   N_("Failed to attach driver below us! %Rrc"), rc);
 
     pThis->pDrvMedia = PDMIBASE_QUERY_INTERFACE(pBase, PDMIMEDIA);
@@ -645 +812 @@
     pThis->pDrvMediaAsyncPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMEDIAASYNCPORT);
 
-    /* Create the AVL tree. */
-    pThis->pTreeSegments = (PAVLRFOFFTREE)RTMemAllocZ(sizeof(AVLRFOFFTREE));
-    if (!pThis->pTreeSegments)
-        rc = VERR_NO_MEMORY;
+    if (pThis->fCheckConsistency)
+    {
+        /* Create the AVL tree. */
+        pThis->pTreeSegments = (PAVLRFOFFTREE)RTMemAllocZ(sizeof(AVLRFOFFTREE));
+        if (!pThis->pTreeSegments)
+            rc = VERR_NO_MEMORY;
+    }
+
+    if (pThis->fTraceRequests)
+    {
+        for (unsigned i = 0; i < RT_ELEMENTS(pThis->apReqActive); i++)
+        {
+            pThis->apReqActive[i].pIoReq  = NULL;
+            pThis->apReqActive[i].tsStart = 0;
+        }
+
+        pThis->iNextFreeSlot = 0;
+
+        /* Init event semaphore. */
+        rc = RTSemEventCreate(&pThis->SemEvent);
+        AssertRC(rc);
+        pThis->fRunning = true;
+        rc = RTThreadCreate(&pThis->hThread, drvdiskIntIoReqExpiredCheck, pThis,
+                            0, RTTHREADTYPE_INFREQUENT_POLLER, 0, "DiskIntegrity");
+        AssertRC(rc);
+    }
 
     return rc;