Changeset 19395 in vbox

Timestamp:

May 5, 2009 8:28:42 PM (16 years ago)

Author:

vboxsync

Message:

GVMM,VM: Register the other EMTs or we assert painfully in gvmmR0ByVMAndEMT. A couple of todos and stuff.

Location:

trunk

Files:

• include/VBox/gvm.h (modified) (2 diffs)
• include/VBox/gvmm.h (modified) (2 diffs)
• src/VBox/VMM/VM.cpp (modified) (13 diffs)
• src/VBox/VMM/VMEmt.cpp (modified) (6 diffs)
• src/VBox/VMM/VMMAll/REMAll.cpp (modified) (1 diff)
• src/VBox/VMM/VMMR0/GVMMR0.cpp (modified) (33 diffs)
• src/VBox/VMM/VMReq.cpp (modified) (1 diff)

trunk/include/VBox/gvm.h

@@ -42 +42 @@
 typedef struct GVMCPU
 {
-    /* VCPU id (0 - (pVM->cCPUs - 1) */
-    uint32_t        idCpu;
+    /** VCPU id (0 - (pVM->cCPUs - 1). */
+    VMCPUID         idCpu;
 
     /** Handle to the EMT thread. */
@@ -83 +83 @@
     /** The ring-0 mapping of the VM structure. */
     PVM             pVM;
-    /** Number of VCPUs (same as pVM->cCPUs) */
-    uint32_t        cCPUs;
+    /** Number of Virtual CPUs, i.e. how many entries there are in aCpus.
+     * Same same as PVM::cCPUs. */
+    uint32_t        cCpus;
     uint32_t        padding;
 

trunk/include/VBox/gvmm.h

@@ -125 +125 @@
 GVMMR0DECL(int)     GVMMR0QueryConfig(PSUPDRVSESSION pSession, const char *pszName, uint64_t *pu64Value);
 
-GVMMR0DECL(int)     GVMMR0CreateVM(PSUPDRVSESSION pSession, uint32_t cCPUs, PVM *ppVM);
+GVMMR0DECL(int)     GVMMR0CreateVM(PSUPDRVSESSION pSession, uint32_t cCpus, PVM *ppVM);
 GVMMR0DECL(int)     GVMMR0InitVM(PVM pVM);
 GVMMR0DECL(void)    GVMMR0DoneInitVM(PVM pVM);
 GVMMR0DECL(bool)    GVMMR0DoingTermVM(PVM pVM, PGVM pGVM);
 GVMMR0DECL(int)     GVMMR0DestroyVM(PVM pVM);
-GVMMR0DECL(int)     GVMMR0RegisterVCpu(PVM pVM, unsigned idCpu);
+GVMMR0DECL(int)     GVMMR0RegisterVCpu(PVM pVM, VMCPUID idCpu);
 GVMMR0DECL(PGVM)    GVMMR0ByHandle(uint32_t hGVM);
 GVMMR0DECL(PGVM)    GVMMR0ByVM(PVM pVM);
-GVMMR0DECL(int)     GVMMR0ByVMAndEMT(PVM pVM, unsigned idCpu, PGVM *ppGVM);
+GVMMR0DECL(int)     GVMMR0ByVMAndEMT(PVM pVM, VMCPUID idCpu, PGVM *ppGVM);
 GVMMR0DECL(PVM)     GVMMR0GetVMByHandle(uint32_t hGVM);
 GVMMR0DECL(PVM)     GVMMR0GetVMByEMT(RTNATIVETHREAD hEMT);
-GVMMR0DECL(int)     GVMMR0SchedHalt(PVM pVM, unsigned idCpu, uint64_t u64ExpireGipTime);
-GVMMR0DECL(int)     GVMMR0SchedWakeUp(PVM pVM, unsigned idCpu);
-GVMMR0DECL(int)     GVMMR0SchedPoll(PVM pVM, unsigned idCpu, bool fYield);
+GVMMR0DECL(int)     GVMMR0SchedHalt(PVM pVM, VMCPUID idCpu, uint64_t u64ExpireGipTime);
+GVMMR0DECL(int)     GVMMR0SchedWakeUp(PVM pVM, VMCPUID idCpu);
+GVMMR0DECL(int)     GVMMR0SchedPoll(PVM pVM, VMCPUID idCpu, bool fYield);
 GVMMR0DECL(int)     GVMMR0QueryStatistics(PGVMMSTATS pStats, PSUPDRVSESSION pSession, PVM pVM);
 GVMMR0DECL(int)     GVMMR0ResetStatistics(PCGVMMSTATS pStats, PSUPDRVSESSION pSession, PVM pVM);
@@ -153 +153 @@
     PSUPDRVSESSION  pSession;
     /** Number of virtual CPUs for the new VM. (IN) */
-    uint32_t        cCPUs;
+    uint32_t        cCpus;
     /** Pointer to the ring-3 mapping of the shared VM structure on return. (OUT) */
     PVMR3           pVMR3;

trunk/src/VBox/VMM/VM.cpp

@@ -237 +237 @@
             /*
              * Call vmR3CreateU in the EMT thread and wait for it to finish.
+             *
+             * Note! VMCPUID_ANY is used here because VMR3ReqQueueU would have trouble
+             *       submitting a request to a specific VCPU without a pVM. So, to make
+             *       sure init is running on EMT(0), vmR3EmulationThreadWithId makes sure
+             *       that only EMT(0) is servicing VMCPUID_ANY requests when pVM is NULL.
              */
             PVMREQ pReq;
-            rc = VMR3ReqCallU(pUVM, VMCPUID_ANY /* can't use CPU0 here as it's too early (pVM==0) */, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3CreateU,
-                              4, pUVM, cCPUs, pfnCFGMConstructor, pvUserCFGM);
+            rc = VMR3ReqCallU(pUVM, VMCPUID_ANY, &pReq, RT_INDEFINITE_WAIT, 0, (PFNRT)vmR3CreateU, 4,
+                              pUVM, cCPUs, pfnCFGMConstructor, pvUserCFGM);
             if (RT_SUCCESS(rc))
             {
@@ -379 +384 @@
  *
  * @returns VBox status code.
- * @param   cCPUs   Number of virtual CPUs
+ * @param   cCpus   Number of virtual CPUs
  * @param   ppUVM   Where to store the UVM pointer.
  */
-static int vmR3CreateUVM(uint32_t cCPUs, PUVM *ppUVM)
+static int vmR3CreateUVM(uint32_t cCpus, PUVM *ppUVM)
 {
     uint32_t i;
@@ -389 +394 @@
      * Create and initialize the UVM.
      */
-    PUVM pUVM = (PUVM)RTMemAllocZ(RT_OFFSETOF(UVM, aCpus[cCPUs]));
+    PUVM pUVM = (PUVM)RTMemAllocZ(RT_OFFSETOF(UVM, aCpus[cCpus]));
     AssertReturn(pUVM, VERR_NO_MEMORY);
     pUVM->u32Magic = UVM_MAGIC;
-    pUVM->cCpus = cCPUs;
+    pUVM->cCpus = cCpus;
 
     AssertCompile(sizeof(pUVM->vm.s) <= sizeof(pUVM->vm.padding));
@@ -404 +409 @@
 
     /* Initialize the VMCPU array in the UVM. */
-    for (i = 0; i < cCPUs; i++)
+    for (i = 0; i < cCpus; i++)
     {
         pUVM->aCpus[i].pUVM   = pUVM;
@@ -416 +421 @@
     {
         /* Allocate a halt method event semaphore for each VCPU. */
-        for (i = 0; i < cCPUs; i++)
+        for (i = 0; i < cCpus; i++)
         {
             rc = RTSemEventCreate(&pUVM->aCpus[i].vm.s.EventSemWait);
@@ -440 +445 @@
                          * Start the emulation threads for all VMCPUs.
                          */
-                        for (i = 0; i < cCPUs; i++)
+                        for (i = 0; i < cCpus; i++)
                         {
                             rc = RTThreadCreate(&pUVM->aCpus[i].vm.s.ThreadEMT, vmR3EmulationThread, &pUVM->aCpus[i], _1M,
@@ -467 +472 @@
                 STAMR3TermUVM(pUVM);
             }
-            for (i = 0; i < cCPUs; i++)
+            for (i = 0; i < cCpus; i++)
             {
                 RTSemEventDestroy(pUVM->aCpus[i].vm.s.EventSemWait);
+                pUVM->aCpus[i].vm.s.EventSemWait = NIL_RTSEMEVENT;
             }
         }
@@ -484 +490 @@
  * @thread EMT
  */
-static int vmR3CreateU(PUVM pUVM, uint32_t cCPUs, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM)
+static int vmR3CreateU(PUVM pUVM, uint32_t cCpus, PFNCFGMCONSTRUCTOR pfnCFGMConstructor, void *pvUserCFGM)
 {
     int rc = VINF_SUCCESS;
@@ -510 +516 @@
     CreateVMReq.pVMR0           = NIL_RTR0PTR;
     CreateVMReq.pVMR3           = NULL;
-    CreateVMReq.cCPUs           = cCPUs;
+    CreateVMReq.cCpus           = cCpus;
     rc = SUPCallVMMR0Ex(NIL_RTR0PTR, 0 /* VCPU 0 */, VMMR0_DO_GVMM_CREATE_VM, 0, &CreateVMReq.Hdr);
     if (RT_SUCCESS(rc))
@@ -518 +524 @@
         AssertRelease(pVM->pVMR0 == CreateVMReq.pVMR0);
         AssertRelease(pVM->pSession == pUVM->vm.s.pSession);
-        AssertRelease(pVM->cCPUs == cCPUs);
+        AssertRelease(pVM->cCPUs == cCpus);
         AssertRelease(pVM->offVMCPU == RT_UOFFSETOF(VM, aCpus));
 
@@ -571 +577 @@
                 rc = CFGMR3QueryU32Def(CFGMR3GetRoot(pVM), "NumCPUs", &cCPUsCfg, 1);
                 AssertLogRelMsgRC(rc, ("Configuration error: Querying \"NumCPUs\" as integer failed, rc=%Rrc\n", rc));
-                if (RT_SUCCESS(rc) && cCPUsCfg != cCPUs)
+                if (RT_SUCCESS(rc) && cCPUsCfg != cCpus)
                 {
                     AssertLogRelMsgFailed(("Configuration error: \"NumCPUs\"=%RU32 and VMR3CreateVM::cCPUs=%RU32 does not match!\n",
-                                           cCPUsCfg, cCPUs));
+                                           cCPUsCfg, cCpus));
                     rc = VERR_INVALID_PARAMETER;
                 }
@@ -667 +673 @@
 }
 
+/**
+ * Register the calling EMT with GVM.
+ *
+ * @returns VBox status code.
+ * @param   pVM         The VM handle.
+ * @param   idCpu       The Virtual CPU ID.
+ */
+static DECLCALLBACK(int) vmR3RegisterEMT(PVM pVM, VMCPUID idCpu)
+{
+    Assert(VMMGetCpuId(pVM) == idCpu);
+    int rc = SUPCallVMMR0Ex(pVM->pVMR0, idCpu, VMMR0_DO_GVMM_REGISTER_VMCPU, 0, NULL);
+    if (RT_FAILURE(rc))
+        LogRel(("idCpu=%u rc=%Rrc\n", idCpu, rc));
+    return rc;
+}
+
 
 /**
@@ -674 +696 @@
 {
     int rc;
+
+    /*
+     * Register the other EMTs with GVM.
+     */
+    for (VMCPUID idCpu = 1; idCpu < pVM->cCPUs; idCpu++)
+    {
+        PVMREQ pReq;
+        rc = VMR3ReqCallU(pUVM, idCpu, &pReq, RT_INDEFINITE_WAIT, 0 /*fFlags*/,
+                          (PFNRT)vmR3RegisterEMT, 2, pVM, idCpu);
+        if (RT_SUCCESS(rc))
+            rc = pReq->iStatus;
+        VMR3ReqFree(pReq);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
 
     /*

trunk/src/VBox/VMM/VMEmt.cpp

@@ -44 +44 @@
 #include <iprt/time.h>
 
-
-/**
- * The emulation thread.
+/*******************************************************************************
+*   Internal Functions                                                         *
+*******************************************************************************/
+int vmR3EmulationThreadWithId(RTTHREAD ThreadSelf, PUVMCPU pUVCpu, VMCPUID idCpu);
+
+
+/**
+ * The emulation thread main function.
  *
  * @returns Thread exit code.
  * @param   ThreadSelf  The handle to the executing thread.
- * @param   pvArgs      Pointer to the user mode VM structure (UVM).
+ * @param   pvArgs      Pointer to the user mode per-VCpu structure (UVMPCU).
  */
 DECLCALLBACK(int) vmR3EmulationThread(RTTHREAD ThreadSelf, void *pvArgs)
 {
     PUVMCPU pUVCpu = (PUVMCPU)pvArgs;
-    PUVM    pUVM    = pUVCpu->pUVM;
-    RTCPUID idCpu   = pUVCpu->idCpu;
+    return vmR3EmulationThreadWithId(ThreadSelf, pUVCpu, pUVCpu->idCpu);
+}
+
+
+/**
+ * The emulation thread main function, with Virtual CPU ID for debugging.
+ *
+ * @returns Thread exit code.
+ * @param   ThreadSelf  The handle to the executing thread.
+ * @param   pUVCpu      Pointer to the user mode per-VCpu structure.
+ * @param   idCpu       The virtual CPU ID, for backtrace purposes.
+ */
+int vmR3EmulationThreadWithId(RTTHREAD ThreadSelf, PUVMCPU pUVCpu, VMCPUID idCpu)
+{
+    PUVM    pUVM = pUVCpu->pUVM;
     int     rc;
 
@@ -95 +113 @@
             }
 
+            /*
+             * Only the first VCPU may initialize the VM during early init
+             * and must therefore service all VMCPUID_ANY requests.
+             * See also VMR3Create
+             */
             if (    pUVM->vm.s.pReqs
-                &&  pUVCpu->idCpu == 0 /* Only the first VCPU may initialize the VM during early init */)
+                &&  pUVCpu->idCpu == 0)
             {
                 /*
-                 * Service execute in EMT request.
+                 * Service execute in any EMT request.
                  */
                 rc = VMR3ReqProcessU(pUVM, VMCPUID_ANY);
                 Log(("vmR3EmulationThread: Req rc=%Rrc, VM state %d -> %d\n", rc, enmBefore, pUVM->pVM ? pUVM->pVM->enmVMState : VMSTATE_CREATING));
             }
-            else
-            if (pUVCpu->vm.s.pReqs)
+            else if (pUVCpu->vm.s.pReqs)
             {
                 /*
-                 * Service execute in EMT request.
+                 * Service execute in specific EMT request.
                  */
                 rc = VMR3ReqProcessU(pUVM, pUVCpu->idCpu);
@@ -143 +165 @@
             {
                 /*
-                 * Service execute in EMT request.
+                 * Service execute in any EMT request.
                  */
                 rc = VMR3ReqProcessU(pUVM, VMCPUID_ANY);
@@ -151 +173 @@
             {
                 /*
-                 * Service execute in EMT request.
+                 * Service execute in specific EMT request.
                  */
                 rc = VMR3ReqProcessU(pUVM, pUVCpu->idCpu);
@@ -692 +714 @@
     PVMCPU  pVCpu = pUVCpu->pVCpu;
     PVM     pVM   = pUVCpu->pVM;
+    Assert(VMMGetCpu(pVM) == pVCpu);
 
     /*
@@ -775 +798 @@
     PVM    pVM   = pUVCpu->pUVM->pVM;
     PVMCPU pVCpu = VMMGetCpu(pVM);
+    Assert(pVCpu->idCpu == pUVCpu->idCpu);
 
     int rc = VINF_SUCCESS;

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

@@ -58 +58 @@
     {
         /* Tell the recompiler to flush its TLB. */
+#ifndef DEBUG_bird /* temporary */
         Assert(pVM->cCPUs == 1); /* @todo SMP */
+#endif
         CPUMSetChangedFlags(VMMGetCpu(pVM), CPUM_CHANGED_GLOBAL_TLB_FLUSH);
         pVM->rem.s.cInvalidatedPages = 0;

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

@@ -189 +189 @@
 static DECLCALLBACK(void) gvmmR0HandleObjDestructor(void *pvObj, void *pvGVMM, void *pvHandle);
 static int gvmmR0ByVM(PVM pVM, PGVM *ppGVM, PGVMM *ppGVMM, bool fTakeUsedLock);
-static int gvmmR0ByVMAndEMT(PVM pVM, unsigned idCpu, PGVM *ppGVM, PGVMM *ppGVMM);
+static int gvmmR0ByVMAndEMT(PVM pVM, VMCPUID idCpu, PGVM *ppGVM, PGVMM *ppGVMM);
 
 
@@ -486 +486 @@
     pReq->pVMR0 = NULL;
     pReq->pVMR3 = NIL_RTR3PTR;
-    int rc = GVMMR0CreateVM(pReq->pSession, pReq->cCPUs, &pVM);
+    int rc = GVMMR0CreateVM(pReq->pSession, pReq->cCpus, &pVM);
     if (RT_SUCCESS(rc))
     {
@@ -503 +503 @@
  * @returns VBox status code.
  * @param   pSession    The support driver session.
- * @param   cCPUs       Number of virtual CPUs for the new VM.
+ * @param   cCpus       Number of virtual CPUs for the new VM.
  * @param   ppVM        Where to store the pointer to the VM structure.
  *
  * @thread  EMT.
  */
-GVMMR0DECL(int) GVMMR0CreateVM(PSUPDRVSESSION pSession, uint32_t cCPUs, PVM *ppVM)
+GVMMR0DECL(int) GVMMR0CreateVM(PSUPDRVSESSION pSession, uint32_t cCpus, PVM *ppVM)
 {
     LogFlow(("GVMMR0CreateVM: pSession=%p\n", pSession));
@@ -517 +517 @@
     *ppVM = NULL;
 
-    if (    cCPUs == 0
-        ||  cCPUs > VMCPU_MAX_CPU_COUNT)
+    if (    cCpus == 0
+        ||  cCpus > VMCPU_MAX_CPU_COUNT)
         return VERR_INVALID_PARAMETER;
 
@@ -571 +571 @@
                      * Allocate the global VM structure (GVM) and initialize it.
                      */
-                    PGVM pGVM = (PGVM)RTMemAllocZ(RT_UOFFSETOF(GVM, aCpus[cCPUs]));
+                    PGVM pGVM = (PGVM)RTMemAllocZ(RT_UOFFSETOF(GVM, aCpus[cCpus]));
                     if (pGVM)
                     {
@@ -577 +577 @@
                         pGVM->hSelf     = iHandle;
                         pGVM->pVM       = NULL;
-                        pGVM->cCPUs     = cCPUs;
+                        pGVM->cCpus     = cCpus;
 
                         gvmmR0InitPerVMData(pGVM);
@@ -585 +585 @@
                          * Allocate the shared VM structure and associated page array.
                          */
-                        const uint32_t  cbVM   = RT_UOFFSETOF(VM, aCpus[cCPUs]);
+                        const uint32_t  cbVM   = RT_UOFFSETOF(VM, aCpus[cCpus]);
                         const uint32_t  cPages = RT_ALIGN_32(cbVM, PAGE_SIZE) >> PAGE_SHIFT;
                         rc = RTR0MemObjAllocLow(&pGVM->gvmm.s.VMMemObj, cPages << PAGE_SHIFT, false /* fExecutable */);
@@ -597 +597 @@
                             pVM->hSelf      = iHandle;
                             pVM->cbSelf     = cbVM;
-                            pVM->cCPUs      = cCPUs;
+                            pVM->cCPUs      = cCpus;
                             pVM->offVMCPU   = RT_UOFFSETOF(VM, aCpus);
 
@@ -622 +622 @@
 
                                     /* Initialize all the VM pointers. */
-                                    for (uint32_t i = 0; i < cCPUs; i++)
+                                    for (uint32_t i = 0; i < cCpus; i++)
                                     {
                                         pVM->aCpus[i].pVMR0 = pVM;
@@ -709 +709 @@
     pGVM->gvmm.s.fDoneVMMR0Term = false;
 
-    for (unsigned i=0; i< pGVM->cCPUs; i++)
+    for (VMCPUID i = 0; i < pGVM->cCpus; i++)
     {
         pGVM->aCpus[i].gvmm.s.HaltEventMulti = NIL_RTSEMEVENTMULTI;
@@ -732 +732 @@
     PGVM pGVM;
     PGVMM pGVMM;
-    int rc = gvmmR0ByVMAndEMT(pVM, 0 /* VCPU 0 */, &pGVM, &pGVMM);
+    int rc = gvmmR0ByVMAndEMT(pVM, 0 /* idCpu */, &pGVM, &pGVMM);
     if (RT_SUCCESS(rc))
     {
@@ -738 +738 @@
             && pGVM->aCpus[0].gvmm.s.HaltEventMulti == NIL_RTSEMEVENTMULTI)
         {
-            for (unsigned i=0; i < pGVM->cCPUs; i++)
+            for (VMCPUID i = 0; i < pGVM->cCpus; i++)
             {
                 rc = RTSemEventMultiCreate(&pGVM->aCpus[i].gvmm.s.HaltEventMulti);
@@ -762 +762 @@
  *
  * @param   pVM         Pointer to the shared VM structure.
+ * @thread  EMT(0)
  */
 GVMMR0DECL(void) GVMMR0DoneInitVM(PVM pVM)
@@ -768 +769 @@
     PGVM pGVM;
     PGVMM pGVMM;
-    int rc = gvmmR0ByVMAndEMT(pVM, 0 /* VCPU 0 */, &pGVM, &pGVMM);
+    int rc = gvmmR0ByVMAndEMT(pVM, 0 /* idCpu */, &pGVM, &pGVMM);
     AssertRCReturnVoid(rc);
 
@@ -782 +783 @@
  * @param   pVM         Pointer to the shared VM structure.
  * @param   pGVM        Pointer to the global VM structure. Optional.
+ * @thread  EMT(0)
  */
 GVMMR0DECL(bool) GVMMR0DoingTermVM(PVM pVM, PGVM pGVM)
@@ -791 +793 @@
     {
         PGVMM pGVMM;
-        int rc = gvmmR0ByVMAndEMT(pVM, 0 /* VCPU 0 */, &pGVM, &pGVMM);
+        int rc = gvmmR0ByVMAndEMT(pVM, 0 /* idCpu */, &pGVM, &pGVMM);
         AssertRCReturn(rc, false);
     }
@@ -814 +816 @@
  * @param   pVM         Where to store the pointer to the VM structure.
  *
- * @thread  EMT if it's associated with the VM, otherwise any thread.
+ * @thread  EMT(0) if it's associated with the VM, otherwise any thread.
  */
 GVMMR0DECL(int) GVMMR0DestroyVM(PVM pVM)
@@ -865 +867 @@
     else
     {
-        SUPR0Printf("GVMMR0DestroyVM: pHandle=%p:{.pVM=%p, hEMT=%p, .pvObj=%p} pVM=%p hSelf=%p\n",
+        SUPR0Printf("GVMMR0DestroyVM: pHandle=%p:{.pVM=%p, hEMTCpu0=%p, .pvObj=%p} pVM=%p hSelf=%p\n",
                     pHandle, pHandle->pVM, pHandle->hEMTCpu0, pHandle->pvObj, pVM, hSelf);
         gvmmR0CreateDestroyUnlock(pGVMM);
@@ -1019 +1021 @@
         }
 
-        for (unsigned i=0; i< pGVM->cCPUs; i++)
+        for (VMCPUID i = 0; i < pGVM->cCpus; i++)
         {
             if (pGVM->aCpus[i].gvmm.s.HaltEventMulti != NIL_RTSEMEVENTMULTI)
@@ -1064 +1066 @@
  * @param   idCpu           VCPU id.
  */
-GVMMR0DECL(int) GVMMR0RegisterVCpu(PVM pVM, unsigned idCpu)
+GVMMR0DECL(int) GVMMR0RegisterVCpu(PVM pVM, VMCPUID idCpu)
 {
     AssertReturn(idCpu != 0, VERR_NOT_OWNER);
@@ -1216 +1218 @@
  * @returns VBox status code.
  * @param   pVM         The shared VM structure (the ring-0 mapping).
- * @param   idCpu       VCPU id
+ * @param   idCpu       The Virtual CPU ID of the calling EMT.
  * @param   ppGVM       Where to store the GVM pointer.
  * @param   ppGVMM      Where to store the pointer to the GVMM instance data.
  * @thread  EMT
  *
- * @remark  This will assert in failure paths.
- */
-static int gvmmR0ByVMAndEMT(PVM pVM, unsigned idCpu, PGVM *ppGVM, PGVMM *ppGVMM)
+ * @remark  This will assert in all failure paths.
+ */
+static int gvmmR0ByVMAndEMT(PVM pVM, VMCPUID idCpu, PGVM *ppGVM, PGVMM *ppGVMM)
 {
     PGVMM pGVMM;
@@ -1242 +1244 @@
      */
     PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
-    RTNATIVETHREAD hAllegedEMT = RTThreadNativeSelf();
     AssertReturn(pHandle->pVM == pVM, VERR_NOT_OWNER);
     AssertPtrReturn(pHandle->pvObj, VERR_INTERNAL_ERROR);
@@ -1249 +1250 @@
     AssertPtrReturn(pGVM, VERR_INTERNAL_ERROR);
     AssertReturn(pGVM->pVM == pVM, VERR_INTERNAL_ERROR);
+    RTNATIVETHREAD hAllegedEMT = RTThreadNativeSelf();
+    AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID);
+#ifdef DEBUG_bird /* did bad stuff to my box just now, take it easy. */
+    if (RT_UNLIKELY(pGVM->aCpus[idCpu].hEMT != hAllegedEMT))
+    {
+        SUPR0Printf("gvmmR0ByVMAndEMT: %x != %x idCpu=%u\n", pGVM->aCpus[idCpu].hEMT, hAllegedEMT, idCpu);
+        return VERR_INTERNAL_ERROR;
+    }
+#else
     AssertReturn(pGVM->aCpus[idCpu].hEMT == hAllegedEMT, VERR_INTERNAL_ERROR);
+#endif
 
     *ppGVM = pGVM;
@@ -1263 +1274 @@
  * @returns VBox status code.
  * @param   pVM         The shared VM structure (the ring-0 mapping).
- * @param   idCpu       VCPU id
+ * @param   idCpu       The Virtual CPU ID of the calling EMT.
  * @param   ppGVM       Where to store the GVM pointer.
  * @thread  EMT
  */
-GVMMR0DECL(int) GVMMR0ByVMAndEMT(PVM pVM, unsigned idCpu, PGVM *ppGVM)
+GVMMR0DECL(int) GVMMR0ByVMAndEMT(PVM pVM, VMCPUID idCpu, PGVM *ppGVM)
 {
     AssertPtrReturn(ppGVM, VERR_INVALID_POINTER);
@@ -1323 +1334 @@
             &&  VALID_PTR(pGVMM->aHandles[i].pGVM))
         {
+            if (pGVMM->aHandles[i].hEMTCpu0 == hEMT)
+                return pGVMM->aHandles[i].pVM;
+
+            /** @todo this isn't safe as GVM may be deallocated while we're running.
+             * Will change this to use RTPROCESS on the handle level as storing all the
+             * thread handles there doesn't scale very well. */
             PGVM pGVM = pGVMM->aHandles[i].pGVM;
-
-            for (unsigned idCpu = 0; idCpu < pGVM->cCPUs; idCpu++)
+            for (VMCPUID idCpu = 0; idCpu < pGVM->cCpus; idCpu++)
                 if (pGVM->aCpus[idCpu].hEMT == hEMT)
                     return pGVMM->aHandles[i].pVM;
@@ -1343 +1359 @@
 static unsigned gvmmR0SchedDoWakeUps(PGVMM pGVMM, uint64_t u64Now)
 {
+/** @todo Rewrite this algorithm. See performance defect XYZ. */
+
     /*
      * The first pass will wake up VMs which have actually expired
@@ -1359 +1377 @@
             &&  pCurGVM->u32Magic == GVM_MAGIC)
         {
-            for (unsigned idCpu = 0; idCpu < pCurGVM->cCPUs; idCpu++)
+            for (VMCPUID idCpu = 0; idCpu < pCurGVM->cCpus; idCpu++)
             {
                 PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
@@ -1399 +1417 @@
                 &&  pCurGVM->u32Magic == GVM_MAGIC)
             {
-                for (unsigned idCpu = 0; idCpu < pCurGVM->cCPUs; idCpu++)
+                for (VMCPUID idCpu = 0; idCpu < pCurGVM->cCpus; idCpu++)
                 {
                     PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
@@ -1429 +1447 @@
                 &&  pCurGVM->u32Magic == GVM_MAGIC)
             {
-                for (unsigned idCpu = 0; idCpu < pCurGVM->cCPUs; idCpu++)
+                for (VMCPUID idCpu = 0; idCpu < pCurGVM->cCpus; idCpu++)
                 {
                     PGVMCPU pCurGVCpu = &pCurGVM->aCpus[idCpu];
@@ -1459 +1477 @@
  *          VERR_INTERRUPTED if a signal was scheduled for the thread.
  * @param   pVM                 Pointer to the shared VM structure.
- * @param   idCpu               VCPU id
+ * @param   idCpu               The Virtual CPU ID of the calling EMT.
  * @param   u64ExpireGipTime    The time for the sleep to expire expressed as GIP time.
- * @thread  EMT.
- */
-GVMMR0DECL(int) GVMMR0SchedHalt(PVM pVM, unsigned idCpu, uint64_t u64ExpireGipTime)
+ * @thread  EMT(idCpu).
+ */
+GVMMR0DECL(int) GVMMR0SchedHalt(PVM pVM, VMCPUID idCpu, uint64_t u64ExpireGipTime)
 {
     LogFlow(("GVMMR0SchedHalt: pVM=%p\n", pVM));
@@ -1470 +1488 @@
      * Validate the VM structure, state and handle.
      */
-    PGVMM   pGVMM;
-    PGVM    pGVM;
-    PGVMCPU pCurGVCpu;
-
+    PGVM pGVM;
+    PGVMM pGVMM;
     int rc = gvmmR0ByVMAndEMT(pVM, idCpu, &pGVM, &pGVMM);
     if (RT_FAILURE(rc))
         return rc;
-
     pGVM->gvmm.s.StatsSched.cHaltCalls++;
 
-    pCurGVCpu = &pGVM->aCpus[idCpu];
-    Assert(idCpu < pGVM->cCPUs);
+    PGVMCPU pCurGVCpu = &pGVM->aCpus[idCpu];
+    Assert(idCpu < pGVM->cCpus);
     Assert(!pCurGVCpu->gvmm.s.u64HaltExpire);
 
@@ -1538 +1553 @@
  *          VINF_GVM_NOT_BLOCKED if the EMT thread wasn't blocked.
  * @param   pVM                 Pointer to the shared VM structure.
- * @param   idCpu               VCPU id
+ * @param   idCpu               The Virtual CPU ID of the EMT to wake up.
  * @thread  Any but EMT.
  */
-GVMMR0DECL(int) GVMMR0SchedWakeUp(PVM pVM, unsigned idCpu)
+GVMMR0DECL(int) GVMMR0SchedWakeUp(PVM pVM, VMCPUID idCpu)
 {
     /*
      * Validate input and take the UsedLock.
      */
-    PGVMM   pGVMM;
-    PGVM    pGVM;
-    PGVMCPU pCurGVCpu;
-
+    PGVM pGVM;
+    PGVMM pGVMM;
     int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, true /* fTakeUsedLock */);
     if (RT_SUCCESS(rc))
     {
-        Assert(idCpu < pGVM->cCPUs);
-
-        pCurGVCpu = &pGVM->aCpus[idCpu];
-
-        pGVM->gvmm.s.StatsSched.cWakeUpCalls++;
-
-        /*
-         * Signal the semaphore regardless of whether it's current blocked on it.
-         *
-         * The reason for this is that there is absolutely no way we can be 100%
-         * certain that it isn't *about* go to go to sleep on it and just got
-         * delayed a bit en route. So, we will always signal the semaphore when
-         * the it is flagged as halted in the VMM.
-         */
-        if (pCurGVCpu->gvmm.s.u64HaltExpire)
-        {
-            rc = VINF_SUCCESS;
-            ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0);
+        if (idCpu < pGVM->cCpus)
+        {
+            PGVMCPU pCurGVCpu = &pGVM->aCpus[idCpu];
+            pGVM->gvmm.s.StatsSched.cWakeUpCalls++;
+
+            /*
+             * Signal the semaphore regardless of whether it's current blocked on it.
+             *
+             * The reason for this is that there is absolutely no way we can be 100%
+             * certain that it isn't *about* go to go to sleep on it and just got
+             * delayed a bit en route. So, we will always signal the semaphore when
+             * the it is flagged as halted in the VMM.
+             */
+            if (pCurGVCpu->gvmm.s.u64HaltExpire)
+            {
+                rc = VINF_SUCCESS;
+                ASMAtomicXchgU64(&pCurGVCpu->gvmm.s.u64HaltExpire, 0);
+            }
+            else
+            {
+                rc = VINF_GVM_NOT_BLOCKED;
+                pGVM->gvmm.s.StatsSched.cWakeUpNotHalted++;
+            }
+
+            int rc2 = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
+            AssertRC(rc2);
+
+            /*
+             * While we're here, do a round of scheduling.
+             */
+            Assert(ASMGetFlags() & X86_EFL_IF);
+            const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
+            pGVM->gvmm.s.StatsSched.cWakeUpWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
+
         }
         else
-        {
-            rc = VINF_GVM_NOT_BLOCKED;
-            pGVM->gvmm.s.StatsSched.cWakeUpNotHalted++;
-        }
-
-        int rc2 = RTSemEventMultiSignal(pCurGVCpu->gvmm.s.HaltEventMulti);
-        AssertRC(rc2);
-
-        /*
-         * While we're here, do a round of scheduling.
-         */
-        Assert(ASMGetFlags() & X86_EFL_IF);
-        const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
-        pGVM->gvmm.s.StatsSched.cWakeUpWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
-
-
-        rc2 = gvmmR0UsedUnlock(pGVMM);
+            rc = VERR_INVALID_CPU_ID;
+
+        int rc2 = gvmmR0UsedUnlock(pGVMM);
         AssertRC(rc2);
     }
@@ -1607 +1622 @@
  *          VINF_GVM_YIELDED if an attempt to switch to a different VM task was made.
  * @param   pVM                 Pointer to the shared VM structure.
- * @param   idCpu               VCPU id
+ * @param   idCpu               The Virtual CPU ID of the calling EMT.
  * @param   u64ExpireGipTime    The time for the sleep to expire expressed as GIP time.
  * @param   fYield              Whether to yield or not.
  *                              This is for when we're spinning in the halt loop.
- * @thread  EMT.
- */
-GVMMR0DECL(int) GVMMR0SchedPoll(PVM pVM, unsigned idCpu, bool fYield)
+ * @thread  EMT(idCpu).
+ */
+GVMMR0DECL(int) GVMMR0SchedPoll(PVM pVM, VMCPUID idCpu, bool fYield)
 {
     /*

trunk/src/VBox/VMM/VMReq.cpp

@@ -262 +262 @@
 VMMR3DECL(int) VMR3ReqCallVU(PUVM pUVM, VMCPUID idDstCpu, PVMREQ *ppReq, unsigned cMillies, unsigned fFlags, PFNRT pfnFunction, unsigned cArgs, va_list Args)
 {
-    LogFlow(("VMR3ReqCallV: cMillies=%d fFlags=%#x pfnFunction=%p cArgs=%d\n", cMillies, fFlags, pfnFunction, cArgs));
+    LogFlow(("VMR3ReqCallV: idDstCpu=%u cMillies=%d fFlags=%#x pfnFunction=%p cArgs=%d\n", idDstCpu, cMillies, fFlags, pfnFunction, cArgs));
 
     /*