Changeset 48044 in vbox for trunk/src/VBox/VMM/VMMR0

Timestamp:

Aug 25, 2013 7:21:27 PM (11 years ago)

Author:

vboxsync

Message:

VMM/HM: Thread-context hooks, disable preemption while touching host state on VM-exits. AMD-V still todo.

Location:

trunk/src/VBox/VMM/VMMR0

Files:

• HMR0.cpp (modified) (1 diff)
• HMSVMR0.cpp (modified) (2 diffs)
• HMVMXR0.cpp (modified) (9 diffs)
• VMMR0.cpp (modified) (2 diffs)

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

@@ -1492 +1492 @@
  * @returns VBox status code.
  * @param   pVCpu       Pointer to the VMCPU.
+ *
+ * @remarks No-long-jump zone!!!
  */
 VMMR0_INT_DECL(int) HMR0LeaveCpu(PVMCPU pVCpu)

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

@@ -1947 +1947 @@
 DECLINLINE(void) hmR0SvmLeaveSession(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
 {
+    HM_DISABLE_PREEMPT_IF_NEEDED();
     Assert(!VMMRZCallRing3IsEnabled(pVCpu));
-
-    /* Avoid repeating this work when thread-context hooks are used and we had been preempted before
-       which would've done this work from the VMXR0ThreadCtxCallback(). */
-    RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
-    bool fPreemptDisabled = false;
-    if (RTThreadPreemptIsEnabled(NIL_RTTHREAD))
-    {
-        Assert(VMMR0ThreadCtxHooksAreRegistered(pVCpu));
-        RTThreadPreemptDisable(&PreemptState);
-        fPreemptDisabled = true;
-    }
-
+    Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
+
+    /* When thread-context hooks are used, we can avoid doing the leave again if we had been preempted before
+       and done this from the VMXR0ThreadCtxCallback(). */
     if (!pVCpu->hm.s.fLeaveDone)
     {
@@ -1976 +1969 @@
     AssertRC(rc); NOREF(rc);
 
-    /* Restore preemption if we previous disabled it ourselves. */
-    if (fPreemptDisabled)
-        RTThreadPreemptRestore(&PreemptState);
+    HM_RESTORE_PREEMPT_IF_NEEDED();
 }
 

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

@@ -6089 +6089 @@
 static void hmR0VmxLeave(PVM pVM, PVMCPU pVCpu, PCPUMCTX pMixedCtx)
 {
+    Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
     Assert(!VMMRZCallRing3IsEnabled(pVCpu));
     Assert(VMMR0IsLogFlushDisabled(pVCpu));
@@ -6160 +6161 @@
 DECLINLINE(void) hmR0VmxLeaveSession(PVM pVM, PVMCPU pVCpu, PCPUMCTX pMixedCtx)
 {
+    HM_DISABLE_PREEMPT_IF_NEEDED();
     Assert(!VMMRZCallRing3IsEnabled(pVCpu));
-
-    RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
-    bool fPreemptDisabled = false;
-    if (RTThreadPreemptIsEnabled(NIL_RTTHREAD))
-    {
-        Assert(VMMR0ThreadCtxHooksAreRegistered(pVCpu));
-        RTThreadPreemptDisable(&PreemptState);
-        fPreemptDisabled = true;
-    }
-
-    /* Avoid repeating this work when thread-context hooks are used and we had been preempted before
-       which would've done this work from the VMXR0ThreadCtxCallback(). */
+    Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
+
+    /* When thread-context hooks are used, we can avoid doing the leave again if we had been preempted before
+       and done this from the VMXR0ThreadCtxCallback(). */
     if (!pVCpu->hm.s.fLeaveDone)
     {
@@ -6189 +6183 @@
     AssertRC(rc); NOREF(rc);
 
-    /* Restore preemption if we previous disabled it ourselves. */
-    if (fPreemptDisabled)
-        RTThreadPreemptRestore(&PreemptState);
+    HM_RESTORE_PREEMPT_IF_NEEDED();
 }
 
@@ -9660 +9652 @@
         {
             STAM_COUNTER_INC(&pVCpu->hm.s.StatDRxIoCheck);
+
+            /* We're playing with the host CPU state here, make sure we don't preempt. */
+            HM_DISABLE_PREEMPT_IF_NEEDED();
             bool fIsGuestDbgActive = CPUMR0DebugStateMaybeSaveGuest(pVCpu, true /*fDr6*/);
 
@@ -9677 +9672 @@
                      && (rcStrict == VINF_SUCCESS || rcStrict2 < rcStrict))
                 rcStrict = rcStrict2;
+
+            HM_RESTORE_PREEMPT_IF_NEEDED();
         }
     }
@@ -9882 +9879 @@
         }
 
+        /* We're playing with the host CPU state here, make sure we can't preempt. */
+        HM_DISABLE_PREEMPT_IF_NEEDED();
+
         /* Save the host & load the guest debug state, restart execution of the MOV DRx instruction. */
         PVM pVM = pVCpu->CTX_SUFF(pVM);
         CPUMR0LoadGuestDebugState(pVCpu, true /* include DR6 */);
         Assert(CPUMIsGuestDebugStateActive(pVCpu));
+
+        HM_RESTORE_PREEMPT_IF_NEEDED();
 
 #ifdef VBOX_WITH_STATISTICS
@@ -10148 +10150 @@
          * (See Intel spec. 27.1 "Architectural State before a VM-Exit".)
          */
+        HM_DISABLE_PREEMPT_IF_NEEDED();
+
         pMixedCtx->dr[6] &= ~X86_DR6_B_MASK;
         pMixedCtx->dr[6] |= uDR6;
         if (CPUMIsGuestDebugStateActive(pVCpu))
             ASMSetDR6(pMixedCtx->dr[6]);
+
+        HM_RESTORE_PREEMPT_IF_NEEDED();
 
         rc = hmR0VmxSaveGuestDR7(pVCpu, pMixedCtx);
@@ -10206 +10212 @@
     AssertRCReturn(rc, rc);
 
+    /* We're playing with the host CPU state here, have to disable preemption. */
+    HM_DISABLE_PREEMPT_IF_NEEDED();
+
     /* Lazy FPU loading; load the guest-FPU state transparently and continue execution of the guest. */
     PVM pVM = pVCpu->CTX_SUFF(pVM);
@@ -10212 +10221 @@
     {
         Assert(CPUMIsGuestFPUStateActive(pVCpu));
+        HM_RESTORE_PREEMPT_IF_NEEDED();
+
         pVCpu->hm.s.fContextUseFlags |= HM_CHANGED_GUEST_CR0;
         STAM_COUNTER_INC(&pVCpu->hm.s.StatExitShadowNM);
         return VINF_SUCCESS;
     }
+
+    HM_RESTORE_PREEMPT_IF_NEEDED();
 
     /* Forward #NM to the guest. */

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

@@ -901 +901 @@
         {
 #ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
+            Assert(!VMMR0ThreadCtxHooksAreRegistered(pVCpu));
             RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
             RTThreadPreemptDisable(&PreemptState);
@@ -940 +941 @@
                 /* Enter HM context. */
                 rc = HMR0Enter(pVM, pVCpu);
-
-                /* When preemption hooks are in place, enable preemption now that we're in HM context. */
-                if (VMMR0ThreadCtxHooksAreRegistered(pVCpu))
-                {
-                    fPreemptRestored = true;
-                    RTThreadPreemptRestore(&PreemptState);
-                }
-
                 if (RT_SUCCESS(rc))
                 {
                     VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED_HM);
 
+                    /* When preemption hooks are in place, enable preemption now that we're in HM context. */
+                    if (VMMR0ThreadCtxHooksAreRegistered(pVCpu))
+                    {
+                        fPreemptRestored = true;
+                        RTThreadPreemptRestore(&PreemptState);
+                    }
+
                     /* Setup the longjmp machinery and execute guest code. */
                     rc = vmmR0CallRing3SetJmp(&pVCpu->vmm.s.CallRing3JmpBufR0, HMR0RunGuestCode, pVM, pVCpu);
 
-                    /* Leave HM context. This deregisters thread-context hooks if any. */
+                    /* Leave HM context. */
                     int rc2 = HMR0Leave(pVM, pVCpu);
                     AssertRC(rc2);