Changeset 108386 in vbox for trunk/src/VBox/VMM

Timestamp:

Feb 26, 2025 9:14:34 AM (2 months ago)

Author:

vboxsync

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

167750

Message:

VMMR3/VMEmt.cpp,VMMR3/TM.cpp,VMMR3/NEMR3Native-win-armv8.cpp: Workaround for Windows/ARM hosts to allow for guests to use more than 1 vCPU, bugref:10392

Location:

trunk/src/VBox/VMM

Files:

• VMMR3/NEMR3Native-win-armv8.cpp (modified) (2 diffs)
• VMMR3/TM.cpp (modified) (1 diff)
• VMMR3/VMEmt.cpp (modified) (3 diffs)
• include/VMInternal.h (modified) (1 diff)

trunk/src/VBox/VMM/VMMR3/NEMR3Native-win-armv8.cpp

@@ -2698 +2698 @@
 
 
+VMMR3_INT_DECL(int) NEMR3Halt(PVM pVM, PVMCPU pVCpu)
+{
+    /*
+     * Try switch to NEM runloop state.
+     */
+    if (VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED_HALTED))
+    { /* likely */ }
+    else
+    {
+        VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED_EXEC_NEM_CANCELED);
+        LogFlow(("NEM/%u: returning immediately because canceled\n", pVCpu->idCpu));
+        return VINF_SUCCESS;
+    }
+
+    VBOXSTRICTRC    rcStrict            = VINF_SUCCESS;
+
+    /* Ensure that Hyper-V has the whole state. */
+    int rc2 = nemHCWinCopyStateToHyperV(pVM, pVCpu);
+    AssertRCReturn(rc2, rc2);
+
+    if (   !VM_FF_IS_ANY_SET(pVM, VM_FF_EMT_RENDEZVOUS | VM_FF_TM_VIRTUAL_SYNC)
+        && !VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_HM_TO_R3_MASK))
+    {
+        if (VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM_WAIT, VMCPUSTATE_STARTED_EXEC_NEM))
+        {
+            MY_WHV_RUN_VP_EXIT_CONTEXT ExitReason = {0};
+            HRESULT hrc = WHvRunVirtualProcessor(pVM->nem.s.hPartition, pVCpu->idCpu, &ExitReason, sizeof(ExitReason));
+            VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED_EXEC_NEM_WAIT);
+            TMNotifyEndOfExecution(pVM, pVCpu, ASMReadTSC());
+#ifdef LOG_ENABLED
+            LogFlow(("NEM/%u: Exit  @ @todo Reason=%#x\n", pVCpu->idCpu, ExitReason.ExitReason));
+#endif
+            if (SUCCEEDED(hrc))
+            {
+                /*
+                 * Deal with the message.
+                 */
+                rcStrict = nemR3WinHandleExit(pVM, pVCpu, &ExitReason);
+                LogFlow(("NEM/%u: breaking: nemHCWinHandleMessage -> %Rrc\n", pVCpu->idCpu, VBOXSTRICTRC_VAL(rcStrict) ));
+                STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnStatus);
+            }
+            else
+                AssertLogRelMsgFailedReturn(("WHvRunVirtualProcessor failed for CPU #%u: %#x (%u)\n",
+                                             pVCpu->idCpu, hrc, GetLastError()),
+                                            VERR_NEM_IPE_0);
+
+            /** @todo Try handle pending flags, not just return to EM loops.  Take care
+             *        not to set important RCs here unless we've handled a message. */
+            LogFlow(("NEM/%u: breaking: pending FF (%#x / %#RX64)\n",
+                     pVCpu->idCpu, pVM->fGlobalForcedActions, (uint64_t)pVCpu->fLocalForcedActions));
+            STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnFFPost);
+        }
+        else
+        {
+            LogFlow(("NEM/%u: breaking: canceled %d (pre exec)\n", pVCpu->idCpu, VMCPU_GET_STATE(pVCpu) ));
+            STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnCancel);
+        }
+    }
+    else
+    {
+        LogFlow(("NEM/%u: breaking: pending FF (pre exec)\n", pVCpu->idCpu));
+        STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatBreakOnFFPre);
+    }
+
+    if (!VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_HALTED, VMCPUSTATE_STARTED_EXEC_NEM))
+        VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_HALTED, VMCPUSTATE_STARTED_EXEC_NEM_CANCELED);
+
+    return rcStrict;
+}
+
+
 bool nemR3NativeSetSingleInstruction(PVM pVM, PVMCPU pVCpu, bool fEnable)
 {
@@ -3251 +3322 @@
  *
  * Open questions:
- *     - Why can't one read and write WHvArm64RegisterId*
- *     - WHvArm64RegisterDbgbcr0El1 is not readable?
- *     - Getting notified about system register reads/writes (GIC)?
  *     - InstructionByteCount and InstructionBytes for unmapped GPA exit are zero...
- *     - Handling of (vTimer) interrupts, how is WHvRequestInterrupt() supposed to be used?
- */
-
+ */
+

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

@@ -225 +225 @@
      * Init the structure.
      */
+#if defined(VBOX_VMM_TARGET_ARMV8) && defined(RT_OS_WINDOWS)
+    /*
+     * Workaround for Hyper-V on Windows/ARM:
+     *     On Windows/ARM EMTs of APs are waiting in Hyper-V because
+     *     there is no way currently to get notified of PSCI calls to turn them
+     *     on.
+     *     However because they are suspended they can't handle timers, so
+     *     this needs to be done by the boot processor.
+     *     We hope that Microsoft lifts this restriction in the future, allowing us
+     *     to use our already existing wait infrastructure for EMTs.
+     */
+    pVM->tm.s.idTimerCpu = 0;
+#else
     pVM->tm.s.idTimerCpu = pVM->cCpus - 1; /* The last CPU. */
+#endif
 
     int rc = PDMR3CritSectInit(pVM, &pVM->tm.s.VirtualSyncLock, RT_SRC_POS, "TM VirtualSync Lock");

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

@@ -1068 +1068 @@
 
 
+#if defined(VBOX_VMM_TARGET_ARMV8) && defined(RT_OS_WINDOWS)
+
+/**
+ * Method NEM - The host (NEM) does the halting.
+ */
+static DECLCALLBACK(int) vmR3HaltNemHalt(PUVMCPU pUVCpu, const uint64_t fMask, uint64_t u64Now)
+{
+    PVMCPU  pVCpu   = pUVCpu->pVCpu;
+
+    RT_NOREF(fMask, u64Now);
+    return NEMR3Halt(pUVCpu->pVM, pVCpu);
+}
+
+
+/**
+ * Default VMR3NotifyFF() worker.
+ *
+ * @param   pUVCpu          Pointer to the user mode VMCPU structure.
+ * @param   fFlags          Notification flags, VMNOTIFYFF_FLAGS_*.
+ */
+static DECLCALLBACK(void) vmR3NemNotifyCpuFF(PUVMCPU pUVCpu, uint32_t fFlags)
+{
+    PVMCPU pVCpu = pUVCpu->pVCpu;
+    if (pVCpu)
+        NEMR3NotifyFF(pUVCpu->pVM, pVCpu, fFlags);
+}
+#endif
+
+
 /**
  * Array with halt method descriptors.
@@ -1096 +1125 @@
     { VMHALTMETHOD_1,         false, vmR3HaltMethod1Init, NULL,   vmR3HaltMethod1Halt, vmR3DefaultWait,     vmR3DefaultNotifyCpuFF,     NULL },
     { VMHALTMETHOD_GLOBAL_1,   true, vmR3HaltGlobal1Init, NULL,   vmR3HaltGlobal1Halt, vmR3HaltGlobal1Wait, vmR3HaltGlobal1NotifyCpuFF, NULL },
+#if defined(VBOX_VMM_TARGET_ARMV8) && defined(RT_OS_WINDOWS)
+    { VMHALTMETHOD_NEM,       false, NULL,                NULL,   vmR3HaltNemHalt,     vmR3DefaultWait,     vmR3NemNotifyCpuFF,         NULL },
+#endif
 };
 
@@ -1418 +1450 @@
         LogRel(("VMEmt: Halt method %s (%d) not available in driverless mode, using %s (%d) instead\n",
                 vmR3GetHaltMethodName(enmHaltMethod), enmHaltMethod, vmR3GetHaltMethodName(VMHALTMETHOD_1), VMHALTMETHOD_1));
+#if defined(VBOX_VMM_TARGET_ARMV8) && defined(RT_OS_WINDOWS)
+        enmHaltMethod = VMHALTMETHOD_NEM;
+#else
         enmHaltMethod = VMHALTMETHOD_1;
+#endif
     }
 

trunk/src/VBox/VMM/include/VMInternal.h

@@ -155 +155 @@
     /** The first go at a more global approach. */
     VMHALTMETHOD_GLOBAL_1,
+#if defined(VBOX_VMM_TARGET_ARMV8) && defined(RT_OS_WINDOWS)
+    /** NEM takes over halting. */
+    VMHALTMETHOD_NEM,
+#endif
     /** The end of valid methods. (not inclusive of course) */
     VMHALTMETHOD_END,