Changeset 19141 in vbox for trunk/src/VBox/VMM/PATM

Timestamp:

Apr 23, 2009 1:52:18 PM (16 years ago)

Author:

vboxsync

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

46372

Message:

Action flags breakup.
Fixed PGM saved state loading of 2.2.2 images.
Reduced hacks in PATM state loading (fixups).

Location:

trunk/src/VBox/VMM/PATM

Files:

• CSAM.cpp (modified) (2 diffs)
• PATM.cpp (modified) (2 diffs)
• PATMA.asm (modified) (8 diffs)
• PATMInternal.h (modified) (2 diffs)
• PATMPatch.cpp (modified) (1 diff)
• PATMSSM.cpp (modified) (4 diffs)
• VMMAll/CSAMAll.cpp (modified) (3 diffs)
• VMMAll/PATMAll.cpp (modified) (1 diff)
• VMMGC/CSAMGC.cpp (modified) (1 diff)

trunk/src/VBox/VMM/PATM/CSAM.cpp

@@ -228 +228 @@
     pVM->csam.s.fScanningStarted = false;
 
-    VM_FF_CLEAR(pVM, VM_FF_CSAM_PENDING_ACTION);
+    PVMCPU pVCpu = &pVM->aCpus[0];  /* raw mode implies 1 VPCU */
+    VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_CSAM_PENDING_ACTION);
     pVM->csam.s.cDirtyPages = 0;
     /* not necessary */
@@ -2263 +2264 @@
  * @returns VBox status code.
  * @param   pVM         The VM to operate on.
- */
-VMMR3DECL(int) CSAMR3DoPendingAction(PVM pVM)
+ * @param   pVCpu       The VMCPU to operate on.
+ */
+VMMR3DECL(int) CSAMR3DoPendingAction(PVM pVM, PVMCPU pVCpu)
 {
     csamR3FlushDirtyPages(pVM);
     csamR3FlushCodePages(pVM);
 
-    VM_FF_CLEAR(pVM, VM_FF_CSAM_PENDING_ACTION);
+    VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_CSAM_PENDING_ACTION);
     return VINF_SUCCESS;
 }

trunk/src/VBox/VMM/PATM/PATM.cpp

@@ -112 +112 @@
     Log(("PATMR3Init: Patch record size %d\n", sizeof(PATCHINFO)));
 
-    AssertReleaseMsg(PATMInterruptFlag == (VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC | VM_FF_TIMER | VM_FF_REQUEST),
-                     ("Interrupt flags out of sync!! PATMInterruptFlag=%#x expected %#x. broken assembler?\n", PATMInterruptFlag, VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC | VM_FF_TIMER | VM_FF_REQUEST));
+    /* These values can't change as they are hardcoded in patch code (old saved states!) */
+    AssertCompile(VM_FF_TIMER   == VMCPU_FF_TIMER);
+    AssertCompile(VM_FF_REQUEST == VMCPU_FF_REQUEST);
+    AssertCompile(VMCPU_FF_INTERRUPT_APIC == RT_BIT_32(0));
+    AssertCompile(VMCPU_FF_INTERRUPT_PIC == RT_BIT_32(1));
+
+    AssertReleaseMsg(PATMInterruptFlag == (VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST),
+                     ("Interrupt flags out of sync!! PATMInterruptFlag=%#x expected %#x. broken assembler?\n", PATMInterruptFlag, VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST));
 
     /* Allocate patch memory and GC patch state memory. */
@@ -6233 +6239 @@
         }
 #endif
-        EMSetInhibitInterruptsPC(pVM, pVCpu, pNewEip);
+        EMSetInhibitInterruptsPC(pVCpu, pNewEip);
         pVM->patm.s.pGCStateHC->GCPtrInhibitInterrupts = 0;
     }

trunk/src/VBox/VMM/PATM/PATMA.asm

@@ -146 +146 @@
 
     ; if interrupts are pending, then we must go back to the host context to handle them!
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC | VM_FF_TIMER | VM_FF_REQUEST
+    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMClearInhibitIRQFaultIF0_Continue
 
@@ -221 +221 @@
 
     ; if interrupts are pending, then we must go back to the host context to handle them!
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC | VM_FF_TIMER | VM_FF_REQUEST
+    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMClearInhibitIRQContIF0_Continue
 
@@ -744 +744 @@
 
     ; if interrupts are pending, then we must go back to the host context to handle them!
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC | VM_FF_TIMER | VM_FF_REQUEST
+    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMPopf32_Continue
 
@@ -834 +834 @@
 
     ; if interrupts are pending, then we must go back to the host context to handle them!
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC | VM_FF_TIMER | VM_FF_REQUEST
+    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMPopf32_NoExit_Continue
 
@@ -922 +922 @@
     ; if interrupts are pending, then we must go back to the host context to handle them!
     ; @note we destroy the flags here, but that should really not matter (PATM_INT3 case)
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC | VM_FF_TIMER | VM_FF_REQUEST
+    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMPopf16_Continue
     mov     dword [ss:PATM_INTERRUPTFLAG], 1
