Changeset 29902 in vbox for trunk/src

Timestamp:

May 31, 2010 12:56:31 PM (15 years ago)

Author:

vboxsync

Message:

PDM: Flushed out the PDMQueueFlush code as its unused and problematic wrt guest SMP.

Location:

trunk/src/VBox/VMM

Files:

• PDMQueue.cpp (modified) (2 diffs)
• VMM.cpp (modified) (2 diffs)
• VMMAll/PDMAllQueue.cpp (modified) (3 diffs)
• VMMGC/VMMGC.def (modified) (1 diff)
• VMMInternal.h (modified) (1 diff)
• VMMR0/VMMR0.def (modified) (1 diff)

trunk/src/VBox/VMM/PDMQueue.cpp

@@ -666 +666 @@
 
     /*
-     * Only let one EMT flushing queues at any one time to queue preserve order
+     * Only let one EMT flushing queues at any one time to preserve the order
      * and to avoid wasting time. The FF is always cleared here, because it's
      * only used to get someones attention. Queue inserts occuring during the
      * flush are caught using the pending bit.
      *
-     * Note. The order in which the FF and pending bit are set and cleared is important.
+     * Note! The order in which the FF and pending bit are set and cleared is
+     *       important.
      */
     VM_FF_CLEAR(pVM, VM_FF_PDM_QUEUES);
@@ -856 +857 @@
 
 /**
- * This is a worker function used by PDMQueueFlush to perform the
- * flush in ring-3.
- *
- * The queue which should be flushed is pointed to by either pQueueFlushRC,
- * pQueueFlushR0, or pQueue. This function will flush that queue and recalc
- * the queue FF.
- *
- * @param   pVM     The VM handle.
- * @param   pQueue  The queue to flush. Only used in Ring-3.
- */
-VMMR3DECL(void) PDMR3QueueFlushWorker(PVM pVM, PPDMQUEUE pQueue)
-{
-    Assert(pVM->pdm.s.pQueueFlushR0 || pVM->pdm.s.pQueueFlushRC || pQueue);
-    VM_ASSERT_EMT(pVM);
-
-    /** @todo This will clash with PDMR3QueueFlushAll (guest SMP)! */
-    Assert(!(pVM->pdm.s.fQueueFlushing & PDM_QUEUE_FLUSH_FLAG_ACTIVE));
-
-    /*
-     * Flush the queue.
-     */
-    if (!pQueue && pVM->pdm.s.pQueueFlushRC)
-    {
-        pQueue = (PPDMQUEUE)MMHyperRCToR3(pVM, pVM->pdm.s.pQueueFlushRC);
-        pVM->pdm.s.pQueueFlushRC = NIL_RTRCPTR;
-    }
-    else if (!pQueue && pVM->pdm.s.pQueueFlushR0)
-    {
-        pQueue = (PPDMQUEUE)MMHyperR0ToR3(pVM, pVM->pdm.s.pQueueFlushR0);
-        pVM->pdm.s.pQueueFlushR0 = NIL_RTR0PTR;
-    }
-    Assert(!pVM->pdm.s.pQueueFlushR0 && !pVM->pdm.s.pQueueFlushRC);
-
-    if (    !pQueue
-        ||  pdmR3QueueFlush(pQueue))
-    {
-        /*
-         * Recalc the FF (for the queues using force action).
-         */
-        VM_FF_CLEAR(pVM, VM_FF_PDM_QUEUES);
-        for (pQueue = pVM->pUVM->pdm.s.pQueuesForced; pQueue; pQueue = pQueue->pNext)
-            if (    pQueue->pPendingRC
-                ||  pQueue->pPendingR0
-                ||  pQueue->pPendingR3)
-            {
-                VM_FF_SET(pVM, VM_FF_PDM_QUEUES);
-                break;
-            }
-    }
-}
-
-
-/**
  * Free an item.
  *

trunk/src/VBox/VMM/VMM.cpp

@@ -403 +403 @@
     STAM_REG(pVM, &pVM->vmm.s.StatRZRetCallRing3,           STAMTYPE_COUNTER, "/VMM/RZCallR3/Misc",             STAMUNIT_OCCURENCES, "Number of Other ring-3 calls.");
     STAM_REG(pVM, &pVM->vmm.s.StatRZCallPDMLock,            STAMTYPE_COUNTER, "/VMM/RZCallR3/PDMLock",          STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_PDM_LOCK calls.");
-    STAM_REG(pVM, &pVM->vmm.s.StatRZCallPDMQueueFlush,      STAMTYPE_COUNTER, "/VMM/RZCallR3/PDMQueueFlush",    STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_PDM_QUEUE_FLUSH calls.");
     STAM_REG(pVM, &pVM->vmm.s.StatRZCallPGMLock,            STAMTYPE_COUNTER, "/VMM/RZCallR3/PGMLock",          STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_PGM_LOCK calls.");
     STAM_REG(pVM, &pVM->vmm.s.StatRZCallPGMPoolGrow,        STAMTYPE_COUNTER, "/VMM/RZCallR3/PGMPoolGrow",      STAMUNIT_OCCURENCES, "Number of VMMCALLRING3_PGM_POOL_GROW calls.");
@@ -2026 +2025 @@
         {
             pVCpu->vmm.s.rcCallRing3 = PDMR3LockCall(pVM);
-            break;
-        }
-
-        /*
-         * Flush a PDM queue.
-         */
-        case VMMCALLRING3_PDM_QUEUE_FLUSH:
-        {
-            PDMR3QueueFlushWorker(pVM, NULL);
-            pVCpu->vmm.s.rcCallRing3 = VINF_SUCCESS;
             break;
         }

