Changeset 53063 in vbox for trunk

Timestamp:

Oct 15, 2014 12:41:35 PM (10 years ago)

Author:

vboxsync

Message:

HostDrivers/Support: Add TSC-delta measurement ioctl interface, fixed spinning on concurrent measurements.

Location:

trunk

Files:

• include/VBox/sup.h (modified) (1 diff)
• src/VBox/HostDrivers/Support/SUPDrv.c (modified) (7 diffs)
• src/VBox/HostDrivers/Support/SUPDrvIOC.h (modified) (2 diffs)
• src/VBox/HostDrivers/Support/SUPLib.cpp (modified) (2 diffs)

trunk/include/VBox/sup.h

@@ -1434 +1434 @@
 SUPR3DECL(int) SUPR3ResumeSuspendedKeyboards(void);
 
+
+/**
+ * Measure the TSC-delta for the specified CPU.
+ *
+ * @returns VBox status code.
+ * @param   idCpu               The CPU to measure the TSC-delta for.
+ * @param   fAsync              Whether the measurement is asynchronous, returns
+ *                              immediately after signalling a measurement
+ *                              request.
+ * @param   fForce              Whether to perform a measurement even if the
+ *                              specified CPU has a (possibly) valid TSC delta.
+ * @param   cRetries            Number of times to retry failed delta
+ *                              measurements.
+ */
+SUPR3DECL(int) SUPR3TscDeltaMeasure(RTCPUID idCpu, bool fAsync, bool fForce, uint8_t cRetries);
+
 /** @} */
 #endif /* IN_RING3 */

trunk/src/VBox/HostDrivers/Support/SUPDrv.c

@@ -154 +154 @@
 static int                  supdrvIOCtl_LoggerSettings(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPLOGGERSETTINGS pReq);
 static int                  supdrvIOCtl_MsrProber(PSUPDRVDEVEXT pDevExt, PSUPMSRPROBER pReq);
+static int                  supdrvIOCtl_TscDeltaMeasure(PSUPDRVDEVEXT pDevExt, PSUPTSCDELTAMEASURE pReq);
 static int                  supdrvGipCreate(PSUPDRVDEVEXT pDevExt);
 static void                 supdrvGipDestroy(PSUPDRVDEVEXT pDevExt);
@@ -2242 +2243 @@
         }
 
+        case SUP_CTL_CODE_NO_SIZE(SUP_IOCTL_TSC_DELTA_MEASURE):
+        {
+            /* validate */
+            PSUPTSCDELTAMEASURE pReq = (PSUPTSCDELTAMEASURE)pReqHdr;
+            REQ_CHECK_SIZES(SUP_IOCTL_TSC_DELTA_MEASURE);
+
+            pReqHdr->rc = supdrvIOCtl_TscDeltaMeasure(pDevExt, pReq);
+            return 0;
+        }
+
         default:
             Log(("Unknown IOCTL %#lx\n", (long)uIOCtl));
@@ -6642 +6653 @@
 static int supdrvMeasureTscDeltaOne(PSUPDRVDEVEXT pDevExt, uint32_t idxWorker)
 {
-    PSUPGLOBALINFOPAGE pGip  = pDevExt->pGip;
-    RTCPUID    idMaster      = pDevExt->idGipMaster;
-    uint32_t   idxMaster     = supdrvGipCpuIndexFromCpuId(pGip, idMaster);
-    PSUPGIPCPU pGipCpuWorker = &pGip->aCPUs[idxWorker];
-    int        rc            = VERR_CPU_OFFLINE;
-
-    if (idxWorker == idxMaster)
+    int rc;
+    PSUPGLOBALINFOPAGE pGip;
+    PSUPGIPCPU pGipCpuWorker;
+    RTCPUID idMaster;
+
+    AssertReturn(pDevExt, VERR_INVALID_PARAMETER);
+    AssertReturn(pDevExt->pGip, VERR_INVALID_PARAMETER);
+
+    pGip          = pDevExt->pGip;
+    idMaster      = pDevExt->idGipMaster;
+    pGipCpuWorker = &pGip->aCPUs[idxWorker];
+
+    if (pGipCpuWorker->idCpu == idMaster)
     {
         ASMAtomicWriteS64(&pGipCpuWorker->i64TSCDelta, 0);
@@ -6656 +6673 @@
     /* Set the master TSC as the initiator. */
     while (ASMAtomicCmpXchgU32(&g_idTscDeltaInitiator, idMaster, NIL_RTCPUID) == false)
-        ASMNopPause();
+    {
+        /*
+         * Sleep here rather than spin as there is a parallel measurement
+         * being executed and that can take a good while to be done.
+         */
+        RTThreadSleep(1);
+    }
 
     if (RTCpuSetIsMember(&pGip->OnlineCpuSet, pGipCpuWorker->idCpu))
@@ -6670 +6693 @@
         }
     }
