Changeset 61643 in vbox

Timestamp:

Jun 10, 2016 1:07:04 AM (8 years ago)

Author:

vboxsync

Message:

EM,VMM: Attempt at dealing with guru meditations in SMP VMs.

Location:

trunk

Files:

• include/VBox/vmm/vmapi.h (modified) (1 diff)
• src/VBox/VMM/VMMR3/EM.cpp (modified) (5 diffs)
• src/VBox/VMM/VMMR3/VM.cpp (modified) (12 diffs)
• src/VBox/VMM/VMMR3/VMEmt.cpp (modified) (1 diff)
• src/VBox/VMM/include/VMInternal.h (modified) (1 diff)

trunk/include/VBox/vmm/vmapi.h

@@ -437 +437 @@
 VMMR3DECL(int)          VMR3AtStateRegister(PUVM pUVM, PFNVMATSTATE pfnAtState, void *pvUser);
 VMMR3DECL(int)          VMR3AtStateDeregister(PUVM pUVM, PFNVMATSTATE pfnAtState, void *pvUser);
+VMMR3_INT_DECL(bool)    VMR3SetGuruMeditation(PVM pVM);
 VMMR3_INT_DECL(bool)    VMR3TeleportedAndNotFullyResumedYet(PVM pVM);
 VMMR3DECL(int)          VMR3AtErrorRegister(PUVM pUVM, PFNVMATERROR pfnAtError, void *pvUser);

trunk/src/VBox/VMM/VMMR3/EM.cpp

@@ -1695 +1695 @@
                 case VMSTATE_FATAL_ERROR:
                 case VMSTATE_FATAL_ERROR_LS:
+                case VMSTATE_GURU_MEDITATION:
+                case VMSTATE_GURU_MEDITATION_LS:
                     Log2(("emR3ForcedActions: %s -> VINF_EM_SUSPEND\n", VMGetStateName(enmState) ));
                     STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
@@ -2036 +2038 @@
                 case VMSTATE_FATAL_ERROR:
                 case VMSTATE_FATAL_ERROR_LS:
+                case VMSTATE_GURU_MEDITATION:
+                case VMSTATE_GURU_MEDITATION_LS:
                     Log2(("emR3ForcedActions: %s -> VINF_EM_SUSPEND\n", VMGetStateName(enmState) ));
                     STAM_REL_PROFILE_STOP(&pVCpu->em.s.StatForcedActions, a);
@@ -2655 +2659 @@
                             /* switch to guru meditation mode */
                             pVCpu->em.s.enmState = EMSTATE_GURU_MEDITATION;
+                            VMR3SetGuruMeditation(pVM); /* This notifies the other EMTs. */
                             VMMR3FatalDump(pVM, pVCpu, rc);
                         }
