Changeset 54224 in vbox for trunk/src/VBox/HostDrivers/Support/SUPDrv.c

Timestamp:

Feb 16, 2015 10:41:32 PM (10 years ago)

Author:

vboxsync

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

98289

Message:

SUP,IPRT: Started as a build fix ended up as a cleanup (mostly untested as I'm windows). We'll keep SUP_IOCTL_TSC_READ for the purpose of dealing with the i64TSCDelta == INT64_MAX in SUPReadTsc/SUPReadTscWithDelta. Moved the excessive inline code from sup.h to SUPLibAll.cpp (new file) and SUPDrv.c (apply delta). Don't bother too much about trying to share code between SUPLibAll.cpp and SUPDrv.c/++ as the SUPReadTsc[WithDelta] scenario does not care about knowing when things goes bad, it just needs a TSC that is as good as we can get. The SUPDrv.c code on the other hand probably needs other kind of status codes, assertions and whatnot to be better off with its own version of the code. Remove the now unused assembly macro for applying the delta - the way the delta is applied will not change, period, so better just document it instead.

File:

• trunk/src/VBox/HostDrivers/Support/SUPDrv.c (modified) (8 diffs)

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

@@ -164 +164 @@
 static int                  supdrvIOCtl_MsrProber(PSUPDRVDEVEXT pDevExt, PSUPMSRPROBER pReq);
 static int                  supdrvIOCtl_TscDeltaMeasure(PSUPDRVDEVEXT pDevExt, PSUPTSCDELTAMEASURE pReq);
-static int                  supdrvIOCtl_TscRead(PSUPDRVDEVEXT pDevExt, PSUPTSCREAD pReq);
+static int                  supdrvIOCtl_TscRead(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPTSCREAD pReq);
 static int                  supdrvGipCreate(PSUPDRVDEVEXT pDevExt);
 static void                 supdrvGipDestroy(PSUPDRVDEVEXT pDevExt);
@@ -2262 +2262 @@
             REQ_CHECK_SIZES(SUP_IOCTL_TSC_READ);
 
-            pReqHdr->rc = supdrvIOCtl_TscRead(pDevExt, pReq);
+            pReqHdr->rc = supdrvIOCtl_TscRead(pDevExt, pSession, pReq);
             return 0;
         }
@@ -6140 +6140 @@
 
 /**
+ * Applies the TSC delta to the supplied raw TSC value.
+ *
+ * @returns VBox status code. (Ignored by all users, just FYI.)
+ * @param   pGip            Pointer to the GIP.
+ * @param   puTsc           Pointer to a valid TSC value before the TSC delta has been applied.
+ * @param   idApic          The APIC ID of the CPU @c puTsc corresponds to.
+ * @param   fDeltaApplied   Where to store whether the TSC delta was succesfully
+ *                          applied or not (optional, can be NULL).
+ *
+ * @remarks Maybe called with interrupts disabled in ring-0!
+ *
+ * @note    Don't you dare change the delta calculation.  If you really do, make
+ *          sure you update all places where it's used (IPRT, SUPLibAll.cpp,
+ *          SUPDrv.c, supdrvGipMpEvent, and more).
+ */
+DECLINLINE(int) supdrvTscDeltaApply(PSUPGLOBALINFOPAGE pGip, uint64_t *puTsc, uint16_t idApic, bool *pfDeltaApplied)
+{
+    int rc;
+
+    /*
+     * Validate input.
+     */
+    AssertPtr(puTsc);
+    AssertPtr(pGip);
+    Assert(GIP_ARE_TSC_DELTAS_APPLICABLE(pGip));
+
+    /*
+     * Carefully convert the idApic into a GIPCPU entry.
+     */
+    if (RT_LIKELY(idApic < RT_ELEMENTS(pGip->aiCpuFromApicId)))
+    {
+        uint16_t iCpu = pGip->aiCpuFromApicId[idApic];
+        if (RT_LIKELY(iCpu < pGip->cCpus))
+        {
+            PSUPGIPCPU pGipCpu = &pGip->aCPUs[iCpu];
+
+            /*
+             * Apply the delta if valid.
+             */
+            if (RT_LIKELY(pGipCpu->i64TSCDelta != INT64_MAX))
+            {
+                *puTsc -= pGipCpu->i64TSCDelta;
+                if (pfDeltaApplied)
+                    *pfDeltaApplied = true;
+                return VINF_SUCCESS;
+            }
+
+            rc = VINF_SUCCESS;
+        }
+        else
+        {
+            AssertMsgFailed(("iCpu=%u cCpus=%u\n", iCpu, pGip->cCpus));
+            rc = VERR_INVALID_CPU_INDEX;
+        }
+    }
+    else
+    {
+        AssertMsgFailed(("idApic=%u\n", idApic));
+        rc = VERR_INVALID_CPU_ID;
+    }
+    if (pfDeltaApplied)
+        *pfDeltaApplied = false;
+    return rc;
+}
+
+
+/**
  * Measures the TSC frequency of the system.
  *
@@ -6222 +6289 @@
             bool fAppliedBefore;
             bool fAppliedAfter;
-            rc = SUPTscDeltaApply(pGip, &u64TscBefore, idApicBefore, &fAppliedBefore);   AssertRCReturn(rc, rc);
-            rc = SUPTscDeltaApply(pGip, &u64TscAfter,  idApicAfter,  &fAppliedAfter);    AssertRCReturn(rc, rc);
+            rc = supdrvTscDeltaApply(pGip, &u64TscBefore, idApicBefore, &fAppliedBefore);   AssertRCReturn(rc, rc);
+            rc = supdrvTscDeltaApply(pGip, &u64TscAfter,  idApicAfter,  &fAppliedAfter);    AssertRCReturn(rc, rc);
 
             if (   !fAppliedBefore
@@ -6296 +6363 @@
     ASMSetFlags(uFlags);
     if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
-        SUPTscDeltaApply(pGip, &u64Tsc, idApic, &fDeltaApplied);
+        supdrvTscDeltaApply(pGip, &u64Tsc, idApic, &fDeltaApplied);
     u64DeltaNanoTS = u64NanoTS - pDevExt->u64NanoTSAnchor;
     u64DeltaTsc = u64Tsc - pDevExt->u64TscAnchor;
@@ -6371 +6438 @@
     ASMSetFlags(uFlags);
     if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
-        SUPTscDeltaApply(pGip, &pDevExt->u64TscAnchor, idApic, &fDeltaApplied);
+        supdrvTscDeltaApply(pGip, &pDevExt->u64TscAnchor, idApic, &fDeltaApplied);
 
 #ifdef SUPDRV_USE_TSC_DELTA_THREAD
@@ -6684 +6751 @@
          */
         Assert(!ASMIntAreEnabled());
