Changeset 53396 in vbox for trunk/src/VBox

Timestamp:

Nov 25, 2014 3:01:59 PM (10 years ago)

Author:

vboxsync

Message:

HostDrivers/Support: Don't try measuring TSC deltas on OSes that normalizes TSC-deltas themselves, currently only Windows.

Location:

trunk/src/VBox/HostDrivers/Support

Files:

• SUPDrv.c (modified) (17 diffs)
• SUPDrvInternal.h (modified) (1 diff)
• darwin/SUPDrv-darwin.cpp (modified) (1 diff)
• freebsd/SUPDrv-freebsd.c (modified) (1 diff)
• linux/SUPDrv-linux.c (modified) (1 diff)
• os2/SUPDrv-os2.cpp (modified) (1 diff)
• solaris/SUPDrv-solaris.c (modified) (1 diff)
• win/SUPDrv-win.cpp (modified) (1 diff)

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

@@ -206 +206 @@
 static volatile uint32_t    g_cMpOnOffEvents;
 /** TSC reading during start of TSC frequency refinement phase. */
-uint64_t                    g_u64TSCAnchor;
+static uint64_t             g_u64TSCAnchor;
 /** Timestamp (in nanosec) during start of TSC frequency refinement phase. */
-uint64_t                    g_u64NanoTSAnchor;
+static uint64_t             g_u64NanoTSAnchor;
+/** Whether the host OS has already normalized the hardware TSC deltas across
+ *  CPUs. */
+static bool                 g_fOsTscDeltasInSync;
 
 /**
@@ -5855 +5858 @@
 static int supdrvTscDeltaInit(PSUPDRVDEVEXT pDevExt)
 {
+    Assert(!g_fOsTscDeltasInSync);
     int rc = RTSpinlockCreate(&pDevExt->hTscDeltaSpinlock, RTSPINLOCK_FLAGS_INTERRUPT_UNSAFE, "VBoxTscSpnLck");
     if (RT_SUCCESS(rc))
@@ -6067 +6071 @@
     cCpus = RTMpGetArraySize();
     if (   cCpus > RTCPUSET_MAX_CPUS
-        || cCpus > 256 /*ApicId is used for the mappings*/)
+        || cCpus > 256 /* ApicId is used for the mappings */)
     {
         SUPR0Printf("VBoxDrv: Too many CPUs (%u) for the GIP (max %u)\n", cCpus, RT_MIN(RTCPUSET_MAX_CPUS, 256));
@@ -6099 +6103 @@
     supdrvGipInit(pDevExt, pGip, HCPhysGip, RTTimeSystemNanoTS(), RT_NS_1SEC / u32Interval /*=Hz*/, u32Interval, cCpus);
 
+    if (RT_UNLIKELY(   g_fOsTscDeltasInSync
+                    && pGip->u32Mode == SUPGIPMODE_ASYNC_TSC
+                    && !supdrvOSGetForcedAsyncTscMode(pDevExt)))
+    {
+        OSDBGPRINT(("supdrvGipCreate: The TSC-deltas should be normalized by the host OS, but verifying shows it's not!\n"));
+        return VERR_INTERNAL_ERROR_2;
+    }
+
 #ifdef SUPDRV_USE_TSC_DELTA_THREAD
-    /* Initialize TSC-delta measurement thread before executing any Mp event callbacks. */
-    rc = supdrvTscDeltaInit(pDevExt);
+    if (!g_fOsTscDeltasInSync)
+    {
+        /* Initialize TSC-delta measurement thread before executing any Mp event callbacks. */
+        rc = supdrvTscDeltaInit(pDevExt);
+    }
 #endif
     if (RT_SUCCESS(rc))
@@ -6112 +6127 @@
             {
 #ifndef SUPDRV_USE_TSC_DELTA_THREAD
-                /*
-                 * Measure the TSC deltas now that we have MP notifications.
-                 */
-                int      cTries = 5;
                 uint16_t iCpu;
-                do
+                if (!g_fOsTscDeltasInSync)
                 {
-                    rc = supdrvMeasureTscDeltas(pDevExt, NULL /* pidxMaster */);
-                    if (rc != VERR_TRY_AGAIN)
-                        break;
-                } while (--cTries > 0);
-                for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
-                    Log(("supdrvTscDeltaInit: cpu[%u] delta %lld\n", iCpu, pGip->aCPUs[iCpu].i64TSCDelta));
+                    /*
+                     * Measure the TSC deltas now that we have MP notifications.
+                     */
+                    int cTries = 5;
+                    do
+                    {
+                        rc = supdrvMeasureTscDeltas(pDevExt, NULL /* pidxMaster */);
+                        if (rc != VERR_TRY_AGAIN)
+                            break;
+                    } while (--cTries > 0);
+                    for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
+                        Log(("supdrvTscDeltaInit: cpu[%u] delta %lld\n", iCpu, pGip->aCPUs[iCpu].i64TSCDelta));
+                }
+                else
+                {
+                    for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
+                        Assert(!pGip->aCPUs[iCpu].i64TSCDelta);
+                }
 #endif
-
-                rc = supdrvGipMeasureTscFreq(pGip);
                 if (RT_SUCCESS(rc))
                 {
-                    if (supdrvIsInvariantTsc())
+                    rc = supdrvGipMeasureTscFreq(pGip);
+                    if (RT_SUCCESS(rc))
                     {
-                        for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
-                            pGip->aCPUs[iCpu].u64CpuHz = pGip->u64CpuHz;
-                    }
-
-                    /*
-                     * Create the timer.
-                     * If CPU_ALL isn't supported we'll have to fall back to synchronous mode.
-                     */
-                    if (pGip->u32Mode == SUPGIPMODE_ASYNC_TSC)
-                    {
-                        rc = RTTimerCreateEx(&pDevExt->pGipTimer, u32Interval, RTTIMER_FLAGS_CPU_ALL, supdrvGipAsyncTimer, pDevExt);
-                        if (rc == VERR_NOT_SUPPORTED)
+                        if (supdrvIsInvariantTsc())
+                            pGip->aCPUs[0].u64CpuHz = pGip->u64CpuHz;
+
+                        /*
+                         * Create the timer.
+                         * If CPU_ALL isn't supported we'll have to fall back to synchronous mode.
+                         */
+                        if (pGip->u32Mode == SUPGIPMODE_ASYNC_TSC)
                         {
-                            OSDBGPRINT(("supdrvGipCreate: omni timer not supported, falling back to synchronous mode\n"));
-                            pGip->u32Mode = SUPGIPMODE_SYNC_TSC;
+                            rc = RTTimerCreateEx(&pDevExt->pGipTimer, u32Interval, RTTIMER_FLAGS_CPU_ALL, supdrvGipAsyncTimer,
+                                                 pDevExt);
+                            if (rc == VERR_NOT_SUPPORTED)
+                            {
+                                OSDBGPRINT(("supdrvGipCreate: omni timer not supported, falling back to synchronous mode\n"));
+                                pGip->u32Mode = SUPGIPMODE_SYNC_TSC;
+                            }
+                        }
+                        if (pGip->u32Mode != SUPGIPMODE_ASYNC_TSC)
+                            rc = RTTimerCreateEx(&pDevExt->pGipTimer, u32Interval, 0 /* fFlags */, supdrvGipSyncTimer, pDevExt);
+                        if (RT_SUCCESS(rc))
+                        {
+                            /*
+                             * We're good.
+                             */
+                            Log(("supdrvGipCreate: %u ns interval.\n", u32Interval));
+                            g_pSUPGlobalInfoPage = pGip;
+                            return VINF_SUCCESS;
+                        }
+                        else
+                        {
+                            OSDBGPRINT(("supdrvGipCreate: RTTimerCreateEx failed (%u ns interval). rc=%Rrc\n", u32Interval, rc));
+                            Assert(!pDevExt->pGipTimer);
                         }
                     }
-                    if (pGip->u32Mode != SUPGIPMODE_ASYNC_TSC)
-                        rc = RTTimerCreateEx(&pDevExt->pGipTimer, u32Interval, 0 /* fFlags */, supdrvGipSyncTimer, pDevExt);
-                    if (RT_SUCCESS(rc))
-                    {
-                        /*
-                         * We're good.
-                         */
-                        Log(("supdrvGipCreate: %u ns interval.\n", u32Interval));
-                        g_pSUPGlobalInfoPage = pGip;
-                        return VINF_SUCCESS;
-                    }
                     else
-                    {
-                        OSDBGPRINT(("supdrvGipCreate: failed create GIP timer at %u ns interval. rc=%Rrc\n", u32Interval, rc));
-                        Assert(!pDevExt->pGipTimer);
-                    }
+                        OSDBGPRINT(("supdrvGipCreate: supdrvGipMeasureTscFreq failed. rc=%Rrc\n", rc));
                 }
+                else
+                    OSDBGPRINT(("supdrvGipCreate: supdrvMeasureTscDeltas failed. rc=%Rrc\n", rc));
             }
             else