@@ -2672 +2677 @@
                 {
                     TMR3NotifySuspend(pVM, pVCpu);
+                    VMR3SetGuruMeditation(pVM); /* This notifies the other EMTs. */
                     VMMR3FatalDump(pVM, pVCpu, rc);
                     emR3Debug(pVM, pVCpu, rc);
@@ -2701 +2707 @@
         Log(("EMR3ExecuteVM: returns %Rrc because of longjmp / fatal error; (state %s / %s)\n", rc, emR3GetStateName(pVCpu->em.s.enmState), emR3GetStateName(pVCpu->em.s.enmPrevState)));
         TMR3NotifySuspend(pVM, pVCpu);
+        VMR3SetGuruMeditation(pVM); /* This notifies the other EMTs. */
         VMMR3FatalDump(pVM, pVCpu, rc);
         emR3Debug(pVM, pVCpu, rc);

trunk/src/VBox/VMM/VMMR3/VM.cpp

@@ -123 +123 @@
 static void                 vmR3DoAtState(PVM pVM, PUVM pUVM, VMSTATE enmStateNew, VMSTATE enmStateOld);
 static int                  vmR3TrySetState(PVM pVM, const char *pszWho, unsigned cTransitions, ...);
-static void                 vmR3SetStateLocked(PVM pVM, PUVM pUVM, VMSTATE enmStateNew, VMSTATE enmStateOld);
+static void                 vmR3SetStateLocked(PVM pVM, PUVM pUVM, VMSTATE enmStateNew, VMSTATE enmStateOld, bool fSetRatherThanClearFF);
 static void                 vmR3SetState(PVM pVM, VMSTATE enmStateNew, VMSTATE enmStateOld);
 static int                  vmR3SetErrorU(PUVM pUVM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(6, 7);
@@ -1595 +1595 @@
         {
             case VMSTATE_RUNNING_LS:
-                vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDING_LS, VMSTATE_RUNNING_LS);
+                vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDING_LS, VMSTATE_RUNNING_LS, false /*fSetRatherThanClearFF*/);
                 rc = VINF_SUCCESS;
                 break;
@@ -1609 +1609 @@
 
             case VMSTATE_OFF_LS:
-                vmR3SetStateLocked(pVM, pUVM, VMSTATE_OFF, VMSTATE_OFF_LS);
+                vmR3SetStateLocked(pVM, pUVM, VMSTATE_OFF, VMSTATE_OFF_LS, false /*fSetRatherThanClearFF*/);
                 rc = VERR_SSM_LIVE_POWERED_OFF;
                 break;
 
             case VMSTATE_FATAL_ERROR_LS:
-                vmR3SetStateLocked(pVM, pUVM, VMSTATE_FATAL_ERROR, VMSTATE_FATAL_ERROR_LS);
+                vmR3SetStateLocked(pVM, pUVM, VMSTATE_FATAL_ERROR, VMSTATE_FATAL_ERROR_LS, false /*fSetRatherThanClearFF*/);
                 rc = VERR_SSM_LIVE_FATAL_ERROR;
                 break;
 
             case VMSTATE_GURU_MEDITATION_LS:
-                vmR3SetStateLocked(pVM, pUVM, VMSTATE_GURU_MEDITATION, VMSTATE_GURU_MEDITATION_LS);
+                vmR3SetStateLocked(pVM, pUVM, VMSTATE_GURU_MEDITATION, VMSTATE_GURU_MEDITATION_LS, false /*fSetRatherThanClearFF*/);
                 rc = VERR_SSM_LIVE_GURU_MEDITATION;
                 break;
@@ -2339 +2339 @@
         enmVMState = pVM->enmVMState;
         if (enmVMState == VMSTATE_POWERING_OFF_LS)
-            vmR3SetStateLocked(pVM, pUVM, VMSTATE_OFF_LS, VMSTATE_POWERING_OFF_LS);
+            vmR3SetStateLocked(pVM, pUVM, VMSTATE_OFF_LS, VMSTATE_POWERING_OFF_LS, false /*fSetRatherThanClearFF*/);
         else
-            vmR3SetStateLocked(pVM, pUVM, VMSTATE_OFF,    VMSTATE_POWERING_OFF);
+            vmR3SetStateLocked(pVM, pUVM, VMSTATE_OFF,    VMSTATE_POWERING_OFF, false /*fSetRatherThanClearFF*/);
         RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
     }
@@ -2778 +2778 @@
         {
             if (pUVM->vm.s.enmPrevVMState == VMSTATE_SUSPENDED)
-                vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDED, VMSTATE_SOFT_RESETTING);
+                vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDED, VMSTATE_SOFT_RESETTING, false /*fSetRatherThanClearFF*/);
             else
-                vmR3SetStateLocked(pVM, pUVM, VMSTATE_RUNNING,   VMSTATE_SOFT_RESETTING);
+                vmR3SetStateLocked(pVM, pUVM, VMSTATE_RUNNING,   VMSTATE_SOFT_RESETTING, false /*fSetRatherThanClearFF*/);
         }
         else
-            vmR3SetStateLocked(pVM, pUVM, VMSTATE_RUNNING_LS, VMSTATE_SOFT_RESETTING_LS);
+            vmR3SetStateLocked(pVM, pUVM, VMSTATE_RUNNING_LS, VMSTATE_SOFT_RESETTING_LS, false /*fSetRatherThanClearFF*/);
         RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
     }
@@ -2895 +2895 @@
         {
             if (pUVM->vm.s.enmPrevVMState == VMSTATE_SUSPENDED)
-                vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDED, VMSTATE_RESETTING);
+                vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDED, VMSTATE_RESETTING, false /*fSetRatherThanClearFF*/);
             else
-                vmR3SetStateLocked(pVM, pUVM, VMSTATE_RUNNING,   VMSTATE_RESETTING);
+                vmR3SetStateLocked(pVM, pUVM, VMSTATE_RUNNING,   VMSTATE_RESETTING, false /*fSetRatherThanClearFF*/);
         }
         else
-            vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDING_LS, VMSTATE_RESETTING_LS);
+            vmR3SetStateLocked(pVM, pUVM, VMSTATE_SUSPENDING_LS, VMSTATE_RESETTING_LS, false /*fSetRatherThanClearFF*/);
         RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
 
@@ -3486 +3486 @@
  * Sets the current VM state, with the AtStatCritSect already entered.
  *
