Changeset 56672 in vbox for trunk/src/VBox

Timestamp:

Jun 29, 2015 12:53:55 PM (9 years ago)

Author:

vboxsync

Message:

VMM/GIM: Workaround PGM issue with large pages in Hyper-V by directly rewriting guest memory than using the MMIO2 mapping.

Location:

trunk/src/VBox/VMM

Files:

• VMMR0/GIMR0Hv.cpp (modified) (2 diffs)
• VMMR3/GIMHv.cpp (modified) (10 diffs)

trunk/src/VBox/VMM/VMMR0/GIMR0Hv.cpp

@@ -99 +99 @@
         return VERR_GIM_PVTSC_NOT_ENABLED;
 
+    /** @todo this is buggy when large pages are used due to a PGM limitation, see
+     *        @bugref{7532}.
+     *
+     *        In any case, we do not ever update this page while the guest is
+     *        running after setting it up (in ring-3, see gimR3HvEnableTscPage()) as
+     *        the TSC offset is handled in the VMCS/VMCB (HM) or by trapping RDTSC
+     *        (raw-mode). */
+#if 0
     PCGIMHV          pcHv     = &pVM->gim.s.u.Hv;
     PCGIMMMIO2REGION pcRegion = &pcHv->aMmio2Regions[GIM_HV_REF_TSC_PAGE_REGION_IDX];
@@ -128 +136 @@
     Assert(pRefTsc->u32TscSequence != 0);
     Assert(pRefTsc->u32TscSequence != UINT32_C(0xffffffff));
+#endif
     return VINF_SUCCESS;
 }

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

@@ -131 +131 @@
     pRegion->iRegion    = GIM_HV_HYPERCALL_PAGE_REGION_IDX;
     pRegion->fRCMapping = false;
-    pRegion->cbRegion   = PAGE_SIZE;
+    pRegion->cbRegion   = PAGE_SIZE;  /* Sanity checked in gimR3HvLoad(), gimR3HvEnableTscPage() & gimR3HvEnableHypercallPage() */
     pRegion->GCPhysPage = NIL_RTGCPHYS;
     RTStrCopy(pRegion->szDescription, sizeof(pRegion->szDescription), "Hyper-V hypercall page");
@@ -138 +138 @@
     pRegion->iRegion    = GIM_HV_REF_TSC_PAGE_REGION_IDX;
     pRegion->fRCMapping = false;
-    pRegion->cbRegion   = PAGE_SIZE;
+    pRegion->cbRegion   = PAGE_SIZE;  /* Sanity checked in gimR3HvLoad(), gimR3HvEnableTscPage() & gimR3HvEnableHypercallPage() */
     pRegion->GCPhysPage = NIL_RTGCPHYS;
     RTStrCopy(pRegion->szDescription, sizeof(pRegion->szDescription), "Hyper-V TSC page");
@@ -479 +479 @@
     rc = SSMR3GetStrZ(pSSM, pRegion->szDescription, sizeof(pRegion->szDescription));
     AssertRCReturn(rc, rc);
+
+    if (pRegion->cbRegion != PAGE_SIZE)
+        return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Hypercall page region size %u invalid, expected %u"),
+                                pRegion->cbRegion, PAGE_SIZE);
+
     if (MSR_GIM_HV_HYPERCALL_IS_ENABLED(pHv->u64HypercallMsr))
     {
@@ -505 +510 @@
     rc = SSMR3GetU32(pSSM, &uTscSequence);
     AssertRCReturn(rc, rc);
+
+    if (pRegion->cbRegion != PAGE_SIZE)
+        return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("TSC page region size %u invalid, expected %u"),
+                                pRegion->cbRegion, PAGE_SIZE);
+
     if (MSR_GIM_HV_REF_TSC_IS_ENABLED(pHv->u64TscPageMsr))
     {
@@ -560 +570 @@
      */
     Assert(!pRegion->fMapped);
+
+    /** @todo this is buggy when large pages are used due to a PGM limitation, see
+     *        @bugref{7532}. Instead of the overlay style mapping, we just
+     *               rewrite guest memory directly. */
+#if 0
     rc = GIMR3Mmio2Map(pVM, pRegion, GCPhysTscPage);
     if (RT_SUCCESS(rc))
@@ -592 +607 @@
     else
         LogRelFunc(("GIMR3Mmio2Map failed. rc=%Rrc\n", rc));
-
     return VERR_GIM_OPERATION_FAILED;
+#else
+    AssertReturn(pRegion->cbRegion == PAGE_SIZE, VERR_GIM_IPE_2);
+    PGIMHVREFTSC pRefTsc = (PGIMHVREFTSC)RTMemAllocZ(PAGE_SIZE);
+    if (RT_UNLIKELY(!pRefTsc))
+    {
+        LogRelFunc(("Failed to alloc %u bytes\n", PAGE_SIZE));
+        return VERR_NO_MEMORY;
+    }
+
+    uint64_t const u64TscKHz = TMCpuTicksPerSecond(pVM) / UINT64_C(1000);
+    uint32_t       u32TscSeq = 1;
+    if (   fUseThisTscSeq
+        && uTscSeq < UINT32_C(0xfffffffe))
+        u32TscSeq = uTscSeq + 1;
+    pRefTsc->u32TscSequence  = u32TscSeq;
+    pRefTsc->u64TscScale     = ((INT64_C(10000) << 32) / u64TscKHz) << 32;
+    pRefTsc->i64TscOffset    = 0;
+
+    rc = PGMPhysSimpleWriteGCPhys(pVM, GCPhysTscPage, pRefTsc, sizeof(*pRefTsc));
+    if (RT_SUCCESS(rc))
+    {
+        LogRel(("GIM: HyperV: Enabled TSC page at %#RGp - u64TscScale=%#RX64 u64TscKHz=%#RX64 (%'RU64) Seq=%#RU32\n",
+                GCPhysTscPage, pRefTsc->u64TscScale, u64TscKHz, u64TscKHz, pRefTsc->u32TscSequence));
+
+        pRegion->GCPhysPage = GCPhysTscPage;
+        pRegion->fMapped = true;
+        TMR3CpuTickParavirtEnable(pVM);
+    }
+    else
+    {
+        LogRelFunc(("GIM: HyperV: PGMPhysSimpleWriteGCPhys failed. rc=%Rrc\n", rc));
+        rc = VERR_GIM_OPERATION_FAILED;
+    }
+    RTMemFree(pRefTsc);
+    return rc;
+#endif
 }
 
