Changeset 54395 in vbox

Timestamp:

Feb 23, 2015 5:34:01 PM (10 years ago)

Author:

vboxsync

Message:

IPRT, HostDriver, VMMR0: MP notifications fixes for TSC-delta measurements, scheduling of notification callback taken care by the API consumer instead of IPRT.

Location:

trunk/src/VBox

Files:

• HostDrivers/Support/SUPDrvGip.cpp (modified) (30 diffs)
• Runtime/r0drv/linux/mpnotification-r0drv-linux.c (modified) (5 diffs)
• Runtime/r0drv/solaris/mpnotification-r0drv-solaris.c (modified) (3 diffs)
• VMM/VMMR0/HMR0.cpp (modified) (5 diffs)

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

@@ -109 +109 @@
 #define GIP_TSC_DELTA_SYNC_PRESTART_WORKER  5
 /** The TSC-refinement interval in seconds. */
-#define GIP_TSC_REFINE_PREIOD_IN_SECS       5
+#define GIP_TSC_REFINE_PERIOD_IN_SECS       5
 /** The TSC-delta threshold for the SUPGIPUSETSCDELTA_PRACTICALLY_ZERO rating */
 #define GIP_TSC_DELTA_THRESHOLD_PRACTICALLY_ZERO    32
@@ -142 +142 @@
 static DECLCALLBACK(void)   supdrvGipAsyncTimer(PRTTIMER pTimer, void *pvUser, uint64_t iTick);
 static void                 supdrvGipInitCpu(PSUPGLOBALINFOPAGE pGip, PSUPGIPCPU pCpu, uint64_t u64NanoTS, uint64_t uCpuHz);
+static int                  supdrvMeasureInitialTscDeltas(PSUPDRVDEVEXT pDevExt);
+static int                  supdrvMeasureTscDeltaOne(PSUPDRVDEVEXT pDevExt, uint32_t idxWorker);
 #ifdef SUPDRV_USE_TSC_DELTA_THREAD
 static int                  supdrvTscDeltaThreadInit(PSUPDRVDEVEXT pDevExt);
 static void                 supdrvTscDeltaTerm(PSUPDRVDEVEXT pDevExt);
-static int                  supdrvTscDeltaThreadWaitForOnlineCpus(PSUPDRVDEVEXT pDevExt);
+static void                 supdrvTscDeltaThreadStartMeasurement(PSUPDRVDEVEXT pDevExt);
 #endif
 
@@ -197 +199 @@
  * @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).
+ *          SUPDrv.c, supdrvGipMpEvent(), and more).
  */
 DECLINLINE(int) supdrvTscDeltaApply(PSUPGLOBALINFOPAGE pGip, uint64_t *puTsc, uint16_t idApic, bool *pfDeltaApplied)
@@ -769 +771 @@
 
 /**
- * Used by supdrvInitRefineInvariantTscFreqTimer and supdrvGipInitMeasureTscFreq
- * to update the TSC frequency related GIP variables.
+ * Used by supdrvInitRefineInvariantTscFreqTimer() and
+ * supdrvGipInitMeasureTscFreq() to update the TSC frequency related GIP
+ * variables.
  *
  * @param   pGip                The GIP.
@@ -807 +810 @@
  *
  * This is started during driver init and fires once
- * GIP_TSC_REFINE_PREIOD_IN_SECS seconds later.
+ * GIP_TSC_REFINE_PERIOD_IN_SECS seconds later.
  *
  * @param   pTimer      The timer.
@@ -834 +837 @@
      *         an interrupt handler with higher priority than the clock
      *         interrupt, or spinning for ages in timer handlers is frowned
-     *         upon, this look must be disabled!
+     *         upon, this code must be disabled!
      *
      * Darwin, FreeBSD, Linux, Solaris, Windows 8.1+:
@@ -863 +866 @@
     /*
      * If the above measurement was taken on a different CPU than the one we
-     * started the rprocess on, cTscTicksElapsed will need to be adjusted with
+     * started the process on, cTscTicksElapsed will need to be adjusted with
      * the TSC deltas of both the CPUs.
      *
@@ -896 +899 @@
          * calculations.
          */
