Changeset 13577 in vbox for trunk/src

Timestamp:

Oct 27, 2008 1:53:04 PM (16 years ago)

Author:

vboxsync

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

38476

Message:

#1865: SELM.

Location:

trunk/src/VBox/VMM

Files:

• SELM.cpp (modified) (63 diffs)
• SELMInternal.h (modified) (7 diffs)
• VMMAll/SELMAll.cpp (modified) (39 diffs)
• VMMGC/SELMGC.cpp (modified) (16 diffs)
• testcase/tstVMStructGC.cpp (modified) (2 diffs)

trunk/src/VBox/VMM/SELM.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * SELM - The Selector manager.
+ * SELM - The Selector Manager.
  */
 
@@ -22 +22 @@
 /** @page pg_selm   SELM - The Selector Manager
  *
- * Manages the hypervisor GDT entires, monitors and shadows the guest GDT, LDT
- * and TSS. Only active in raw-mode.
+ * SELM takes care of GDT, LDT and TSS shadowing in raw-mode, and the injection
+ * of a few hyper selector for the raw-mode context.  In the hardware assisted
+ * virtualization mode its only task is to decode entries in the guest GDT or
+ * LDT once in a while.
  *
  * @see grp_selm
+ *
+ *
+ * @section seg_selm_shadowing   Shadowing
+ *
+ * SELMR3UpdateFromCPUM() and SELMR3SyncTSS() does the bulk synchronization
+ * work.  The three structures (GDT, LDT, TSS) are all shadowed wholesale atm.
+ * The idea is to do it in a more on-demand fashion when we get time.  There
+ * also a whole bunch of issues with the current synchronization of all three
+ * tables, see notes and todos in the code.
+ *
+ * When the guest makes changes to the GDT we will try update the shadow copy
+ * without involving SELMR3UpdateFromCPUM(), see selmGCSyncGDTEntry().
+ *
+ * When the guest make LDT changes we'll trigger a full resync of the LDT
+ * (SELMR3UpdateFromCPUM()), which, needless to say, isn't optimal.
+ *
+ * The TSS shadowing is limited to the fields we need to care about, namely SS0
+ * and ESP0.  The Patch Manager makes use of these.  We monitor updates to the
+ * guest TSS and will try keep our SS0 and ESP0 copies up to date this way
+ * rather than go the SELMR3SyncTSS() route.
+ *
+ * When in raw-mode SELM also injects a few extra GDT selectors which are used
+ * by the raw-mode (hyper) context.  These start their life at the high end of
+ * the table and will be relocated when the guest tries to make use of them...
+ * Well, that was that idea at least, only the code isn't quite there yet which
+ * is why we have trouble with guests which actually have a full sized GDT.
+ *
+ * So, the summary of the current GDT, LDT and TSS shadowing is that there is a
+ * lot of relatively simple and enjoyable work to be done, see @bugref{3267}.
  *
  */
@@ -76 +107 @@
 #define SELM_SAVED_STATE_VERSION    5
 
+
 /*******************************************************************************
 *   Internal Functions                                                         *
 *******************************************************************************/