@@ -6333 +6360 @@
                     pGip->u64CpuHz = (u64TSC - g_u64TSCAnchor) / (u64DeltaNanoTS / RT_NS_1SEC);
 
-                for (iCpu = 0; iCpu < pGip->cCpus; iCpu++)
-                    pGip->aCPUs[iCpu].u64CpuHz = pGip->u64CpuHz;
+                pGip->aCPUs[0].u64CpuHz = pGip->u64CpuHz;
                 g_u64TSCAnchor = 0;
             }
@@ -6465 +6491 @@
      * update the state and it'll get serviced when the thread's listening interval times out.
      */
-    if (supdrvIsInvariantTsc())
+    if (   !g_fOsTscDeltasInSync
+        && supdrvIsInvariantTsc())
     {
         RTCpuSetAdd(&pDevExt->TscDeltaCpuSet, idCpu);
@@ -6523 +6550 @@
     }
 
-    /* Reset the TSC delta, we will recalculate it lazily. */
-    ASMAtomicWriteS64(&pGip->aCPUs[i].i64TSCDelta, INT64_MAX);
+    /* Reset the TSC delta (if required), we will recalculate it lazily. */
+    if (!g_fOsTscDeltasInSync)
+        ASMAtomicWriteS64(&pGip->aCPUs[i].i64TSCDelta, INT64_MAX);
 
     /* commit it */
