Changeset 90461 in vbox

Timestamp:

Aug 1, 2021 8:56:10 PM (3 years ago)

Author:

vboxsync

Message:

VMMDev: New port for lock contention testing. bugref:6695

Location:

trunk

Files:

• include/VBox/VMMDevTesting.h (modified) (2 diffs)
• src/VBox/Devices/VMMDev/VMMDev.cpp (modified) (1 diff)
• src/VBox/Devices/VMMDev/VMMDevState.h (modified) (5 diffs)
• src/VBox/Devices/VMMDev/VMMDevTesting.cpp (modified) (4 diffs)

trunk/include/VBox/VMMDevTesting.h

@@ -90 +90 @@
 /** The go-to-ring-3-NOP I/O port - 1,2,4 RW. */
 #define VMMDEV_TESTING_IOPORT_NOP_R3    (VMMDEV_TESTING_IOPORT_BASE + 5)
+/** Take the VMMDev lock in arrival context and return - 1,2,4 RW.
+ * Writing configures counter action by a thread taking the lock to trigger
+ * contention:
+ *  - Bits 19-0 is the lock hold time in microseconds. Zero disables it.
+ *  - Bit 31 make the thread poke the EMT(s) prior to releasing the lock.
+ *  - Bits 30-20 are reserved and must be zero. */
+#define VMMDEV_TESTING_IOPORT_LOCKED    (VMMDEV_TESTING_IOPORT_BASE + 6)
 
 /** @name Commands.
@@ -153 +160 @@
 /** @}  */
 
+/** What the NOP accesses returns. */
+#define VMMDEV_TESTING_NOP_RET                  UINT32_C(0x64726962) /* bird */
 
-/** What the NOP accesses returns. */
-#define VMMDEV_TESTING_NOP_RET          UINT32_C(0x64726962) /* bird */
+/** @name Locked Control dword
+ * @{ */
+/** Locked Control: Lock hold interval in microseconds. */
+#define VMMDEV_TESTING_LOCKED_HOLD_MASK         UINT32_C(0x00003fff)
+/** Locked Control: Wait time in microseconds between locking attempts. */
+#define VMMDEV_TESTING_LOCKED_WAIT_MASK         UINT32_C(0x0fffc000)
+/** Locked Control: Wait time shift count. */
+#define VMMDEV_TESTING_LOCKED_WAIT_SHIFT        14
+/** Locked Control: Must be zero. */
+#define VMMDEV_TESTING_LOCKED_MBZ_MASK          UINT32_C(0x70000000)
+/** Locked Control: Poke EMT(s) flag.   */
+#define VMMDEV_TESTING_LOCKED_POKE              UINT32_C(0x80000000)
+/** @} */
 
 /** @} */

trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

@@ -4482 +4482 @@
     pThis->hIoPortTesting       = NIL_IOMIOPORTHANDLE;
     pThis->hMmioTesting         = NIL_IOMMMIOHANDLE;
+    pThis->hTestingLockEvt      = NIL_SUPSEMEVENT;
 #endif
 

trunk/src/VBox/Devices/VMMDev/VMMDevState.h

@@ -27 +27 @@
 #include <VBox/vmm/pdmifs.h>
 #ifndef VBOX_WITHOUT_TESTING_FEATURES
+# include <VBox/vmm/pdmthread.h>
 # include <iprt/test.h>
 # include <VBox/VMMDevTesting.h>
@@ -260 +261 @@
     uint32_t            StatMemBalloonChunks;
 
+    /** @name Testing
+     * @{ */
     /** Set if testing is enabled. */
     bool                fTestingEnabled;
@@ -266 +269 @@
     /** Alignment padding. */
     bool                afPadding9[HC_ARCH_BITS == 32 ? 2 : 6];
-#ifndef VBOX_WITHOUT_TESTING_FEATURES
+#if !defined(VBOX_WITHOUT_TESTING_FEATURES) || defined(DOXYGEN_RUNNING)
     /** The high timestamp value. */
     uint32_t            u32TestingHighTimestamp;
@@ -303 +306 @@
         uint8_t         abReadBack[VMMDEV_TESTING_READBACK_SIZE];
     } TestingData;
-
+    /** The locking testing control dword. */
+    union
+    {
+        /** Plain view. */
+        uint32_t        u32;
+        struct
+        {
+            /** Number of microseconds to hold the lock. Zero means disabled. */
+            uint32_t    cUsHold : 14;
+            /** Number of microseconds to wait before retaking the lock again. */
+            uint32_t    cUsBetween : 14;
+            /** Reserved MBZ. */
+            uint32_t    uReserved : 3;
+            /** Whether to poke EMTs before releasing it. */
+            uint32_t    fPokeBeforeRelease : 1;
+        } s;
+    } TestingLockControl;
+    /** Alignment padding.  */
+    uint32_t            uPadding10;
+    /** Event semaphore that the locking thread blocks. */
+    SUPSEMEVENT         hTestingLockEvt;
     /** Handle for the I/O ports used by the testing component. */
     IOMIOPORTHANDLE     hIoPortTesting;
     /** Handle for the MMIO region used by the testing component. */
     IOMMMIOHANDLE       hMmioTesting;