-        SUPTscDeltaApply(pGip, &u64TSC, ASMGetApicId(), NULL /* pfDeltaApplied */);
+        supdrvTscDeltaApply(pGip, &u64TSC, ASMGetApicId(), NULL /* pfDeltaApplied */);
     }
 
@@ -8077 +8144 @@
 
 /**
- * Reads the TSC and TSC-delta atomically, applies the TSC delta.
+ * Reads TSC with delta applied.
+ *
+ * Will try to resolve delta value INT64_MAX before applying it.  This is the
+ * main purpose of this function, to handle the case where the delta needs to be
+ * determined.
  *
  * @returns VBox status code.
  * @param   pDevExt         Pointer to the device instance data.
+ * @param   pSession        The support driver session.
  * @param   pReq            Pointer to the TSC-read request.
  */
-static int supdrvIOCtl_TscRead(PSUPDRVDEVEXT pDevExt, PSUPTSCREAD pReq)
-{
-    uint64_t uTsc;
-    uint16_t idApic;
-    int16_t  cTries;
+static int supdrvIOCtl_TscRead(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPTSCREAD pReq)
+{
     PSUPGLOBALINFOPAGE pGip;
     int rc;
 
     /*
-     * Validate.
-     */
-    AssertReturn(pDevExt, VERR_INVALID_PARAMETER);
-    AssertReturn(pReq, VERR_INVALID_PARAMETER);
-    AssertReturn(pDevExt->pGip, VERR_INVALID_PARAMETER);
-
+     * Validate.  We require the client to have mapped GIP (no asserting on
+     * ring-3 preconditions).
+     */
+    AssertPtr(pDevExt); AssertPtr(pReq); AssertPtr(pSession); /* paranoia^2 */
+    if (pSession->GipMapObjR3 == NIL_RTR0MEMOBJ)
+        return VERR_WRONG_ORDER;
     pGip = pDevExt->pGip;
-    Assert(GIP_ARE_TSC_DELTAS_APPLICABLE(pGip));
-
-    cTries = 4;
-    while (cTries-- > 0)
-    {
-        int rc2;
-        uint16_t iCpu;
-
-        rc = SUPGetTsc(&uTsc, &idApic);
-        if (RT_SUCCESS(rc))
-        {
-            pReq->u.Out.u64AdjustedTsc = uTsc;
-            pReq->u.Out.idApic = idApic;
-            return VINF_SUCCESS;
-        }
-
-        /* If we failed to have a TSC-delta, measurement the TSC-delta and retry. */
-        AssertMsgReturn(idApic < RT_ELEMENTS(pGip->aiCpuFromApicId),
-                        ("idApic=%u ArraySize=%u\n", idApic, RT_ELEMENTS(pGip->aiCpuFromApicId)), VERR_INVALID_CPU_INDEX);
-        iCpu = pGip->aiCpuFromApicId[idApic];
-        AssertMsgReturn(iCpu < pGip->cCpus, ("iCpu=%u cCpus=%u\n", iCpu, pGip->cCpus), VERR_INVALID_CPU_INDEX);
-
-        rc2 = supdrvMeasureTscDeltaOne(pDevExt, iCpu);
-        if (RT_SUCCESS(rc2))
-            AssertReturn(pGip->aCPUs[iCpu].i64TSCDelta != INT64_MAX, VERR_INTERNAL_ERROR_2);
+    AssertReturn(pGip, VERR_INTERNAL_ERROR_2);
+
+    /*
+     * We're usually here because we need to apply delta, but we shouldn't be
+     * upset if the GIP is some different mode.
+     */
+    if (GIP_ARE_TSC_DELTAS_APPLICABLE(pGip))
+    {
+        uint32_t cTries = 0;
+        for (;;)
+        {
+            /*
+             * Start by gathering the data, using CLI for disabling preemption
+             * while we do that.
+             */
+            RTCCUINTREG uFlags  = ASMIntDisableFlags();
+            int         iCpuSet = RTMpCpuIdToSetIndex(RTMpCpuId());
+            int         iGipCpu;
+            if (RT_LIKELY(   (unsigned)iCpuSet < RT_ELEMENTS(pGip->aiCpuFromCpuSetIdx)
+                          && (iGipCpu = pGip->aiCpuFromCpuSetIdx[iCpuSet]) < pGip->cCpus ))
+            {
+                int64_t i64Delta   = pGip->aCPUs[iGipCpu].i64TSCDelta;
+                pReq->u.Out.idApic = pGip->aCPUs[iGipCpu].idApic;
+                pReq->u.Out.u64AdjustedTsc = ASMReadTSC();
+                ASMSetFlags(uFlags);
+
+                /*
+                 * If we're lucky we've got a delta, but no predicitions here
+                 * as this I/O control is normally only used when the TSC delta
+                 * is set to INT64_MAX.
+                 */
+                if (i64Delta != INT64_MAX)
+                {
+                    pReq->u.Out.u64AdjustedTsc -= i64Delta;
+                    rc = VINF_SUCCESS;
+                    break;
+                }
+
+                /* Give up after a few times. */
+                if (cTries >= 4)
+                {
+                    rc = VERR_INTERNAL_ERROR_3; /** @todo change to warning. */
+                    break;
+                }
+
+                /* Need to measure the delta an try again. */
+                rc = supdrvMeasureTscDeltaOne(pDevExt, iGipCpu);
+                Assert(pGip->aCPUs[iGipCpu].i64TSCDelta != INT64_MAX || RT_FAILURE_NP(rc));
+            }
+            else
+            {
+                /* This really shouldn't happen. */
+                AssertMsgFailed(("idCpu=%#x iCpuSet=%#x (%d)\n", RTMpCpuId(), iCpuSet, iCpuSet));
+                pReq->u.Out.idApic = ASMGetApicId();
+                pReq->u.Out.u64AdjustedTsc = ASMReadTSC();
+                ASMSetFlags(uFlags);
+                rc = VERR_INTERNAL_ERROR_5; /** @todo change to warning. */
+                break;
+            }
+        }
+    }
+    else
+    {
+        /*
+         * No delta to apply. Easy. Deal with preemption the lazy way.
+         */
+        RTCCUINTREG uFlags  = ASMIntDisableFlags();
+        int         iCpuSet = RTMpCpuIdToSetIndex(RTMpCpuId());
+        int         iGipCpu;
+        if (RT_LIKELY(   (unsigned)iCpuSet < RT_ELEMENTS(pGip->aiCpuFromCpuSetIdx)
+                      && (iGipCpu = pGip->aiCpuFromCpuSetIdx[iCpuSet]) < pGip->cCpus ))
+            pReq->u.Out.idApic = pGip->aCPUs[iGipCpu].idApic;
+        else
+            pReq->u.Out.idApic = ASMGetApicId();
+        pReq->u.Out.u64AdjustedTsc = ASMReadTSC();
+        ASMSetFlags(uFlags);
+        rc = VINF_SUCCESS;
     }