-static DECLCALLBACK(int) selmR3Save(PVM pVM, PSSMHANDLE pSSM);
-static DECLCALLBACK(int) selmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version);
-static DECLCALLBACK(int) selmR3LoadDone(PVM pVM, PSSMHANDLE pSSM);
+static DECLCALLBACK(int)  selmR3Save(PVM pVM, PSSMHANDLE pSSM);
+static DECLCALLBACK(int)  selmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t u32Version);
+static DECLCALLBACK(int)  selmR3LoadDone(PVM pVM, PSSMHANDLE pSSM);
+static DECLCALLBACK(int)  selmR3GuestGDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
+static DECLCALLBACK(int)  selmR3GuestLDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
+static DECLCALLBACK(int)  selmR3GuestTSSWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
 static DECLCALLBACK(void) selmR3InfoGdt(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
 static DECLCALLBACK(void) selmR3InfoGdtGuest(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
@@ -88 +123 @@
 //static DECLCALLBACK(void) selmR3InfoTss(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
 //static DECLCALLBACK(void) selmR3InfoTssGuest(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
-static DECLCALLBACK(int) selmGuestGDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
-static DECLCALLBACK(int) selmGuestLDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
-static DECLCALLBACK(int) selmGuestTSSWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
 
 
@@ -131 +163 @@
      * Allocate GDT table.
      */
-    int rc = MMR3HyperAllocOnceNoRel(pVM, sizeof(pVM->selm.s.paGdtHC[0]) * SELM_GDT_ELEMENTS,
-                                     PAGE_SIZE, MM_TAG_SELM, (void **)&pVM->selm.s.paGdtHC);
+    int rc = MMR3HyperAllocOnceNoRel(pVM, sizeof(pVM->selm.s.paGdtR3[0]) * SELM_GDT_ELEMENTS,
+                                     PAGE_SIZE, MM_TAG_SELM, (void **)&pVM->selm.s.paGdtR3);
     AssertRCReturn(rc, rc);
 
@@ -138 +170 @@
      * Allocate LDT area.
      */
-    rc = MMR3HyperAllocOnceNoRel(pVM, _64K + PAGE_SIZE, PAGE_SIZE, MM_TAG_SELM, &pVM->selm.s.HCPtrLdt);
+    rc = MMR3HyperAllocOnceNoRel(pVM, _64K + PAGE_SIZE, PAGE_SIZE, MM_TAG_SELM, &pVM->selm.s.pvLdtR3);
     AssertRCReturn(rc, rc);
 
@@ -149 +181 @@
     pVM->selm.s.GCPtrGuestTss      = RTRCPTR_MAX;
 
-    pVM->selm.s.paGdtGC            = 0;
-    pVM->selm.s.GCPtrLdt           = RTRCPTR_MAX;
-    pVM->selm.s.GCPtrTss           = RTRCPTR_MAX;
-    pVM->selm.s.GCSelTss           = ~0;
+    pVM->selm.s.paGdtRC            = NIL_RTRCPTR; /* Must be set in SELMR3Relocate because of monitoring. */
+    pVM->selm.s.pvLdtRC            = RTRCPTR_MAX;
+    pVM->selm.s.pvMonShwTssRC      = RTRCPTR_MAX;
+    pVM->selm.s.GCSelTss           = RTSEL_MAX;
 
     pVM->selm.s.fDisableMonitoring = false;
@@ -175 +207 @@
      * Statistics.
      */
-    STAM_REG(pVM, &pVM->selm.s.StatGCWriteGuestGDTHandled,     STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/GDTInt",  STAMUNIT_OCCURENCES,     "The number of handled writes to the Guest GDT.");
-    STAM_REG(pVM, &pVM->selm.s.StatGCWriteGuestGDTUnhandled,   STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/GDTEmu",  STAMUNIT_OCCURENCES,     "The number of unhandled writes to the Guest GDT.");
-    STAM_REG(pVM, &pVM->selm.s.StatGCWriteGuestLDT,            STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/LDT",     STAMUNIT_OCCURENCES,     "The number of writes to the Guest LDT was detected.");
-    STAM_REG(pVM, &pVM->selm.s.StatGCWriteGuestTSSHandled,     STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/TSSInt",  STAMUNIT_OCCURENCES,     "The number of handled writes to the Guest TSS.");
-    STAM_REG(pVM, &pVM->selm.s.StatGCWriteGuestTSSRedir,       STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/TSSRedir",STAMUNIT_OCCURENCES,     "The number of handled redir bitmap writes to the Guest TSS.");
-    STAM_REG(pVM, &pVM->selm.s.StatGCWriteGuestTSSHandledChanged,STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/TSSIntChg", STAMUNIT_OCCURENCES, "The number of handled writes to the Guest TSS where the R0 stack changed.");
-    STAM_REG(pVM, &pVM->selm.s.StatGCWriteGuestTSSUnhandled,   STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/TSSEmu",  STAMUNIT_OCCURENCES,     "The number of unhandled writes to the Guest TSS.");
+    STAM_REG(pVM, &pVM->selm.s.StatRCWriteGuestGDTHandled,     STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/GDTInt",  STAMUNIT_OCCURENCES,     "The number of handled writes to the Guest GDT.");
+    STAM_REG(pVM, &pVM->selm.s.StatRCWriteGuestGDTUnhandled,   STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/GDTEmu",  STAMUNIT_OCCURENCES,     "The number of unhandled writes to the Guest GDT.");
+    STAM_REG(pVM, &pVM->selm.s.StatRCWriteGuestLDT,            STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/LDT",     STAMUNIT_OCCURENCES,     "The number of writes to the Guest LDT was detected.");
+    STAM_REG(pVM, &pVM->selm.s.StatRCWriteGuestTSSHandled,     STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/TSSInt",  STAMUNIT_OCCURENCES,     "The number of handled writes to the Guest TSS.");
+    STAM_REG(pVM, &pVM->selm.s.StatRCWriteGuestTSSRedir,       STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/TSSRedir",STAMUNIT_OCCURENCES,     "The number of handled redir bitmap writes to the Guest TSS.");
+    STAM_REG(pVM, &pVM->selm.s.StatRCWriteGuestTSSHandledChanged,STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/TSSIntChg", STAMUNIT_OCCURENCES, "The number of handled writes to the Guest TSS where the R0 stack changed.");
+    STAM_REG(pVM, &pVM->selm.s.StatRCWriteGuestTSSUnhandled,   STAMTYPE_COUNTER, "/SELM/GC/Write/Guest/TSSEmu",  STAMUNIT_OCCURENCES,     "The number of unhandled writes to the Guest TSS.");
     STAM_REG(pVM, &pVM->selm.s.StatTSSSync,                    STAMTYPE_PROFILE, "/PROF/SELM/TSSSync",           STAMUNIT_TICKS_PER_CALL, "Profiling of the SELMR3SyncTSS() body.");
     STAM_REG(pVM, &pVM->selm.s.StatUpdateFromCPUM,             STAMTYPE_PROFILE, "/PROF/SELM/UpdateFromCPUM",    STAMUNIT_TICKS_PER_CALL, "Profiling of the SELMR3UpdateFromCPUM() body.");
@@ -217 +249 @@
 VMMR3DECL(int) SELMR3InitFinalize(PVM pVM)
 {
-    /*
-     * Make Double Fault work with WP enabled?
-     *
-     * The double fault is a task switch and thus requires write access to the GDT of the TSS
-     * (to set it busy), to the old TSS (to store state), and to the Trap 8 TSS for the back link.
-     *
-     * Since we in enabling write access to these pages make ourself vulnerable to attacks,
-     * it is not possible to do this by default.
+    /** @cfgm{/DoubleFault,bool,false}
+     * Enables catching of double faults in the raw-mode context VMM code.  This can
+     * be used when the tripple faults or hangs occure and one suspect an unhandled
+     * double fault.  This is not enabled by default because it means making the
+     * hyper selectors writeable for all supervisor code, including the guest's.
+     * The double fault is a task switch and thus requires write access to the GDT
+     * of the TSS (to set it busy), to the old TSS (to store state), and to the Trap
+     * 8 TSS for the back link.
      */
     bool f;
-    int rc = CFGMR3QueryBool(CFGMR3GetRoot(pVM), "DoubleFault", &f);
-#if !defined(DEBUG_bird)
-    if (VBOX_SUCCESS(rc) && f)
+#if defined(DEBUG_bird)
+    int rc = CFGMR3QueryBoolDef(CFGMR3GetRoot(pVM), "DoubleFault", &f, true);
+#else
+    int rc = CFGMR3QueryBoolDef(CFGMR3GetRoot(pVM), "DoubleFault", &f, false);
 #endif
-    {
-        PX86DESC paGdt = pVM->selm.s.paGdtHC;
+    AssertLogRelRCReturn(rc, rc);
+    if (f)
+    {
+        PX86DESC paGdt = pVM->selm.s.paGdtR3;
         rc = PGMMapSetPage(pVM, MMHyperHC2GC(pVM, &paGdt[pVM->selm.s.aHyperSel[SELM_HYPER_SEL_TSS_TRAP08] >> 3]), sizeof(paGdt[0]),
                            X86_PTE_RW | X86_PTE_P | X86_PTE_A | X86_PTE_D);
@@ -257 +292 @@
 static void selmR3SetupHyperGDTSelectors(PVM pVM)
 {
-    PX86DESC paGdt = pVM->selm.s.paGdtHC;
+    PX86DESC paGdt = pVM->selm.s.paGdtR3;
 
     /*
@@ -358 +393 @@
 VMMR3DECL(void) SELMR3Relocate(PVM pVM)
 {
-    PX86DESC paGdt = pVM->selm.s.paGdtHC;
+    PX86DESC paGdt = pVM->selm.s.paGdtR3;
     LogFlow(("SELMR3Relocate\n"));
 
@@ -419 +454 @@
         int rc;
 #ifdef SELM_TRACK_SHADOW_GDT_CHANGES
-        if (pVM->selm.s.paGdtGC != 0)
-        {
-            rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.paGdtGC);
+        if (pVM->selm.s.paGdtRC != NIL_RTRCPTR)
+        {
+            rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.paGdtRC);
             AssertRC(rc);
         }
-        pVM->selm.s.paGdtGC = MMHyperHC2GC(pVM, paGdt);
-        rc = PGMR3HandlerVirtualRegister(pVM, PGMVIRTHANDLERTYPE_HYPERVISOR, pVM->selm.s.paGdtGC,
-                                         pVM->selm.s.paGdtGC + SELM_GDT_ELEMENTS * sizeof(paGdt[0]) - 1,
-                                         0, 0, "selmgcShadowGDTWriteHandler", 0, "Shadow GDT write access handler");
+        pVM->selm.s.paGdtRC = MMHyperR3ToRC(pVM, paGdt);
+        rc = PGMR3HandlerVirtualRegister(pVM, PGMVIRTHANDLERTYPE_HYPERVISOR, pVM->selm.s.paGdtRC,
+                                         pVM->selm.s.paGdtRC + SELM_GDT_ELEMENTS * sizeof(paGdt[0]) - 1,
+                                         0, 0, "selmRCShadowGDTWriteHandler", 0, "Shadow GDT write access handler");
         AssertRC(rc);
 #endif
 #ifdef SELM_TRACK_SHADOW_TSS_CHANGES
-        if (pVM->selm.s.GCPtrTss != RTRCPTR_MAX)
-        {
-            rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.GCPtrTss);
+        if (pVM->selm.s.pvMonShwTssRC != RTRCPTR_MAX)
+        {
+            rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.pvMonShwTssRC);
             AssertRC(rc);
         }
-        pVM->selm.s.GCPtrTss = VM_GUEST_ADDR(pVM, &pVM->selm.s.Tss);
-        rc = PGMR3HandlerVirtualRegister(pVM, PGMVIRTHANDLERTYPE_HYPERVISOR, pVM->selm.s.GCPtrTss,
-                                         pVM->selm.s.GCPtrTss + sizeof(pVM->selm.s.Tss) - 1,
-                                         0, 0, "selmgcShadowTSSWriteHandler", 0, "Shadow TSS write access handler");
+        pVM->selm.s.pvMonShwTssRC = VM_RC_ADDR(pVM, &pVM->selm.s.Tss);
+        rc = PGMR3HandlerVirtualRegister(pVM, PGMVIRTHANDLERTYPE_HYPERVISOR, pVM->selm.s.pvMonShwTssRC,
+                                         pVM->selm.s.pvMonShwTssRC + sizeof(pVM->selm.s.Tss) - 1,
+                                         0, 0, "selmRCShadowTSSWriteHandler", 0, "Shadow TSS write access handler");
         AssertRC(rc);
 #endif
@@ -447 +482 @@
          */
 #ifdef SELM_TRACK_SHADOW_LDT_CHANGES
-        if (pVM->selm.s.GCPtrLdt != RTRCPTR_MAX)
-        {
-            rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.GCPtrLdt);
+        if (pVM->selm.s.pvLdtRC != RTRCPTR_MAX)
+        {
+            rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.pvLdtRC);
             AssertRC(rc);
         }
 #endif
-        pVM->selm.s.GCPtrLdt = MMHyperHC2GC(pVM, pVM->selm.s.HCPtrLdt);
+        pVM->selm.s.pvLdtRC = MMHyperR3ToRC(pVM, pVM->selm.s.pvLdtR3);
 #ifdef SELM_TRACK_SHADOW_LDT_CHANGES
-        rc = PGMR3HandlerVirtualRegister(pVM, PGMVIRTHANDLERTYPE_HYPERVISOR, pVM->selm.s.GCPtrLdt,
-                                         pVM->selm.s.GCPtrLdt + _64K + PAGE_SIZE - 1,
-                                         0, 0, "selmgcShadowLDTWriteHandler", 0, "Shadow LDT write access handler");
+        rc = PGMR3HandlerVirtualRegister(pVM, PGMVIRTHANDLERTYPE_HYPERVISOR, pVM->selm.s.pvLdtRC,
+                                         pVM->selm.s.pvLdtRC + _64K + PAGE_SIZE - 1,
+                                         0, 0, "selmRCShadowLDTWriteHandler", 0, "Shadow LDT write access handler");
         AssertRC(rc);
 #endif
@@ -534 +569 @@
         AssertRC(rc);
         pVM->selm.s.GCPtrGuestTss = RTRCPTR_MAX;
-        pVM->selm.s.GCSelTss      = ~0;
+        pVM->selm.s.GCSelTss      = RTSEL_MAX;
     }
 #endif
@@ -590 +625 @@
         AssertRC(rc);
         pVM->selm.s.GCPtrGuestTss = RTRCPTR_MAX;
-        pVM->selm.s.GCSelTss      = ~0;
+        pVM->selm.s.GCSelTss      = RTSEL_MAX;
     }
 #endif
@@ -598 +633 @@
      */
 #ifdef SELM_TRACK_SHADOW_GDT_CHANGES
-    if (pVM->selm.s.paGdtGC != 0)
-    {
-        rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.paGdtGC);
+    if (pVM->selm.s.paGdtRC != NIL_RTRCPTR)
+    {
+        rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.paGdtRC);
         AssertRC(rc);
-        pVM->selm.s.paGdtGC = 0;
+        pVM->selm.s.paGdtRC = NIL_RTRCPTR;
     }
 #endif
 #ifdef SELM_TRACK_SHADOW_TSS_CHANGES
-    if (pVM->selm.s.GCPtrTss != RTRCPTR_MAX)
-    {
-        rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.GCPtrTss);
+    if (pVM->selm.s.pvMonShwTssRC != RTRCPTR_MAX)
+    {
+        rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.pvMonShwTssRC);
         AssertRC(rc);
-        pVM->selm.s.GCPtrTss = RTRCPTR_MAX;
+        pVM->selm.s.pvMonShwTssRC = RTRCPTR_MAX;
     }
 #endif
 #ifdef SELM_TRACK_SHADOW_LDT_CHANGES
-    if (pVM->selm.s.GCPtrLdt != RTRCPTR_MAX)
-    {
-        rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.GCPtrLdt);
+    if (pVM->selm.s.pvLdtRC != RTRCPTR_MAX)
+    {
+        rc = PGMHandlerVirtualDeregister(pVM, pVM->selm.s.pvLdtRC);
         AssertRC(rc);
-        pVM->selm.s.GCPtrLdt = RTRCPTR_MAX;
+        pVM->selm.s.pvLdtRC = RTRCPTR_MAX;
     }
 #endif
@@ -628 +663 @@
     pVM->selm.s.fDisableMonitoring = true;
 }
+
 
 /**
@@ -650 +686 @@
     SSMR3PutSel(pSSM, pSelm->aHyperSel[SELM_HYPER_SEL_DS]);
     SSMR3PutSel(pSSM, pSelm->aHyperSel[SELM_HYPER_SEL_CS64]);
-    SSMR3PutSel(pSSM, pSelm->aHyperSel[SELM_HYPER_SEL_CS64]); //reserved for DS64.
+    SSMR3PutSel(pSSM, pSelm->aHyperSel[SELM_HYPER_SEL_CS64]); /* reserved for DS64. */
     SSMR3PutSel(pSSM, pSelm->aHyperSel[SELM_HYPER_SEL_TSS]);
     return SSMR3PutSel(pSSM, pSelm->aHyperSel[SELM_HYPER_SEL_TSS_TRAP08]);
@@ -813 +849 @@
          */
         RTUINT      cbEffLimit = GDTR.cbGdt;
-        PX86DESC   pGDTE = &pVM->selm.s.paGdtHC[1];
+        PX86DESC   pGDTE = &pVM->selm.s.paGdtR3[1];
         rc = PGMPhysSimpleReadGCPtr(pVM, pGDTE, GDTR.pGdt + sizeof(X86DESC), cbEffLimit + 1 - sizeof(X86DESC));
         if (VBOX_FAILURE(rc))
@@ -828 +864 @@
             RTUINT  cbLeft = cbEffLimit + 1 - sizeof(X86DESC);
             RTGCPTR GCPtrSrc = (RTGCPTR)GDTR.pGdt + sizeof(X86DESC);
-            uint8_t *pu8Dst = (uint8_t *)&pVM->selm.s.paGdtHC[1];
+            uint8_t *pu8Dst = (uint8_t *)&pVM->selm.s.paGdtR3[1];
             uint8_t *pu8DstInvalid = pu8Dst;
 
@@ -862 +898 @@
             if (pu8DstInvalid != pu8Dst)
             {
-                cbEffLimit = pu8DstInvalid - (uint8_t *)pVM->selm.s.paGdtHC - 1;
+                cbEffLimit = pu8DstInvalid - (uint8_t *)pVM->selm.s.paGdtR3 - 1;
                 /* If any GDTEs was invalidated, zero them. */
                 if (cbEffLimit < pVM->selm.s.cbEffGuestGdtLimit)
@@ -884 +920 @@
         if (cbEffLimit >= SELM_HYPER_DEFAULT_BASE)
         {
-            PX86DESC pGDTEStart = pVM->selm.s.paGdtHC;
+            PX86DESC pGDTEStart = pVM->selm.s.paGdtR3;
             PX86DESC pGDTE = (PX86DESC)((char *)pGDTEStart + GDTR.cbGdt + 1 - sizeof(X86DESC));
             int       iGDT = 0;
@@ -895 +931 @@
                 if (!pGDTE->Gen.u1Present)
                 {
-                    aHyperSel[iGDT] = ((uintptr_t)pGDTE - (uintptr_t)pVM->selm.s.paGdtHC) / sizeof(X86DESC);
+                    aHyperSel[iGDT] = ((uintptr_t)pGDTE - (uintptr_t)pVM->selm.s.paGdtR3) / sizeof(X86DESC);
                     aHyperSel[iGDT] = aHyperSel[iGDT] << X86_SEL_SHIFT;
                     Log(("SELM: Found unused GDT %04X\n", aHyperSel[iGDT]));
@@ -1027 +1063 @@
 
             rc = PGMR3HandlerVirtualRegister(pVM, PGMVIRTHANDLERTYPE_WRITE, GDTR.pGdt, GDTR.pGdt + GDTR.cbGdt /* already inclusive */,
-                                             0, selmGuestGDTWriteHandler, "selmgcGuestGDTWriteHandler", 0, "Guest GDT write access handler");
+                                             0, selmR3GuestGDTWriteHandler, "selmRCGuestGDTWriteHandler", 0, "Guest GDT write access handler");
             if (VBOX_FAILURE(rc))
                 return rc;
@@ -1091 +1127 @@
          * Get the LDT selector.
          */
-        PX86DESC   pDesc = &pVM->selm.s.paGdtHC[SelLdt >> X86_SEL_SHIFT];
+        PX86DESC    pDesc = &pVM->selm.s.paGdtR3[SelLdt >> X86_SEL_SHIFT];
         RTGCPTR     GCPtrLdt = X86DESC_BASE(*pDesc);
         unsigned    cbLdt = X86DESC_LIMIT(*pDesc);
@@ -1130 +1166 @@
          * (this is necessary due to redundant LDT updates; see todo above at GDT sync)
          */
-        if (MMHyperIsInsideArea(pVM, GCPtrLdt) == true)
+        if (MMHyperIsInsideArea(pVM, GCPtrLdt))
             GCPtrLdt = pVM->selm.s.GCPtrGuestLdt;   /* use the old one */
 
@@ -1161 +1197 @@
 #endif
                 rc = PGMR3HandlerVirtualRegister(pVM, PGMVIRTHANDLERTYPE_WRITE, GCPtrLdt, GCPtrLdt + cbLdt /* already inclusive */,
-                                                 0, selmGuestLDTWriteHandler, "selmgcGuestLDTWriteHandler", 0, "Guest LDT write access handler");
+                                                 0, selmR3GuestLDTWriteHandler, "selmRCGuestLDTWriteHandler", 0, "Guest LDT write access handler");
                 if (rc == VERR_PGM_HANDLER_VIRTUAL_CONFLICT)
                 {
@@ -1190 +1226 @@
         unsigned    off;
         pVM->selm.s.offLdtHyper = off = (GCPtrLdt & PAGE_OFFSET_MASK);
-        RTGCPTR     GCPtrShadowLDT  = (RTGCPTR)((RTGCUINTPTR)pVM->selm.s.GCPtrLdt + off);
-        PX86DESC   pShadowLDT      = (PX86DESC)((uintptr_t)pVM->selm.s.HCPtrLdt + off);
+        RTGCPTR     GCPtrShadowLDT  = (RTGCPTR)((RTGCUINTPTR)pVM->selm.s.pvLdtRC + off);
+        PX86DESC    pShadowLDT      = (PX86DESC)((uintptr_t)pVM->selm.s.pvLdtR3 + off);
 
         /*
@@ -1295 +1331 @@
             else
             {
-                AssertMsg(rc == VERR_PAGE_NOT_PRESENT || rc == VERR_PAGE_TABLE_NOT_PRESENT, ("rc=%d\n", rc));
+                AssertMsg(rc == VERR_PAGE_NOT_PRESENT || rc == VERR_PAGE_TABLE_NOT_PRESENT, ("rc=%Rrc\n", rc));
                 rc = PGMMapSetPage(pVM, GCPtrShadowLDT & PAGE_BASE_GC_MASK, PAGE_SIZE, 0);
                 AssertRC(rc);
@@ -1331 +1367 @@
  * @param   pvUser          User argument.
  */
-static DECLCALLBACK(int) selmGuestGDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
+static DECLCALLBACK(int) selmR3GuestGDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
 {
     Assert(enmAccessType == PGMACCESSTYPE_WRITE);
-    Log(("selmGuestGDTWriteHandler: write to %VGv size %d\n", GCPtr, cbBuf));
+    Log(("selmR3GuestGDTWriteHandler: write to %VGv size %d\n", GCPtr, cbBuf));
     VM_FF_SET(pVM, VM_FF_SELM_SYNC_GDT);
 
     return VINF_PGM_HANDLER_DO_DEFAULT;
 }
+
 
 /**
@@ -1356 +1393 @@
  * @param   pvUser          User argument.
  */
-static DECLCALLBACK(int) selmGuestLDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
+static DECLCALLBACK(int) selmR3GuestLDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
 {
     Assert(enmAccessType == PGMACCESSTYPE_WRITE);
-    Log(("selmGuestLDTWriteHandler: write to %VGv size %d\n", GCPtr, cbBuf));
+    Log(("selmR3GuestLDTWriteHandler: write to %VGv size %d\n", GCPtr, cbBuf));
     VM_FF_SET(pVM, VM_FF_SELM_SYNC_LDT);
     return VINF_PGM_HANDLER_DO_DEFAULT;
 }
+
 
 /**
@@ -1380 +1418 @@
  * @param   pvUser          User argument.
  */
-static DECLCALLBACK(int) selmGuestTSSWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
+static DECLCALLBACK(int) selmR3GuestTSSWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
 {
     Assert(enmAccessType == PGMACCESSTYPE_WRITE);
-    Log(("selmGuestTSSWriteHandler: write to %VGv size %d\n", GCPtr, cbBuf));
+    Log(("selmR3GuestTSSWriteHandler: write to %VGv size %d\n", GCPtr, cbBuf));
     VM_FF_SET(pVM, VM_FF_SELM_SYNC_TSS);
     return VINF_PGM_HANDLER_DO_DEFAULT;
 }
+
 
 /**
@@ -1428 +1467 @@
          * Guest TR is not NULL.
          */
-        PX86DESC   pDesc = &pVM->selm.s.paGdtHC[SelTss >> X86_SEL_SHIFT];
+        PX86DESC    pDesc = &pVM->selm.s.paGdtR3[SelTss >> X86_SEL_SHIFT];
         RTGCPTR     GCPtrTss = X86DESC_BASE(*pDesc);
         unsigned    cbTss = X86DESC_LIMIT(*pDesc);
@@ -1489 +1528 @@
 
                     rc = PGMR3HandlerVirtualRegister(pVM, PGMVIRTHANDLERTYPE_WRITE, GCPtrTss, GCPtrTss + cbTss - 1,
-                                                     0, selmGuestTSSWriteHandler, "selmgcGuestTSSWriteHandler", 0, "Guest TSS write access handler");
+                                                     0, selmR3GuestTSSWriteHandler, "selmRCGuestTSSWriteHandler", 0, "Guest TSS write access handler");
                     if (VBOX_FAILURE(rc))
                     {
@@ -1509 +1548 @@
             if (VBOX_SUCCESS(rc))
             {
-            #ifdef DEBUG
+#ifdef LOG_ENABLED
                 uint32_t ssr0, espr0;
 
@@ -1518 +1557 @@
                     Log(("SELMR3SyncTSS: Updating TSS ring 0 stack to %04X:%08X\n", tss.ss0, tss.esp0));
                 Log(("offIoBitmap=%#x\n", tss.offIoBitmap));
-            #endif
+#endif /* LOG_ENABLED */
                 /* Update our TSS structure for the guest's ring 1 stack */
                 SELMSetRing1Stack(pVM, tss.ss0 | 1, tss.esp0);
@@ -1585 +1624 @@
      */
     RTGCPTR     GCPtrGDTEGuest = GDTR.pGdt;
-    PX86DESC   pGDTE = pVM->selm.s.paGdtHC;
+    PX86DESC   pGDTE = pVM->selm.s.paGdtR3;
     PX86DESC   pGDTEEnd = (PX86DESC)((uintptr_t)pGDTE + GDTR.cbGdt);
     while (pGDTE < pGDTEEnd)
@@ -1603 +1642 @@
                     || pGDTE->Gen.u1DescType  != GDTEGuest.Gen.u1DescType)
                 {
-                    unsigned iGDT = pGDTE - pVM->selm.s.paGdtHC;
+                    unsigned iGDT = pGDTE - pVM->selm.s.paGdtR3;
                     SELMR3DumpDescriptor(*pGDTE, iGDT << 3, "SELMR3DebugCheck: GDT mismatch, shadow");
                     SELMR3DumpDescriptor(GDTEGuest, iGDT << 3, "SELMR3DebugCheck: GDT mismatch,  guest");
@@ -1658 +1697 @@
      */
     unsigned    off = (GCPtrLDTEGuest & PAGE_OFFSET_MASK);
-    PX86DESC   pLDTE = (PX86DESC)((uintptr_t)pVM->selm.s.HCPtrLdt + off);
-    PX86DESC   pLDTEEnd = (PX86DESC)((uintptr_t)pGDTE + cbLdt);
+    PX86DESC    pLDTE = (PX86DESC)((uintptr_t)pVM->selm.s.pvLdtR3 + off);
+    PX86DESC    pLDTEEnd = (PX86DESC)((uintptr_t)pGDTE + cbLdt);
     while (pLDTE < pLDTEEnd)
     {
@@ -1674 +1713 @@
                 || pLDTE->Gen.u1DescType  != LDTEGuest.Gen.u1DescType)
             {
-                unsigned iLDT = pLDTE - (PX86DESC)((uintptr_t)pVM->selm.s.HCPtrLdt + off);
+                unsigned iLDT = pLDTE - (PX86DESC)((uintptr_t)pVM->selm.s.pvLdtR3 + off);
                 SELMR3DumpDescriptor(*pLDTE, iLDT << 3, "SELMR3DebugCheck: LDT mismatch, shadow");
                 SELMR3DumpDescriptor(LDTEGuest, iLDT << 3, "SELMR3DebugCheck: LDT mismatch,  guest");
@@ -1685 +1724 @@
     }
 
-#else
+#else  /* !VBOX_STRICT */
     NOREF(pVM);
-#endif
+#endif /* !VBOX_STRICT */
 
     return VINF_SUCCESS;
@@ -1712 +1751 @@
          * Guest TR is not NULL.
          */
-        PX86DESC   pDesc = &pVM->selm.s.paGdtHC[SelTss >> X86_SEL_SHIFT];
+        PX86DESC    pDesc = &pVM->selm.s.paGdtR3[SelTss >> X86_SEL_SHIFT];
         RTGCPTR     GCPtrTss = X86DESC_BASE(*pDesc);
         unsigned    cbTss = X86DESC_LIMIT(*pDesc);
@@ -1718 +1757 @@
             cbTss = (cbTss << PAGE_SHIFT) | PAGE_OFFSET_MASK;
         cbTss++;
-#if 1
+# if 1
         /* Don't bother with anything but the core structure. (Actually all we care for is the r0 ss.) */
         if (cbTss > sizeof(VBOXTSS))
             cbTss = sizeof(VBOXTSS);
-#endif
+# endif
         AssertMsg((GCPtrTss >> PAGE_SHIFT) == ((GCPtrTss + sizeof(VBOXTSS) - 1) >> PAGE_SHIFT),
                   ("GCPtrTss=%VGv cbTss=%#x - We assume everything is inside one page!\n", GCPtrTss, cbTss));
@@ -1774 +1813 @@
     }
     return false;
-#else
+#else  /* !VBOX_STRICT */
     NOREF(pVM);
     return true;
-#endif
+#endif /* !VBOX_STRICT */
 }
 
@@ -1831 +1870 @@
 }
 
-/**
- * Gets information about a selector.
- * Intended for the debugger mostly and will prefer the guest
- * descriptor tables over the shadow ones.
- *
- * @returns VINF_SUCCESS on success.
- * @returns VERR_INVALID_SELECTOR if the selector isn't fully inside the descriptor table.
- * @returns VERR_SELECTOR_NOT_PRESENT if the selector wasn't present.
- * @returns VERR_PAGE_TABLE_NOT_PRESENT or VERR_PAGE_NOT_PRESENT if the pagetable or page
- *          backing the selector table wasn't present.
- * @returns Other VBox status code on other errors.
+
+/**
+ * Gets information about a 64-bit selector, SELMR3GetSelectorInfo helper.
+ *
+ * See SELMR3GetSelectorInfo for details.
+ *
+ * @returns VBox status code, see SELMR3GetSelectorInfo for details.
  *
  * @param   pVM         VM handle.
@@ -1847 +1882 @@
  * @param   pSelInfo    Where to store the information.
  */
-static int selmr3GetSelectorInfo64(PVM pVM, RTSEL Sel, PSELMSELINFO pSelInfo)
-{
-    X86DESC64 Desc;
-
-    Assert(pSelInfo);
+static int selmR3GetSelectorInfo64(PVM pVM, RTSEL Sel, PSELMSELINFO pSelInfo)
+{
+    pSelInfo->fHyper = false;
 
     /*
      * Read it from the guest descriptor table.
      */
-    pSelInfo->fHyper = false;
-
+    X86DESC64   Desc;
     VBOXGDTR    Gdtr;
     RTGCPTR     GCPtrDesc;
@@ -1871 +1903 @@
     {
         /*
-            * LDT - must locate the LDT first...
-            */
+         * LDT - must locate the LDT first...
+         */
         RTSEL SelLdt = CPUMGetGuestLDTR(pVM);
         if (    (unsigned)(SelLdt & X86_SEL_MASK) < sizeof(X86DESC) /* the first selector is invalid, right? */
@@ -1921 +1953 @@
 
 /**
- * Gets information about a selector.
- * Intended for the debugger mostly and will prefer the guest
- * descriptor tables over the shadow ones.
- *
- * @returns VINF_SUCCESS on success.
- * @returns VERR_INVALID_SELECTOR if the selector isn't fully inside the descriptor table.
- * @returns VERR_SELECTOR_NOT_PRESENT if the selector wasn't present.
- * @returns VERR_PAGE_TABLE_NOT_PRESENT or VERR_PAGE_NOT_PRESENT if the pagetable or page
- *          backing the selector table wasn't present.
- * @returns Other VBox status code on other errors.
+ * Gets information about a 64-bit selector, SELMR3GetSelectorInfo helper.
+ *
+ * See SELMR3GetSelectorInfo for details.
+ *
+ * @returns VBox status code, see SELMR3GetSelectorInfo for details.
  *
  * @param   pVM         VM handle.
@@ -1936 +1963 @@
  * @param   pSelInfo    Where to store the information.
  */
-VMMR3DECL(int) SELMR3GetSelectorInfo(PVM pVM, RTSEL Sel, PSELMSELINFO pSelInfo)
-{
-    Assert(pSelInfo);
-
-    if (CPUMIsGuestInLongMode(pVM))
-        return selmr3GetSelectorInfo64(pVM, Sel, pSelInfo);
-
+static int selmR3GetSelectorInfo32(PVM pVM, RTSEL Sel, PSELMSELINFO pSelInfo)
+{
     /*
      * Read the descriptor entry
@@ -1959 +1981 @@
          */
         pSelInfo->fHyper = true;
-        Desc = pVM->selm.s.paGdtHC[Sel >> X86_SEL_SHIFT];
+        Desc = pVM->selm.s.paGdtR3[Sel >> X86_SEL_SHIFT];
     }
     else if (CPUMIsGuestInProtectedMode(pVM))
@@ -2045 +2067 @@
 
 /**
- * Gets information about a selector from the shadow tables.
- *
- * This is intended to be faster than the SELMR3GetSelectorInfo() method, but requires
- * that the caller ensures that the shadow tables are up to date.
+ * Gets information about a selector.
+ * Intended for the debugger mostly and will prefer the guest
+ * descriptor tables over the shadow ones.
  *
  * @returns VINF_SUCCESS on success.
@@ -2061 +2082 @@
  * @param   pSelInfo    Where to store the information.
  */
+VMMR3DECL(int) SELMR3GetSelectorInfo(PVM pVM, RTSEL Sel, PSELMSELINFO pSelInfo)
+{
+    AssertPtr(pSelInfo);
+    if (CPUMIsGuestInLongMode(pVM))
+        return selmR3GetSelectorInfo64(pVM, Sel, pSelInfo);
+    return selmR3GetSelectorInfo32(pVM, Sel, pSelInfo);
+}
+
+
+/**
+ * Gets information about a selector from the shadow tables.
+ *
+ * This is intended to be faster than the SELMR3GetSelectorInfo() method, but requires
+ * that the caller ensures that the shadow tables are up to date.
+ *
+ * @returns VINF_SUCCESS on success.
+ * @returns VERR_INVALID_SELECTOR if the selector isn't fully inside the descriptor table.
+ * @returns VERR_SELECTOR_NOT_PRESENT if the selector wasn't present.
+ * @returns VERR_PAGE_TABLE_NOT_PRESENT or VERR_PAGE_NOT_PRESENT if the pagetable or page
+ *          backing the selector table wasn't present.
+ * @returns Other VBox status code on other errors.
+ *
+ * @param   pVM         VM handle.
+ * @param   Sel         The selector to get info about.
+ * @param   pSelInfo    Where to store the information.
+ */
 VMMR3DECL(int) SELMR3GetShadowSelectorInfo(PVM pVM, RTSEL Sel, PSELMSELINFO pSelInfo)
 {
@@ -2074 +2121 @@
          * Global descriptor.
          */
-        Desc = pVM->selm.s.paGdtHC[Sel >> X86_SEL_SHIFT];
+        Desc = pVM->selm.s.paGdtR3[Sel >> X86_SEL_SHIFT];
         pSelInfo->fHyper = pVM->selm.s.aHyperSel[SELM_HYPER_SEL_CS] == (Sel & X86_SEL_MASK)
                         || pVM->selm.s.aHyperSel[SELM_HYPER_SEL_DS] == (Sel & X86_SEL_MASK)
@@ -2087 +2134 @@
          * Local Descriptor.
          */
-        PX86DESC paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
+        PX86DESC paLDT = (PX86DESC)((char *)pVM->selm.s.pvLdtR3 + pVM->selm.s.offLdtHyper);
         Desc = paLDT[Sel >> X86_SEL_SHIFT];
         /** @todo check if the LDT page is actually available. */
@@ -2128 +2175 @@
     } const aTypes[32] =
     {
-        #define STRENTRY(str) { sizeof(str) - 1, str }
+#define STRENTRY(str) { sizeof(str) - 1, str }
         /* system */
         STRENTRY("Reserved0 "),                  /* 0x00 */
@@ -2163 +2210 @@
         STRENTRY("CodeConfER "),                 /* 0x1e */
         STRENTRY("CodeConfER Accessed ")         /* 0x1f */
-        #undef SYSENTRY
+#undef SYSENTRY
     };
-    #define ADD_STR(psz, pszAdd) do { strcpy(psz, pszAdd); psz += strlen(pszAdd); } while (0)
+#define ADD_STR(psz, pszAdd) do { strcpy(psz, pszAdd); psz += strlen(pszAdd); } while (0)
     char        szMsg[128];
     char       *psz = &szMsg[0];
@@ -2182 +2229 @@
     else
         ADD_STR(psz, "16-bit ");
-    #undef ADD_STR
+#undef ADD_STR
     *psz = '\0';
 
@@ -2223 +2270 @@
 static DECLCALLBACK(void) selmR3InfoGdt(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    pHlp->pfnPrintf(pHlp, "Shadow GDT (GCAddr=%VGv):\n", MMHyperHC2GC(pVM, pVM->selm.s.paGdtHC));
+    pHlp->pfnPrintf(pHlp, "Shadow GDT (GCAddr=%VGv):\n", MMHyperHC2GC(pVM, pVM->selm.s.paGdtR3));
     for (unsigned iGDT = 0; iGDT < SELM_GDT_ELEMENTS; iGDT++)
     {
-        if (pVM->selm.s.paGdtHC[iGDT].Gen.u1Present)
+        if (pVM->selm.s.paGdtR3[iGDT].Gen.u1Present)
         {
             char szOutput[128];
-            selmR3FormatDescriptor(pVM->selm.s.paGdtHC[iGDT], iGDT << X86_SEL_SHIFT, &szOutput[0], sizeof(szOutput));
+            selmR3FormatDescriptor(pVM->selm.s.paGdtR3[iGDT], iGDT << X86_SEL_SHIFT, &szOutput[0], sizeof(szOutput));
             const char *psz = "";
             if (iGDT == ((unsigned)pVM->selm.s.aHyperSel[SELM_HYPER_SEL_CS] >> X86_SEL_SHIFT))
@@ -2296 +2343 @@
 {
     unsigned    cLDTs = ((unsigned)pVM->selm.s.cbLdtLimit + 1) >> X86_SEL_SHIFT;
-    PX86DESC   paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
-    pHlp->pfnPrintf(pHlp, "Shadow LDT (GCAddr=%VGv limit=%d):\n", pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper, pVM->selm.s.cbLdtLimit);
+    PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.pvLdtR3 + pVM->selm.s.offLdtHyper);
+    pHlp->pfnPrintf(pHlp, "Shadow LDT (GCAddr=%VGv limit=%d):\n", pVM->selm.s.pvLdtRC + pVM->selm.s.offLdtHyper, pVM->selm.s.cbLdtLimit);
     for (unsigned iLDT = 0; iLDT < cLDTs; iLDT++)
     {
@@ -2331 +2378 @@
     if (VBOX_FAILURE(rc))
     {
-        pHlp->pfnPrintf(pHlp, "Guest LDT (Sel=%x): rc=%Vrc\n", SelLdt, rc);
+        pHlp->pfnPrintf(pHlp, "Guest LDT (Sel=%x): rc=%Rrc\n", SelLdt, rc);
         return;
     }
@@ -2371 +2418 @@
 }
 
+
 /**
  * Dumps the hypervisor LDT
@@ -2381 +2429 @@
 }
 
+
 /**
  * Dumps the guest GDT
@@ -2391 +2440 @@
 }
 
+
 /**
  * Dumps the guest LDT

trunk/src/VBox/VMM/SELMInternal.h

@@ -68 +68 @@
  * @param   pSELM   Pointer to SELM instance data.
  */
-#define SELM2VM(pSELM)  ( (PVM)((char*)pSELM - pSELM->offVM) )
+#define SELM2VM(pSELM)  ( (PVM)((char *)pSELM - pSELM->offVM) )
 
 
@@ -81 +81 @@
     RTINT                   offVM;
 
-    /* Flat CS, DS, 64 bit mode CS, TSS & trap 8 TSS. */
+    /** Flat CS, DS, 64 bit mode CS, TSS & trap 8 TSS. */
     RTSEL                   aHyperSel[SELM_HYPER_SEL_MAX];
 
-    /** Pointer to the GCs - HC Ptr.
+    /** Pointer to the GCs - R3 Ptr.
      * This size is governed by SELM_GDT_ELEMENTS. */
-    R3R0PTRTYPE(PX86DESC)   paGdtHC;
-    /** Pointer to the GCs - GC Ptr.
+    R3PTRTYPE(PX86DESC)     paGdtR3;
+    /** Pointer to the GCs - RC Ptr.
      * This is not initialized until the first relocation because it's used to
      * check if the shadow GDT virtual handler requires deregistration. */
-    RCPTRTYPE(PX86DESC)     paGdtGC;
-    /** Current (last) Guest's GDTR. */
+    RCPTRTYPE(PX86DESC)     paGdtRC;
+    /** Current (last) Guest's GDTR.
+     * The pGdt member is set to RTRCPTR_MAX if we're not monitoring the guest GDT. */
     VBOXGDTR                GuestGdtr;
     /** The current (last) effective Guest GDT size. */
@@ -98 +99 @@
     uint32_t                padding0;
 
-    /** HC Pointer to the LDT shadow area placed in Hypervisor memory arena. */
-    R3PTRTYPE(void *)       HCPtrLdt;
-    /** GC Pointer to the LDT shadow area placed in Hypervisor memory arena. */
-    RCPTRTYPE(void *)       GCPtrLdt;
+    /** R3 pointer to the LDT shadow area in HMA. */
+    R3PTRTYPE(void *)       pvLdtR3;
+    /** RC pointer to the LDT shadow area in HMA. */
+    RCPTRTYPE(void *)       pvLdtRC;
 #if GC_ARCH_BITS == 64
     RTRCPTR                 padding1;
 #endif
-    /** GC Pointer to the current Guest's LDT. */
+    /** The address of the guest LDT.
+     * RTRCPTR_MAX if not monitored. */
     RTGCPTR                 GCPtrGuestLdt;
     /** Current LDT limit, both Guest and Shadow. */
     RTUINT                  cbLdtLimit;
-    /** Current LDT offset relative to pvLdt*. */
+    /** Current LDT offset relative to pvLdtR3/pvLdtRC. */
     RTUINT                  offLdtHyper;
 #if HC_ARCH_BITS == 32 && GC_ARCH_BITS == 64
@@ -121 +123 @@
     VBOXTSS                 TssTrap08;
 
-    /** GC Pointer to the TSS shadow area (Tss) placed in Hypervisor memory arena. */
-    RCPTRTYPE(void *)       GCPtrTss;
+    /** Monitored shadow TSS address. */
+    RCPTRTYPE(void *)       pvMonShwTssRC;
 #if GC_ARCH_BITS == 64
     RTRCPTR                 padding3;
 #endif
-    /** GC Pointer to the current Guest's TSS. */
+    /** GC Pointer to the current Guest's TSS.
+     * RTRCPTR_MAX if not monitored. */
     RTGCPTR                 GCPtrGuestTss;
     /** The size of the guest TSS. */
@@ -134 +137 @@
     /** The size of the Guest's TSS part we're monitoring. */
     RTUINT                  cbMonitoredGuestTss;
-    /** GC shadow TSS selector */
+    /** The guest TSS selector at last sync (part of monitoring).
+     * Contains RTSEL_MAX if not set. */
     RTSEL                   GCSelTss;
 
@@ -154 +158 @@
 
     /** GC: The number of handled writes to the Guest's GDT. */
-    STAMCOUNTER             StatGCWriteGuestGDTHandled;
+    STAMCOUNTER             StatRCWriteGuestGDTHandled;
     /** GC: The number of unhandled write to the Guest's GDT. */
-    STAMCOUNTER             StatGCWriteGuestGDTUnhandled;
+    STAMCOUNTER             StatRCWriteGuestGDTUnhandled;
     /** GC: The number of times writes to Guest's LDT was detected. */
-    STAMCOUNTER             StatGCWriteGuestLDT;
+    STAMCOUNTER             StatRCWriteGuestLDT;
     /** GC: The number of handled writes to the Guest's TSS. */
-    STAMCOUNTER             StatGCWriteGuestTSSHandled;
+    STAMCOUNTER             StatRCWriteGuestTSSHandled;
     /** GC: The number of handled writes to the Guest's TSS where we detected a change. */
-    STAMCOUNTER             StatGCWriteGuestTSSHandledChanged;
+    STAMCOUNTER             StatRCWriteGuestTSSHandledChanged;
     /** GC: The number of handled redir writes to the Guest's TSS where we detected a change. */
-    STAMCOUNTER             StatGCWriteGuestTSSRedir;
+    STAMCOUNTER             StatRCWriteGuestTSSRedir;
     /** GC: The number of unhandled writes to the Guest's TSS. */
-    STAMCOUNTER             StatGCWriteGuestTSSUnhandled;
+    STAMCOUNTER             StatRCWriteGuestTSSUnhandled;
     /** The number of times we had to relocate our hypervisor selectors. */
     STAMCOUNTER             StatHyperSelsChanged;
@@ -175 +179 @@
 __BEGIN_DECLS
 
-VMMRCDECL(int) selmgcGuestGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-VMMRCDECL(int) selmgcGuestLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-VMMRCDECL(int) selmgcGuestTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+VMMRCDECL(int) selmRCGuestGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+VMMRCDECL(int) selmRCGuestLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+VMMRCDECL(int) selmRCGuestTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
 
-VMMRCDECL(int) selmgcShadowGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-VMMRCDECL(int) selmgcShadowLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-VMMRCDECL(int) selmgcShadowTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+VMMRCDECL(int) selmRCShadowGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+VMMRCDECL(int) selmRCShadowLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+VMMRCDECL(int) selmRCShadowTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
 
 __END_DECLS

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

@@ -39 +39 @@
 
 
+#ifndef IN_RING0
+
 /**
  * Converts a GC selector based address to a flat address.
@@ -58 +60 @@
     X86DESC    Desc;
     if (!(Sel & X86_SEL_LDT))
-        Desc = pVM->selm.s.CTXSUFF(paGdt)[Sel >> X86_SEL_SHIFT];
+        Desc = pVM->selm.s.CTX_SUFF(paGdt)[Sel >> X86_SEL_SHIFT];
     else
     {
         /** @todo handle LDT pages not present! */
-#ifdef IN_GC
-        PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
-#else
-        PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
-#endif
+        PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.CTX_SUFF(pvLdt) + pVM->selm.s.offLdtHyper);
         Desc = paLDT[Sel >> X86_SEL_SHIFT];
     }
@@ -72 +70 @@
     return (RTGCPTR)((RTGCUINTPTR)Addr + X86DESC_BASE(Desc));
 }
+#endif /* !IN_RING0 */
 
 
@@ -101 +100 @@
     {
         RTGCUINTPTR uFlat = (RTGCUINTPTR)Addr & 0xffff;
-
         if (CPUMAreHiddenSelRegsValid(pVM))
             uFlat += pHiddenSel->u64Base;
@@ -109 +107 @@
     }
 
+#ifdef IN_RING0
+    Assert(CPUMAreHiddenSelRegsValid(pVM));
+#else
     /** @todo when we're in 16 bits mode, we should cut off the address as well.. */
     if (!CPUMAreHiddenSelRegsValid(pVM))
         return SELMToFlatBySel(pVM, Sel, Addr);
+#endif
 
     /* 64 bits mode: CS, DS, ES and SS are treated as if each segment base is 0 (Intel® 64 and IA-32 Architectures Software Developer's Manual: 3.4.2.1). */
@@ -119 +121 @@
         switch (SelReg)
         {
-        case DIS_SELREG_FS:
-        case DIS_SELREG_GS:
-            return (RTGCPTR)(pHiddenSel->u64Base + Addr);
-
-        default:
-            return Addr;    /* base 0 */
-        }
-    }
+            case DIS_SELREG_FS:
+            case DIS_SELREG_GS:
+                return (RTGCPTR)(pHiddenSel->u64Base + Addr);
+
+            default:
+                return Addr;    /* base 0 */
+        }
+    }
+
     /* AMD64 manual: compatibility mode ignores the high 32 bits when calculating an effective address. */
     Assert(pHiddenSel->u64Base <= 0xffffffff);
@@ -149 +152 @@
 VMMDECL(int) SELMToFlatEx(PVM pVM, DIS_SELREG SelReg, PCCPUMCTXCORE pCtxCore, RTGCPTR Addr, unsigned fFlags, PRTGCPTR ppvGC)
 {
+    /*
+     * Fetch the selector first.
+     */
     PCPUMSELREGHID pHiddenSel;
     RTSEL          Sel;
-    int            rc;
-
-    rc = DISFetchRegSegEx(pCtxCore, SelReg, &Sel, &pHiddenSel); AssertRC(rc);
+    int rc = DISFetchRegSegEx(pCtxCore, SelReg, &Sel, &pHiddenSel);
+    AssertRC(rc);
 
     /*
@@ -189 +194 @@
         u1DescType    = pHiddenSel->Attr.n.u1DescType;
         u4Type        = pHiddenSel->Attr.n.u4Type;
-
         u32Limit      = pHiddenSel->u32Limit;
 
@@ -199 +203 @@
             switch (SelReg)
             {
-            case DIS_SELREG_FS:
-            case DIS_SELREG_GS:
-                pvFlat = (pHiddenSel->u64Base + Addr);
-                break;
-
-            default:
-                pvFlat = Addr;
-                break;
+                case DIS_SELREG_FS:
+                case DIS_SELREG_GS:
+                    pvFlat = (pHiddenSel->u64Base + Addr);
+                    break;
+
+                default:
+                    pvFlat = Addr;
+                    break;
             }
         }
@@ -304 +308 @@
                 && (unsigned)(Sel & X86_SEL_MASK) >= pVM->selm.s.GuestGdtr.cbGdt)
                 return VERR_INVALID_SELECTOR;
-            Desc = pVM->selm.s.CTXSUFF(paGdt)[Sel >> X86_SEL_SHIFT];
+            Desc = pVM->selm.s.CTX_SUFF(paGdt)[Sel >> X86_SEL_SHIFT];
         }
         else
@@ -312 +316 @@
 
             /** @todo handle LDT page(s) not present! */
-#ifdef IN_GC
-            PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
-#else
-            PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
-#endif
+            PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.CTX_SUFF(pvLdt) + pVM->selm.s.offLdtHyper);
             Desc = paLDT[Sel >> X86_SEL_SHIFT];
         }
@@ -341 +341 @@
             * Type check.
             */
-#define BOTH(a, b) ((a << 16) | b)
+# define BOTH(a, b) ((a << 16) | b)
             switch (BOTH(u1DescType, u4Type))
             {
@@ -429 +429 @@
 
             }
-#undef BOTH
+# undef BOTH
         }
     }
@@ -435 +435 @@
     return VERR_SELECTOR_NOT_PRESENT;
 }
+
 
 #ifndef IN_RING0
@@ -512 +513 @@
                 && (unsigned)(Sel & X86_SEL_MASK) >= pVM->selm.s.GuestGdtr.cbGdt)
                 return VERR_INVALID_SELECTOR;
-            Desc = pVM->selm.s.CTXSUFF(paGdt)[Sel >> X86_SEL_SHIFT];
+            Desc = pVM->selm.s.CTX_SUFF(paGdt)[Sel >> X86_SEL_SHIFT];
         }
         else
@@ -520 +521 @@
 
             /** @todo handle LDT page(s) not present! */
-#ifdef IN_GC
-            PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
-#else
-            PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
-#endif
+            PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.CTX_SUFF(pvLdt) + pVM->selm.s.offLdtHyper);
             Desc = paLDT[Sel >> X86_SEL_SHIFT];
         }
@@ -652 +649 @@
 #endif /* !IN_RING0 */
 
+
 /**
  * Validates and converts a GC selector based code address to a flat
@@ -675 +673 @@
 
 
+#ifndef IN_RING0
 /**
  * Validates and converts a GC selector based code address to a flat
@@ -695 +694 @@
     X86DESC    Desc;
     if (!(SelCS & X86_SEL_LDT))
-        Desc = pVM->selm.s.CTXSUFF(paGdt)[SelCS >> X86_SEL_SHIFT];
+        Desc = pVM->selm.s.CTX_SUFF(paGdt)[SelCS >> X86_SEL_SHIFT];
     else
     {
         /** @todo handle LDT page(s) not present! */
-#ifdef IN_GC
-        PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.GCPtrLdt + pVM->selm.s.offLdtHyper);
-#else
-        PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.HCPtrLdt + pVM->selm.s.offLdtHyper);
-#endif
+        PX86DESC    paLDT = (PX86DESC)((char *)pVM->selm.s.CTX_SUFF(pvLdt) + pVM->selm.s.offLdtHyper);
         Desc = paLDT[SelCS >> X86_SEL_SHIFT];
     }
@@ -748 +743 @@
     return VERR_SELECTOR_NOT_PRESENT;
 }
+#endif /* !IN_RING0 */
 
 
@@ -813 +809 @@
 
 
+#ifdef IN_GC
 /**
  * Validates and converts a GC selector based code address to a flat address.
@@ -840 +837 @@
     return selmValidateAndConvertCSAddrStd(pVM, SelCPL, SelCS, Addr, ppvFlat, pcBits);
 }
+#endif /* IN_GC */
 
 
@@ -861 +859 @@
         return selmValidateAndConvertCSAddrRealMode(pVM, SelCS, pHiddenCSSel, Addr, ppvFlat);
 
+#ifdef IN_RING0
+    Assert(CPUMAreHiddenSelRegsValid(pVM));
+#else
     /** @todo when we're in 16 bits mode, we should cut off the address as well? (like in selmValidateAndConvertCSAddrRealMode) */
     if (!CPUMAreHiddenSelRegsValid(pVM))
         return selmValidateAndConvertCSAddrStd(pVM, SelCPL, SelCS, Addr, ppvFlat, NULL);
+#endif
     return selmValidateAndConvertCSAddrHidden(pVM, SelCPL, SelCS, pHiddenCSSel, Addr, ppvFlat);
 }
 
 
+#ifndef IN_RING0
 /**
  * Return the cpu mode corresponding to the (CS) selector
@@ -882 +885 @@
     X86DESC Desc;
     if (!(Sel & X86_SEL_LDT))
-        Desc = pVM->selm.s.CTXSUFF(paGdt)[Sel >> X86_SEL_SHIFT];
+        Desc = pVM->selm.s.CTX_SUFF(paGdt)[Sel >> X86_SEL_SHIFT];
     else
     {
         /** @todo handle LDT page(s) not present! */
-        PX86DESC   paLDT = (PX86DESC)((char *)pVM->selm.s.CTXMID(,PtrLdt) + pVM->selm.s.offLdtHyper);
+        PX86DESC   paLDT = (PX86DESC)((char *)pVM->selm.s.CTX_SUFF(pvLdt) + pVM->selm.s.offLdtHyper);
         Desc = paLDT[Sel >> X86_SEL_SHIFT];
     }
     return (Desc.Gen.u1DefBig) ? CPUMODE_32BIT : CPUMODE_16BIT;
 }
