Changeset 5389 in vbox for trunk/src

Timestamp:

Oct 19, 2007 4:45:07 PM (17 years ago)

Author:

vboxsync

Message:

Fully deal with CR0.EM/TS/MP changes in GC.

Location:

trunk/src/VBox/VMM/VMMAll

Files:

• CPUMAllA.asm (modified) (2 diffs)
• CPUMAllRegs.cpp (modified) (1 diff)
• EMAll.cpp (modified) (4 diffs)

trunk/src/VBox/VMM/VMMAll/CPUMAllA.asm

@@ -45 +45 @@
 
 ;;
-; Handles lazy FPU saveing and restoring.
+; Handles lazy FPU saving and restoring.
 ;
 ; This handler will implement lazy fpu (sse/mmx/stuff) saving.
@@ -67 +67 @@
     ;   2. Generate guest trap.
     ;
-    ; When entering the hypvervisor we'll always enable MP (for proper wait
+    ; When entering the hypervisor we'll always enable MP (for proper wait
     ; trapping) and TS (for intercepting all fpu/mmx/sse stuff). The EM flag
     ; is taken from the guest OS in order to get proper SSE handling.

trunk/src/VBox/VMM/VMMAll/CPUMAllRegs.cpp

@@ -441 +441 @@
 
 
+/**
+ * Set the guest CR0. 
+ *  
+ * When called in GC, the hyper CR0 may be updated if that is 
+ * required. The caller only has to take special action if AM, 
+ * WP, PG or PE changes. 
+ *  
+ * @returns VINF_SUCCESS (consider it void).
+ * @param   pVM     Pointer to the shared VM structure.
+ * @param   cr0     The new CR0 value.
+ */
 CPUMDECL(int) CPUMSetGuestCR0(PVM pVM, uint32_t cr0)
 {
+#ifdef IN_GC
+    /*
+     * Check if we need to change hypervisor CR0 because 
+     * of math stuff.
+     */
+    if (    (cr0                   & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP))
+        !=  (pVM->cpum.s.Guest.cr0 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP)))
+    {
+        if (!(pVM->cpum.s.fUseFlags & CPUM_USED_FPU))
+        {
+            /* 
+             * We haven't saved the host FPU state yet, so TS and MT are both set 
+             * and EM should be reflecting the guest EM (it always does this).
+             */
+            if ((cr0 & X86_CR0_EM) != (pVM->cpum.s.Guest.cr0 & X86_CR0_EM))
+            {
+                uint32_t HyperCR0 = ASMGetCR0();
+                AssertMsg((HyperCR0 & (X86_CR0_TS | X86_CR0_MP)) == (X86_CR0_TS | X86_CR0_MP), ("%#x\n", HyperCR0));
+                AssertMsg((HyperCR0 & X86_CR0_EM) == (pVM->cpum.s.Guest.cr0 & X86_CR0_EM), ("%#x\n", HyperCR0));
+                HyperCR0 &= ~X86_CR0_EM;
+                HyperCR0 |= cr0 & X86_CR0_EM;
+                Log(("CPUM New HyperCR0=%#x\n", HyperCR0));
+                ASMSetCR0(HyperCR0);
+            }
+#ifdef VBOX_STRICT
+            else
+            {
+                uint32_t HyperCR0 = ASMGetCR0();
+                AssertMsg((HyperCR0 & (X86_CR0_TS | X86_CR0_MP)) == (X86_CR0_TS | X86_CR0_MP), ("%#x\n", HyperCR0));
+                AssertMsg((HyperCR0 & X86_CR0_EM) == (pVM->cpum.s.Guest.cr0 & X86_CR0_EM), ("%#x\n", HyperCR0));
+            }
+#endif
+        }
+        else
+        {
+            /*
+             * Already saved the state, so we're just mirroring 
+             * the guest flags.
+             */
+            uint32_t HyperCR0 = ASMGetCR0();
+            AssertMsg(     (HyperCR0               & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP)) 
+                      ==   (pVM->cpum.s.Guest.cr0  & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP)), 
+                      ("%#x %#x\n", HyperCR0, pVM->cpum.s.Guest.cr0));
+            HyperCR0 &= ~(X86_CR0_TS | X86_CR0_EM | X86_CR0_MP);
+            HyperCR0 |= cr0 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP);
+            Log(("CPUM New HyperCR0=%#x\n", HyperCR0));
+            ASMSetCR0(HyperCR0);
+        }
+    }
+#endif 
+
+    /* 
+     * Check for changes causing TLB flushes (for REM). 
+     * The caller is responsible for calling PGM when appropriate.  
+     */
     if (    (cr0                   & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE))
         !=  (pVM->cpum.s.Guest.cr0 & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)))
         pVM->cpum.s.fChanged |= CPUM_CHANGED_GLOBAL_TLB_FLUSH;
     pVM->cpum.s.fChanged |= CPUM_CHANGED_CR0;