+    else
+        rc = VERR_CPU_OFFLINE;
 
     ASMAtomicWriteU32(&g_idTscDeltaInitiator, NIL_RTCPUID);
@@ -7314 +7339 @@
 }
 
+
 /**
  * Resume built-in keyboard on MacBook Air and Pro hosts.
@@ -7329 +7355 @@
 }
 
+
+/**
+ * Service a TSC-delta measurement request.
+ *
+ * @returns VBox status code.
+ * @param   pDevExt             Pointer to the device instance data.
+ * @param   pReq                Pointer to the TSC-delta measurement request.
+ */
+static int supdrvIOCtl_TscDeltaMeasure(PSUPDRVDEVEXT pDevExt, PSUPTSCDELTAMEASURE pReq)
+{
+    PSUPGLOBALINFOPAGE pGip;
+    RTCPUID            idCpuWorker;
+    int                rc = VERR_CPU_NOT_FOUND;
+    int16_t            cTries;
+    RTMSINTERVAL       cMsWaitRetry;
+    uint16_t           iCpu;
+
+    /*
+     * Validate.
+     */
+    AssertReturn(pDevExt, VERR_INVALID_PARAMETER);
+    AssertReturn(pReq, VERR_INVALID_PARAMETER);
+    AssertReturn(pDevExt->pGip, VERR_INVALID_PARAMETER);
+    idCpuWorker = pReq->u.In.idCpu;
+    if (idCpuWorker == NIL_RTCPUID)
+        return VERR_INVALID_CPU_ID;
+
+#ifdef SUPDRV_USE_TSC_DELTA_THREAD
+    if (pReq->u.In.fAsync)
+    {
+        /** @todo Async. doesn't implement options like retries, waiting. We'll need
+         *        to pass those options to the thread somehow and implement it in the
+         *        thread. Check if anyone uses/needs fAsync before implementing this. */
+        RTCpuSetAdd(&pDevExt->TscDeltaCpuSet, idCpu);
+        RTSpinlockAcquire(pDevExt->hTscDeltaSpinlock);
+        if (   pDevExt->enmTscDeltaState == kSupDrvTscDeltaState_Listening
+            || pDevExt->enmTscDeltaState == kSupDrvTscDeltaState_Measuring)
+        {
+            pDevExt->enmTscDeltaState = kSupDrvTscDeltaState_WaitAndMeasure;
+        }
+        RTSpinlockRelease(pDevExt->hTscDeltaSpinlock);
+        RTThreadUserSignal(pDevExt->hTscDeltaThread);
+        return VINF_SUCCESS;
+    }
+#endif
+
+    cTries       = RT_MAX(pReq->u.In.cRetries + 1, 10);
+    cMsWaitRetry = RT_MAX(pReq->u.In.cMsWaitRetry, 5);
+    pGip = pDevExt->pGip;
+    for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
+    {
+        PSUPGIPCPU pGipCpuWorker = &pGip->aCPUs[iCpu];
+        if (pGipCpuWorker->idCpu == idCpuWorker)
+        {
+            if (   pGipCpuWorker->i64TSCDelta != INT64_MAX
+                && !pReq->u.In.fForce)
+                return VINF_SUCCESS;
+
+            while (!cTries--)
+            {
+                rc = supdrvMeasureTscDeltaOne(pDevExt, iCpu);
+                if (RT_SUCCESS(rc))
+                {
+                    Assert(pGipCpuWorker->i64TSCDelta != INT64_MAX);
+                    break;
+                }
+
+                if (cMsWaitRetry)
+                    RTThreadSleep(cMsWaitRetry);
+            }
+
+            break;
+        }
+    }
+    return rc;
+}
+

