Changeset 56392 in vbox for trunk/src/VBox/Devices/Storage

Timestamp:

Jun 12, 2015 2:56:14 PM (10 years ago)

Author:

vboxsync

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

100992

Message:

DevATA: Replaced AsyncIORequestMutex (RTSEMMUTEX) with a PDM critical section.

File:

• trunk/src/VBox/Devices/Storage/DevATA.cpp (modified) (19 diffs)

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

@@ -435 +435 @@
     /** Magic delay before triggering interrupts in DMA mode. */
     uint32_t            DelayIRQMillies;
-    /** The mutex protecting the request queue. */
-    RTSEMMUTEX          AsyncIORequestMutex;
+    /** The lock protecting the request queue. */
+    PDMCRITSECT         AsyncIORequestLock;
     /** The event semaphore the thread is waiting on during suspended I/O. */
     RTSEMEVENT          SuspendIOSem;
@@ -704 +704 @@
 static void ataAsyncIOClearRequests(PATACONTROLLER pCtl)
 {
-    int rc;
-
-    rc = RTSemMutexRequest(pCtl->AsyncIORequestMutex, RT_INDEFINITE_WAIT);
+    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VERR_IGNORED);
     AssertRC(rc);
+
     pCtl->AsyncIOReqHead = 0;
     pCtl->AsyncIOReqTail = 0;
-    rc = RTSemMutexRelease(pCtl->AsyncIORequestMutex);
+
+    rc = PDMCritSectLeave(&pCtl->AsyncIORequestLock);
     AssertRC(rc);
 }
@@ -717 +717 @@
 static void ataAsyncIOPutRequest(PATACONTROLLER pCtl, const ATARequest *pReq)
 {
-    int rc;
-
-    rc = RTSemMutexRequest(pCtl->AsyncIORequestMutex, RT_INDEFINITE_WAIT);
+    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VERR_IGNORED);
     AssertRC(rc);
+
     Assert((pCtl->AsyncIOReqHead + 1) % RT_ELEMENTS(pCtl->aAsyncIORequests) != pCtl->AsyncIOReqTail);
     memcpy(&pCtl->aAsyncIORequests[pCtl->AsyncIOReqHead], pReq, sizeof(*pReq));
     pCtl->AsyncIOReqHead++;
     pCtl->AsyncIOReqHead %= RT_ELEMENTS(pCtl->aAsyncIORequests);
-    rc = RTSemMutexRelease(pCtl->AsyncIORequestMutex);
+
+    rc = PDMCritSectLeave(&pCtl->AsyncIORequestLock);
     AssertRC(rc);
+
     rc = PDMR3CritSectScheduleExitEvent(&pCtl->lock, pCtl->AsyncIOSem);
     if (RT_FAILURE(rc))
@@ -738 +739 @@
 static const ATARequest *ataAsyncIOGetCurrentRequest(PATACONTROLLER pCtl)
 {
-    int rc;
     const ATARequest *pReq;
 
-    rc = RTSemMutexRequest(pCtl->AsyncIORequestMutex, RT_INDEFINITE_WAIT);
+    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VERR_IGNORED);
     AssertRC(rc);
+
     if (pCtl->AsyncIOReqHead != pCtl->AsyncIOReqTail)
         pReq = &pCtl->aAsyncIORequests[pCtl->AsyncIOReqTail];
     else
         pReq = NULL;
-    rc = RTSemMutexRelease(pCtl->AsyncIORequestMutex);
+
+    rc = PDMCritSectLeave(&pCtl->AsyncIORequestLock);
     AssertRC(rc);
     return pReq;
@@ -763 +765 @@
 static void ataAsyncIORemoveCurrentRequest(PATACONTROLLER pCtl, ATAAIO ReqType)
 {
-    int rc;
-
-    rc = RTSemMutexRequest(pCtl->AsyncIORequestMutex, RT_INDEFINITE_WAIT);
+    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VERR_IGNORED);
     AssertRC(rc);
+
     if (pCtl->AsyncIOReqHead != pCtl->AsyncIOReqTail && pCtl->aAsyncIORequests[pCtl->AsyncIOReqTail].ReqType == ReqType)
     {
@@ -772 +773 @@
         pCtl->AsyncIOReqTail %= RT_ELEMENTS(pCtl->aAsyncIORequests);
     }
