Changeset 17106 in vbox for trunk/src/VBox/VMM/VMMGC

Timestamp:

Feb 25, 2009 12:35:15 AM (16 years ago)

Author:

vboxsync

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

43338

Message:

VMM,REM: Removed the single page limitation on the TSS monitoring and going over the interrupt redirection bitmap monitoring.

File:

• trunk/src/VBox/VMM/VMMGC/SELMGC.cpp (modified) (3 diffs)

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

@@ -255 +255 @@
 
 /**
+ * Read wrapper used by selmRCGuestTSSWriteHandler.
+ * @returns VBox status code (appropriate for trap handling and GC return).
+ * @param   pVM         The VM handle
+ * @param   pvDst       Where to put the bits we read.
+ * @param   pvSrc       Guest address to read from.
+ * @param   cb          The number of bytes to read.
+ */
+DECLINLINE(int) selmRCReadTssBits(PVM pVM, void *pvDst, void const *pvSrc, size_t cb)
+{
+    int rc = MMGCRamRead(pVM, pvDst, (void *)pvSrc, cb);
+    if (RT_SUCCESS(rc))
+        return VINF_SUCCESS;
+
+    /** @todo use different fallback?    */
+    rc = PGMPrefetchPage(pVM, (uintptr_t)pvSrc);
+    AssertMsg(rc == VINF_SUCCESS, ("PGMPrefetchPage %p failed with %Rrc\n", &pvSrc, rc));
+    if (rc == VINF_SUCCESS)
+    {
+        rc = MMGCRamRead(pVM, pvDst, (void *)pvSrc, cb);
+        AssertMsg(rc == VINF_SUCCESS, ("MMGCRamRead %p failed with %Rrc\n", &pvSrc, rc));
+    }
+    return rc;
+}
+
+/**
  * \#PF Virtual Handler callback for Guest write access to the Guest's own current TSS.
  *
@@ -271 +296 @@
 
     /*
-     * Try emulate the access and compare the R0 ss:esp with the shadow tss values.
-     *
-     * Note, that it's safe to access the TSS after a successfull instruction emulation,
-     * even if the stuff that was changed wasn't the ss0 or esp0 bits. The CPU insists
-     * on the TSS being all one physical page, so ASSUMING that we're not trapping
-     * I/O map accesses this is safe.
+     * Try emulate the access.
      */
     uint32_t cb;
@@ -282 +302 @@
     if (RT_SUCCESS(rc) && cb)
     {
-        PCVBOXTSS pGuestTSS = (PVBOXTSS)pVM->selm.s.GCPtrGuestTss;
-        if (    pGuestTSS->esp0 !=  pVM->selm.s.Tss.esp1
-            ||  pGuestTSS->ss0  != (pVM->selm.s.Tss.ss1 & ~1)) /* undo raw-r0 */
+        rc = VINF_SUCCESS;
+
+        /*
+         * If it's on the same page as the esp0 and ss0 fields or actually one of them,
+         * then check if any of these has changed.
+         */
+        PCVBOXTSS pGuestTss = (PVBOXTSS)pVM->selm.s.GCPtrGuestTss;
+        if (    PAGE_ADDRESS(&pGuestTss->esp0) == PAGE_ADDRESS(&pGuestTss->padding_ss0)
+            &&  PAGE_ADDRESS(&pGuestTss->esp0) == PAGE_ADDRESS((uint8_t *)pGuestTss + offRange)
+            &&  (    pGuestTss->esp0 !=  pVM->selm.s.Tss.esp1
+                 ||  pGuestTss->ss0  != (pVM->selm.s.Tss.ss1 & ~1)) /* undo raw-r0 */
+           )
         {
             Log(("selmRCGuestTSSWriteHandler: R0 stack: %RTsel:%RGv -> %RTsel:%RGv\n",
-                 (RTSEL)(pVM->selm.s.Tss.ss1 & ~1), (RTGCPTR)pVM->selm.s.Tss.esp1, (RTSEL)pGuestTSS->ss0, (RTGCPTR)pGuestTSS->esp0));
-            pVM->selm.s.Tss.esp1 = pGuestTSS->esp0;
-            pVM->selm.s.Tss.ss1 = pGuestTSS->ss0 | 1;
+                 (RTSEL)(pVM->selm.s.Tss.ss1 & ~1), (RTGCPTR)pVM->selm.s.Tss.esp1, (RTSEL)pGuestTss->ss0, (RTGCPTR)pGuestTss->esp0));
+            pVM->selm.s.Tss.esp1 = pGuestTss->esp0;
+            pVM->selm.s.Tss.ss1  = pGuestTss->ss0 | 1;
             STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestTSSHandledChanged);
         }