+#endif /* !IN_RING0 */
 
 
@@ -904 +908 @@
 VMMDECL(DISCPUMODE) SELMGetCpuModeFromSelector(PVM pVM, X86EFLAGS eflags, RTSEL Sel, CPUMSELREGHID *pHiddenSel)
 {
+#ifdef IN_RING0
+    Assert(CPUMAreHiddenSelRegsValid(pVM));
+#else  /* !IN_RING0 */
     if (!CPUMAreHiddenSelRegsValid(pVM))
     {
@@ -915 +922 @@
         return selmGetCpuModeFromSelector(pVM, Sel);
     }
+#endif /* !IN_RING0 */
     if (    CPUMIsGuestInLongMode(pVM)
         &&  pHiddenSel->Attr.n.u1Long)
@@ -924 +932 @@
 }
 
+
 /**
  * Returns Hypervisor's Trap 08 (\#DF) selector.
@@ -960 +969 @@
     pVM->selm.s.Tss.esp1 = (uint32_t)esp;
 }
+
 
 #ifndef IN_RING0
@@ -969 +979 @@
  * @param   pSS     Ring1 SS register value.
  * @param   pEsp    Ring1 ESP register value.
+ *
+ * @todo Merge in the GC version of this, eliminating it - or move this to
+ *       SELM.cpp, making it SELMR3GetRing1Stack.
  */
 VMMDECL(int) SELMGetRing1Stack(PVM pVM, uint32_t *pSS, PRTGCPTR32 pEsp)