-    rc = RTSemMutexRelease(pCtl->AsyncIORequestMutex);
+
+    rc = PDMCritSectLeave(&pCtl->AsyncIORequestLock);
     AssertRC(rc);
 }
@@ -786 +788 @@
 static void ataAsyncIODumpRequests(PATACONTROLLER pCtl)
 {
-    int rc;
-    uint8_t curr;
-
-    rc = RTSemMutexRequest(pCtl->AsyncIORequestMutex, RT_INDEFINITE_WAIT);
+    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VERR_IGNORED);
     AssertRC(rc);
+
     LogRel(("PIIX3 ATA: Ctl#%d: request queue dump (topmost is current):\n", ATACONTROLLER_IDX(pCtl)));
-    curr = pCtl->AsyncIOReqTail;
+    uint8_t curr = pCtl->AsyncIOReqTail;
     do
     {
@@ -822 +822 @@
         curr = (curr + 1) % RT_ELEMENTS(pCtl->aAsyncIORequests);
     } while (curr != pCtl->AsyncIOReqTail);
-    rc = RTSemMutexRelease(pCtl->AsyncIORequestMutex);
+
+    rc = PDMCritSectLeave(&pCtl->AsyncIORequestLock);
     AssertRC(rc);
 }
@@ -836 +837 @@
 static bool ataAsyncIOIsIdle(PATACONTROLLER pCtl, bool fStrict)
 {
-    int rc;
-    bool fIdle;
-
-    rc = RTSemMutexRequest(pCtl->AsyncIORequestMutex, RT_INDEFINITE_WAIT);
+    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VERR_IGNORED);
     AssertRC(rc);
-    fIdle = pCtl->fRedoIdle;
+
+    bool fIdle = pCtl->fRedoIdle;
     if (!fIdle)
         fIdle = (pCtl->AsyncIOReqHead == pCtl->AsyncIOReqTail);
     if (fStrict)
         fIdle &= (pCtl->uAsyncIOState == ATA_AIO_NEW);
-    rc = RTSemMutexRelease(pCtl->AsyncIORequestMutex);
+
+    rc = PDMCritSectLeave(&pCtl->AsyncIORequestLock);
     AssertRC(rc);
     return fIdle;
@@ -5037 +5037 @@
 {
     /*
-     * Take the mutex here and recheck the idle indicator to avoid
+     * Take the lock here and recheck the idle indicator to avoid
      * unnecessary work and racing ataR3WaitForAsyncIOIsIdle.
      */
-    int rc = RTSemMutexRequest(pCtl->AsyncIORequestMutex, RT_INDEFINITE_WAIT); AssertRC(rc);
+    int rc = PDMCritSectEnter(&pCtl->AsyncIORequestLock, VERR_IGNORED);
+    AssertRC(rc);
 
     if (    pCtl->fSignalIdle
@@ -5049 +5050 @@
     }
 
-    rc = RTSemMutexRelease(pCtl->AsyncIORequestMutex); AssertRC(rc);
+    rc = PDMCritSectLeave(&pCtl->AsyncIORequestLock);
+    AssertRC(rc);
 }
 
@@ -5538 +5540 @@
 
     /* Cleanup the state.  */
-    /* Do not destroy request mutex yet, still needed for proper shutdown. */
+    /* Do not destroy request lock yet, still needed for proper shutdown. */
     pCtl->fShutdown = false;
 
