/**
* Converts an address to a host physical address.
*
* @returns VBox status code.
* @retval VINF_SUCCESS
* @retval VERR_INVALID_PARAMETER if the address is invalid.
* @retval VERR_INVALID_STATE if the VM is being terminated or if the virtual
* CPU handle is invalid.
* @retval VERR_NOT_SUPPORTED is the type of address cannot be converted.
* @retval VERR_PAGE_NOT_PRESENT
* @retval VERR_PAGE_TABLE_NOT_PRESENT
* @retval VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT
* @retval VERR_PAGE_MAP_LEVEL4_NOT_PRESENT
* @retval VERR_PGM_PHYS_PAGE_RESERVED
* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS
*
* @param pVM The VM handle.
* @param idCpu The ID of the CPU context to convert virtual
* addresses.
* @param pAddress The address.
* @param pHCPhys Where to return the physical address.
*/
VMMR3DECL(int) DBGFR3AddrToHostPhys(PVM pVM, VMCPUID idCpu, PDBGFADDRESS pAddress, PRTHCPHYS pHCPhys)
{
/*
* Parameter validation.
*/
AssertPtr(pHCPhys);
*pHCPhys = NIL_RTHCPHYS;
AssertPtr(pAddress);
AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_STATE);
AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
/*
* Convert it if we can.
*/
int rc;
if (pAddress->fFlags & DBGFADDRESS_FLAGS_HMA)
rc = VERR_NOT_SUPPORTED; /** @todo implement this */
else
{
RTGCPHYS GCPhys;
rc = DBGFR3AddrToPhys(pVM, idCpu, pAddress, &GCPhys);
if (RT_SUCCESS(rc))
rc = PGMPhysGCPhys2HCPhys(pVM, pAddress->FlatPtr, pHCPhys);
}
return rc;
}
/**
* @interface_method_impl{DBGCCMDHLP,pfnVarFromDbgfAddr}
*/
static DECLCALLBACK(int) dbgcHlpVarFromDbgfAddr(PDBGCCMDHLP pCmdHlp, PCDBGFADDRESS pAddress, PDBGCVAR pResult)
{
AssertPtrReturn(pAddress, VERR_INVALID_POINTER);
AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
AssertPtrReturn(pResult, VERR_INVALID_POINTER);
switch (pAddress->fFlags & DBGFADDRESS_FLAGS_TYPE_MASK)
{
case DBGFADDRESS_FLAGS_FAR16:
case DBGFADDRESS_FLAGS_FAR32:
case DBGFADDRESS_FLAGS_FAR64:
DBGCVAR_INIT_GC_FAR(pResult, pAddress->Sel, pAddress->off);
break;
case DBGFADDRESS_FLAGS_FLAT:
DBGCVAR_INIT_GC_FLAT(pResult, pAddress->FlatPtr);
break;
case DBGFADDRESS_FLAGS_PHYS:
DBGCVAR_INIT_GC_PHYS(pResult, pAddress->FlatPtr);
break;
default:
DBGCVAR_INIT(pResult);
AssertMsgFailedReturn(("%#x\n", pAddress->fFlags), VERR_INVALID_PARAMETER);
break;
}
return VINF_SUCCESS;
}
/**
* Converts an address to a guest physical address.
*
* @returns VBox status code.
* @retval VINF_SUCCESS
* @retval VERR_INVALID_PARAMETER if the address is invalid.
* @retval VERR_INVALID_STATE if the VM is being terminated or if the virtual
* CPU handle is invalid.
* @retval VERR_NOT_SUPPORTED is the type of address cannot be converted.
* @retval VERR_PAGE_NOT_PRESENT
* @retval VERR_PAGE_TABLE_NOT_PRESENT
* @retval VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT
* @retval VERR_PAGE_MAP_LEVEL4_NOT_PRESENT
*
* @param pVM The VM handle.
* @param idCpu The ID of the CPU context to convert virtual
* addresses.
* @param pAddress The address.
* @param pGCPhys Where to return the physical address.
*/
VMMR3DECL(int) DBGFR3AddrToPhys(PVM pVM, VMCPUID idCpu, PDBGFADDRESS pAddress, PRTGCPHYS pGCPhys)
{
/*
* Parameter validation.
*/
AssertPtr(pGCPhys);
*pGCPhys = NIL_RTGCPHYS;
AssertPtr(pAddress);
AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_STATE);
AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
/*
* Convert by address type.
*/
int rc;
if (pAddress->fFlags & DBGFADDRESS_FLAGS_HMA)
rc = VERR_NOT_SUPPORTED;
else if (pAddress->fFlags & DBGFADDRESS_FLAGS_PHYS)
{
*pGCPhys = pAddress->FlatPtr;
rc = VINF_SUCCESS;
}
else
{
PVMCPU pVCpu = VMMGetCpuById(pVM, idCpu);
if (VMCPU_IS_EMT(pVCpu))
rc = dbgfR3AddrToPhysOnVCpu(pVCpu, pAddress, pGCPhys);
else
rc = VMR3ReqCallWait(pVCpu->pVMR3, pVCpu->idCpu,
(PFNRT)dbgfR3AddrToPhysOnVCpu, 3, pVCpu, pAddress, pGCPhys);
}
return rc;
}
/**
* Checks if the specified address is valid (checks the structure pointer too).
*
* @returns true if valid.
* @returns false if invalid.
* @param pVM The VM handle.
* @param pAddress The address to validate.
*/
VMMR3DECL(bool) DBGFR3AddrIsValid(PVM pVM, PCDBGFADDRESS pAddress)
{
if (!VALID_PTR(pAddress))
return false;
if (!DBGFADDRESS_IS_VALID(pAddress))
return false;
/* more? */
return true;
}
/**
* Subtracts an offset from an address.
*
* @returns VINF_SUCCESS on success.
*
* @param pAddress The address.
* @param uSubtrahend How much to subtract.
*
* @remarks No address space or segment limit checks are performed,
*/
VMMR3DECL(PDBGFADDRESS) DBGFR3AddrSub(PDBGFADDRESS pAddress, RTGCUINTPTR uSubtrahend)
{
/*
* Parameter validation.
*/
AssertPtrReturn(pAddress, NULL);
AssertReturn(DBGFADDRESS_IS_VALID(pAddress), NULL);
/*
* Add the stuff.
*/
pAddress->off -= uSubtrahend;
pAddress->FlatPtr -= uSubtrahend;
return pAddress;
}
/**
* Converts an address to a volatile host virtual address.
*
* @returns VBox status code.
* @retval VINF_SUCCESS
* @retval VERR_INVALID_PARAMETER if the address is invalid.
* @retval VERR_INVALID_STATE if the VM is being terminated or if the virtual
* CPU handle is invalid.
* @retval VERR_NOT_SUPPORTED is the type of address cannot be converted.
* @retval VERR_PAGE_NOT_PRESENT
* @retval VERR_PAGE_TABLE_NOT_PRESENT
* @retval VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT
* @retval VERR_PAGE_MAP_LEVEL4_NOT_PRESENT
* @retval VERR_PGM_PHYS_PAGE_RESERVED
* @retval VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS
*
* @param pVM The VM handle.
* @param idCpu The ID of the CPU context to convert virtual
* addresses.
* @param pAddress The address.
* @param fReadOnly Whether returning a read-only page is fine or not.
* If set to thru the page may have to be made writable
* before we return.
* @param ppvR3Ptr Where to return the address.
*/
VMMR3DECL(int) DBGFR3AddrToVolatileR3Ptr(PVM pVM, VMCPUID idCpu, PDBGFADDRESS pAddress, bool fReadOnly, void **ppvR3Ptr)
{
/*
* Parameter validation.
*/
AssertPtr(ppvR3Ptr);
*ppvR3Ptr = NULL;
AssertPtr(pAddress);
AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_STATE);
AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
/*
* Convert it.
*/
return VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3AddrToVolatileR3PtrOnVCpu, 5, pVM, idCpu, pAddress, fReadOnly, ppvR3Ptr);
}
/**
* Internal worker routine.
*
* On x86 the typical stack frame layout is like this:
* .. ..
* 16 parameter 2
* 12 parameter 1
* 8 parameter 0
* 4 return address
* 0 old ebp; current ebp points here
*
* @todo Add AMD64 support (needs teaming up with the module management for
* unwind tables).
*/
static int dbgfR3StackWalk(PUVM pUVM, VMCPUID idCpu, RTDBGAS hAs, PDBGFSTACKFRAME pFrame)
{
/*
* Stop if we got a read error in the previous run.
*/
if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_LAST)
return VERR_NO_MORE_FILES;
/*
* Read the raw frame data.
*/
const DBGFADDRESS AddrOldPC = pFrame->AddrPC;
const unsigned cbRetAddr = DBGFReturnTypeSize(pFrame->enmReturnType);
unsigned cbStackItem;
switch (AddrOldPC.fFlags & DBGFADDRESS_FLAGS_TYPE_MASK)
{
case DBGFADDRESS_FLAGS_FAR16: cbStackItem = 2; break;
case DBGFADDRESS_FLAGS_FAR32: cbStackItem = 4; break;
case DBGFADDRESS_FLAGS_FAR64: cbStackItem = 8; break;
case DBGFADDRESS_FLAGS_RING0: cbStackItem = sizeof(RTHCUINTPTR); break;
default:
switch (pFrame->enmReturnType)
{
case DBGFRETURNTYPE_FAR16:
case DBGFRETURNTYPE_IRET16:
case DBGFRETURNTYPE_IRET32_V86:
case DBGFRETURNTYPE_NEAR16: cbStackItem = 2; break;
case DBGFRETURNTYPE_FAR32:
case DBGFRETURNTYPE_IRET32:
case DBGFRETURNTYPE_IRET32_PRIV:
case DBGFRETURNTYPE_NEAR32: cbStackItem = 4; break;
case DBGFRETURNTYPE_FAR64:
case DBGFRETURNTYPE_IRET64:
case DBGFRETURNTYPE_NEAR64: cbStackItem = 8; break;
default:
AssertMsgFailed(("%d\n", pFrame->enmReturnType));
cbStackItem = 4;
break;
}
}
union
{
uint64_t *pu64;
uint32_t *pu32;
uint16_t *pu16;
uint8_t *pb;
void *pv;
} u, uRet, uArgs, uBp;
size_t cbRead = cbRetAddr + cbStackItem + sizeof(pFrame->Args);
u.pv = alloca(cbRead);
uBp = u;
uRet.pb = u.pb + cbStackItem;
uArgs.pb = u.pb + cbStackItem + cbRetAddr;
Assert(DBGFADDRESS_IS_VALID(&pFrame->AddrFrame));
int rc = dbgfR3Read(pUVM, idCpu, u.pv,
pFrame->fFlags & DBGFSTACKFRAME_FLAGS_ALL_VALID
? &pFrame->AddrReturnFrame
: &pFrame->AddrFrame,
cbRead, &cbRead);
if ( RT_FAILURE(rc)
|| cbRead < cbRetAddr + cbStackItem)
pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_LAST;
/*
* The first step is taken in a different way than the others.
*/
if (!(pFrame->fFlags & DBGFSTACKFRAME_FLAGS_ALL_VALID))
{
pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_ALL_VALID;
pFrame->iFrame = 0;
/* Current PC - set by caller, just find symbol & line. */
if (DBGFADDRESS_IS_VALID(&pFrame->AddrPC))
{
pFrame->pSymPC = DBGFR3AsSymbolByAddrA(pUVM, hAs, &pFrame->AddrPC, RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL,
NULL /*poffDisp*/, NULL /*phMod*/);
pFrame->pLinePC = DBGFR3AsLineByAddrA(pUVM, hAs, &pFrame->AddrPC, NULL /*poffDisp*/, NULL /*phMod*/);
}
}
else /* 2nd and subsequent steps */
{
/* frame, pc and stack is taken from the existing frames return members. */
pFrame->AddrFrame = pFrame->AddrReturnFrame;
pFrame->AddrPC = pFrame->AddrReturnPC;
pFrame->pSymPC = pFrame->pSymReturnPC;
pFrame->pLinePC = pFrame->pLineReturnPC;
/* increment the frame number. */
pFrame->iFrame++;
}
/*
* Return Frame address.
*/
pFrame->AddrReturnFrame = pFrame->AddrFrame;
switch (cbStackItem)
{
case 2: pFrame->AddrReturnFrame.off = *uBp.pu16; break;
case 4: pFrame->AddrReturnFrame.off = *uBp.pu32; break;
case 8: pFrame->AddrReturnFrame.off = *uBp.pu64; break;
default: AssertMsgFailedReturn(("cbStackItem=%d\n", cbStackItem), VERR_DBGF_STACK_IPE_1);
}
pFrame->AddrReturnFrame.FlatPtr += pFrame->AddrReturnFrame.off - pFrame->AddrFrame.off;
/*
* Return PC and Stack Addresses.
*/
/** @todo AddrReturnStack is not correct for stdcall and pascal. (requires scope info) */
pFrame->AddrReturnStack = pFrame->AddrFrame;
pFrame->AddrReturnStack.off += cbStackItem + cbRetAddr;
pFrame->AddrReturnStack.FlatPtr += cbStackItem + cbRetAddr;
pFrame->AddrReturnPC = pFrame->AddrPC;
switch (pFrame->enmReturnType)
{
case DBGFRETURNTYPE_NEAR16:
if (DBGFADDRESS_IS_VALID(&pFrame->AddrReturnPC))
{
pFrame->AddrReturnPC.FlatPtr += *uRet.pu16 - pFrame->AddrReturnPC.off;
pFrame->AddrReturnPC.off = *uRet.pu16;
}
else
DBGFR3AddrFromFlat(pUVM, &pFrame->AddrReturnPC, *uRet.pu16);
break;
case DBGFRETURNTYPE_NEAR32:
if (DBGFADDRESS_IS_VALID(&pFrame->AddrReturnPC))
{
pFrame->AddrReturnPC.FlatPtr += *uRet.pu32 - pFrame->AddrReturnPC.off;
pFrame->AddrReturnPC.off = *uRet.pu32;
}
else
DBGFR3AddrFromFlat(pUVM, &pFrame->AddrReturnPC, *uRet.pu32);
break;
case DBGFRETURNTYPE_NEAR64:
if (DBGFADDRESS_IS_VALID(&pFrame->AddrReturnPC))
{
pFrame->AddrReturnPC.FlatPtr += *uRet.pu64 - pFrame->AddrReturnPC.off;
pFrame->AddrReturnPC.off = *uRet.pu64;
}
else
DBGFR3AddrFromFlat(pUVM, &pFrame->AddrReturnPC, *uRet.pu64);
break;
case DBGFRETURNTYPE_FAR16:
DBGFR3AddrFromSelOff(pUVM, idCpu, &pFrame->AddrReturnPC, uRet.pu16[1], uRet.pu16[0]);
break;
case DBGFRETURNTYPE_FAR32:
DBGFR3AddrFromSelOff(pUVM, idCpu, &pFrame->AddrReturnPC, uRet.pu16[2], uRet.pu32[0]);
break;
case DBGFRETURNTYPE_FAR64:
DBGFR3AddrFromSelOff(pUVM, idCpu, &pFrame->AddrReturnPC, uRet.pu16[4], uRet.pu64[0]);
break;
case DBGFRETURNTYPE_IRET16:
DBGFR3AddrFromSelOff(pUVM, idCpu, &pFrame->AddrReturnPC, uRet.pu16[1], uRet.pu16[0]);
break;
case DBGFRETURNTYPE_IRET32:
DBGFR3AddrFromSelOff(pUVM, idCpu, &pFrame->AddrReturnPC, uRet.pu16[2], uRet.pu32[0]);
break;
case DBGFRETURNTYPE_IRET32_PRIV:
DBGFR3AddrFromSelOff(pUVM, idCpu, &pFrame->AddrReturnPC, uRet.pu16[2], uRet.pu32[0]);
break;
case DBGFRETURNTYPE_IRET32_V86:
DBGFR3AddrFromSelOff(pUVM, idCpu, &pFrame->AddrReturnPC, uRet.pu16[2], uRet.pu32[0]);
break;
case DBGFRETURNTYPE_IRET64:
DBGFR3AddrFromSelOff(pUVM, idCpu, &pFrame->AddrReturnPC, uRet.pu16[4], uRet.pu64[0]);
break;
default:
AssertMsgFailed(("enmReturnType=%d\n", pFrame->enmReturnType));
return VERR_INVALID_PARAMETER;
}
pFrame->pSymReturnPC = DBGFR3AsSymbolByAddrA(pUVM, hAs, &pFrame->AddrReturnPC, RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL,
NULL /*poffDisp*/, NULL /*phMod*/);
pFrame->pLineReturnPC = DBGFR3AsLineByAddrA(pUVM, hAs, &pFrame->AddrReturnPC, NULL /*poffDisp*/, NULL /*phMod*/);
/*
* Frame bitness flag.
*/
switch (cbStackItem)
{
case 2: pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_16BIT; break;
case 4: pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_32BIT; break;
case 8: pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_64BIT; break;
default: AssertMsgFailedReturn(("cbStackItem=%d\n", cbStackItem), VERR_DBGF_STACK_IPE_2);
}
/*
* The arguments.
*/
memcpy(&pFrame->Args, uArgs.pv, sizeof(pFrame->Args));
return VINF_SUCCESS;
}