-        if (CPUMGetGuestCR4(pVM) & X86_CR4_VME)
-        {
-            uint32_t offIntRedirBitmap = pGuestTSS->offIoBitmap - sizeof(pVM->selm.s.Tss.IntRedirBitmap);
-
-            /** @todo not sure how the partial case is handled; probably not allowed */
-            if (   offIntRedirBitmap <= offRange
-                && offIntRedirBitmap + sizeof(pVM->selm.s.Tss.IntRedirBitmap) >= offRange + cb
-                && offIntRedirBitmap + sizeof(pVM->selm.s.Tss.IntRedirBitmap) <= pVM->selm.s.cbGuestTss)
+        /* Handle misaligned TSS in a safe manner (just in case). */
+        else if (   offRange >= RT_UOFFSETOF(VBOXTSS, esp0)
+                 && offRange < RT_UOFFSETOF(VBOXTSS, padding_ss0))
+        {
+            struct
             {
-                Log(("offIoBitmap=%x offIntRedirBitmap=%x cbTSS=%x\n", pGuestTSS->offIoBitmap, offIntRedirBitmap, pVM->selm.s.cbGuestTss));
-                /** @todo only update the changed part. */
-                for (uint32_t i = 0; i < sizeof(pVM->selm.s.Tss.IntRedirBitmap) / 8;i++)
+                uint32_t esp0;
+                uint16_t ss0;
+                uint16_t padding_ss0;
+            } s;
+            AssertCompileSize(s, 8);
+            rc = selmRCReadTssBits(pVM, &s, &pGuestTss->esp0, sizeof(s));
+            if (    rc == VINF_SUCCESS
+                &&  (    s.esp0 !=  pVM->selm.s.Tss.esp1
+                     ||  s.ss0  != (pVM->selm.s.Tss.ss1 & ~1)) /* undo raw-r0 */
+               )
+            {
+                Log(("selmRCGuestTSSWriteHandler: R0 stack: %RTsel:%RGv -> %RTsel:%RGv\n",
+                     (RTSEL)(pVM->selm.s.Tss.ss1 & ~1), (RTGCPTR)pVM->selm.s.Tss.esp1, (RTSEL)s.ss0, (RTGCPTR)s.esp0));
+                pVM->selm.s.Tss.esp1 = s.esp0;
+                pVM->selm.s.Tss.ss1  = s.ss0 | 1;
+                STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestTSSHandledChanged);
+            }
+        }
+
+        /*
+         * If VME is enabled we need to check if the interrupt redirection bitmap
+         * needs updating.
+         */
+        if (    offRange >= RT_UOFFSETOF(VBOXTSS, offIoBitmap)
+            &&  (CPUMGetGuestCR4(pVM) & X86_CR4_VME))
+        {
+            if (offRange - RT_UOFFSETOF(VBOXTSS, offIoBitmap) < sizeof(pGuestTss->offIoBitmap))
+            {
+                uint16_t offIoBitmap = pGuestTss->offIoBitmap;
+                if (offIoBitmap != pVM->selm.s.offGuestIoBitmap)
                 {
-                    rc = MMGCRamRead(pVM, &pVM->selm.s.Tss.IntRedirBitmap[i * 8], (uint8_t *)pGuestTSS + offIntRedirBitmap + i * 8, 8);
-                    if (RT_FAILURE(rc))
+                    Log(("TSS offIoBitmap changed: old=%#x new=%#x -> resync in ring-3\n", pVM->selm.s.offGuestIoBitmap, offIoBitmap));
+                    VM_FF_SET(pVM, VM_FF_SELM_SYNC_TSS);
+                    VM_FF_SET(pVM, VM_FF_TO_R3);
+                }
+                else
+                    Log(("TSS offIoBitmap: old=%#x new=%#x [unchanged]\n", pVM->selm.s.offGuestIoBitmap, offIoBitmap));
+            }
+            else
+            {
+                /** @todo not sure how the partial case is handled; probably not allowed */
+                uint32_t offIntRedirBitmap = pVM->selm.s.offGuestIoBitmap - sizeof(pVM->selm.s.Tss.IntRedirBitmap);
+                if (   offIntRedirBitmap <= offRange
+                    && offIntRedirBitmap + sizeof(pVM->selm.s.Tss.IntRedirBitmap) >= offRange + cb
+                    && offIntRedirBitmap + sizeof(pVM->selm.s.Tss.IntRedirBitmap) <= pVM->selm.s.cbGuestTss)
+                {
+                    Log(("TSS IntRedirBitmap Changed: offIoBitmap=%x offIntRedirBitmap=%x cbTSS=%x offRange=%x cb=%x\n",
+                         pVM->selm.s.offGuestIoBitmap, offIntRedirBitmap, pVM->selm.s.cbGuestTss, offRange, cb));
+
+                    /** @todo only update the changed part. */
+                    for (uint32_t i = 0; i < sizeof(pVM->selm.s.Tss.IntRedirBitmap) / 8; i++)
                     {
-                        /* Shadow page table might be out of sync */
-                        rc = PGMPrefetchPage(pVM, (RTGCPTR)(RTRCUINTPTR)((uint8_t *)pGuestTSS + offIntRedirBitmap + i*8));
-                        if (RT_FAILURE(rc))
-                        {
-                            AssertMsg(rc == VINF_SUCCESS, ("PGMPrefetchPage %RGv failed with %Rrc\n", (RTGCPTR)((uintptr_t)pGuestTSS + offIntRedirBitmap + i*8), rc));
+                        rc = selmRCReadTssBits(pVM, &pVM->selm.s.Tss.IntRedirBitmap[i * 8],
+                                               (uint8_t *)pGuestTss + offIntRedirBitmap + i * 8, 8);
+                        if (rc != VINF_SUCCESS)
                             break;
-                        }
-                        rc = MMGCRamRead(pVM, &pVM->selm.s.Tss.IntRedirBitmap[i * 8], (uint8_t *)pGuestTSS + offIntRedirBitmap + i * 8, 8);
                     }
-                    AssertMsg(rc == VINF_SUCCESS, ("MMGCRamRead %RGv failed with %Rrc\n", (RTGCPTR)((uintptr_t)pGuestTSS + offIntRedirBitmap + i * 8), rc));
+                    STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestTSSRedir);
                 }
-                STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestTSSRedir);
             }
         }
+
+        /* Return to ring-3 for a full resync if any of the above fails... (?) */
+        if (rc != VINF_SUCCESS)
+        {
+            VM_FF_SET(pVM, VM_FF_SELM_SYNC_TSS);
+            VM_FF_SET(pVM, VM_FF_TO_R3);
+            if (RT_SUCCESS(rc))
+                rc = VINF_SUCCESS;
+        }
+
         STAM_COUNTER_INC(&pVM->selm.s.StatRCWriteGuestTSSHandled);
     }