/** * Shared module check helper (called on the way out). * * @param pVM Pointer to the VM. * @param VMCPUID VCPU id */ static DECLCALLBACK(void) pgmR3CheckSharedModulesHelper(PVM pVM, VMCPUID idCpu) { /* We must stall other VCPUs as we'd otherwise have to send IPI flush commands for every single change we make. */ STAM_REL_PROFILE_START(&pVM->pgm.s.StatShModCheck, a); int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ALL_AT_ONCE, pgmR3SharedModuleRegRendezvous, &idCpu); AssertRCSuccess(rc); STAM_REL_PROFILE_STOP(&pVM->pgm.s.StatShModCheck, a); }
/** * Changes the halt method. * * @returns VBox status code. * @param pUVM Pointer to the user mode VM structure. * @param enmHaltMethod The new halt method. * @thread EMT. */ int vmR3SetHaltMethodU(PUVM pUVM, VMHALTMETHOD enmHaltMethod) { PVM pVM = pUVM->pVM; Assert(pVM); VM_ASSERT_EMT(pVM); AssertReturn(enmHaltMethod > VMHALTMETHOD_INVALID && enmHaltMethod < VMHALTMETHOD_END, VERR_INVALID_PARAMETER); /* * Resolve default (can be overridden in the configuration). */ if (enmHaltMethod == VMHALTMETHOD_DEFAULT) { uint32_t u32; int rc = CFGMR3QueryU32(CFGMR3GetChild(CFGMR3GetRoot(pVM), "VM"), "HaltMethod", &u32); if (RT_SUCCESS(rc)) { enmHaltMethod = (VMHALTMETHOD)u32; if (enmHaltMethod <= VMHALTMETHOD_INVALID || enmHaltMethod >= VMHALTMETHOD_END) return VMSetError(pVM, VERR_INVALID_PARAMETER, RT_SRC_POS, N_("Invalid VM/HaltMethod value %d"), enmHaltMethod); } else if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_CHILD_NOT_FOUND) return VMSetError(pVM, rc, RT_SRC_POS, N_("Failed to Query VM/HaltMethod as uint32_t")); else enmHaltMethod = VMHALTMETHOD_GLOBAL_1; //enmHaltMethod = VMHALTMETHOD_1; //enmHaltMethod = VMHALTMETHOD_OLD; } LogRel(("VM: Halt method %s (%d)\n", vmR3GetHaltMethodName(enmHaltMethod), enmHaltMethod)); /* * Find the descriptor. */ unsigned i = 0; while ( i < RT_ELEMENTS(g_aHaltMethods) && g_aHaltMethods[i].enmHaltMethod != enmHaltMethod) i++; AssertReturn(i < RT_ELEMENTS(g_aHaltMethods), VERR_INVALID_PARAMETER); /* * This needs to be done while the other EMTs are not sleeping or otherwise messing around. */ return VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, vmR3SetHaltMethodCallback, (void *)(uintptr_t)i); }
/** * Write core dump of the guest. * * @returns VBox status code. * @param pVM Pointer to the VM. * @param pszFilename The name of the file to which the guest core * dump should be written. * @param fReplaceFile Whether to replace the file or not. * * @remarks The VM should be suspended before calling this function or DMA may * interfer with the state. */ VMMR3DECL(int) DBGFR3CoreWrite(PVM pVM, const char *pszFilename, bool fReplaceFile) { VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE); AssertReturn(pszFilename, VERR_INVALID_HANDLE); /* * Pass the core write request down to EMT rendezvous which makes sure * other EMTs, if any, are not running. IO threads could still be running * but we don't care about them. */ DBGFCOREDATA CoreData; RT_ZERO(CoreData); CoreData.pszFilename = pszFilename; CoreData.fReplaceFile = fReplaceFile; int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, dbgfR3CoreWriteRendezvous, &CoreData); if (RT_SUCCESS(rc)) LogRel((DBGFLOG_NAME ": Successfully wrote guest core dump '%s'\n", pszFilename)); else LogRel((DBGFLOG_NAME ": Failed to write guest core dump '%s'. rc=%Rrc\n", pszFilename, rc)); return rc; }
/** * Enables the KVM wall-clock structure. * * Since the wall-clock can be read by any VCPU but it is a global struct. in * guest-memory, we do an EMT rendezvous here to be on the safe side. The * alternative is to use an MMIO2 region and use the WallClock.u32Version field * for transactional update. However, this MSR is rarely written to (typically * once during bootup) it's currently not a performance issue especially since * we're already in ring-3. If we really wanted better performance in this code * path, we should be doing it in ring-0 with transactional update while make * sure there is only 1 writer as well. * * @returns VBox status code. * @param pVM Pointer to the VM. * @param GCPhysWallClock Where the guest wall-clock structure is located. * @param uVersion The version (sequence number) value to use. * * @remarks Don't do any release assertions here, these can be triggered by * guest R0 code. */ VMMR3_INT_DECL(int) gimR3KvmEnableWallClock(PVM pVM, RTGCPHYS GCPhysWallClock) { KVMWALLCLOCKINFO WallClockInfo; WallClockInfo.GCPhysWallClock = GCPhysWallClock; return VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, gimR3KvmEnableWallClockCallback, &WallClockInfo); }