@@ -980 +993 @@
         Assert(pVM->selm.s.GCPtrGuestTss && pVM->selm.s.cbMonitoredGuestTss);
 
-#ifdef IN_GC
+# ifdef IN_GC
         bool    fTriedAlready = false;
 
@@ -986 +999 @@
         rc  = MMGCRamRead(pVM, &tss.ss0,  (RCPTRTYPE(void *))(GCPtrTss + RT_OFFSETOF(VBOXTSS, ss0)), sizeof(tss.ss0));
         rc |= MMGCRamRead(pVM, &tss.esp0, (RCPTRTYPE(void *))(GCPtrTss + RT_OFFSETOF(VBOXTSS, esp0)), sizeof(tss.esp0));
-  #ifdef DEBUG
+#  ifdef DEBUG
         rc |= MMGCRamRead(pVM, &tss.offIoBitmap, (RCPTRTYPE(void *))(GCPtrTss + RT_OFFSETOF(VBOXTSS, offIoBitmap)), sizeof(tss.offIoBitmap));
-  #endif
+#  endif
 
         if (VBOX_FAILURE(rc))
@@ -1006 +1019 @@
         }
 
-#else /* !IN_GC */
+# else /* !IN_GC */
         /* Reading too much. Could be cheaper than two seperate calls though. */
         rc = PGMPhysSimpleReadGCPtr(pVM, &tss, GCPtrTss, sizeof(VBOXTSS));