-#endif /* !VBOX_WITHOUT_TESTING_FEATURES */
+#endif /* !VBOX_WITHOUT_TESTING_FEATURES || DOXYGEN_RUNNING */
+    /** @} */
 
     /** @name Heartbeat
@@ -453 +477 @@
     /** Testing instance for dealing with the output. */
     RTTEST                          hTestingTest;
+    /** The locking test thread (). */
+    PPDMTHREAD                      pTestingLockThread;
 #endif
 } VMMDEVR3;

trunk/src/VBox/Devices/VMMDev/VMMDevTesting.cpp

@@ -33 +33 @@
 #include <iprt/time.h>
 #include <iprt/test.h>
+
+#ifdef IN_RING3
+# define USING_VMM_COMMON_DEFS /* HACK ALERT! We ONLY want the EMT thread handles, so the common defs doesn't matter. */
+# include <VBox/vmm/vmcc.h>
+#endif
 
 #include "VMMDevState.h"
@@ -577 +582 @@
                 }
 
+                /*
+                 * Configure the locking contention test.
+                 */
+                case VMMDEV_TESTING_IOPORT_LOCKED - VMMDEV_TESTING_IOPORT_BASE:
+                    switch (cb)
+                    {
+                        case 4:
+                        case 2:
+                        case 1:
+                        {
+                            int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VINF_SUCCESS);
+                            AssertRCReturn(rc, rc);
+
+                            u32 &= ~VMMDEV_TESTING_LOCKED_MBZ_MASK;
+                            if (pThis->TestingLockControl.u32 != u32)
+                            {
+                                pThis->TestingLockControl.u32 = u32;
+                                PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hTestingLockEvt);
+                            }
+
+                            PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
+                            return VINF_SUCCESS;
+                        }
+
+                        default:
+                            AssertFailed();
+                            return VERR_INTERNAL_ERROR_2;
+                    }
+
                 default:
                     break;
@@ -676 +710 @@
 }
 
-
 #ifdef IN_RING3
+
+/**
+ * @callback_method_impl{FNPDMTHREADDEV}
+ */
+static DECLCALLBACK(int)  vmmdevR3TestingLockingThread(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
+{
+    PVMMDEV pThis = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
+    PVM     pVM   = PDMDevHlpGetVM(pDevIns);
+    AssertPtr(pVM);
+
+    while (RT_LIKELY(pThread->enmState == PDMTHREADSTATE_RUNNING))
+    {
+        /*
+         * Enter the critical section and
+         */
+        int rc = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VINF_SUCCESS);
+        AssertLogRelRCReturn(rc, rc);
+
+        uint32_t cNsNextWait;
+        if (pThis->TestingLockControl.s.cUsHold)
+        {
+            PDMDevHlpSUPSemEventWaitNsRelIntr(pDevIns, pThis->hTestingLockEvt, pThis->TestingLockControl.s.cUsHold);
+            if (pThis->TestingLockControl.s.fPokeBeforeRelease)
+                VMCC_FOR_EACH_VMCPU_STMT(pVM, RTThreadPoke(pVCpu->hThread));
+            cNsNextWait = pThis->TestingLockControl.s.cUsBetween * RT_NS_1US;
+        }
+        else
+            cNsNextWait = 0;
+
+        rc = PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect);
+        AssertLogRelRCReturn(rc, rc);
+
+        /*
+         * Wait for the next iteration.
+         */
+        if (RT_LIKELY(pThread->enmState == PDMTHREADSTATE_RUNNING))
+        { /* likely */ }
+        else
+            break;
+        if (cNsNextWait > 0)
+            PDMDevHlpSUPSemEventWaitNsRelIntr(pDevIns, pThis->hTestingLockEvt, cNsNextWait);
+        else
+            PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pThis->hTestingLockEvt, RT_INDEFINITE_WAIT);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @callback_method_impl{FNPDMTHREADWAKEUPDEV}
+ */
+static DECLCALLBACK(int) vmmdevR3TestingLockingThreadWakeup(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
+{
+    PVMMDEV pThis = PDMDEVINS_2_DATA(pDevIns, PVMMDEV);
+    RT_NOREF(pThread);
+    return PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hTestingLockEvt);
+}
+
 
 /**
@@ -739 +831 @@
 
     /*
+     * Create the locking thread.
+     */
+    rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->hTestingLockEvt);
+    AssertRCReturn(rc, rc);
+    rc = PDMDevHlpThreadCreate(pDevIns, &pThisCC->pTestingLockThread, NULL /*pvUser*/, vmmdevR3TestingLockingThread,
+                               vmmdevR3TestingLockingThreadWakeup, 0 /*cbStack*/, RTTHREADTYPE_IO, "VMMLockT");
+    AssertRCReturn(rc, rc);
+
+    /*
      * Open the XML output file(/pipe/whatever) if specfied.
      */