@@ -6706 +6734 @@
     if (!RTMpOnAllIsConcurrentSafe())
     {
+        /** @todo This was introduced for Windows, but since Windows doesn't use this
+         *        code path any longer (as DPC timeouts BSOD regardless of interrupts,
+         *        see @bugref{6710} comment 81), eventually phase it out. */
         uint64_t       uTscNow;
         uint64_t       uTscStart;
@@ -6896 +6927 @@
     AssertReturn(pDevExt, VERR_INVALID_PARAMETER);
     AssertReturn(pDevExt->pGip, VERR_INVALID_PARAMETER);
+    Assert(!g_fOsTscDeltasInSync);
 
     pGip          = pDevExt->pGip;
@@ -6960 +6992 @@
     uint32_t   cOnlineCpus    = pGip->cOnlineCpus;
 
+    Assert(!g_fOsTscDeltasInSync);
+
     /*
      * If we determined the TSC is async., don't bother with measuring deltas.
@@ -7056 +7090 @@
  * case we have to choose the asynchronous timer mode.
  *
- * @param   poffMin     Pointer to the determined difference between different cores.
+ * @param   poffMin     Pointer to the determined difference between different
+ *                      cores (optional, can be NULL).
  * @return  false if the time stamp counters appear to be synchronized, true otherwise.
  */
@@ -7116 +7151 @@
     }
 
-    *poffMin = offMin; /* Almost RTMpOnSpecific profiling. */
+    if (poffMin)
+        *poffMin = offMin; /* Almost RTMpOnSpecific profiling. */
     Log(("supdrvDetermineAsyncTsc: returns %d; iEndCpu=%d rc=%d offMin=%llx offMax=%llx\n",
          fAsync, iEndCpu, rc, offMin, offMax));
@@ -7200 +7236 @@
     pCpu->u64TSC             = ASMReadTSC();
     pCpu->u64TSCSample       = GIP_TSC_DELTA_RSVD;