@@ -1014 +1027 @@
             return rc;
         }
-#endif /* !IN_GC */
-
-#ifdef LOG_ENABLED
+# endif /* !IN_GC */
+
+# ifdef LOG_ENABLED
         uint32_t ssr0  = pVM->selm.s.Tss.ss1;
         uint32_t espr0 = pVM->selm.s.Tss.esp1;
@@ -1025 +1038 @@
 
         Log(("offIoBitmap=%#x\n", tss.offIoBitmap));
-#endif
+# endif
         /* Update our TSS structure for the guest's ring 1 stack */
         SELMSetRing1Stack(pVM, tss.ss0 | 1, (RTGCPTR32)tss.esp0);
@@ -1036 +1049 @@
     return VINF_SUCCESS;
 }
-#endif
+#endif /* !IN_RING0 */
+
 
 /**
  * Returns Guest TSS pointer
  *
+ * @returns Pointer to the guest TSS, RTRCPTR_MAX if not being monitored.
  * @param   pVM     VM Handle.
  */
@@ -1086 +1101 @@
 
 #ifndef IN_RING0
+
 /**
  * Gets the hypervisor code selector (CS).
@@ -1148 +1164 @@
  *          switchers. Don't exploit this API!
  */
-VMMDECL(RTGCPTR) SELMGetHyperGDT(PVM pVM)
+VMMDECL(RTRCPTR) SELMGetHyperGDT(PVM pVM)
 {
     /*
-     * Always convert this from the HC pointer since. We're can be
+     * Always convert this from the HC pointer since we can be
      * called before the first relocation and have to work correctly
      * without having dependencies on the relocation order.
      */
-    return (RTGCPTR)MMHyperHC2GC(pVM, pVM->selm.s.paGdtHC);
-}
-#endif /* IN_RING0 */
+    return (RTRCPTR)MMHyperR3ToRC(pVM, pVM->selm.s.paGdtR3);
+}
+
+#endif /* !IN_RING0 */
 
 /**
@@ -1178 +1195 @@
          * Do we have a valid TSS?
          */