@@ -987 +987 @@
     ; if interrupts are pending, then we must go back to the host context to handle them!
     ; @note we destroy the flags here, but that should really not matter (PATM_INT3 case)
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC | VM_FF_TIMER | VM_FF_REQUEST
+    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
     jz      PATMPopf16_Continue_NoExit
     mov     dword [ss:PATM_INTERRUPTFLAG], 1
@@ -1238 +1238 @@
 ; Note: This is very important as pending pic interrupts can be overriden by apic interrupts if we don't check early enough (Fedora 5 boot)
 ; @@todo fix this properly, so we can dispatch pending interrupts in GC
-    test    dword [ss:PATM_VM_FORCEDACTIONS], VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC
+    test    dword [ss:PATM_VM_FORCEDACTIONS], VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC
     jz      iret_continue
 
@@ -2582 +2582 @@
 ; For assertion during init (to make absolutely sure the flags are in sync in vm.mac & vm.h)
 GLOBALNAME PATMInterruptFlag
-    DD      VM_FF_INTERRUPT_APIC | VM_FF_INTERRUPT_PIC | VM_FF_TIMER | VM_FF_REQUEST
-
+    DD      VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_TIMER | VMCPU_FF_REQUEST
+

trunk/src/VBox/VMM/PATM/PATMInternal.h

@@ -41 +41 @@
 #else
 # define PATM_SSM_VERSION                    54
+# define PATM_SSM_VERSION_FIXUP_HACK         54
 # define PATM_SSM_VERSION_VER16              53
 #endif
@@ -134 +135 @@
 #define PATM_STAT_MEMSIZE                   (PATM_STAT_MAX_COUNTERS*sizeof(STAMRATIOU32))
 
+/** aCpus[0].fLocalForcedActions fixup (must be uneven to avoid theoretical clashes with valid pointers) */
+#define PATM_FIXUP_CPU_FF_ACTION            0xffffff01
+/** default cpuid pointer fixup */
+#define PATM_FIXUP_CPUID_DEFAULT            0xffffff03
+/** standard cpuid pointer fixup */
+#define PATM_FIXUP_CPUID_STANDARD           0xffffff05
+/** extended cpuid pointer fixup */
+#define PATM_FIXUP_CPUID_EXTENDED           0xffffff07
+/** centaur cpuid pointer fixup */
+#define PATM_FIXUP_CPUID_CENTAUR            0xffffff09
 
 typedef struct

trunk/src/VBox/VMM/PATM/PATMPatch.cpp

@@ -287 +287 @@
                 case PATM_VM_FORCEDACTIONS:
                     /* @todo dirty assumptions when correcting this fixup during saved state loading. */
-                    dest = pVM->pVMRC + RT_OFFSETOF(VM, fForcedActions);
+                    dest = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions);
                     break;
 

trunk/src/VBox/VMM/PATM/PATMSSM.cpp

@@ -142 +142 @@
     PSSMHANDLE          pSSM = pVM->patm.s.savedstate.pSSM;
     RELOCREC            rec  = *(PRELOCREC)pNode;
+    RTRCPTR            *pFixup = (RTRCPTR *)rec.pRelocPos;
 
     Assert(rec.pRelocPos);
+    /* Convert pointer to an offset into patch memory. */
     PATM_SUBTRACT_PTR(rec.pRelocPos, pVM->patm.s.pPatchMemHC);
+
+    if (rec.uType == FIXUP_ABSOLUTE)
+    {
+        /* Core.Key abused to store the fixup type. */
+        if (*pFixup == pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions))
+            rec.Core.Key = (AVLPVKEY)PATM_FIXUP_CPU_FF_ACTION;
+        else 
+        if (*pFixup == CPUMR3GetGuestCpuIdDefRCPtr(pVM))
+            rec.Core.Key = (AVLPVKEY)PATM_FIXUP_CPUID_DEFAULT;
+        else 
+        if (*pFixup == CPUMR3GetGuestCpuIdStdRCPtr(pVM))
+            rec.Core.Key = (AVLPVKEY)PATM_FIXUP_CPUID_STANDARD;
+        else 
+        if (*pFixup == CPUMR3GetGuestCpuIdExtRCPtr(pVM))
+            rec.Core.Key = (AVLPVKEY)PATM_FIXUP_CPUID_EXTENDED;
+        else 
+        if (*pFixup == CPUMR3GetGuestCpuIdCentaurRCPtr(pVM))
+            rec.Core.Key = (AVLPVKEY)PATM_FIXUP_CPUID_CENTAUR;
+    }
 
     /* Save the lookup record. */
@@ -286 +307 @@
 
     if (    u32Version != PATM_SSM_VERSION
+        &&  u32Version != PATM_SSM_VERSION_FIXUP_HACK
         &&  u32Version != PATM_SSM_VERSION_VER16
 #ifdef PATM_WITH_NEW_SSM
@@ -874 +896 @@
         }
         else
