/**
* Flushes the physical handler notifications if the queue is almost full.
*
* This is for avoiding trouble in RC when changing CR3.
*
* @param pVM Pointer to the VM.
* @param pVCpu Pointer to the VMCPU of the calling EMT.
*/
VMMDECL(void) REMNotifyHandlerPhysicalFlushIfAlmostFull(PVM pVM, PVMCPU pVCpu)
{
Assert(pVM->cCpus == 1); NOREF(pVCpu);
/*
* Less than 48 items means we should flush.
*/
uint32_t cFree = 0;
for (uint32_t idx = pVM->rem.s.idxFreeList;
idx != UINT32_MAX;
idx = pVM->rem.s.aHandlerNotifications[idx].idxNext)
{
Assert(idx < RT_ELEMENTS(pVM->rem.s.aHandlerNotifications));
if (++cFree >= 48)
return;
}
AssertRelease(VM_FF_IS_SET(pVM, VM_FF_REM_HANDLER_NOTIFY));
AssertRelease(pVM->rem.s.idxPendingList != UINT32_MAX);
/* Ok, we gotta flush them. */
VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_REM_REPLAY_HANDLER_NOTIFICATIONS, 0);
AssertRelease(pVM->rem.s.idxPendingList == UINT32_MAX);
AssertRelease(pVM->rem.s.idxFreeList != UINT32_MAX);
}
/**
* 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;
AssertReleaseMsg(VALID_PTR(pUVM) && pUVM->u32Magic == UVM_MAGIC,
("Invalid arguments to the emulation thread!\n"));
rc = RTTlsSet(pUVM->vm.s.idxTLS, pUVCpu);
AssertReleaseMsgRCReturn(rc, ("RTTlsSet %x failed with %Rrc\n", pUVM->vm.s.idxTLS, rc), rc);
if ( pUVM->pVmm2UserMethods
&& pUVM->pVmm2UserMethods->pfnNotifyEmtInit)
pUVM->pVmm2UserMethods->pfnNotifyEmtInit(pUVM->pVmm2UserMethods, pUVM, pUVCpu);
/*
* The request loop.
*/
rc = VINF_SUCCESS;
Log(("vmR3EmulationThread: Emulation thread starting the days work... Thread=%#x pUVM=%p\n", ThreadSelf, pUVM));
VMSTATE enmBefore = VMSTATE_CREATED; /* (only used for logging atm.) */
for (;;)
{
/*
* During early init there is no pVM, so make a special path
* for that to keep things clearly separate.
*/
if (!pUVM->pVM)
{
/*
* Check for termination first.
*/
if (pUVM->vm.s.fTerminateEMT)
{
rc = VINF_EM_TERMINATE;
break;
}
/*
* 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.pNormalReqs || pUVM->vm.s.pPriorityReqs)
&& pUVCpu->idCpu == 0)
{
/*
* Service execute in any EMT request.
*/
rc = VMR3ReqProcessU(pUVM, VMCPUID_ANY, false /*fPriorityOnly*/);
Log(("vmR3EmulationThread: Req rc=%Rrc, VM state %s -> %s\n", rc, VMR3GetStateName(enmBefore), pUVM->pVM ? VMR3GetStateName(pUVM->pVM->enmVMState) : "CREATING"));
}
else if (pUVCpu->vm.s.pNormalReqs || pUVCpu->vm.s.pPriorityReqs)
{
/*
* Service execute in specific EMT request.
*/
rc = VMR3ReqProcessU(pUVM, pUVCpu->idCpu, false /*fPriorityOnly*/);
Log(("vmR3EmulationThread: Req (cpu=%u) rc=%Rrc, VM state %s -> %s\n", pUVCpu->idCpu, rc, VMR3GetStateName(enmBefore), pUVM->pVM ? VMR3GetStateName(pUVM->pVM->enmVMState) : "CREATING"));
}
else
{
/*
* Nothing important is pending, so wait for something.
*/
rc = VMR3WaitU(pUVCpu);
if (RT_FAILURE(rc))
{
AssertLogRelMsgFailed(("VMR3WaitU failed with %Rrc\n", rc));
break;
}
}
}
else
{
/*
* Pending requests which needs servicing?
*
* We check for state changes in addition to status codes when
* servicing requests. (Look after the ifs.)
*/
PVM pVM = pUVM->pVM;
enmBefore = pVM->enmVMState;
if (pUVM->vm.s.fTerminateEMT)
{
rc = VINF_EM_TERMINATE;
break;
}
if (VM_FF_IS_PENDING(pVM, VM_FF_EMT_RENDEZVOUS))
{
rc = VMMR3EmtRendezvousFF(pVM, &pVM->aCpus[idCpu]);
Log(("vmR3EmulationThread: Rendezvous rc=%Rrc, VM state %s -> %s\n", rc, VMR3GetStateName(enmBefore), VMR3GetStateName(pVM->enmVMState)));
}
else if (pUVM->vm.s.pNormalReqs || pUVM->vm.s.pPriorityReqs)
{
/*
* Service execute in any EMT request.
*/
rc = VMR3ReqProcessU(pUVM, VMCPUID_ANY, false /*fPriorityOnly*/);
Log(("vmR3EmulationThread: Req rc=%Rrc, VM state %s -> %s\n", rc, VMR3GetStateName(enmBefore), VMR3GetStateName(pVM->enmVMState)));
}
else if (pUVCpu->vm.s.pNormalReqs || pUVCpu->vm.s.pPriorityReqs)
{
/*
* Service execute in specific EMT request.
*/
rc = VMR3ReqProcessU(pUVM, pUVCpu->idCpu, false /*fPriorityOnly*/);
Log(("vmR3EmulationThread: Req (cpu=%u) rc=%Rrc, VM state %s -> %s\n", pUVCpu->idCpu, rc, VMR3GetStateName(enmBefore), VMR3GetStateName(pVM->enmVMState)));
}
else if (VM_FF_IS_SET(pVM, VM_FF_DBGF))
{
/*
* Service the debugger request.
*/
rc = DBGFR3VMMForcedAction(pVM);
Log(("vmR3EmulationThread: Dbg rc=%Rrc, VM state %s -> %s\n", rc, VMR3GetStateName(enmBefore), VMR3GetStateName(pVM->enmVMState)));
}
else if (VM_FF_TEST_AND_CLEAR(pVM, VM_FF_RESET))
{
/*
* Service a delayed reset request.
*/
rc = VMR3Reset(pVM->pUVM);
VM_FF_CLEAR(pVM, VM_FF_RESET);
Log(("vmR3EmulationThread: Reset rc=%Rrc, VM state %s -> %s\n", rc, VMR3GetStateName(enmBefore), VMR3GetStateName(pVM->enmVMState)));
}
else
{
/*
* Nothing important is pending, so wait for something.
*/
rc = VMR3WaitU(pUVCpu);
if (RT_FAILURE(rc))
{
AssertLogRelMsgFailed(("VMR3WaitU failed with %Rrc\n", rc));
break;
}
}
/*
* Check for termination requests, these have extremely high priority.
*/
if ( rc == VINF_EM_TERMINATE
|| pUVM->vm.s.fTerminateEMT)
break;
}
/*
* Some requests (both VMR3Req* and the DBGF) can potentially resume
* or start the VM, in that case we'll get a change in VM status
* indicating that we're now running.
*/
if ( RT_SUCCESS(rc)
&& pUVM->pVM)
{
PVM pVM = pUVM->pVM;
PVMCPU pVCpu = &pVM->aCpus[idCpu];
if ( pVM->enmVMState == VMSTATE_RUNNING
&& VMCPUSTATE_IS_STARTED(VMCPU_GET_STATE(pVCpu)))
{
rc = EMR3ExecuteVM(pVM, pVCpu);
Log(("vmR3EmulationThread: EMR3ExecuteVM() -> rc=%Rrc, enmVMState=%d\n", rc, pVM->enmVMState));
if (EMGetState(pVCpu) == EMSTATE_GURU_MEDITATION)
vmR3SetGuruMeditation(pVM);
}
}
} /* forever */
/*
* Cleanup and exit.
*/
Log(("vmR3EmulationThread: Terminating emulation thread! Thread=%#x pUVM=%p rc=%Rrc enmBefore=%d enmVMState=%d\n",
ThreadSelf, pUVM, rc, enmBefore, pUVM->pVM ? pUVM->pVM->enmVMState : VMSTATE_TERMINATED));
if ( idCpu == 0
&& pUVM->pVM)
{
PVM pVM = pUVM->pVM;
vmR3SetTerminated(pVM);
pUVM->pVM = NULL;
/** @todo SMP: This isn't 100% safe. We should wait for the other
* threads to finish before destroy the VM. */
int rc2 = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_GVMM_DESTROY_VM, 0, NULL);
AssertLogRelRC(rc2);
}
if ( pUVM->pVmm2UserMethods
&& pUVM->pVmm2UserMethods->pfnNotifyEmtTerm)
pUVM->pVmm2UserMethods->pfnNotifyEmtTerm(pUVM->pVmm2UserMethods, pUVM, pUVCpu);
pUVCpu->vm.s.NativeThreadEMT = NIL_RTNATIVETHREAD;
Log(("vmR3EmulationThread: EMT is terminated.\n"));
return rc;
}
/**
* Process HM specific forced actions.
*
* This function is called when any FFs in the VM_FF_HIGH_PRIORITY_PRE_RAW_MASK
* or/and VMCPU_FF_HIGH_PRIORITY_PRE_RAW_MASK are pending.
*
* @returns VBox status code. May return VINF_EM_NO_MEMORY but none of the other
* EM statuses.
* @param pVM The cross context VM structure.
* @param pVCpu The cross context virtual CPU structure.
*/
static int emR3HmForcedActions(PVM pVM, PVMCPU pVCpu)
{
/*
* Sync page directory.
*/
if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3 | VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL))
{
CPUM_IMPORT_EXTRN_RET(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_CR3 | CPUMCTX_EXTRN_CR4);
Assert(pVCpu->em.s.enmState != EMSTATE_WAIT_SIPI);
int rc = PGMSyncCR3(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
if (RT_FAILURE(rc))
return rc;
#ifdef VBOX_WITH_RAW_MODE
Assert(!VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_SELM_SYNC_GDT | VMCPU_FF_SELM_SYNC_LDT));
#endif
/* Prefetch pages for EIP and ESP. */
/** @todo This is rather expensive. Should investigate if it really helps at all. */
/** @todo this should be skipped! */
CPUM_IMPORT_EXTRN_RET(pVCpu, CPUMCTX_EXTRN_CS | CPUMCTX_EXTRN_SS);
rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pVCpu->cpum.GstCtx.rip));
if (rc == VINF_SUCCESS)
rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_SS, CPUMCTX2CORE(&pVCpu->cpum.GstCtx), pVCpu->cpum.GstCtx.rsp));
if (rc != VINF_SUCCESS)
{
if (rc != VINF_PGM_SYNC_CR3)
{
AssertLogRelMsgReturn(RT_FAILURE(rc), ("%Rrc\n", rc), VERR_IPE_UNEXPECTED_INFO_STATUS);
return rc;
}
rc = PGMSyncCR3(pVCpu, pVCpu->cpum.GstCtx.cr0, pVCpu->cpum.GstCtx.cr3, pVCpu->cpum.GstCtx.cr4, VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3));
if (RT_FAILURE(rc))
return rc;
}
/** @todo maybe prefetch the supervisor stack page as well */
#ifdef VBOX_WITH_RAW_MODE
Assert(!VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_SELM_SYNC_GDT | VMCPU_FF_SELM_SYNC_LDT));
#endif
}
/*
* Allocate handy pages (just in case the above actions have consumed some pages).
*/
if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_PGM_NEED_HANDY_PAGES, VM_FF_PGM_NO_MEMORY))
{
int rc = PGMR3PhysAllocateHandyPages(pVM);
if (RT_FAILURE(rc))
return rc;
}
/*
* Check whether we're out of memory now.
*
* This may stem from some of the above actions or operations that has been executed
* since we ran FFs. The allocate handy pages must for instance always be followed by
* this check.
*/
if (VM_FF_IS_SET(pVM, VM_FF_PGM_NO_MEMORY))
return VINF_EM_NO_MEMORY;
return VINF_SUCCESS;
}