-        if (    pVM->selm.s.GCSelTss == (RTSEL)~0
+        if (    pVM->selm.s.GCSelTss == RTSEL_MAX
             || !pVM->selm.s.fGuestTss32Bit)
             return VERR_SELM_NO_TSS;
@@ -1205 +1222 @@
     return VINF_SUCCESS;
 }
+

trunk/src/VBox/VMM/VMMGC/SELMGC.cpp

@@ -100 +100 @@
      * 'little' adjustment we do for DPL 0 selectors.
      */
-    PX86DESC   pShadowDescr = &pVM->selm.s.paGdtGC[iGDTEntry];
+    PX86DESC   pShadowDescr = &pVM->selm.s.paGdtRC[iGDTEntry];
     if (Desc.Gen.u1DescType)
     {
@@ -150 +150 @@
     if (Sel == (pRegFrame->cs & X86_SEL_MASK))
         Log(("GDT write to selector in CS register %04X\n", pRegFrame->cs));
-    else
-    if (Sel == (pRegFrame->ds & X86_SEL_MASK))
+    else if (Sel == (pRegFrame->ds & X86_SEL_MASK))
         Log(("GDT write to selector in DS register %04X\n", pRegFrame->ds));
-    else
-    if (Sel == (pRegFrame->es & X86_SEL_MASK))
+    else if (Sel == (pRegFrame->es & X86_SEL_MASK))
         Log(("GDT write to selector in ES register %04X\n", pRegFrame->es));
-    else
-    if (Sel == (pRegFrame->fs & X86_SEL_MASK))
+    else if (Sel == (pRegFrame->fs & X86_SEL_MASK))
         Log(("GDT write to selector in FS register %04X\n", pRegFrame->fs));
-    else
-    if (Sel == (pRegFrame->gs & X86_SEL_MASK))
+    else if (Sel == (pRegFrame->gs & X86_SEL_MASK))
         Log(("GDT write to selector in GS register %04X\n", pRegFrame->gs));
-    else
-    if (Sel == (pRegFrame->ss & X86_SEL_MASK))
+    else if (Sel == (pRegFrame->ss & X86_SEL_MASK))
         Log(("GDT write to selector in SS register %04X\n", pRegFrame->ss));
 #endif
@@ -182 +177 @@
  *                      (If it's a EIP range this's the EIP, if not it's pvFault.)
  */
-VMMRCDECL(int) selmgcGuestGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
-{
-    LogFlow(("selmgcGuestGDTWriteHandler errcode=%x fault=%VGv offRange=%08x\n", (uint32_t)uErrorCode, pvFault, offRange));
+VMMRCDECL(int) selmRCGuestGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+{
+    LogFlow(("selmRCGuestGDTWriteHandler errcode=%x fault=%VGv offRange=%08x\n", (uint32_t)uErrorCode, pvFault, offRange));
 
     /*
@@ -218 +213 @@
                 if (rc2 == VINF_SUCCESS)
                 {
-                    STAM_COUNTER_INC(&pVM->selm.s.StatGCWriteGuestGDTHandled);
+                    STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestGDTHandled);
                     return rc;
                 }
@@ -238 +233 @@
         VM_FF_SET(pVM, VM_FF_SELM_SYNC_GDT);
     }
-    STAM_COUNTER_INC(&pVM->selm.s.StatGCWriteGuestGDTUnhandled);
+    STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestGDTUnhandled);
     return rc;
 }
@@ -255 +250 @@
  *                      (If it's a EIP range this's the EIP, if not it's pvFault.)
  */
-VMMRCDECL(int) selmgcGuestLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+VMMRCDECL(int) selmRCGuestLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
 {
     /** @todo To be implemented. */
-    ////LogCom(("selmgcGuestLDTWriteHandler: eip=%08X pvFault=%VGv pvRange=%VGv\r\n", pRegFrame->eip, pvFault, pvRange));
+    ////LogCom(("selmRCGuestLDTWriteHandler: eip=%08X pvFault=%VGv pvRange=%VGv\r\n", pRegFrame->eip, pvFault, pvRange));
 
     VM_FF_SET(pVM, VM_FF_SELM_SYNC_LDT);
-    STAM_COUNTER_INC(&pVM->selm.s.StatGCWriteGuestLDT);
+    STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestLDT);
     return VINF_EM_RAW_EMULATE_INSTR_LDT_FAULT;
 }
@@ -278 +273 @@
  *                      (If it's a EIP range this's the EIP, if not it's pvFault.)
  */
-VMMRCDECL(int) selmgcGuestTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
-{
-    LogFlow(("selmgcGuestTSSWriteHandler errcode=%x fault=%VGv offRange=%08x\n", (uint32_t)uErrorCode, pvFault, offRange));
+VMMRCDECL(int) selmRCGuestTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+{
+    LogFlow(("selmRCGuestTSSWriteHandler errcode=%x fault=%VGv offRange=%08x\n", (uint32_t)uErrorCode, pvFault, offRange));
 
     /*
@@ -298 +293 @@
             ||  pGuestTSS->ss0  != (pVM->selm.s.Tss.ss1 & ~1)) /* undo raw-r0 */
         {
-            Log(("selmgcGuestTSSWriteHandler: R0 stack: %RTsel:%VGv -> %RTsel:%VGv\n",
+            Log(("selmRCGuestTSSWriteHandler: R0 stack: %RTsel:%VGv -> %RTsel:%VGv\n",
                  (RTSEL)(pVM->selm.s.Tss.ss1 & ~1), pVM->selm.s.Tss.esp1, (RTSEL)pGuestTSS->ss0, pGuestTSS->esp0));
             pVM->selm.s.Tss.esp1 = pGuestTSS->esp0;
             pVM->selm.s.Tss.ss1 = pGuestTSS->ss0 | 1;
-            STAM_COUNTER_INC(&pVM->selm.s.StatGCWriteGuestTSSHandledChanged);
+            STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestTSSHandledChanged);
         }
         if (CPUMGetGuestCR4(pVM) & X86_CR4_VME)
@@ -331 +326 @@
                     AssertMsg(rc == VINF_SUCCESS, ("MMGCRamRead %VGv failed with %Vrc\n", (uint8_t *)pGuestTSS + offIntRedirBitmap + i * 8, rc));
                 }
-                STAM_COUNTER_INC(&pVM->selm.s.StatGCWriteGuestTSSRedir);
+                STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestTSSRedir);
             }
         }
-        STAM_COUNTER_INC(&pVM->selm.s.StatGCWriteGuestTSSHandled);
+        STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestTSSHandled);
     }
     else
@@ -340 +335 @@
         Assert(VBOX_FAILURE(rc));
         VM_FF_SET(pVM, VM_FF_SELM_SYNC_TSS);
-        STAM_COUNTER_INC(&pVM->selm.s.StatGCWriteGuestTSSUnhandled);
+        STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestTSSUnhandled);
         if (rc == VERR_EM_INTERPRETER)
             rc = VINF_EM_RAW_EMULATE_INSTR_TSS_FAULT;