@@ -609 +659 @@
     if (pRegion->fMapped)
     {
+#if 0
         GIMR3Mmio2Unmap(pVM, pRegion);
         Assert(!pRegion->fMapped);
+#else
+        pRegion->fMapped = false;
+#endif
         LogRel(("GIM: HyperV: Disabled TSC-page\n"));
 
@@ -631 +685 @@
     if (pRegion->fMapped)
     {
+#if 0
         GIMR3Mmio2Unmap(pVM, pRegion);
         Assert(!pRegion->fMapped);
+#else
+        pRegion->fMapped = false;
+#endif
         for (VMCPUID i = 0; i < pVM->cCpus; i++)
             VMMHypercallsDisable(&pVM->aCpus[i]);
@@ -674 +732 @@
      */
     Assert(!pRegion->fMapped);
+
+    /** @todo this is buggy when large pages are used due to a PGM limitation, see
+     *        @bugref{7532}. Instead of the overlay style mapping, we just
+     *               rewrite guest memory directly. */
+#if 0
     int rc = GIMR3Mmio2Map(pVM, pRegion, GCPhysHypercallPage);
     if (RT_SUCCESS(rc))
@@ -711 +774 @@
     LogRel(("GIM: HyperV: GIMR3Mmio2Map failed. rc=%Rrc\n", rc));
     return rc;
-}
-
+#else
+    AssertReturn(pRegion->cbRegion == PAGE_SIZE, VERR_GIM_IPE_3);
+    void *pvHypercallPage = RTMemAllocZ(PAGE_SIZE);
+    if (RT_UNLIKELY(!pvHypercallPage))
+    {
+        LogRelFunc(("Failed to alloc %u bytes\n", PAGE_SIZE));
+        return VERR_NO_MEMORY;
+    }
+
+    /*
+     * Patch the hypercall-page.
+     */
+    size_t cbWritten = 0;
+    int rc = VMMPatchHypercall(pVM, pvHypercallPage, PAGE_SIZE, &cbWritten);
+    if (   RT_SUCCESS(rc)
+        && cbWritten < PAGE_SIZE)
+    {
+        uint8_t *pbLast = (uint8_t *)pvHypercallPage + cbWritten;
+        *pbLast = 0xc3;  /* RET */
+
+        rc = PGMPhysSimpleWriteGCPhys(pVM, GCPhysHypercallPage, pvHypercallPage, PAGE_SIZE);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Notify VMM that hypercalls are now enabled for all VCPUs.
+             */
+            for (VMCPUID i = 0; i < pVM->cCpus; i++)
+                VMMHypercallsEnable(&pVM->aCpus[i]);
+
+            pRegion->GCPhysPage = GCPhysHypercallPage;
+            pRegion->fMapped = true;
+            LogRel(("GIM: HyperV: Enabled hypercalls at %#RGp\n", GCPhysHypercallPage));
+        }
+        else
+            LogRel(("GIM: HyperV: PGMPhysSimpleWriteGCPhys failed during hypercall page setup. rc=%Rrc\n", rc));
+    }
+    else
+    {
+        if (rc == VINF_SUCCESS)
+            rc = VERR_GIM_OPERATION_FAILED;
+        LogRel(("GIM: HyperV: VMMPatchHypercall failed. rc=%Rrc cbWritten=%u\n", rc, cbWritten));
+    }
+
+    RTMemFree(pvHypercallPage);
+    return rc;
+#endif
+}
+