+
     pVM->cpum.s.Guest.cr0 = cr0 | X86_CR0_ET;
     return VINF_SUCCESS;

trunk/src/VBox/VMM/VMMAll/EMAll.cpp

@@ -1526 +1526 @@
 #ifdef IN_GC
     /* Need to change the hyper CR0? Doing it the lazy way then. */
-    if (    (OldCr0 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP | X86_CR0_AM | X86_CR0_WP))
-        !=  (NewCr0 & (X86_CR0_TS | X86_CR0_EM | X86_CR0_MP | X86_CR0_AM | X86_CR0_WP)))
+    if (    (OldCr0 & (X86_CR0_AM | X86_CR0_WP))
+        !=  (NewCr0 & (X86_CR0_AM | X86_CR0_WP)))
     {
         Log(("EMInterpretLMSW: CR0: %#x->%#x => R3\n", OldCr0, NewCr0));
@@ -1547 +1547 @@
 EMDECL(int) EMInterpretCLTS(PVM pVM)
 {
-    uint32_t Cr0 = CPUMGetGuestCR0(pVM);
-    if (!(Cr0 & X86_CR0_TS))
+    uint32_t cr0 = CPUMGetGuestCR0(pVM);
+    if (!(cr0 & X86_CR0_TS))
         return VINF_SUCCESS;
-
-#ifdef IN_GC
-    /* Need to change the hyper CR0? Doing it the lazy way then. */
-    Log(("EMInterpretCLTS: CR0: %#x->%#x => R3\n", Cr0, Cr0 & ~X86_CR0_TS));
-    VM_FF_SET(pVM, VM_FF_TO_R3);
-#endif
-    return CPUMSetGuestCR0(pVM, Cr0 & ~X86_CR0_TS);
+    return CPUMSetGuestCR0(pVM, cr0 & ~X86_CR0_TS);
 }
 
@@ -1588 +1582 @@
             oldval = CPUMGetGuestCR0(pVM);
 #ifndef IN_RING3
-            /* CR0.WP changes require a reschedule run in ring 3. */
-            if ((val32 & X86_CR0_WP) != (oldval & X86_CR0_WP))
-                return VERR_EM_INTERPRETER;
-#endif
-            rc = CPUMSetGuestCR0(pVM, val32); AssertRC(rc); /** @todo CPUSetGuestCR0 stuff should be void, this is silly. */
+            /* CR0.WP and CR0.AM changes require a reschedule run in ring 3. */
+            if (    (val32 & (X86_CR0_WP | X86_CR0_AM)) 
+                !=  (oldval & (X86_CR0_WP | X86_CR0_AM)))
+                return VERR_EM_INTERPRETER;
+#endif
+            CPUMSetGuestCR0(pVM, val32);
             val32 = CPUMGetGuestCR0(pVM);
-            if (    (oldval & (X86_CR0_PG|X86_CR0_WP|X86_CR0_PE))
-                !=  (val32  & (X86_CR0_PG|X86_CR0_WP|X86_CR0_PE)))
+            if (    (oldval & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE))
+                !=  (val32  & (X86_CR0_PG | X86_CR0_WP | X86_CR0_PE)))
             {
                 /* global flush */
@@ -1601 +1596 @@
                 AssertRCReturn(rc, rc);
             }
-# ifdef IN_GC
-            /* Feeling extremely lazy. */
-            if (    (oldval & (X86_CR0_TS|X86_CR0_EM|X86_CR0_MP|X86_CR0_AM))
-                !=  (val32  & (X86_CR0_TS|X86_CR0_EM|X86_CR0_MP|X86_CR0_AM)))
-            {
-                Log(("emInterpretMovCRx: CR0: %#x->%#x => R3\n", oldval, val32));
-                VM_FF_SET(pVM, VM_FF_TO_R3);
-            }
-# endif
             return PGMChangeMode(pVM, CPUMGetGuestCR0(pVM), CPUMGetGuestCR4(pVM), 0);