@@ -348 +343 @@
 
 
-
 /**
  * \#PF Virtual Handler callback for Guest write access to the VBox shadow GDT.
@@ -361 +355 @@
  *                      (If it's a EIP range this's the EIP, if not it's pvFault.)
  */
-VMMRCDECL(int) selmgcShadowGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
-{
-    LogRel(("FATAL ERROR: selmgcShadowGDTWriteHandler: eip=%08X pvFault=%VGv pvRange=%VGv\r\n", pRegFrame->eip, pvFault, pvRange));
+VMMRCDECL(int) selmRCShadowGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+{
+    LogRel(("FATAL ERROR: selmRCShadowGDTWriteHandler: eip=%08X pvFault=%VGv pvRange=%VGv\r\n", pRegFrame->eip, pvFault, pvRange));
     return VERR_SELM_SHADOW_GDT_WRITE;
 }
 
+
 /**
  * \#PF Virtual Handler callback for Guest write access to the VBox shadow LDT.
@@ -379 +374 @@
  *                      (If it's a EIP range this's the EIP, if not it's pvFault.)
  */
-VMMRCDECL(int) selmgcShadowLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
-{
-    LogRel(("FATAL ERROR: selmgcShadowLDTWriteHandler: eip=%08X pvFault=%VGv pvRange=%VGv\r\n", pRegFrame->eip, pvFault, pvRange));
-    Assert((RTRCPTR)pvFault >= pVM->selm.s.GCPtrLdt && (RTRCUINTPTR)pvFault < (RTRCUINTPTR)pVM->selm.s.GCPtrLdt + 65536 + PAGE_SIZE);
+VMMRCDECL(int) selmRCShadowLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+{
+    LogRel(("FATAL ERROR: selmRCShadowLDTWriteHandler: eip=%08X pvFault=%VGv pvRange=%VGv\r\n", pRegFrame->eip, pvFault, pvRange));
+    Assert((RTRCPTR)pvFault >= pVM->selm.s.pvLdtRC && (RTRCUINTPTR)pvFault < (RTRCUINTPTR)pVM->selm.s.pvLdtRC + 65536 + PAGE_SIZE);
     return VERR_SELM_SHADOW_LDT_WRITE;
 }
 
+
 /**
  * \#PF Virtual Handler callback for Guest write access to the VBox shadow TSS.
@@ -398 +394 @@
  *                      (If it's a EIP range this's the EIP, if not it's pvFault.)
  */
-VMMRCDECL(int) selmgcShadowTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
-{
-    LogRel(("FATAL ERROR: selmgcShadowTSSWriteHandler: eip=%08X pvFault=%VGv pvRange=%VGv\r\n", pRegFrame->eip, pvFault, pvRange));
+VMMRCDECL(int) selmRCShadowTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+{
+    LogRel(("FATAL ERROR: selmRCShadowTSSWriteHandler: eip=%08X pvFault=%VGv pvRange=%VGv\r\n", pRegFrame->eip, pvFault, pvRange));
     return VERR_SELM_SHADOW_TSS_WRITE;
 }
@@ -417 +413 @@
     if (pVM->selm.s.fSyncTSSRing0Stack)
     {
-        RCPTRTYPE(uint8_t *) GCPtrTss = (RCPTRTYPE(uint8_t *))pVM->selm.s.GCPtrGuestTss;
-        int     rc;
-        VBOXTSS tss;
+        uint8_t *   GCPtrGuestTss = (uint8_t *)(uintptr_t)pVM->selm.s.GCPtrGuestTss;
+        bool        fTriedAlready = false;
+        int         rc;
+        VBOXTSS     tss;
 
         Assert(pVM->selm.s.GCPtrGuestTss && pVM->selm.s.cbMonitoredGuestTss);
 
-#ifdef IN_GC
-        bool    fTriedAlready = false;
-
 l_tryagain:
-        rc  = MMGCRamRead(pVM, &tss.ss0,  GCPtrTss + RT_OFFSETOF(VBOXTSS, ss0), sizeof(tss.ss0));
-        rc |= MMGCRamRead(pVM, &tss.esp0, GCPtrTss + RT_OFFSETOF(VBOXTSS, esp0), sizeof(tss.esp0));
-  #ifdef DEBUG
-        rc |= MMGCRamRead(pVM, &tss.offIoBitmap, GCPtrTss + RT_OFFSETOF(VBOXTSS, offIoBitmap), sizeof(tss.offIoBitmap));
-  #endif
+        rc  = MMGCRamRead(pVM, &tss.ss0,  GCPtrGuestTss + RT_OFFSETOF(VBOXTSS, ss0), sizeof(tss.ss0));
+        rc |= MMGCRamRead(pVM, &tss.esp0, GCPtrGuestTss + RT_OFFSETOF(VBOXTSS, esp0), sizeof(tss.esp0));
+#ifdef DEBUG
+        rc |= MMGCRamRead(pVM, &tss.offIoBitmap, GCPtrGuestTss + RT_OFFSETOF(VBOXTSS, offIoBitmap), sizeof(tss.offIoBitmap));
+#endif
 
         if (VBOX_FAILURE(rc))
@@ -440 +434 @@
                 /** @todo might cross page boundary */
                 fTriedAlready = true;
-                rc = PGMPrefetchPage(pVM, (RTGCPTR)(RTRCUINTPTR)GCPtrTss);
+                rc = PGMPrefetchPage(pVM, (RTGCPTR)(uintptr_t)GCPtrGuestTss);
                 if (rc != VINF_SUCCESS)
                     return rc;
                 goto l_tryagain;
             }
-            AssertMsgFailed(("Unable to read TSS structure at %08X\n", GCPtrTss));
+            AssertMsgFailed(("Unable to read TSS structure at %RRv\n", GCPtrGuestTss));
             return rc;
         }
-
-#else /* !IN_GC */
-        /* Reading too much. Could be cheaper than two seperate calls though. */
-        rc = PGMPhysSimpleReadGCPtr(pVM, &tss, GCPtrTss, sizeof(VBOXTSS));
-        if (VBOX_FAILURE(rc))
-        {
-            AssertReleaseMsgFailed(("Unable to read TSS structure at %08X\n", GCPtrTss));
-            return rc;
-        }
-#endif /* !IN_GC */
 
 #ifdef LOG_ENABLED

trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp

@@ -704 +704 @@
     GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_TSS]);
     GEN_CHECK_OFF(SELM, aHyperSel[SELM_HYPER_SEL_TSS_TRAP08]);