-        else if (cNsElapsed <= GIP_TSC_REFINE_PREIOD_IN_SECS * 5 * RT_NS_1SEC_64)
+        else if (cNsElapsed <= GIP_TSC_REFINE_PERIOD_IN_SECS * 5 * RT_NS_1SEC_64)
         {
             int rc = RTTimerStart(pTimer, RT_NS_1SEC);
@@ -905 +908 @@
         {
             SUPR0Printf("vboxdrv: Failed to refine invariant TSC frequency because deltas are unavailable after %u (%u) seconds\n",
-                        (uint32_t)(cNsElapsed / RT_NS_1SEC), GIP_TSC_REFINE_PREIOD_IN_SECS);
+                        (uint32_t)(cNsElapsed / RT_NS_1SEC), GIP_TSC_REFINE_PERIOD_IN_SECS);
             SUPR0Printf("vboxdrv: start: %u, %u, %#llx  stop: %u, %u, %#llx\n",
                         iStartCpuSet, iStartGipCpu, iStartTscDelta, iStopCpuSet, iStopGipCpu, iStopTscDelta);
@@ -927 +930 @@
          * Reschedule the timer if we haven't yet reached the defined refinement period.
          */
-        if (cNsElapsed < GIP_TSC_REFINE_PREIOD_IN_SECS * RT_NS_1SEC_64)
+        if (cNsElapsed < GIP_TSC_REFINE_PERIOD_IN_SECS * RT_NS_1SEC_64)
         {
             int rc = RTTimerStart(pTimer, RT_NS_1SEC);
@@ -980 +983 @@
      * first VMs before we're done.  On most systems we will be loading the
      * support driver during boot and VMs won't be started for a while yet,
-     * it is really only a problem during development (especiall with
+     * it is really only a problem during development (especially with
      * on-demand driver starting on windows).
      *
-     * To avoid wasting time doing a long supdrvGipInitMeasureTscFreq call
-     * to calculate the frequencey during driver loading, the timer is set
+     * To avoid wasting time doing a long supdrvGipInitMeasureTscFreq() call
+     * to calculate the frequency during driver loading, the timer is set
      * to fire after 200 ms the first time. It will then reschedule itself
-     * to fire every second until GIP_TSC_REFINE_PREIOD_IN_SECS has been
+     * to fire every second until GIP_TSC_REFINE_PERIOD_IN_SECS has been
      * reached or it notices that there is a user land client with GIP
      * mapped (we want a stable frequency for all VMs).
@@ -1292 +1295 @@
 
     AssertPtrReturnVoid(pGip);
+    Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
     AssertRelease(idCpu == RTMpCpuId());
     Assert(pGip->cPossibleCpus == RTMpGetCount());
@@ -1333 +1337 @@
     ASMAtomicWriteU16(&pGip->aiCpuFromCpuSetIdx[iCpuSet], i);
 
+    /* Add this CPU to this set of CPUs we need to calculate the TSC-delta for. */
+    RTCpuSetAddByIndex(&pDevExt->TscDeltaCpuSet, RTMpCpuIdToSetIndex(idCpu));
+
     /* Update the Mp online/offline counter. */
     ASMAtomicIncU32(&pDevExt->cMpOnOffEvents);
 
-    /* Add this CPU to the set of CPUs for which we need to calculate their TSC-deltas. */
-    if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED)
-    {
-        RTCpuSetAddByIndex(&pDevExt->TscDeltaCpuSet, iCpuSet);
-#ifdef SUPDRV_USE_TSC_DELTA_THREAD
-        RTSpinlockAcquire(pDevExt->hTscDeltaSpinlock);
-        if (   pDevExt->enmTscDeltaThreadState == kTscDeltaThreadState_Listening
-            || pDevExt->enmTscDeltaThreadState == kTscDeltaThreadState_Measuring)
-        {
-            pDevExt->enmTscDeltaThreadState = kTscDeltaThreadState_WaitAndMeasure;
-        }
-        RTSpinlockRelease(pDevExt->hTscDeltaSpinlock);
-#endif
-    }
-
-    /* commit it */
+    /* Commit it. */
     ASMAtomicWriteSize(&pGip->aCPUs[i].enmState, SUPGIPCPUSTATE_ONLINE);
 
     RTSpinlockRelease(pDevExt->hGipSpinlock);
+}
+
+
+/**
+ * RTMpOnSpecific callback wrapper for supdrvGipMpEventOnlineOrInitOnCpu().
+ *
+ * @param   idCpu     The CPU ID we are running on.
+ * @param   pvUser1    Opaque pointer to the device instance data.
+ * @param   pvUser2    Not used.
+ */
+static DECLCALLBACK(void) supdrvGipMpEventOnlineCallback(RTCPUID idCpu, void *pvUser1, void *pvUser2)
+{
+    PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pvUser1;
+    NOREF(pvUser2);
+    supdrvGipMpEventOnlineOrInitOnCpu(pDevExt, idCpu);
 }
 
@@ -1396 +1403 @@
     }
 