- * @param   pVM                 The cross context VM structure.
- * @param   pUVM                The UVM handle.
- * @param   enmStateNew         The new state.
- * @param   enmStateOld         The old state.
- */
-static void vmR3SetStateLocked(PVM pVM, PUVM pUVM, VMSTATE enmStateNew, VMSTATE enmStateOld)
+ * @param   pVM                     The cross context VM structure.
+ * @param   pUVM                    The UVM handle.
+ * @param   enmStateNew             The new state.
+ * @param   enmStateOld             The old state.
+ * @param   fSetRatherThanClearFF   The usual behavior is to clear the
+ *                                  VM_FF_CHECK_VM_STATE force flag, but for
+ *                                  some transitions (-> guru) we need to kick
+ *                                  the other EMTs to stop what they're doing.
+ */
+static void vmR3SetStateLocked(PVM pVM, PUVM pUVM, VMSTATE enmStateNew, VMSTATE enmStateOld, bool fSetRatherThanClearFF)
 {
     vmR3ValidateStateTransition(enmStateOld, enmStateNew);
@@ -3497 +3501 @@
     AssertMsg(pVM->enmVMState == enmStateOld,
               ("%s != %s\n", VMR3GetStateName(pVM->enmVMState), VMR3GetStateName(enmStateOld)));
+
     pUVM->vm.s.enmPrevVMState = enmStateOld;
     pVM->enmVMState           = enmStateNew;
-    VM_FF_CLEAR(pVM, VM_FF_CHECK_VM_STATE);
+
+    if (!fSetRatherThanClearFF)
+        VM_FF_CLEAR(pVM, VM_FF_CHECK_VM_STATE);
+    else if (pVM->cCpus > 0)
+        VM_FF_SET(pVM, VM_FF_CHECK_VM_STATE);
 
     vmR3DoAtState(pVM, pUVM, enmStateNew, enmStateOld);
@@ -3519 +3528 @@
     AssertMsg(pVM->enmVMState == enmStateOld,
               ("%s != %s\n", VMR3GetStateName(pVM->enmVMState), VMR3GetStateName(enmStateOld)));
-    vmR3SetStateLocked(pVM, pUVM, enmStateNew, pVM->enmVMState);
+    vmR3SetStateLocked(pVM, pUVM, enmStateNew, pVM->enmVMState, false /*fSetRatherThanClearFF*/);
 
     RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
@@ -3572 +3581 @@
         if (enmStateCur == enmStateOld)
         {
-            vmR3SetStateLocked(pVM, pUVM, enmStateNew, enmStateOld);
+            vmR3SetStateLocked(pVM, pUVM, enmStateNew, enmStateOld, false /*fSetRatherThanClearFF*/);
             rc = i + 1;
             break;
@@ -3622 +3631 @@
 
 /**
- * Flag a guru meditation ... a hack.
- *
+ * Interface used by EM to signal that it's entering the guru meditation state.
+ *
+ * This will notifying other threads.
+ *
+ * @returns true if the state changed to Guru, false if no state change.
  * @param   pVM             The cross context VM structure.
- *
- * @todo    Rewrite this part. The guru meditation should be flagged
- *          immediately by the VMM and not by VMEmt.cpp when it's all over.
- */
-void vmR3SetGuruMeditation(PVM pVM)
+ */
+VMMR3_INT_DECL(bool) VMR3SetGuruMeditation(PVM pVM)
 {
     PUVM pUVM = pVM->pUVM;
@@ -3635 +3644 @@
 
     VMSTATE enmStateCur = pVM->enmVMState;
+    bool fRc = true;
     if (enmStateCur == VMSTATE_RUNNING)
-        vmR3SetStateLocked(pVM, pUVM, VMSTATE_GURU_MEDITATION, VMSTATE_RUNNING);
+        vmR3SetStateLocked(pVM, pUVM, VMSTATE_GURU_MEDITATION, VMSTATE_RUNNING, true /*fSetRatherThanClearFF*/);
     else if (enmStateCur == VMSTATE_RUNNING_LS)
     {
-        vmR3SetStateLocked(pVM, pUVM, VMSTATE_GURU_MEDITATION_LS, VMSTATE_RUNNING_LS);
+        vmR3SetStateLocked(pVM, pUVM, VMSTATE_GURU_MEDITATION_LS, VMSTATE_RUNNING_LS, true /*fSetRatherThanClearFF*/);
         SSMR3Cancel(pUVM);
     }
+    else
+        fRc = false;
 
     RTCritSectLeave(&pUVM->vm.s.AtStateCritSect);
+    return fRc;
 }
 

trunk/src/VBox/VMM/VMMR3/VMEmt.cpp

@@ -237 +237 @@
                 rc = EMR3ExecuteVM(pVM, pVCpu);
                 Log(("vmR3EmulationThread: EMR3ExecuteVM() -> rc=%Rrc, enmVMState=%d\n", rc, pVM->enmVMState));
-                if (EMGetState(pVCpu) == EMSTATE_GURU_MEDITATION)
-                    vmR3SetGuruMeditation(pVM);
             }
         }

trunk/src/VBox/VMM/include/VMInternal.h

@@ -457 +457 @@
 DECLCALLBACK(int)   vmR3SetRuntimeErrorV(PVM pVM, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list *pVa);
 void                vmSetRuntimeErrorCopy(PVM pVM, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va);
-void                vmR3SetGuruMeditation(PVM pVM);
 void                vmR3SetTerminated(PVM pVM);