trunk/src/VBox/VMM/VMMAll/PDMAllQueue.cpp

@@ -79 +79 @@
     Assert(VALID_PTR(pItem));
 
+#if 0 /* the paranoid android version: */
+    void *pvNext;
+    do
+    {
+        pvNext = ASMAtomicUoReadPtr((void * volatile *)&pQueue->CTX_SUFF(pPending));
+        ASMAtomicUoWritePtr((void * volatile *)&pItem->CTX_SUFF(pNext), pvNext);
+    } while (!ASMAtomicCmpXchgPtr((void * volatile *)&pQueue->CTX_SUFF(pPending), pItem, pvNext));
+#else
     PPDMQUEUEITEMCORE pNext;
     do
@@ -85 +93 @@
         pItem->CTX_SUFF(pNext) = pNext;
     } while (!ASMAtomicCmpXchgPtr((void * volatile *)&pQueue->CTX_SUFF(pPending), pItem, pNext));
+#endif
 
     if (!pQueue->pTimer)
@@ -170 +179 @@
 }
 
-
-/**
- * Flushes a PDM queue.
- *
- * @param   pQueue          The queue handle.
- */
-VMMDECL(void) PDMQueueFlush(PPDMQUEUE pQueue)
-{
-    Assert(VALID_PTR(pQueue));
-    Assert(pQueue->pVMR3);
-    PVM pVM = pQueue->CTX_SUFF(pVM);
-
-#if defined(IN_RC) || defined(IN_RING0)
-    Assert(pQueue->CTX_SUFF(pVM));
-    pVM->pdm.s.CTX_SUFF(pQueueFlush) = pQueue;
-    VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PDM_QUEUE_FLUSH, (uintptr_t)pQueue);
-
-#else /* IN_RING3: */
-    VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)PDMR3QueueFlushWorker, 2, pVM, pQueue);
-#endif
-}

trunk/src/VBox/VMM/VMMGC/VMMGC.def

@@ -27 +27 @@
     PDMCritSectIsOwner
     PDMQueueAlloc
-    PDMQueueFlush
     PDMQueueInsert
     PGMHandlerPhysicalPageTempOff

trunk/src/VBox/VMM/VMMInternal.h

@@ -371 +371 @@
     STAMCOUNTER                 StatRZCallPDMLock;
     STAMCOUNTER                 StatRZCallLogFlush;
-    STAMCOUNTER                 StatRZCallPDMQueueFlush;
     STAMCOUNTER                 StatRZCallPGMPoolGrow;
     STAMCOUNTER                 StatRZCallPGMMapChunk;

trunk/src/VBox/VMM/VMMR0/VMMR0.def

@@ -27 +27 @@
     PDMCritSectTryEnterDebug
     PDMQueueAlloc
-    PDMQueueFlush
     PDMQueueInsert
     PGMHandlerPhysicalPageTempOff