@@ -6416 +6418 @@
             {
                 /* Make it signal PDM & itself when its done */
-                RTSemMutexRequest(pThis->aCts[i].AsyncIORequestMutex, RT_INDEFINITE_WAIT);
+                PDMCritSectEnter(&pThis->aCts[i].AsyncIORequestLock, VERR_IGNORED);
                 ASMAtomicWriteBool(&pThis->aCts[i].fSignalIdle, true);
-                RTSemMutexRelease(pThis->aCts[i].AsyncIORequestMutex);
+                PDMCritSectLeave(&pThis->aCts[i].AsyncIORequestLock);
+
                 fRc = ataAsyncIOIsIdle(&pThis->aCts[i], false /*fStrict*/);
                 if (!fRc)
@@ -6914 +6917 @@
             if (pThis->aCts[i].AsyncIOThread != NIL_RTTHREAD)
             {
-                int rc = RTSemMutexRequest(pThis->aCts[i].AsyncIORequestMutex, RT_INDEFINITE_WAIT);
+                int rc = PDMCritSectEnter(&pThis->aCts[i].AsyncIORequestLock, VERR_IGNORED);
                 AssertRC(rc);
 
@@ -6921 +6924 @@
                 AssertRC(rc);
 
-                rc = RTSemMutexRelease(pThis->aCts[i].AsyncIORequestMutex);
+                rc = PDMCritSectLeave(&pThis->aCts[i].AsyncIORequestLock);
                 AssertRC(rc);
 
@@ -7029 +7032 @@
     for (uint32_t i = 0; i < RT_ELEMENTS(pThis->aCts); i++)
     {
-        if (pThis->aCts[i].AsyncIORequestMutex != NIL_RTSEMMUTEX)
-        {
-            RTSemMutexDestroy(pThis->aCts[i].AsyncIORequestMutex);
-            pThis->aCts[i].AsyncIORequestMutex = NIL_RTSEMMUTEX;
-        }
+        if (PDMCritSectIsInitialized(&pThis->aCts[i].AsyncIORequestLock))
+            PDMR3CritSectDelete(&pThis->aCts[i].AsyncIORequestLock);
         if (pThis->aCts[i].AsyncIOSem != NIL_RTSEMEVENT)
         {
@@ -7123 +7123 @@
         pThis->aCts[i].AsyncIOSem = NIL_RTSEMEVENT;
         pThis->aCts[i].SuspendIOSem = NIL_RTSEMEVENT;
-        pThis->aCts[i].AsyncIORequestMutex = NIL_RTSEMMUTEX;
         pThis->aCts[i].AsyncIOThread = NIL_RTTHREAD;
     }
@@ -7376 +7375 @@
 #endif /* VBOX_WITH_STATISTICS */
 
-        /* Initialize per-controller critical section */
-        rc = PDMDevHlpCritSectInit(pDevIns, &pThis->aCts[i].lock, RT_SRC_POS, "ATA#%u", i);
-        if (RT_FAILURE(rc))
-            return PDMDEV_SET_ERROR(pDevIns, rc, N_("PIIX3 cannot initialize critical section"));
+        /* Initialize per-controller critical section. */
+        rc = PDMDevHlpCritSectInit(pDevIns, &pThis->aCts[i].lock,               RT_SRC_POS, "ATA#%u-Ctl", i);
+        AssertLogRelRCReturn(rc, rc);
+
+        /* Initialize per-controller async I/O request critical section. */
+        rc = PDMDevHlpCritSectInit(pDevIns, &pThis->aCts[i].AsyncIORequestLock, RT_SRC_POS, "ATA#%u-Req", i);
+        AssertLogRelRCReturn(rc, rc);
     }
 
@@ -7413 +7415 @@
         rc = RTSemEventCreate(&pCtl->SuspendIOSem);
         AssertLogRelRCReturn(rc, rc);
-        rc = RTSemMutexCreate(&pCtl->AsyncIORequestMutex);
-        AssertLogRelRCReturn(rc, rc);
+
         ataAsyncIOClearRequests(pCtl);
         rc = RTThreadCreateF(&pCtl->AsyncIOThread, ataAsyncIOLoop, (void *)pCtl, 128*1024 /*cbStack*/,
                              RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "ATA-%u", i);
         AssertLogRelRCReturn(rc, rc);
-        Assert(pCtl->AsyncIOThread != NIL_RTTHREAD && pCtl->AsyncIOSem != NIL_RTSEMEVENT && pCtl->SuspendIOSem != NIL_RTSEMEVENT && pCtl->AsyncIORequestMutex != NIL_RTSEMMUTEX);
-        Log(("%s: controller %d AIO thread id %#x; sem %p susp_sem %p mutex %p\n", __FUNCTION__, i, pCtl->AsyncIOThread, pCtl->AsyncIOSem, pCtl->SuspendIOSem, pCtl->AsyncIORequestMutex));
+        Assert(  pCtl->AsyncIOThread != NIL_RTTHREAD    && pCtl->AsyncIOSem != NIL_RTSEMEVENT
+               && pCtl->SuspendIOSem != NIL_RTSEMEVENT  && PDMCritSectIsInitialized(&pCtl->AsyncIORequestLock));
+        Log(("%s: controller %d AIO thread id %#x; sem %p susp_sem %p\n", __FUNCTION__, i, pCtl->AsyncIOThread, pCtl->AsyncIOSem, pCtl->SuspendIOSem));
 
         for (uint32_t j = 0; j < RT_ELEMENTS(pCtl->aIfs); j++)