-    pCpu->i64TSCDelta        = INT64_MAX;
+    pCpu->i64TSCDelta        = g_fOsTscDeltasInSync ? 0 : INT64_MAX;
 
     ASMAtomicWriteSize(&pCpu->enmState, SUPGIPCPUSTATE_INVALID);
@@ -7247 +7283 @@
     LogFlow(("supdrvGipInit: pGip=%p HCPhys=%lx u64NanoTS=%llu uUpdateHz=%d cCpus=%u\n", pGip, (long)HCPhys, u64NanoTS, uUpdateHz, cCpus));
 #endif
+
+    /*
+     * Record whether the host OS has already normalized inter-CPU deltas for the hardware TSC.
+     * We only bother with TSC-deltas only on invariant CPUs for now.
+     */
+    g_fOsTscDeltasInSync = supdrvIsInvariantTsc() && supdrvOSAreTscDeltasInSync();
 
     /*
@@ -7642 +7684 @@
         return VERR_INVALID_CPU_ID;
 
+    if (g_fOsTscDeltasInSync)
+        return VINF_SUCCESS;
+
     cTries       = RT_MAX(pReq->u.In.cRetries + 1, 10);
     cMsWaitRetry = RT_MAX(pReq->u.In.cMsWaitRetry, 5);
@@ -7737 +7782 @@
             AssertMsgReturn(iCpu < pGip->cCpus, ("iCpu=%u cCpus=%u\n", iCpu, pGip->cCpus), VERR_INVALID_CPU_INDEX);
 
+            Assert(!g_fOsTscDeltasInSync);
             rc2 = supdrvMeasureTscDeltaOne(pDevExt, iCpu);
             if (RT_SUCCESS(rc2))

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

@@ -751 +751 @@
 bool VBOXCALL   supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char *pszObjName, int *prc);
 bool VBOXCALL   supdrvOSGetForcedAsyncTscMode(PSUPDRVDEVEXT pDevExt);
+bool VBOXCALL   supdrvOSAreTscDeltasInSync(void);
 int  VBOXCALL   supdrvOSEnableVTx(bool fEnabled);
 bool VBOXCALL   supdrvOSSuspendVTxOnCpu(void);

trunk/src/VBox/HostDrivers/Support/darwin/SUPDrv-darwin.cpp

@@ -954 +954 @@
 
 
+bool VBOXCALL supdrvOSAreTscDeltasInSync(void)
+{
+    return false;
+}
+
 void VBOXCALL   supdrvOSLdrNotifyOpened(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
 {

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

@@ -540 +540 @@
 
 
+bool VBOXCALL  supdrvOSAreTscDeltasInSync(void)
+{
+    return false;
+}
+
+
 int  VBOXCALL   supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
 {

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

@@ -867 +867 @@
 
 
+bool VBOXCALL supdrvOSAreTscDeltasInSync(void)
+{
+    return false;
+}
+
+
 int  VBOXCALL   supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
 {

trunk/src/VBox/HostDrivers/Support/os2/SUPDrv-os2.cpp

@@ -407 +407 @@
 
 
+bool VBOXCALL  supdrvOSAreTscDeltasInSync(void)
+{
+    NOREF(pDevExt);
+    return false;
+}
+
+
 int  VBOXCALL   supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
 {

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

@@ -964 +964 @@
 }
 
+
+bool VBOXCALL  supdrvOSAreTscDeltasInSync(void)
+{
+    return false;
+}
+
+
 #if  defined(VBOX_WITH_NATIVE_SOLARIS_LOADING) \
  && !defined(VBOX_WITHOUT_NATIVE_R0_LOADER)

trunk/src/VBox/HostDrivers/Support/win/SUPDrv-win.cpp

@@ -1655 +1655 @@
 
 
+/**
+ * Whether the hardware TSC has been synchronized by the OS.
+ */
+bool VBOXCALL  supdrvOSAreTscDeltasInSync(void)
+{
+    /* Windows writes back the hardware TSC registers to adjust for inter-CPU deltas. */
+    return true;
+}
+
+
 #define MY_SystemLoadGdiDriverInSystemSpaceInformation  54
 #define MY_SystemUnloadGdiDriverInformation             27