-        /* Note: rather assumptive! */
-        if (    *pFixup >= pVM->pVMRC
+        if (    ulSSMVersion <= PATM_SSM_VERSION_FIXUP_HACK
+            &&  *pFixup >= pVM->pVMRC
             &&  *pFixup < pVM->pVMRC + 32)
         {
-            LogFlow(("Changing fForcedActions fixup from %x to %x\n", *pFixup, pVM->pVMRC + RT_OFFSETOF(VM, fForcedActions)));
-            *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, fForcedActions);
+            LogFlow(("Changing fLocalForcedActions fixup from %x to %x\n", *pFixup, pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions)));
+            *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions);
         }
         else
-        if (    *pFixup >= pVM->pVMRC
+        if (    ulSSMVersion <= PATM_SSM_VERSION_FIXUP_HACK
+            &&  *pFixup >= pVM->pVMRC
             &&  *pFixup < pVM->pVMRC + 8192)
         {
@@ -909 +932 @@
         }
         else
-            AssertMsgFailed(("Unexpected fixup value %x\n", *pFixup));
+        if (ulSSMVersion >= PATM_SSM_VERSION)
+        {
+#ifdef LOG_ENABLED
+            RTRCPTR oldFixup = *pFixup;
+#endif
+            /* Core.Key abused to store the type of fixup */
+            switch ((uint32_t)pRec->Core.Key)
+            {
+            case PATM_FIXUP_CPU_FF_ACTION:
+                *pFixup = pVM->pVMRC + RT_OFFSETOF(VM, aCpus[0].fLocalForcedActions);
+                LogFlow(("Changing cpu ff action fixup from %x to %x\n", oldFixup, *pFixup));
+                break;
+            case PATM_FIXUP_CPUID_DEFAULT:
+                *pFixup = CPUMR3GetGuestCpuIdDefRCPtr(pVM);
+                LogFlow(("Changing cpuid def fixup from %x to %x\n", oldFixup, *pFixup));
+                break;
+            case PATM_FIXUP_CPUID_STANDARD:
+                *pFixup = CPUMR3GetGuestCpuIdStdRCPtr(pVM);
+                LogFlow(("Changing cpuid std fixup from %x to %x\n", oldFixup, *pFixup));
+                break;
+            case PATM_FIXUP_CPUID_EXTENDED:
+                *pFixup = CPUMR3GetGuestCpuIdExtRCPtr(pVM);
+                LogFlow(("Changing cpuid ext fixup from %x to %x\n", oldFixup, *pFixup));
+                break;
+            case PATM_FIXUP_CPUID_CENTAUR:
+                *pFixup = CPUMR3GetGuestCpuIdCentaurRCPtr(pVM);
+                LogFlow(("Changing cpuid centaur fixup from %x to %x\n", oldFixup, *pFixup));
+                break;
+            default:
+                AssertMsgFailed(("Unexpected fixup value %x\n", *pFixup));
+                break;
+            }
+        }
 
 #ifdef RT_OS_WINDOWS
-        AssertCompile(RT_OFFSETOF(VM, fForcedActions) < 32);
+        AssertCompile(RT_OFFSETOF(VM, fGlobalForcedActions) < 32);
 #endif
         break;

trunk/src/VBox/VMM/PATM/VMMAll/CSAMAll.cpp

@@ -37 +37 @@
 #include "CSAMInternal.h"
 #include <VBox/vm.h>
+#include <VBox/vmm.h>
 #include <VBox/dbg.h>
 #include <VBox/err.h>
@@ -68 +69 @@
 
     STAM_COUNTER_ADD(&pVM->csam.s.StatNrTraps, 1);
-    VM_FF_SET(pVM, VM_FF_CSAM_SCAN_PAGE);
+    VMCPU_FF_SET(VMMGetCpu0(pVM), VMCPU_FF_CSAM_SCAN_PAGE);
     return VINF_CSAM_PENDING_ACTION;
 }
@@ -205 +206 @@
     {
         pVM->csam.s.pvPossibleCodePage[pVM->csam.s.cPossibleCodePages++] = (RTRCPTR)GCPtr;
-        VM_FF_SET(pVM, VM_FF_CSAM_PENDING_ACTION);
+        VMCPU_FF_SET(VMMGetCpu0(pVM), VMCPU_FF_CSAM_PENDING_ACTION);
     }
     return;

trunk/src/VBox/VMM/PATM/VMMAll/PATMAll.cpp

@@ -191 +191 @@
         if (CTXSUFF(pVM->patm.s.pGCState)->GCPtrInhibitInterrupts == (RTRCPTR)pCtxCore->eip)
         {
-            EMSetInhibitInterruptsPC(pVM, VMMGetCpu0(pVM), pCtxCore->eip);
+            EMSetInhibitInterruptsPC(VMMGetCpu0(pVM), pCtxCore->eip);
         }
         CTXSUFF(pVM->patm.s.pGCState)->GCPtrInhibitInterrupts = 0;

trunk/src/VBox/VMM/PATM/VMMGC/CSAMGC.cpp

@@ -117 +117 @@
     }
 
-    VM_FF_SET(pVM, VM_FF_CSAM_PENDING_ACTION);
+    VMCPU_FF_SET(pVCpu, VMCPU_FF_CSAM_PENDING_ACTION);
 
     /* Note that pvFault might be a different address in case of aliases. So use pvRange + offset instead!. */