trunk/src/VBox/HostDrivers/Support/SUPDrvIOC.h

@@ -215 +215 @@
  *          - (none).
  */
-#define SUPDRV_IOC_VERSION                              0x001b0000
+#define SUPDRV_IOC_VERSION                              0x001b0001
 
 /** SUP_IOCTL_COOKIE. */
@@ -1471 +1471 @@
 
 
+/** @name SUP_IOCTL_TSC_DELTA_MEASURE
+ * Measure the TSC-delta between the specified CPU and the master TSC.
+ *
+ * @{
+ */
+#define SUP_IOCTL_TSC_DELTA_MEASURE                     SUP_CTL_CODE_SIZE(36, SUP_IOCTL_TSC_DELTA_MEASURE_SIZE)
+#define SUP_IOCTL_TSC_DELTA_MEASURE_SIZE                sizeof(SUPTSCDELTAMEASURE)
+#define SUP_IOCTL_TSC_DELTA_MEASURE_SIZE_IN             sizeof(SUPTSCDELTAMEASURE)
+#define SUP_IOCTL_TSC_DELTA_MEASURE_SIZE_OUT            sizeof(SUPREQHDR)
+typedef struct SUPTSCDELTAMEASURE
+{
+    /** The header. */
+    SUPREQHDR               Hdr;
+
+    /** Input/output union. */
+    union
+    {
+        struct
+        {
+            /** Which CPU to take the TSC-delta measurement for. */
+            RTCPUID         idCpu;
+            /** Number of times to retry on failure (specify 0 for default). */
+            uint8_t         cRetries;
+            /** Number of milliseconds to wait before each retry. */
+            uint8_t         cMsWaitRetry;
+            /** Whether to force taking a measurement if one exists already. */
+            bool            fForce;
+            /** Whether to do the measurement asynchronously (if possible). */
+            bool            fAsync;
+            /** Padding for future. */
+            uint64_t        auPadding[3];
+        } In;
+    } u;
+} SUPTSCDELTAMEASURE, *PSUPTSCDELTAMEASURE;
+AssertCompileMemberAlignment(SUPTSCDELTAMEASURE, u, 8);
+/** @} */
+
+
 #pragma pack()                          /* paranoia */
 

trunk/src/VBox/HostDrivers/Support/SUPLib.cpp

@@ -280 +280 @@
         CookieReq.u.In.u32ReqVersion = SUPDRV_IOC_VERSION;
         const uint32_t uMinVersion = (SUPDRV_IOC_VERSION & 0xffff0000) == 0x001b0000
-                                   ? 0x001b0000
+                                   ? 0x001b0001
                                    : SUPDRV_IOC_VERSION & 0xffff0000;
         CookieReq.u.In.u32MinVersion = uMinVersion;
@@ -2176 +2176 @@
 }
 
+
+SUPR3DECL(int) SUPR3TscDeltaMeasure(RTCPUID idCpu, bool fAsync, bool fForce, uint8_t cRetries, uint8_t cMsWaitRetry)
+{
+    SUPTSCDELTAMEASURE Req;
+    Req.Hdr.u32Cookie        = g_u32Cookie;
+    Req.Hdr.u32SessionCookie = g_u32SessionCookie;
+    Req.Hdr.cbIn             = SUP_IOCTL_TSC_DELTA_MEASURE_SIZE_IN;
+    Req.Hdr.cbOut            = SUP_IOCTL_TSC_DELTA_MEASURE_SIZE_OUT;
+    Req.Hdr.fFlags           = SUPREQHDR_FLAGS_DEFAULT;
+    Req.Hdr.rc               = VERR_INTERNAL_ERROR;
+
+    Req.u.In.cRetries     = cRetries;
+    Req.u.In.fAsync       = fAsync;
+    Req.u.In.fForce       = fForce;
+    Req.u.In.idCpu        = idCpu;
+    Req.u.In.cMsWaitRetry = cMsWaitRetry;
+
+    int rc = suplibOsIOCtl(&g_supLibData, SUP_IOCTL_TSC_DELTA_MEASURE, &Req, SUP_IOCTL_TSC_DELTA_MEASURE_SIZE);
+    if (RT_SUCCESS(rc))
+        rc = Req.Hdr.rc;
+    return rc;
+}
+