-    /* commit it */
+    /* Commit it. */
     ASMAtomicWriteSize(&pGip->aCPUs[i].enmState, SUPGIPCPUSTATE_OFFLINE);
 
@@ -1412 +1419 @@
  * @param   idCpu       The cpu it applies to.
  * @param   pvUser      Pointer to the device extension.
- *
- * @remarks This function -must- fire on the newly online'd CPU for the
- *          RTMPEVENT_ONLINE case and can fire on any CPU for the
- *          RTMPEVENT_OFFLINE case.
  */
 static DECLCALLBACK(void) supdrvGipMpEvent(RTMPEVENT enmEvent, RTCPUID idCpu, void *pvUser)
@@ -1422 +1425 @@
     PSUPGLOBALINFOPAGE  pGip    = pDevExt->pGip;
 
-    AssertRelease(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
-
-    /*
-     * Update the GIP CPU data.
-     */
     if (pGip)
     {
+        RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
         switch (enmEvent)
         {
             case RTMPEVENT_ONLINE:
-                AssertRelease(idCpu == RTMpCpuId());
-                supdrvGipMpEventOnlineOrInitOnCpu(pDevExt, idCpu);
+            {
+                RTThreadPreemptDisable(&PreemptState);
+                if (idCpu == RTMpCpuId())
+                {
+                    supdrvGipMpEventOnlineOrInitOnCpu(pDevExt, idCpu);
+                    RTThreadPreemptRestore(&PreemptState);
+                }
+                else
+                {
+                    RTThreadPreemptRestore(&PreemptState);
+                    RTMpOnSpecific(idCpu, supdrvGipMpEventOnlineCallback, pDevExt, NULL /* pvUser2 */);
+                }
+
+                /*
+                 * Recompute TSC-delta for the newly online'd CPU.
+                 */
+                if (pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED)
+                {
+#ifdef SUPDRV_USE_TSC_DELTA_THREAD
+                    supdrvTscDeltaThreadStartMeasurement(pDevExt);
+#else
+                    uint32_t iCpu = supdrvGipFindOrAllocCpuIndexForCpuId(pGip, idCpu);
+                    supdrvMeasureTscDeltaOne(pDevExt, iCpu);
+#endif
+                }
                 break;
+            }
+
             case RTMPEVENT_OFFLINE:
                 supdrvGipMpEventOffline(pDevExt, idCpu);
@@ -1689 +1713 @@
     ASMAtomicWriteU16(&pCpu->idApic,    UINT16_MAX);
 
-    /* 
+    /*
      * The first time we're called, we don't have a CPU frequency handy,
      * so pretend it's a 4 GHz CPU.  On CPUs that are online, we'll get
@@ -1873 +1897 @@
      * If we're in any of the other two modes, neither which require MP init,
      * notifications or deltas for the job, do the full measurement now so
-     * that supdrvGipInitOnCpu can populate the TSC interval and history
+     * that supdrvGipInitOnCpu() can populate the TSC interval and history
      * array with more reasonable values.
      */
     if (pGip->u32Mode == SUPGIPMODE_INVARIANT_TSC)
     {
-        rc = supdrvGipInitMeasureTscFreq(pDevExt, pGip, true /*fRough*/); /* cannot fail */
+        rc = supdrvGipInitMeasureTscFreq(pDevExt, pGip, true /* fRough */); /* cannot fail */
         supdrvGipInitStartTimerForRefiningInvariantTscFreq(pDevExt, pGip);
     }
     else
-        rc = supdrvGipInitMeasureTscFreq(pDevExt, pGip, false /*fRough*/);
+        rc = supdrvGipInitMeasureTscFreq(pDevExt, pGip, false /* fRough */);
     if (RT_SUCCESS(rc))
     {
@@ -1910 +1934 @@
                 {
 #ifdef SUPDRV_USE_TSC_DELTA_THREAD
-                    if (pDevExt->hTscDeltaThread != NIL_RTTHREAD)
-                        RTThreadUserSignal(pDevExt->hTscDeltaThread);
+                    supdrvTscDeltaThreadStartMeasurement(pDevExt);
 #else
                     uint16_t iCpu;
@@ -2432 +2455 @@
 
     ASMSetFlags(uFlags);
-
-#ifdef SUPDRV_USE_TSC_DELTA_THREAD
-    if (   pGip->enmUseTscDelta > SUPGIPUSETSCDELTA_ZERO_CLAIMED
-        && !RTCpuSetIsEmpty(&pDevExt->TscDeltaCpuSet))
-    {
-        RTSpinlockAcquire(pDevExt->hTscDeltaSpinlock);
-        if (   pDevExt->enmTscDeltaThreadState == kTscDeltaThreadState_Listening
-            || pDevExt->enmTscDeltaThreadState == kTscDeltaThreadState_Measuring)
-            pDevExt->enmTscDeltaThreadState = kTscDeltaThreadState_WaitAndMeasure;
-        RTSpinlockRelease(pDevExt->hTscDeltaSpinlock);
-        /** @todo Do the actual poking using -- RTThreadUserSignal() */
-    }
-#endif
 }
 
@@ -2577 +2587 @@
 
 /**
- * Argument package/state passed by supdrvMeasureTscDeltaOne to the RTMpOn
+ * Argument package/state passed by supdrvMeasureTscDeltaOne() to the RTMpOn
  * callback worker.
  */
@@ -3157 +3167 @@
  * The idea here is that we have the two CPUs execute the exact same code
  * collecting a largish set of TSC samples.  The code has one data dependency on
- * the other CPU which intention it is to synchronize the execution as well as
- * help cross references the two sets of TSC samples (the sequence numbers).
+ * the other CPU with the intention to synchronize the execution as well
+ * as help cross references the two sets of TSC samples (the sequence numbers).
  *
  * The @a fLag parameter is used to modify the execution a tiny bit on one or
@@ -3811 +3821 @@
          */
         PSUPDRVGIPTSCDELTARGS pArgs = (PSUPDRVGIPTSCDELTARGS)RTMemAllocZ(sizeof(*pArgs));
-        if (pArgs)
+        if (RT_LIKELY(pArgs))
         {
             pArgs->pWorker      = pGipCpuWorker;
@@ -4106 +4116 @@
                 RTSpinlockRelease(pDevExt->hTscDeltaSpinlock);
                 pDevExt->cMsTscDeltaTimeout = 1;
-                RTThreadSleep(10);
+                RTThreadSleep(1);
                 /* fall thru */
             }
@@ -4256 +4266 @@
 
 /**
- * Waits for TSC-delta measurements to be completed for all online CPUs.
- *
- * @returns VBox status code.
- * @param   pDevExt         Pointer to the device instance data.
- */
-static int supdrvTscDeltaThreadWaitForOnlineCpus(PSUPDRVDEVEXT pDevExt)
-{
-    int cTriesLeft = 5;
-    int cMsTotalWait;
-    int cMsWaited = 0;
-    int cMsWaitGranularity = 1;
-
-    PSUPGLOBALINFOPAGE pGip = pDevExt->pGip;
-    AssertReturn(pGip, VERR_INVALID_POINTER);
-
-    if (RT_UNLIKELY(pDevExt->hTscDeltaThread == NIL_RTTHREAD))
-        return VERR_THREAD_NOT_WAITABLE;
-
-    cMsTotalWait = RT_MIN(pGip->cPresentCpus + 10, 200);
-    while (cTriesLeft-- > 0)
-    {
-        if (RTCpuSetIsEqual(&pDevExt->TscDeltaObtainedCpuSet, &pGip->OnlineCpuSet))
-            return VINF_SUCCESS;
-        RTThreadSleep(cMsWaitGranularity);
-        cMsWaited += cMsWaitGranularity;
-        if (cMsWaited >= cMsTotalWait)
-            break;
-    }
-
-    return VERR_TIMEOUT;
+ * Signals the TSC-delta thread to start measuring TSC-deltas.
+ *
+ * @param   pDevExt     Pointer to the device instance data.
+ */
+static void supdrvTscDeltaThreadStartMeasurement(PSUPDRVDEVEXT pDevExt)
+{
+    if (RT_LIKELY(pDevExt->hTscDeltaThread != NIL_RTTHREAD))
+    {
+        RTSpinlockAcquire(pDevExt->hTscDeltaSpinlock);
+        if (   pDevExt->enmTscDeltaThreadState == kTscDeltaThreadState_Listening
+            || pDevExt->enmTscDeltaThreadState == kTscDeltaThreadState_Measuring)
+        {
+            pDevExt->enmTscDeltaThreadState = kTscDeltaThreadState_WaitAndMeasure;
+        }
+        RTSpinlockRelease(pDevExt->hTscDeltaSpinlock);
+        RTThreadUserSignal(pDevExt->hTscDeltaThread);
+    }
 }
 
@@ -4457 +4454 @@
         return VERR_INVALID_FLAGS;
 
+    /*
+     * The request is a noop if the TSC delta isn't being used.
+     */
+    if (pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ZERO_CLAIMED)
+        return VINF_SUCCESS;
+
     if (cTries == 0)
         cTries = 12;
@@ -4466 +4469 @@
     else if (cMsWaitRetry > 1000)
         cMsWaitRetry = 1000;
-
-    /*
-     * The request is a noop if the TSC delta isn't being used.
-     */
-    if (pGip->enmUseTscDelta <= SUPGIPUSETSCDELTA_ZERO_CLAIMED)
-        return VINF_SUCCESS;
 
 #ifdef SUPDRV_USE_TSC_DELTA_THREAD
@@ -4497 +4494 @@
             rc = VINF_SUCCESS;
         }
-        else
+        else if (pDevExt->enmTscDeltaThreadState != kTscDeltaThreadState_WaitAndMeasure)
             rc = VERR_THREAD_IS_DEAD;
         RTSpinlockRelease(pDevExt->hTscDeltaSpinlock);
@@ -4613 +4610 @@
 
     return SUPR0TscDeltaMeasureBySetIndex(pSession, iCpuSet, fFlags, cMsWaitRetry,
-                                          cTries == 0 ? 5*RT_MS_1SEC : cMsWaitRetry * cTries /*cMsWaitThread*/,
+                                          cTries == 0 ? 5 * RT_MS_1SEC : cMsWaitRetry * cTries /*cMsWaitThread*/,
                                           cTries);
 }
@@ -4691 +4688 @@
                 rc = supdrvMeasureTscDeltaOne(pDevExt, iGipCpu);
                 Assert(pGip->aCPUs[iGipCpu].i64TSCDelta != INT64_MAX || RT_FAILURE_NP(rc));
-                /** @todo should probably delay on failure... dpc watchdogs   */
+                /** @todo should probably delay on failure... dpc watchdogs */
             }
             else

trunk/src/VBox/Runtime/r0drv/linux/mpnotification-r0drv-linux.c

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2008-2011 Oracle Corporation
+ * Copyright (C) 2008-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -32 +32 @@
 #include "internal/iprt.h"
 
-#include <iprt/mp.h>
 #include <iprt/asm-amd64-x86.h>
 #include <iprt/err.h>
@@ -70 +69 @@
 
 /**
- * Notification wrapper that updates CPU states and invokes our notification
- * callbacks.
- *
- * @param idCpu             The CPU Id.
- * @param pvUser1           Pointer to the notifier_block (unused).
- * @param pvUser2           The notification event.
- * @remarks This can be invoked in interrupt context.
- */
-static DECLCALLBACK(void) rtMpNotificationLinuxOnCurrentCpu(RTCPUID idCpu, void *pvUser1, void *pvUser2)
-{
-    unsigned long ulNativeEvent = *(unsigned long *)pvUser2;
-    NOREF(pvUser1);
-
-    AssertRelease(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
-    AssertReleaseMsg(idCpu == RTMpCpuId(),  /* ASSUMES iCpu == RTCPUID */
-                     ("idCpu=%u RTMpCpuId=%d ApicId=%d\n", idCpu, RTMpCpuId(), ASMGetApicId() ));
-
-    switch (ulNativeEvent)
-    {
-# ifdef CPU_DOWN_FAILED
-        case CPU_DOWN_FAILED:
-#  if defined(CPU_TASKS_FROZEN) && defined(CPU_DOWN_FAILED_FROZEN)
-        case CPU_DOWN_FAILED_FROZEN:
-#  endif
-# endif
-        case CPU_ONLINE:
-# if defined(CPU_TASKS_FROZEN) && defined(CPU_ONLINE_FROZEN)
-        case CPU_ONLINE_FROZEN:
-# endif
-            rtMpNotificationDoCallbacks(RTMPEVENT_ONLINE, idCpu);
-            break;
-
-# ifdef CPU_DOWN_PREPARE
-        case CPU_DOWN_PREPARE:
-#  if defined(CPU_TASKS_FROZEN) && defined(CPU_DOWN_PREPARE_FROZEN)
-        case CPU_DOWN_PREPARE_FROZEN:
-#  endif
-            rtMpNotificationDoCallbacks(RTMPEVENT_OFFLINE, idCpu);
-            break;
-# endif
-    }
-}
-
-
-/**
  * The native callback.
  *
@@ -121 +75 @@
  * @param   ulNativeEvent   The native event.
  * @param   pvCpu           The cpu id cast into a pointer value.
+ *
  * @remarks This can fire with preemption enabled and on any CPU.
  */
 static int rtMpNotificationLinuxCallback(struct notifier_block *pNotifierBlock, unsigned long ulNativeEvent, void *pvCpu)
 {
-    int rc;
     bool fProcessEvent = false;
     RTCPUID idCpu      = (uintptr_t)pvCpu;
@@ -188 +142 @@
         return NOTIFY_DONE;
 
-    /*
-     * Reschedule the callbacks to fire on the specific CPU with preemption disabled.
-     */
-    rc = RTMpOnSpecific(idCpu, rtMpNotificationLinuxOnCurrentCpu, pNotifierBlock, &ulNativeEvent);
-    Assert(RT_SUCCESS(rc)); NOREF(rc);
+    switch (ulNativeEvent)
+    {
+# ifdef CPU_DOWN_FAILED
+        case CPU_DOWN_FAILED:
+#  if defined(CPU_TASKS_FROZEN) && defined(CPU_DOWN_FAILED_FROZEN)
+        case CPU_DOWN_FAILED_FROZEN:
+#  endif
+# endif
+        case CPU_ONLINE:
+# if defined(CPU_TASKS_FROZEN) && defined(CPU_ONLINE_FROZEN)
+        case CPU_ONLINE_FROZEN:
+# endif
+            rtMpNotificationDoCallbacks(RTMPEVENT_ONLINE, idCpu);
+            break;
+
+# ifdef CPU_DOWN_PREPARE
+        case CPU_DOWN_PREPARE:
+#  if defined(CPU_TASKS_FROZEN) && defined(CPU_DOWN_PREPARE_FROZEN)
+        case CPU_DOWN_PREPARE_FROZEN:
+#  endif
+            rtMpNotificationDoCallbacks(RTMPEVENT_OFFLINE, idCpu);
+            break;
+# endif
+    }
+
     return NOTIFY_DONE;
 }

trunk/src/VBox/Runtime/r0drv/solaris/mpnotification-r0drv-solaris.c

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2008-2012 Oracle Corporation
+ * Copyright (C) 2008-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -64 +64 @@
 
 /**
- * PFNRTMPWORKER worker for executing Mp events on the target CPU.
- *
- * @param    idCpu          The current CPU Id.
- * @param    pvArg          Opaque pointer to event type (online/offline).
- * @param    pvIgnored1     Ignored.
- */
-static void rtMpNotificationSolOnCurrentCpu(RTCPUID idCpu, void *pvArg, void *pvIgnored1)
-{
-    NOREF(pvIgnored1);
-    NOREF(idCpu);
-
-    PRTMPARGS pArgs = (PRTMPARGS)pvArg;
-    AssertRelease(pArgs && pArgs->idCpu == RTMpCpuId());
-    Assert(pArgs->pvUser1);
-    Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
-
-    RTMPEVENT enmMpEvent = *(RTMPEVENT *)pArgs->pvUser1;
-    rtMpNotificationDoCallbacks(enmMpEvent, pArgs->idCpu);
-}
-
-
-/**
  * Solaris callback function for Mp event notification.
  *
+ * @returns Solaris error code.
  * @param    CpuState   The current event/state of the CPU.
- * @param    iCpu       Which CPU is this event fore.
+ * @param    iCpu       Which CPU is this event for.
  * @param    pvArg      Ignored.
  *
  * @remarks This function assumes index == RTCPUID.
- * @returns Solaris error code.
+ *          We may -not- be firing on the CPU going online/offline and called
+ *          with preemption enabled.
  */
 static int rtMpNotificationCpuEvent(cpu_setup_t CpuState, int iCpu, void *pvArg)
 {
     RTMPEVENT enmMpEvent;
-
-    RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
-    RTThreadPreemptDisable(&PreemptState);
 
     /*
@@ -119 +96 @@
         return 0;
 
-    /*
-     * Since we don't absolutely need to do CPU bound code in any of the CPU offline
-     * notification hooks, run it on the current CPU. Scheduling a callback to execute
-     * on the CPU going offline at this point is too late and will not work reliably.
-     */
-    bool fRunningOnTargetCpu = iCpu == RTMpCpuId();
-    if (   fRunningOnTargetCpu == true
-        || enmMpEvent == RTMPEVENT_OFFLINE)
-    {
-        rtMpNotificationDoCallbacks(enmMpEvent, iCpu);
-    }
-    else
-    {
-        /** @todo We should probably be using thread_affinity_set() here, see
-         *        cpu_online() code. */
-        /*
-         * We're not on the target CPU, schedule (synchronous) the event notification callback
-         * to run on the target CPU i.e. the CPU that was online'd.
-         */
-        RTMPARGS Args;
-        RT_ZERO(Args);
-        Args.pvUser1 = &enmMpEvent;
-        Args.pvUser2 = NULL;
-        Args.idCpu   = iCpu;
-        RTMpOnSpecific(iCpu, rtMpNotificationSolOnCurrentCpu, &Args, NULL /* pvIgnored1 */);
-    }
-
-    RTThreadPreemptRestore(&PreemptState);
-
+    rtMpNotificationDoCallbacks(enmMpEvent, iCpu);
     NOREF(pvArg);
     return 0;

trunk/src/VBox/VMM/VMMR0/HMR0.cpp

@@ -994 +994 @@
  *
  * @returns VBox status code.
- * @param   idCpu       The identifier for the CPU the function is called on.
+ * @param   idCpu       The identifier for the CPU this function is called on.
  *
  * @remarks Must be called with preemption disabled.
@@ -1007 +1007 @@
     Assert(idCpu < RT_ELEMENTS(g_HvmR0.aCpuInfo));
     Assert(!pCpu->fConfigured || pCpu->hMemObj != NIL_RTR0MEMOBJ);
+    AssertRelease(idCpu == RTMpCpuId());
 
     if (pCpu->hMemObj == NIL_RTR0MEMOBJ)
@@ -1012 +1013 @@
 
     int rc;
-    if (   pCpu->fConfigured
-        && idCpu == RTMpCpuId())    /* We may not be firing on the CPU being disabled/going offline. */
+    if (pCpu->fConfigured)
     {
         void    *pvCpuPage     = RTR0MemObjAddress(pCpu->hMemObj);
@@ -1043 +1043 @@
     AssertReturnVoid(g_HvmR0.fGlobalInit);
     hmR0FirstRcSetStatus(pFirstRc, hmR0DisableCpu(idCpu));
+}
+
+
+/**
+ * Worker function passed to RTMpOnSpecific() that is to be called on the target
+ * CPU.
+ *
+ * @param   idCpu       The identifier for the CPU the function is called on.
+ * @param   pvUser1     Null, not used.
+ * @param   pvUser2     Null, not used.
+ */
+static DECLCALLBACK(void) hmR0DisableCpuOnSpecificCallback(RTCPUID idCpu, void *pvUser1, void *pvUser2)
+{
+    NOREF(pvUser1);
+    NOREF(pvUser2);
+    hmR0DisableCpu(idCpu);
 }
 
@@ -1061 +1077 @@
      * CPU comes online, the initialization is done lazily in HMR0Enter().
      */
-    Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
     switch (enmEvent)
     {
         case RTMPEVENT_OFFLINE:
         {
-            int rc = hmR0DisableCpu(idCpu);
-            AssertRC(rc);
+            RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
+            RTThreadPreemptDisable(&PreemptState);
+            if (idCpu == RTMpCpuId())
+            {
+                int rc = hmR0DisableCpu(idCpu);
+                AssertRC(rc);
+                RTThreadPreemptRestore(&PreemptState);
+            }
+            else
+            {
+                RTThreadPreemptRestore(&PreemptState);
+                RTMpOnSpecific(idCpu, hmR0DisableCpuOnSpecificCallback, NULL /* pvUser1 */, NULL /* pvUser2 */);
+            }
             break;
         }