-    GEN_CHECK_OFF(SELM, paGdtHC);
-    GEN_CHECK_OFF(SELM, paGdtGC);
+    GEN_CHECK_OFF(SELM, paGdtR3);
+    GEN_CHECK_OFF(SELM, paGdtRC);
     GEN_CHECK_OFF(SELM, GuestGdtr);
     GEN_CHECK_OFF(SELM, cbEffGuestGdtLimit);
-    GEN_CHECK_OFF(SELM, HCPtrLdt);
-    GEN_CHECK_OFF(SELM, GCPtrLdt);
+    GEN_CHECK_OFF(SELM, pvLdtR3);
+    GEN_CHECK_OFF(SELM, pvLdtRC);
     GEN_CHECK_OFF(SELM, GCPtrGuestLdt);
     GEN_CHECK_OFF(SELM, cbLdtLimit);
@@ -715 +715 @@
     GEN_CHECK_OFF(SELM, Tss);
     GEN_CHECK_OFF(SELM, TssTrap08);
-    GEN_CHECK_OFF(SELM, GCPtrTss);
+    GEN_CHECK_OFF(SELM, pvMonShwTssRC);
     GEN_CHECK_OFF(SELM, GCPtrGuestTss);
     GEN_CHECK_OFF(SELM, cbGuestTss);