[23] | 1 | /* $Id: DBGFStack.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
|
---|
[1] | 2 | /** @file
|
---|
[12677] | 3 | * DBGF - Debugger Facility, Call Stack Analyser.
|
---|
[1] | 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[82968] | 7 | * Copyright (C) 2006-2020 Oracle Corporation
|
---|
[1] | 8 | *
|
---|
| 9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
| 10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
| 11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
[5999] | 12 | * General Public License (GPL) as published by the Free Software
|
---|
| 13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
| 14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
| 15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
[1] | 16 | */
|
---|
| 17 |
|
---|
| 18 |
|
---|
[57358] | 19 | /*********************************************************************************************************************************
|
---|
| 20 | * Header Files *
|
---|
| 21 | *********************************************************************************************************************************/
|
---|
[1] | 22 | #define LOG_GROUP LOG_GROUP_DBGF
|
---|
[35346] | 23 | #include <VBox/vmm/dbgf.h>
|
---|
| 24 | #include <VBox/vmm/selm.h>
|
---|
| 25 | #include <VBox/vmm/mm.h>
|
---|
[1] | 26 | #include "DBGFInternal.h"
|
---|
[35346] | 27 | #include <VBox/vmm/vm.h>
|
---|
[44399] | 28 | #include <VBox/vmm/uvm.h>
|
---|
[1] | 29 | #include <VBox/err.h>
|
---|
| 30 | #include <VBox/log.h>
|
---|
[19291] | 31 | #include <iprt/param.h>
|
---|
[1] | 32 | #include <iprt/assert.h>
|
---|
[73377] | 33 | #include <iprt/alloca.h>
|
---|
| 34 | #include <iprt/mem.h>
|
---|
[1] | 35 | #include <iprt/string.h>
|
---|
[73388] | 36 | #include <iprt/formats/pecoff.h>
|
---|
[1] | 37 |
|
---|
| 38 |
|
---|
[73377] | 39 | /*********************************************************************************************************************************
|
---|
| 40 | * Structures and Typedefs *
|
---|
| 41 | *********************************************************************************************************************************/
|
---|
[73460] | 42 | static DECLCALLBACK(int) dbgfR3StackReadCallback(PRTDBGUNWINDSTATE pThis, RTUINTPTR uSp, size_t cbToRead, void *pvDst);
|
---|
[73444] | 43 |
|
---|
[73377] | 44 | /**
|
---|
| 45 | * Unwind context.
|
---|
| 46 | *
|
---|
| 47 | * @note Using a constructor and destructor here for simple+safe cleanup.
|
---|
| 48 | */
|
---|
| 49 | typedef struct DBGFUNWINDCTX
|
---|
| 50 | {
|
---|
| 51 | PUVM m_pUVM;
|
---|
| 52 | VMCPUID m_idCpu;
|
---|
| 53 | RTDBGAS m_hAs;
|
---|
[73460] | 54 | PCCPUMCTX m_pInitialCtx;
|
---|
[73471] | 55 | bool m_fIsHostRing0;
|
---|
[73460] | 56 | uint64_t m_uOsScratch; /**< For passing to DBGFOSREG::pfnStackUnwindAssist. */
|
---|
[73397] | 57 |
|
---|
[73377] | 58 | RTDBGMOD m_hCached;
|
---|
| 59 | RTUINTPTR m_uCachedMapping;
|
---|
| 60 | RTUINTPTR m_cbCachedMapping;
|
---|
[73495] | 61 | RTDBGSEGIDX m_idxCachedSegMapping;
|
---|
[73377] | 62 |
|
---|
[73495] | 63 | RTDBGUNWINDSTATE m_State;
|
---|
[73388] | 64 |
|
---|
[73377] | 65 | DBGFUNWINDCTX(PUVM pUVM, VMCPUID idCpu, PCCPUMCTX pInitialCtx, RTDBGAS hAs)
|
---|
| 66 | {
|
---|
[73460] | 67 | m_State.u32Magic = RTDBGUNWINDSTATE_MAGIC;
|
---|
[73444] | 68 | m_State.enmArch = RTLDRARCH_AMD64;
|
---|
| 69 | m_State.pfnReadStack = dbgfR3StackReadCallback;
|
---|
| 70 | m_State.pvUser = this;
|
---|
| 71 | RT_ZERO(m_State.u);
|
---|
[73377] | 72 | if (pInitialCtx)
|
---|
| 73 | {
|
---|
[73444] | 74 | m_State.u.x86.auRegs[X86_GREG_xAX] = pInitialCtx->rax;
|
---|
| 75 | m_State.u.x86.auRegs[X86_GREG_xCX] = pInitialCtx->rcx;
|
---|
| 76 | m_State.u.x86.auRegs[X86_GREG_xDX] = pInitialCtx->rdx;
|
---|
| 77 | m_State.u.x86.auRegs[X86_GREG_xBX] = pInitialCtx->rbx;
|
---|
| 78 | m_State.u.x86.auRegs[X86_GREG_xSP] = pInitialCtx->rsp;
|
---|
| 79 | m_State.u.x86.auRegs[X86_GREG_xBP] = pInitialCtx->rbp;
|
---|
| 80 | m_State.u.x86.auRegs[X86_GREG_xSI] = pInitialCtx->rsi;
|
---|
| 81 | m_State.u.x86.auRegs[X86_GREG_xDI] = pInitialCtx->rdi;
|
---|
| 82 | m_State.u.x86.auRegs[X86_GREG_x8 ] = pInitialCtx->r8;
|
---|
| 83 | m_State.u.x86.auRegs[X86_GREG_x9 ] = pInitialCtx->r9;
|
---|
| 84 | m_State.u.x86.auRegs[X86_GREG_x10] = pInitialCtx->r10;
|
---|
| 85 | m_State.u.x86.auRegs[X86_GREG_x11] = pInitialCtx->r11;
|
---|
| 86 | m_State.u.x86.auRegs[X86_GREG_x12] = pInitialCtx->r12;
|
---|
| 87 | m_State.u.x86.auRegs[X86_GREG_x13] = pInitialCtx->r13;
|
---|
| 88 | m_State.u.x86.auRegs[X86_GREG_x14] = pInitialCtx->r14;
|
---|
| 89 | m_State.u.x86.auRegs[X86_GREG_x15] = pInitialCtx->r15;
|
---|
| 90 | m_State.uPc = pInitialCtx->rip;
|
---|
| 91 | m_State.u.x86.uRFlags = pInitialCtx->rflags.u;
|
---|
| 92 | m_State.u.x86.auSegs[X86_SREG_ES] = pInitialCtx->es.Sel;
|
---|
| 93 | m_State.u.x86.auSegs[X86_SREG_CS] = pInitialCtx->cs.Sel;
|
---|
| 94 | m_State.u.x86.auSegs[X86_SREG_SS] = pInitialCtx->ss.Sel;
|
---|
| 95 | m_State.u.x86.auSegs[X86_SREG_DS] = pInitialCtx->ds.Sel;
|
---|
| 96 | m_State.u.x86.auSegs[X86_SREG_GS] = pInitialCtx->gs.Sel;
|
---|
| 97 | m_State.u.x86.auSegs[X86_SREG_FS] = pInitialCtx->fs.Sel;
|
---|
| 98 | m_State.u.x86.fRealOrV86 = CPUMIsGuestInRealOrV86ModeEx(pInitialCtx);
|
---|
[73377] | 99 | }
|
---|
[73471] | 100 | else if (hAs == DBGF_AS_R0)
|
---|
| 101 | VMMR3InitR0StackUnwindState(pUVM, idCpu, &m_State);
|
---|
[73397] | 102 |
|
---|
[73377] | 103 | m_pUVM = pUVM;
|
---|
| 104 | m_idCpu = idCpu;
|
---|
[73397] | 105 | m_hAs = DBGFR3AsResolveAndRetain(pUVM, hAs);
|
---|
[73460] | 106 | m_pInitialCtx = pInitialCtx;
|
---|
[73471] | 107 | m_fIsHostRing0 = hAs == DBGF_AS_R0;
|
---|
[73460] | 108 | m_uOsScratch = 0;
|
---|
[73377] | 109 |
|
---|
| 110 | m_hCached = NIL_RTDBGMOD;
|
---|
| 111 | m_uCachedMapping = 0;
|
---|
| 112 | m_cbCachedMapping = 0;
|
---|
[73495] | 113 | m_idxCachedSegMapping = NIL_RTDBGSEGIDX;
|
---|
[73377] | 114 | }
|
---|
| 115 |
|
---|
| 116 | ~DBGFUNWINDCTX();
|
---|
| 117 |
|
---|
| 118 | } DBGFUNWINDCTX;
|
---|
| 119 | /** Pointer to unwind context. */
|
---|
| 120 | typedef DBGFUNWINDCTX *PDBGFUNWINDCTX;
|
---|
| 121 |
|
---|
| 122 |
|
---|
| 123 | static void dbgfR3UnwindCtxFlushCache(PDBGFUNWINDCTX pUnwindCtx)
|
---|
| 124 | {
|
---|
| 125 | if (pUnwindCtx->m_hCached != NIL_RTDBGMOD)
|
---|
| 126 | {
|
---|
| 127 | RTDbgModRelease(pUnwindCtx->m_hCached);
|
---|
| 128 | pUnwindCtx->m_hCached = NIL_RTDBGMOD;
|
---|
| 129 | }
|
---|
[73495] | 130 | pUnwindCtx->m_cbCachedMapping = 0;
|
---|
| 131 | pUnwindCtx->m_idxCachedSegMapping = NIL_RTDBGSEGIDX;
|
---|
[73377] | 132 | }
|
---|
| 133 |
|
---|
| 134 |
|
---|
| 135 | DBGFUNWINDCTX::~DBGFUNWINDCTX()
|
---|
| 136 | {
|
---|
| 137 | dbgfR3UnwindCtxFlushCache(this);
|
---|
[73397] | 138 | if (m_hAs != NIL_RTDBGAS)
|
---|
| 139 | {
|
---|
| 140 | RTDbgAsRelease(m_hAs);
|
---|
| 141 | m_hAs = NIL_RTDBGAS;
|
---|
| 142 | }
|
---|
[73377] | 143 | }
|
---|
| 144 |
|
---|
| 145 |
|
---|
[73397] | 146 | /**
|
---|
[73460] | 147 | * @interface_method_impl{RTDBGUNWINDSTATE,pfnReadStack}
|
---|
[73444] | 148 | */
|
---|
[73460] | 149 | static DECLCALLBACK(int) dbgfR3StackReadCallback(PRTDBGUNWINDSTATE pThis, RTUINTPTR uSp, size_t cbToRead, void *pvDst)
|
---|
[73444] | 150 | {
|
---|
| 151 | Assert( pThis->enmArch == RTLDRARCH_AMD64
|
---|
| 152 | || pThis->enmArch == RTLDRARCH_X86_32);
|
---|
| 153 |
|
---|
| 154 | PDBGFUNWINDCTX pUnwindCtx = (PDBGFUNWINDCTX)pThis->pvUser;
|
---|
| 155 | DBGFADDRESS SrcAddr;
|
---|
| 156 | int rc = VINF_SUCCESS;
|
---|
[73471] | 157 | if (pUnwindCtx->m_fIsHostRing0)
|
---|
| 158 | DBGFR3AddrFromHostR0(&SrcAddr, uSp);
|
---|
| 159 | else
|
---|
[73444] | 160 | {
|
---|
[73471] | 161 | if ( pThis->enmArch == RTLDRARCH_X86_32
|
---|
| 162 | || pThis->enmArch == RTLDRARCH_X86_16)
|
---|
| 163 | {
|
---|
| 164 | if (!pThis->u.x86.fRealOrV86)
|
---|
| 165 | rc = DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &SrcAddr, pThis->u.x86.auSegs[X86_SREG_SS], uSp);
|
---|
| 166 | else
|
---|
| 167 | DBGFR3AddrFromFlat(pUnwindCtx->m_pUVM, &SrcAddr, uSp + ((uint32_t)pThis->u.x86.auSegs[X86_SREG_SS] << 4));
|
---|
| 168 | }
|
---|
[73444] | 169 | else
|
---|
[73471] | 170 | DBGFR3AddrFromFlat(pUnwindCtx->m_pUVM, &SrcAddr, uSp);
|
---|
[73444] | 171 | }
|
---|
| 172 | if (RT_SUCCESS(rc))
|
---|
| 173 | rc = DBGFR3MemRead(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &SrcAddr, pvDst, cbToRead);
|
---|
[73495] | 174 | if (RT_SUCCESS(rc))
|
---|
| 175 | return rc;
|
---|
| 176 | return -rc; /* Ignore read errors. */
|
---|
[73444] | 177 | }
|
---|
| 178 |
|
---|
| 179 |
|
---|
| 180 | /**
|
---|
[73397] | 181 | * Sets PC and SP.
|
---|
| 182 | *
|
---|
| 183 | * @returns true.
|
---|
| 184 | * @param pUnwindCtx The unwind context.
|
---|
| 185 | * @param pAddrPC The program counter (PC) value to set.
|
---|
| 186 | * @param pAddrStack The stack pointer (SP) value to set.
|
---|
| 187 | */
|
---|
[73377] | 188 | static bool dbgfR3UnwindCtxSetPcAndSp(PDBGFUNWINDCTX pUnwindCtx, PCDBGFADDRESS pAddrPC, PCDBGFADDRESS pAddrStack)
|
---|
| 189 | {
|
---|
[73444] | 190 | Assert( pUnwindCtx->m_State.enmArch == RTLDRARCH_AMD64
|
---|
| 191 | || pUnwindCtx->m_State.enmArch == RTLDRARCH_X86_32);
|
---|
| 192 |
|
---|
[73397] | 193 | if (!DBGFADDRESS_IS_FAR(pAddrPC))
|
---|
[73444] | 194 | pUnwindCtx->m_State.uPc = pAddrPC->FlatPtr;
|
---|
[73397] | 195 | else
|
---|
| 196 | {
|
---|
[73444] | 197 | pUnwindCtx->m_State.uPc = pAddrPC->off;
|
---|
| 198 | pUnwindCtx->m_State.u.x86.auSegs[X86_SREG_CS] = pAddrPC->Sel;
|
---|
[73397] | 199 | }
|
---|
| 200 | if (!DBGFADDRESS_IS_FAR(pAddrStack))
|
---|
[73444] | 201 | pUnwindCtx->m_State.u.x86.auRegs[X86_GREG_xSP] = pAddrStack->FlatPtr;
|
---|
[73397] | 202 | else
|
---|
| 203 | {
|
---|
[73444] | 204 | pUnwindCtx->m_State.u.x86.auRegs[X86_GREG_xSP] = pAddrStack->off;
|
---|
| 205 | pUnwindCtx->m_State.u.x86.auSegs[X86_SREG_SS] = pAddrStack->Sel;
|
---|
[73397] | 206 | }
|
---|
[73377] | 207 | return true;
|
---|
| 208 | }
|
---|
| 209 |
|
---|
| 210 |
|
---|
[73388] | 211 | /**
|
---|
[73495] | 212 | * Tries to unwind one frame using unwind info.
|
---|
[73397] | 213 | *
|
---|
| 214 | * @returns true on success, false on failure.
|
---|
[73495] | 215 | * @param pUnwindCtx The unwind context.
|
---|
[73397] | 216 | */
|
---|
[73495] | 217 | static bool dbgfR3UnwindCtxDoOneFrame(PDBGFUNWINDCTX pUnwindCtx)
|
---|
[73397] | 218 | {
|
---|
[73388] | 219 | /*
|
---|
[73495] | 220 | * Need to load it into the cache?
|
---|
[73388] | 221 | */
|
---|
[73495] | 222 | RTUINTPTR offCache = pUnwindCtx->m_State.uPc - pUnwindCtx->m_uCachedMapping;
|
---|
| 223 | if (offCache >= pUnwindCtx->m_cbCachedMapping)
|
---|
[73388] | 224 | {
|
---|
[73495] | 225 | RTDBGMOD hDbgMod = NIL_RTDBGMOD;
|
---|
| 226 | RTUINTPTR uBase = 0;
|
---|
| 227 | RTDBGSEGIDX idxSeg = NIL_RTDBGSEGIDX;
|
---|
| 228 | int rc = RTDbgAsModuleByAddr(pUnwindCtx->m_hAs, pUnwindCtx->m_State.uPc, &hDbgMod, &uBase, &idxSeg);
|
---|
| 229 | if (RT_SUCCESS(rc))
|
---|
[73388] | 230 | {
|
---|
[73495] | 231 | dbgfR3UnwindCtxFlushCache(pUnwindCtx);
|
---|
| 232 | pUnwindCtx->m_hCached = hDbgMod;
|
---|
| 233 | pUnwindCtx->m_uCachedMapping = uBase;
|
---|
| 234 | pUnwindCtx->m_idxCachedSegMapping = idxSeg;
|
---|
| 235 | pUnwindCtx->m_cbCachedMapping = idxSeg == NIL_RTDBGSEGIDX ? RTDbgModImageSize(hDbgMod)
|
---|
| 236 | : RTDbgModSegmentSize(hDbgMod, idxSeg);
|
---|
| 237 | offCache = pUnwindCtx->m_State.uPc - uBase;
|
---|
[73388] | 238 | }
|
---|
[73495] | 239 | else
|
---|
| 240 | return false;
|
---|
[73388] | 241 | }
|
---|
| 242 |
|
---|
[73377] | 243 | /*
|
---|
[73495] | 244 | * Do the lookup.
|
---|
[73377] | 245 | */
|
---|
[73495] | 246 | AssertCompile(UINT32_MAX == NIL_RTDBGSEGIDX);
|
---|
| 247 | int rc = RTDbgModUnwindFrame(pUnwindCtx->m_hCached, pUnwindCtx->m_idxCachedSegMapping, offCache, &pUnwindCtx->m_State);
|
---|
[73377] | 248 | if (RT_SUCCESS(rc))
|
---|
[73495] | 249 | return true;
|
---|
[73377] | 250 | return false;
|
---|
| 251 | }
|
---|
| 252 |
|
---|
| 253 |
|
---|
[1] | 254 | /**
|
---|
[73377] | 255 | * Read stack memory, will init entire buffer.
|
---|
[1] | 256 | */
|
---|
[73377] | 257 | DECLINLINE(int) dbgfR3StackRead(PUVM pUVM, VMCPUID idCpu, void *pvBuf, PCDBGFADDRESS pSrcAddr, size_t cb, size_t *pcbRead)
|
---|
[1] | 258 | {
|
---|
[44399] | 259 | int rc = DBGFR3MemRead(pUVM, idCpu, pSrcAddr, pvBuf, cb);
|
---|
[13816] | 260 | if (RT_FAILURE(rc))
|
---|
[1] | 261 | {
|
---|
[19286] | 262 | /* fallback: byte by byte and zero the ones we fail to read. */
|
---|
[1] | 263 | size_t cbRead;
|
---|
| 264 | for (cbRead = 0; cbRead < cb; cbRead++)
|
---|
| 265 | {
|
---|
[19286] | 266 | DBGFADDRESS Addr = *pSrcAddr;
|
---|
[44399] | 267 | rc = DBGFR3MemRead(pUVM, idCpu, DBGFR3AddrAdd(&Addr, cbRead), (uint8_t *)pvBuf + cbRead, 1);
|
---|
[13816] | 268 | if (RT_FAILURE(rc))
|
---|
[1] | 269 | break;
|
---|
| 270 | }
|
---|
| 271 | if (cbRead)
|
---|
| 272 | rc = VINF_SUCCESS;
|
---|
| 273 | memset((char *)pvBuf + cbRead, 0, cb - cbRead);
|
---|
| 274 | *pcbRead = cbRead;
|
---|
| 275 | }
|
---|
| 276 | else
|
---|
| 277 | *pcbRead = cb;
|
---|
| 278 | return rc;
|
---|
| 279 | }
|
---|
| 280 |
|
---|
[73460] | 281 | /**
|
---|
| 282 | * Collects sure registers on frame exit.
|
---|
| 283 | *
|
---|
| 284 | * @returns VINF_SUCCESS or VERR_NO_MEMORY.
|
---|
| 285 | * @param pUVM The user mode VM handle for the allocation.
|
---|
| 286 | * @param pFrame The frame in question.
|
---|
| 287 | * @param pState The unwind state.
|
---|
| 288 | */
|
---|
| 289 | static int dbgfR3StackWalkCollectRegisterChanges(PUVM pUVM, PDBGFSTACKFRAME pFrame, PRTDBGUNWINDSTATE pState)
|
---|
[73444] | 290 | {
|
---|
| 291 | pFrame->cSureRegs = 0;
|
---|
| 292 | pFrame->paSureRegs = NULL;
|
---|
[1] | 293 |
|
---|
[73444] | 294 | if ( pState->enmArch == RTLDRARCH_AMD64
|
---|
| 295 | || pState->enmArch == RTLDRARCH_X86_32
|
---|
| 296 | || pState->enmArch == RTLDRARCH_X86_16)
|
---|
| 297 | {
|
---|
| 298 | if (pState->u.x86.Loaded.fAll)
|
---|
| 299 | {
|
---|
| 300 | /*
|
---|
| 301 | * Count relevant registers.
|
---|
| 302 | */
|
---|
| 303 | uint32_t cRegs = 0;
|
---|
| 304 | if (pState->u.x86.Loaded.s.fRegs)
|
---|
| 305 | for (uint32_t f = 1; f < RT_BIT_32(RT_ELEMENTS(pState->u.x86.auRegs)); f <<= 1)
|
---|
| 306 | if (pState->u.x86.Loaded.s.fRegs & f)
|
---|
| 307 | cRegs++;
|
---|
| 308 | if (pState->u.x86.Loaded.s.fSegs)
|
---|
| 309 | for (uint32_t f = 1; f < RT_BIT_32(RT_ELEMENTS(pState->u.x86.auSegs)); f <<= 1)
|
---|
| 310 | if (pState->u.x86.Loaded.s.fSegs & f)
|
---|
| 311 | cRegs++;
|
---|
| 312 | if (pState->u.x86.Loaded.s.fRFlags)
|
---|
| 313 | cRegs++;
|
---|
| 314 | if (pState->u.x86.Loaded.s.fErrCd)
|
---|
| 315 | cRegs++;
|
---|
| 316 | if (cRegs > 0)
|
---|
| 317 | {
|
---|
| 318 | /*
|
---|
| 319 | * Allocate the arrays.
|
---|
| 320 | */
|
---|
| 321 | PDBGFREGVALEX paSureRegs = (PDBGFREGVALEX)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF_STACK, sizeof(DBGFREGVALEX) * cRegs);
|
---|
| 322 | AssertReturn(paSureRegs, VERR_NO_MEMORY);
|
---|
| 323 | pFrame->paSureRegs = paSureRegs;
|
---|
| 324 | pFrame->cSureRegs = cRegs;
|
---|
| 325 |
|
---|
| 326 | /*
|
---|
| 327 | * Popuplate the arrays.
|
---|
| 328 | */
|
---|
| 329 | uint32_t iReg = 0;
|
---|
| 330 | if (pState->u.x86.Loaded.s.fRegs)
|
---|
[73490] | 331 | for (uint32_t i = 0; i < RT_ELEMENTS(pState->u.x86.auRegs); i++)
|
---|
[73444] | 332 | if (pState->u.x86.Loaded.s.fRegs & RT_BIT(i))
|
---|
| 333 | {
|
---|
| 334 | paSureRegs[iReg].Value.u64 = pState->u.x86.auRegs[i];
|
---|
| 335 | paSureRegs[iReg].enmType = DBGFREGVALTYPE_U64;
|
---|
| 336 | paSureRegs[iReg].enmReg = (DBGFREG)(DBGFREG_RAX + i);
|
---|
| 337 | iReg++;
|
---|
| 338 | }
|
---|
| 339 |
|
---|
| 340 | if (pState->u.x86.Loaded.s.fSegs)
|
---|
[73490] | 341 | for (uint32_t i = 0; i < RT_ELEMENTS(pState->u.x86.auSegs); i++)
|
---|
[73444] | 342 | if (pState->u.x86.Loaded.s.fSegs & RT_BIT(i))
|
---|
| 343 | {
|
---|
| 344 | paSureRegs[iReg].Value.u16 = pState->u.x86.auSegs[i];
|
---|
| 345 | paSureRegs[iReg].enmType = DBGFREGVALTYPE_U16;
|
---|
| 346 | switch (i)
|
---|
| 347 | {
|
---|
| 348 | case X86_SREG_ES: paSureRegs[iReg].enmReg = DBGFREG_ES; break;
|
---|
| 349 | case X86_SREG_CS: paSureRegs[iReg].enmReg = DBGFREG_CS; break;
|
---|
| 350 | case X86_SREG_SS: paSureRegs[iReg].enmReg = DBGFREG_SS; break;
|
---|
| 351 | case X86_SREG_DS: paSureRegs[iReg].enmReg = DBGFREG_DS; break;
|
---|
| 352 | case X86_SREG_FS: paSureRegs[iReg].enmReg = DBGFREG_FS; break;
|
---|
| 353 | case X86_SREG_GS: paSureRegs[iReg].enmReg = DBGFREG_GS; break;
|
---|
| 354 | default: AssertFailedBreak();
|
---|
| 355 | }
|
---|
| 356 | iReg++;
|
---|
| 357 | }
|
---|
| 358 |
|
---|
| 359 | if (iReg < cRegs)
|
---|
| 360 | {
|
---|
| 361 | if (pState->u.x86.Loaded.s.fRFlags)
|
---|
| 362 | {
|
---|
| 363 | paSureRegs[iReg].Value.u64 = pState->u.x86.uRFlags;
|
---|
| 364 | paSureRegs[iReg].enmType = DBGFREGVALTYPE_U64;
|
---|
| 365 | paSureRegs[iReg].enmReg = DBGFREG_RFLAGS;
|
---|
| 366 | iReg++;
|
---|
| 367 | }
|
---|
| 368 | if (pState->u.x86.Loaded.s.fErrCd)
|
---|
| 369 | {
|
---|
| 370 | paSureRegs[iReg].Value.u64 = pState->u.x86.uErrCd;
|
---|
| 371 | paSureRegs[iReg].enmType = DBGFREGVALTYPE_U64;
|
---|
| 372 | paSureRegs[iReg].enmReg = DBGFREG_END;
|
---|
| 373 | paSureRegs[iReg].pszName = "trap-errcd";
|
---|
| 374 | iReg++;
|
---|
| 375 | }
|
---|
| 376 | }
|
---|
| 377 | Assert(iReg == cRegs);
|
---|
| 378 | }
|
---|
| 379 | }
|
---|
| 380 | }
|
---|
| 381 |
|
---|
| 382 | return VINF_SUCCESS;
|
---|
| 383 | }
|
---|
| 384 |
|
---|
| 385 |
|
---|
[1] | 386 | /**
|
---|
| 387 | * Internal worker routine.
|
---|
| 388 | *
|
---|
| 389 | * On x86 the typical stack frame layout is like this:
|
---|
| 390 | * .. ..
|
---|
| 391 | * 16 parameter 2
|
---|
| 392 | * 12 parameter 1
|
---|
| 393 | * 8 parameter 0
|
---|
| 394 | * 4 return address
|
---|
| 395 | * 0 old ebp; current ebp points here
|
---|
| 396 | */
|
---|
[73397] | 397 | DECL_NO_INLINE(static, int) dbgfR3StackWalk(PDBGFUNWINDCTX pUnwindCtx, PDBGFSTACKFRAME pFrame, bool fFirst)
|
---|
[1] | 398 | {
|
---|
| 399 | /*
|
---|
| 400 | * Stop if we got a read error in the previous run.
|
---|
| 401 | */
|
---|
| 402 | if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_LAST)
|
---|
| 403 | return VERR_NO_MORE_FILES;
|
---|
| 404 |
|
---|
| 405 | /*
|
---|
[73397] | 406 | * Advance the frame (except for the first).
|
---|
[1] | 407 | */
|
---|
[73397] | 408 | if (!fFirst) /** @todo we can probably eliminate this fFirst business... */
|
---|
[1] | 409 | {
|
---|
[73397] | 410 | /* frame, pc and stack is taken from the existing frames return members. */
|
---|
| 411 | pFrame->AddrFrame = pFrame->AddrReturnFrame;
|
---|
| 412 | pFrame->AddrPC = pFrame->AddrReturnPC;
|
---|
| 413 | pFrame->pSymPC = pFrame->pSymReturnPC;
|
---|
| 414 | pFrame->pLinePC = pFrame->pLineReturnPC;
|
---|
| 415 |
|
---|
| 416 | /* increment the frame number. */
|
---|
| 417 | pFrame->iFrame++;
|
---|
| 418 |
|
---|
| 419 | /* UNWIND_INFO_RET -> USED_UNWIND; return type */
|
---|
| 420 | if (!(pFrame->fFlags & DBGFSTACKFRAME_FLAGS_UNWIND_INFO_RET))
|
---|
| 421 | pFrame->fFlags &= ~DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO;
|
---|
| 422 | else
|
---|
| 423 | {
|
---|
| 424 | pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO;
|
---|
| 425 | pFrame->fFlags &= ~DBGFSTACKFRAME_FLAGS_UNWIND_INFO_RET;
|
---|
[73460] | 426 | if (pFrame->enmReturnFrameReturnType != RTDBGRETURNTYPE_INVALID)
|
---|
[73397] | 427 | {
|
---|
| 428 | pFrame->enmReturnType = pFrame->enmReturnFrameReturnType;
|
---|
[73460] | 429 | pFrame->enmReturnFrameReturnType = RTDBGRETURNTYPE_INVALID;
|
---|
[73397] | 430 | }
|
---|
| 431 | }
|
---|
[73460] | 432 | pFrame->fFlags &= ~DBGFSTACKFRAME_FLAGS_TRAP_FRAME;
|
---|
[73397] | 433 | }
|
---|
| 434 |
|
---|
| 435 | /*
|
---|
| 436 | * Figure the return address size and use the old PC to guess stack item size.
|
---|
| 437 | */
|
---|
| 438 | /** @todo this is bogus... */
|
---|
[73460] | 439 | unsigned cbRetAddr = RTDbgReturnTypeSize(pFrame->enmReturnType);
|
---|
[73397] | 440 | unsigned cbStackItem;
|
---|
| 441 | switch (pFrame->AddrPC.fFlags & DBGFADDRESS_FLAGS_TYPE_MASK)
|
---|
| 442 | {
|
---|
[1] | 443 | case DBGFADDRESS_FLAGS_FAR16: cbStackItem = 2; break;
|
---|
| 444 | case DBGFADDRESS_FLAGS_FAR32: cbStackItem = 4; break;
|
---|
| 445 | case DBGFADDRESS_FLAGS_FAR64: cbStackItem = 8; break;
|
---|
[19575] | 446 | case DBGFADDRESS_FLAGS_RING0: cbStackItem = sizeof(RTHCUINTPTR); break;
|
---|
[22106] | 447 | default:
|
---|
| 448 | switch (pFrame->enmReturnType)
|
---|
| 449 | {
|
---|
[73460] | 450 | case RTDBGRETURNTYPE_FAR16:
|
---|
| 451 | case RTDBGRETURNTYPE_IRET16:
|
---|
| 452 | case RTDBGRETURNTYPE_IRET32_V86:
|
---|
| 453 | case RTDBGRETURNTYPE_NEAR16: cbStackItem = 2; break;
|
---|
[22106] | 454 |
|
---|
[73460] | 455 | case RTDBGRETURNTYPE_FAR32:
|
---|
| 456 | case RTDBGRETURNTYPE_IRET32:
|
---|
| 457 | case RTDBGRETURNTYPE_IRET32_PRIV:
|
---|
| 458 | case RTDBGRETURNTYPE_NEAR32: cbStackItem = 4; break;
|
---|
[22106] | 459 |
|
---|
[73460] | 460 | case RTDBGRETURNTYPE_FAR64:
|
---|
| 461 | case RTDBGRETURNTYPE_IRET64:
|
---|
| 462 | case RTDBGRETURNTYPE_NEAR64: cbStackItem = 8; break;
|
---|
[22106] | 463 |
|
---|
| 464 | default:
|
---|
| 465 | AssertMsgFailed(("%d\n", pFrame->enmReturnType));
|
---|
| 466 | cbStackItem = 4;
|
---|
| 467 | break;
|
---|
| 468 | }
|
---|
[1] | 469 | }
|
---|
| 470 |
|
---|
[73397] | 471 | /*
|
---|
| 472 | * Read the raw frame data.
|
---|
| 473 | * We double cbRetAddr in case we have a far return.
|
---|
| 474 | */
|
---|
[1] | 475 | union
|
---|
| 476 | {
|
---|
| 477 | uint64_t *pu64;
|
---|
| 478 | uint32_t *pu32;
|
---|
| 479 | uint16_t *pu16;
|
---|
| 480 | uint8_t *pb;
|
---|
| 481 | void *pv;
|
---|
| 482 | } u, uRet, uArgs, uBp;
|
---|
[60560] | 483 | size_t cbRead = cbRetAddr*2 + cbStackItem + sizeof(pFrame->Args);
|
---|
[1] | 484 | u.pv = alloca(cbRead);
|
---|
| 485 | uBp = u;
|
---|
| 486 | uRet.pb = u.pb + cbStackItem;
|
---|
| 487 | uArgs.pb = u.pb + cbStackItem + cbRetAddr;
|
---|
| 488 |
|
---|
| 489 | Assert(DBGFADDRESS_IS_VALID(&pFrame->AddrFrame));
|
---|
[73397] | 490 | int rc = dbgfR3StackRead(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, u.pv, &pFrame->AddrFrame, cbRead, &cbRead);
|
---|
| 491 | if ( RT_FAILURE(rc)
|
---|
| 492 | || cbRead < cbRetAddr + cbStackItem)
|
---|
[1] | 493 | pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_LAST;
|
---|
| 494 |
|
---|
| 495 | /*
|
---|
[73397] | 496 | * Return Frame address.
|
---|
| 497 | *
|
---|
| 498 | * If we used unwind info to get here, the unwind register context will be
|
---|
| 499 | * positioned after the return instruction has been executed. We start by
|
---|
| 500 | * picking up the rBP register here for return frame and will try improve
|
---|
| 501 | * on it further down by using unwind info.
|
---|
[1] | 502 | */
|
---|
[73397] | 503 | pFrame->AddrReturnFrame = pFrame->AddrFrame;
|
---|
| 504 | if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO)
|
---|
[1] | 505 | {
|
---|
[73460] | 506 | if ( pFrame->enmReturnType == RTDBGRETURNTYPE_IRET32_PRIV
|
---|
| 507 | || pFrame->enmReturnType == RTDBGRETURNTYPE_IRET64)
|
---|
[73397] | 508 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnFrame,
|
---|
[73444] | 509 | pUnwindCtx->m_State.u.x86.auSegs[X86_SREG_SS], pUnwindCtx->m_State.u.x86.auRegs[X86_GREG_xBP]);
|
---|
[73460] | 510 | else if (pFrame->enmReturnType == RTDBGRETURNTYPE_IRET32_V86)
|
---|
[73397] | 511 | DBGFR3AddrFromFlat(pUnwindCtx->m_pUVM, &pFrame->AddrReturnFrame,
|
---|
[73444] | 512 | ((uint32_t)pUnwindCtx->m_State.u.x86.auSegs[X86_SREG_SS] << 4)
|
---|
| 513 | + pUnwindCtx->m_State.u.x86.auRegs[X86_GREG_xBP]);
|
---|
[73397] | 514 | else
|
---|
[1] | 515 | {
|
---|
[73444] | 516 | pFrame->AddrReturnFrame.off = pUnwindCtx->m_State.u.x86.auRegs[X86_GREG_xBP];
|
---|
[73397] | 517 | pFrame->AddrReturnFrame.FlatPtr += pFrame->AddrReturnFrame.off - pFrame->AddrFrame.off;
|
---|
[1] | 518 | }
|
---|
| 519 | }
|
---|
[73397] | 520 | else
|
---|
[1] | 521 | {
|
---|
[73397] | 522 | switch (cbStackItem)
|
---|
| 523 | {
|
---|
| 524 | case 2: pFrame->AddrReturnFrame.off = *uBp.pu16; break;
|
---|
| 525 | case 4: pFrame->AddrReturnFrame.off = *uBp.pu32; break;
|
---|
| 526 | case 8: pFrame->AddrReturnFrame.off = *uBp.pu64; break;
|
---|
| 527 | default: AssertMsgFailedReturn(("cbStackItem=%d\n", cbStackItem), VERR_DBGF_STACK_IPE_1);
|
---|
| 528 | }
|
---|
[1] | 529 |
|
---|
[73397] | 530 | /* Watcom tries to keep the frame pointer odd for far returns. */
|
---|
| 531 | if ( cbStackItem <= 4
|
---|
| 532 | && !(pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO))
|
---|
[60560] | 533 | {
|
---|
[73397] | 534 | if (pFrame->AddrReturnFrame.off & 1)
|
---|
[60560] | 535 | {
|
---|
[73397] | 536 | pFrame->AddrReturnFrame.off &= ~(RTGCUINTPTR)1;
|
---|
[73460] | 537 | if (pFrame->enmReturnType == RTDBGRETURNTYPE_NEAR16)
|
---|
[73397] | 538 | {
|
---|
| 539 | pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_USED_ODD_EVEN;
|
---|
[73460] | 540 | pFrame->enmReturnType = RTDBGRETURNTYPE_FAR16;
|
---|
[73397] | 541 | cbRetAddr = 4;
|
---|
| 542 | }
|
---|
[73460] | 543 | else if (pFrame->enmReturnType == RTDBGRETURNTYPE_NEAR32)
|
---|
[73397] | 544 | {
|
---|
[75240] | 545 | #if 1
|
---|
| 546 | /* Assumes returning 32-bit code. */
|
---|
[73397] | 547 | pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_USED_ODD_EVEN;
|
---|
[73460] | 548 | pFrame->enmReturnType = RTDBGRETURNTYPE_FAR32;
|
---|
[73397] | 549 | cbRetAddr = 8;
|
---|
[75240] | 550 | #else
|
---|
| 551 | /* Assumes returning 16-bit code. */
|
---|
| 552 | pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_USED_ODD_EVEN;
|
---|
| 553 | pFrame->enmReturnType = RTDBGRETURNTYPE_FAR16;
|
---|
| 554 | cbRetAddr = 4;
|
---|
| 555 | #endif
|
---|
[73397] | 556 | }
|
---|
[60560] | 557 | }
|
---|
[73397] | 558 | else if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_ODD_EVEN)
|
---|
[60560] | 559 | {
|
---|
[73460] | 560 | if (pFrame->enmReturnType == RTDBGRETURNTYPE_FAR16)
|
---|
[73397] | 561 | {
|
---|
[73460] | 562 | pFrame->enmReturnType = RTDBGRETURNTYPE_NEAR16;
|
---|
[73397] | 563 | cbRetAddr = 2;
|
---|
| 564 | }
|
---|
[73460] | 565 | else if (pFrame->enmReturnType == RTDBGRETURNTYPE_NEAR32)
|
---|
[73397] | 566 | {
|
---|
[73460] | 567 | pFrame->enmReturnType = RTDBGRETURNTYPE_FAR32;
|
---|
[73397] | 568 | cbRetAddr = 4;
|
---|
| 569 | }
|
---|
| 570 | pFrame->fFlags &= ~DBGFSTACKFRAME_FLAGS_USED_ODD_EVEN;
|
---|
[60560] | 571 | }
|
---|
[73397] | 572 | uArgs.pb = u.pb + cbStackItem + cbRetAddr;
|
---|
[60560] | 573 | }
|
---|
[73397] | 574 |
|
---|
| 575 | pFrame->AddrReturnFrame.FlatPtr += pFrame->AddrReturnFrame.off - pFrame->AddrFrame.off;
|
---|
| 576 | }
|
---|
| 577 |
|
---|
| 578 | /*
|
---|
| 579 | * Return Stack Address.
|
---|
| 580 | */
|
---|
| 581 | pFrame->AddrReturnStack = pFrame->AddrReturnFrame;
|
---|
| 582 | if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO)
|
---|
| 583 | {
|
---|
[73460] | 584 | if ( pFrame->enmReturnType == RTDBGRETURNTYPE_IRET32_PRIV
|
---|
| 585 | || pFrame->enmReturnType == RTDBGRETURNTYPE_IRET64)
|
---|
[73397] | 586 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnStack,
|
---|
[73444] | 587 | pUnwindCtx->m_State.u.x86.auSegs[X86_SREG_SS], pUnwindCtx->m_State.u.x86.auRegs[X86_GREG_xSP]);
|
---|
[73460] | 588 | else if (pFrame->enmReturnType == RTDBGRETURNTYPE_IRET32_V86)
|
---|
[73397] | 589 | DBGFR3AddrFromFlat(pUnwindCtx->m_pUVM, &pFrame->AddrReturnStack,
|
---|
[73444] | 590 | ((uint32_t)pUnwindCtx->m_State.u.x86.auSegs[X86_SREG_SS] << 4)
|
---|
| 591 | + pUnwindCtx->m_State.u.x86.auRegs[X86_GREG_xSP]);
|
---|
[73397] | 592 | else
|
---|
[60560] | 593 | {
|
---|
[73444] | 594 | pFrame->AddrReturnStack.off = pUnwindCtx->m_State.u.x86.auRegs[X86_GREG_xSP];
|
---|
[73397] | 595 | pFrame->AddrReturnStack.FlatPtr += pFrame->AddrReturnStack.off - pFrame->AddrStack.off;
|
---|
[60560] | 596 | }
|
---|
| 597 | }
|
---|
[73397] | 598 | else
|
---|
| 599 | {
|
---|
| 600 | pFrame->AddrReturnStack.off += cbStackItem + cbRetAddr;
|
---|
| 601 | pFrame->AddrReturnStack.FlatPtr += cbStackItem + cbRetAddr;
|
---|
| 602 | }
|
---|
[60560] | 603 |
|
---|
[1] | 604 | /*
|
---|
[73397] | 605 | * Return PC.
|
---|
[1] | 606 | */
|
---|
[73397] | 607 | pFrame->AddrReturnPC = pFrame->AddrPC;
|
---|
| 608 | if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO)
|
---|
[1] | 609 | {
|
---|
[73460] | 610 | if (RTDbgReturnTypeIsNear(pFrame->enmReturnType))
|
---|
[73397] | 611 | {
|
---|
[73444] | 612 | pFrame->AddrReturnPC.off = pUnwindCtx->m_State.uPc;
|
---|
[73397] | 613 | pFrame->AddrReturnPC.FlatPtr += pFrame->AddrReturnPC.off - pFrame->AddrPC.off;
|
---|
| 614 | }
|
---|
| 615 | else
|
---|
| 616 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC,
|
---|
[73444] | 617 | pUnwindCtx->m_State.u.x86.auSegs[X86_SREG_CS], pUnwindCtx->m_State.uPc);
|
---|
[1] | 618 | }
|
---|
[73397] | 619 | else
|
---|
[75240] | 620 | {
|
---|
| 621 | int rc2;
|
---|
[73397] | 622 | switch (pFrame->enmReturnType)
|
---|
| 623 | {
|
---|
[73460] | 624 | case RTDBGRETURNTYPE_NEAR16:
|
---|
[73397] | 625 | if (DBGFADDRESS_IS_VALID(&pFrame->AddrReturnPC))
|
---|
| 626 | {
|
---|
| 627 | pFrame->AddrReturnPC.FlatPtr += *uRet.pu16 - pFrame->AddrReturnPC.off;
|
---|
| 628 | pFrame->AddrReturnPC.off = *uRet.pu16;
|
---|
| 629 | }
|
---|
| 630 | else
|
---|
| 631 | DBGFR3AddrFromFlat(pUnwindCtx->m_pUVM, &pFrame->AddrReturnPC, *uRet.pu16);
|
---|
| 632 | break;
|
---|
[73460] | 633 | case RTDBGRETURNTYPE_NEAR32:
|
---|
[73397] | 634 | if (DBGFADDRESS_IS_VALID(&pFrame->AddrReturnPC))
|
---|
| 635 | {
|
---|
| 636 | pFrame->AddrReturnPC.FlatPtr += *uRet.pu32 - pFrame->AddrReturnPC.off;
|
---|
| 637 | pFrame->AddrReturnPC.off = *uRet.pu32;
|
---|
| 638 | }
|
---|
| 639 | else
|
---|
| 640 | DBGFR3AddrFromFlat(pUnwindCtx->m_pUVM, &pFrame->AddrReturnPC, *uRet.pu32);
|
---|
| 641 | break;
|
---|
[73460] | 642 | case RTDBGRETURNTYPE_NEAR64:
|
---|
[73397] | 643 | if (DBGFADDRESS_IS_VALID(&pFrame->AddrReturnPC))
|
---|
| 644 | {
|
---|
| 645 | pFrame->AddrReturnPC.FlatPtr += *uRet.pu64 - pFrame->AddrReturnPC.off;
|
---|
| 646 | pFrame->AddrReturnPC.off = *uRet.pu64;
|
---|
| 647 | }
|
---|
| 648 | else
|
---|
| 649 | DBGFR3AddrFromFlat(pUnwindCtx->m_pUVM, &pFrame->AddrReturnPC, *uRet.pu64);
|
---|
| 650 | break;
|
---|
[73460] | 651 | case RTDBGRETURNTYPE_FAR16:
|
---|
[75240] | 652 | rc2 = DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, uRet.pu16[1], uRet.pu16[0]);
|
---|
| 653 | if (RT_SUCCESS(rc2))
|
---|
| 654 | break;
|
---|
| 655 | rc2 = DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, pFrame->AddrPC.Sel, uRet.pu16[0]);
|
---|
| 656 | if (RT_SUCCESS(rc2))
|
---|
| 657 | pFrame->enmReturnType = RTDBGRETURNTYPE_NEAR16;
|
---|
| 658 | else
|
---|
| 659 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, uRet.pu16[1], uRet.pu16[0]);
|
---|
[73397] | 660 | break;
|
---|
[73460] | 661 | case RTDBGRETURNTYPE_FAR32:
|
---|
[75240] | 662 | rc2 = DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, uRet.pu16[2], uRet.pu32[0]);
|
---|
| 663 | if (RT_SUCCESS(rc2))
|
---|
| 664 | break;
|
---|
| 665 | rc2 = DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, pFrame->AddrPC.Sel, uRet.pu32[0]);
|
---|
| 666 | if (RT_SUCCESS(rc2))
|
---|
| 667 | pFrame->enmReturnType = RTDBGRETURNTYPE_NEAR32;
|
---|
| 668 | else
|
---|
| 669 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, uRet.pu16[2], uRet.pu32[0]);
|
---|
[73397] | 670 | break;
|
---|
[73460] | 671 | case RTDBGRETURNTYPE_FAR64:
|
---|
[73397] | 672 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, uRet.pu16[4], uRet.pu64[0]);
|
---|
| 673 | break;
|
---|
[73460] | 674 | case RTDBGRETURNTYPE_IRET16:
|
---|
[73397] | 675 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, uRet.pu16[1], uRet.pu16[0]);
|
---|
| 676 | break;
|
---|
[73460] | 677 | case RTDBGRETURNTYPE_IRET32:
|
---|
[73397] | 678 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, uRet.pu16[2], uRet.pu32[0]);
|
---|
| 679 | break;
|
---|
[73460] | 680 | case RTDBGRETURNTYPE_IRET32_PRIV:
|
---|
[73397] | 681 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, uRet.pu16[2], uRet.pu32[0]);
|
---|
| 682 | break;
|
---|
[73460] | 683 | case RTDBGRETURNTYPE_IRET32_V86:
|
---|
[73397] | 684 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, uRet.pu16[2], uRet.pu32[0]);
|
---|
| 685 | break;
|
---|
[73460] | 686 | case RTDBGRETURNTYPE_IRET64:
|
---|
[73397] | 687 | DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &pFrame->AddrReturnPC, uRet.pu16[4], uRet.pu64[0]);
|
---|
| 688 | break;
|
---|
| 689 | default:
|
---|
| 690 | AssertMsgFailed(("enmReturnType=%d\n", pFrame->enmReturnType));
|
---|
| 691 | return VERR_INVALID_PARAMETER;
|
---|
| 692 | }
|
---|
[75240] | 693 | }
|
---|
[1] | 694 |
|
---|
[73397] | 695 |
|
---|
| 696 | pFrame->pSymReturnPC = DBGFR3AsSymbolByAddrA(pUnwindCtx->m_pUVM, pUnwindCtx->m_hAs, &pFrame->AddrReturnPC,
|
---|
[73360] | 697 | RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL | RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
|
---|
[46165] | 698 | NULL /*poffDisp*/, NULL /*phMod*/);
|
---|
[73397] | 699 | pFrame->pLineReturnPC = DBGFR3AsLineByAddrA(pUnwindCtx->m_pUVM, pUnwindCtx->m_hAs, &pFrame->AddrReturnPC,
|
---|
| 700 | NULL /*poffDisp*/, NULL /*phMod*/);
|
---|
[1] | 701 |
|
---|
| 702 | /*
|
---|
[22106] | 703 | * Frame bitness flag.
|
---|
| 704 | */
|
---|
[73397] | 705 | /** @todo use previous return type for this? */
|
---|
| 706 | pFrame->fFlags &= ~(DBGFSTACKFRAME_FLAGS_16BIT | DBGFSTACKFRAME_FLAGS_32BIT | DBGFSTACKFRAME_FLAGS_64BIT);
|
---|
[22106] | 707 | switch (cbStackItem)
|
---|
| 708 | {
|
---|
| 709 | case 2: pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_16BIT; break;
|
---|
| 710 | case 4: pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_32BIT; break;
|
---|
| 711 | case 8: pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_64BIT; break;
|
---|
[39405] | 712 | default: AssertMsgFailedReturn(("cbStackItem=%d\n", cbStackItem), VERR_DBGF_STACK_IPE_2);
|
---|
[22106] | 713 | }
|
---|
| 714 |
|
---|
| 715 | /*
|
---|
[1] | 716 | * The arguments.
|
---|
| 717 | */
|
---|
| 718 | memcpy(&pFrame->Args, uArgs.pv, sizeof(pFrame->Args));
|
---|
| 719 |
|
---|
[73397] | 720 | /*
|
---|
[73460] | 721 | * Collect register changes.
|
---|
| 722 | * Then call the OS layer to assist us (e.g. NT trap frames).
|
---|
| 723 | */
|
---|
| 724 | if (pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO)
|
---|
| 725 | {
|
---|
[73483] | 726 | rc = dbgfR3StackWalkCollectRegisterChanges(pUnwindCtx->m_pUVM, pFrame, &pUnwindCtx->m_State);
|
---|
| 727 | if (RT_FAILURE(rc))
|
---|
| 728 | return rc;
|
---|
[73460] | 729 |
|
---|
| 730 | if ( pUnwindCtx->m_pInitialCtx
|
---|
| 731 | && pUnwindCtx->m_hAs != NIL_RTDBGAS)
|
---|
| 732 | {
|
---|
[73472] | 733 | rc = dbgfR3OSStackUnwindAssist(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, pFrame, &pUnwindCtx->m_State,
|
---|
| 734 | pUnwindCtx->m_pInitialCtx, pUnwindCtx->m_hAs, &pUnwindCtx->m_uOsScratch);
|
---|
[73460] | 735 | if (RT_FAILURE(rc))
|
---|
| 736 | return rc;
|
---|
| 737 | }
|
---|
| 738 | }
|
---|
| 739 |
|
---|
| 740 | /*
|
---|
[73397] | 741 | * Try use unwind information to locate the return frame pointer (for the
|
---|
| 742 | * next loop iteration).
|
---|
| 743 | */
|
---|
| 744 | Assert(!(pFrame->fFlags & DBGFSTACKFRAME_FLAGS_UNWIND_INFO_RET));
|
---|
[73460] | 745 | pFrame->enmReturnFrameReturnType = RTDBGRETURNTYPE_INVALID;
|
---|
[73397] | 746 | if (!(pFrame->fFlags & DBGFSTACKFRAME_FLAGS_LAST))
|
---|
| 747 | {
|
---|
| 748 | /* Set PC and SP if we didn't unwind our way here (context will then point
|
---|
| 749 | and the return PC and SP already). */
|
---|
| 750 | if (!(pFrame->fFlags & DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO))
|
---|
| 751 | {
|
---|
| 752 | dbgfR3UnwindCtxSetPcAndSp(pUnwindCtx, &pFrame->AddrReturnPC, &pFrame->AddrReturnStack);
|
---|
[75240] | 753 | pUnwindCtx->m_State.u.x86.auRegs[X86_GREG_xBP] = pFrame->AddrReturnFrame.off;
|
---|
[73397] | 754 | }
|
---|
| 755 | /** @todo Reevaluate CS if the previous frame return type isn't near. */
|
---|
[73444] | 756 | if ( pUnwindCtx->m_State.enmArch == RTLDRARCH_AMD64
|
---|
| 757 | || pUnwindCtx->m_State.enmArch == RTLDRARCH_X86_32
|
---|
| 758 | || pUnwindCtx->m_State.enmArch == RTLDRARCH_X86_16)
|
---|
| 759 | pUnwindCtx->m_State.u.x86.Loaded.fAll = 0;
|
---|
| 760 | else
|
---|
| 761 | AssertFailed();
|
---|
| 762 | if (dbgfR3UnwindCtxDoOneFrame(pUnwindCtx))
|
---|
[73397] | 763 | {
|
---|
[73471] | 764 | if (pUnwindCtx->m_fIsHostRing0)
|
---|
| 765 | DBGFR3AddrFromHostR0(&pFrame->AddrReturnFrame, pUnwindCtx->m_State.u.x86.FrameAddr.off);
|
---|
| 766 | else
|
---|
| 767 | {
|
---|
| 768 | DBGFADDRESS AddrReturnFrame = pFrame->AddrReturnFrame;
|
---|
| 769 | rc = DBGFR3AddrFromSelOff(pUnwindCtx->m_pUVM, pUnwindCtx->m_idCpu, &AddrReturnFrame,
|
---|
| 770 | pUnwindCtx->m_State.u.x86.FrameAddr.sel, pUnwindCtx->m_State.u.x86.FrameAddr.off);
|
---|
| 771 | if (RT_SUCCESS(rc))
|
---|
| 772 | pFrame->AddrReturnFrame = AddrReturnFrame;
|
---|
| 773 | }
|
---|
[73444] | 774 | pFrame->enmReturnFrameReturnType = pUnwindCtx->m_State.enmRetType;
|
---|
[73397] | 775 | pFrame->fFlags |= DBGFSTACKFRAME_FLAGS_UNWIND_INFO_RET;
|
---|
| 776 | }
|
---|
| 777 | }
|
---|
| 778 |
|
---|
[1] | 779 | return VINF_SUCCESS;
|
---|
| 780 | }
|
---|
| 781 |
|
---|
| 782 |
|
---|
| 783 | /**
|
---|
| 784 | * Walks the entire stack allocating memory as we walk.
|
---|
| 785 | */
|
---|
[73377] | 786 | static DECLCALLBACK(int) dbgfR3StackWalkCtxFull(PUVM pUVM, VMCPUID idCpu, PCCPUMCTX pCtx, RTDBGAS hAs,
|
---|
[19572] | 787 | DBGFCODETYPE enmCodeType,
|
---|
[19291] | 788 | PCDBGFADDRESS pAddrFrame,
|
---|
| 789 | PCDBGFADDRESS pAddrStack,
|
---|
| 790 | PCDBGFADDRESS pAddrPC,
|
---|
[73460] | 791 | RTDBGRETURNTYPE enmReturnType,
|
---|
[19291] | 792 | PCDBGFSTACKFRAME *ppFirstFrame)
|
---|
[1] | 793 | {
|
---|
[73377] | 794 | DBGFUNWINDCTX UnwindCtx(pUVM, idCpu, pCtx, hAs);
|
---|
| 795 |
|
---|
[1] | 796 | /* alloc first frame. */
|
---|
[44399] | 797 | PDBGFSTACKFRAME pCur = (PDBGFSTACKFRAME)MMR3HeapAllocZU(pUVM, MM_TAG_DBGF_STACK, sizeof(*pCur));
|
---|
[1] | 798 | if (!pCur)
|
---|
| 799 | return VERR_NO_MEMORY;
|
---|
| 800 |
|
---|
[19291] | 801 | /*
|
---|
| 802 | * Initialize the frame.
|
---|
| 803 | */
|
---|
| 804 | pCur->pNextInternal = NULL;
|
---|
| 805 | pCur->pFirstInternal = pCur;
|
---|
[1] | 806 |
|
---|
| 807 | int rc = VINF_SUCCESS;
|
---|
[19291] | 808 | if (pAddrPC)
|
---|
| 809 | pCur->AddrPC = *pAddrPC;
|
---|
[42449] | 810 | else if (enmCodeType != DBGFCODETYPE_GUEST)
|
---|
[73377] | 811 | DBGFR3AddrFromFlat(pUVM, &pCur->AddrPC, pCtx->rip);
|
---|
[19291] | 812 | else
|
---|
[73377] | 813 | rc = DBGFR3AddrFromSelOff(pUVM, idCpu, &pCur->AddrPC, pCtx->cs.Sel, pCtx->rip);
|
---|
[19291] | 814 | if (RT_SUCCESS(rc))
|
---|
[1] | 815 | {
|
---|
[22106] | 816 | uint64_t fAddrMask;
|
---|
[19572] | 817 | if (enmCodeType == DBGFCODETYPE_RING0)
|
---|
[22106] | 818 | fAddrMask = HC_ARCH_BITS == 64 ? UINT64_MAX : UINT32_MAX;
|
---|
| 819 | else if (enmCodeType == DBGFCODETYPE_HYPER)
|
---|
[19291] | 820 | fAddrMask = UINT32_MAX;
|
---|
| 821 | else if (DBGFADDRESS_IS_FAR16(&pCur->AddrPC))
|
---|
| 822 | fAddrMask = UINT16_MAX;
|
---|
| 823 | else if (DBGFADDRESS_IS_FAR32(&pCur->AddrPC))
|
---|
| 824 | fAddrMask = UINT32_MAX;
|
---|
[22106] | 825 | else if (DBGFADDRESS_IS_FAR64(&pCur->AddrPC))
|
---|
| 826 | fAddrMask = UINT64_MAX;
|
---|
| 827 | else
|
---|
[1] | 828 | {
|
---|
[44399] | 829 | PVMCPU pVCpu = VMMGetCpuById(pUVM->pVM, idCpu);
|
---|
[73377] | 830 | CPUMMODE enmCpuMode = CPUMGetGuestMode(pVCpu);
|
---|
| 831 | if (enmCpuMode == CPUMMODE_REAL)
|
---|
| 832 | {
|
---|
[19291] | 833 | fAddrMask = UINT16_MAX;
|
---|
[73460] | 834 | if (enmReturnType == RTDBGRETURNTYPE_INVALID)
|
---|
| 835 | pCur->enmReturnType = RTDBGRETURNTYPE_NEAR16;
|
---|
[73377] | 836 | }
|
---|
| 837 | else if ( enmCpuMode == CPUMMODE_PROTECTED
|
---|
[42165] | 838 | || !CPUMIsGuestIn64BitCode(pVCpu))
|
---|
[73377] | 839 | {
|
---|
[19291] | 840 | fAddrMask = UINT32_MAX;
|
---|
[73460] | 841 | if (enmReturnType == RTDBGRETURNTYPE_INVALID)
|
---|
| 842 | pCur->enmReturnType = RTDBGRETURNTYPE_NEAR32;
|
---|
[73377] | 843 | }
|
---|
[22106] | 844 | else
|
---|
[73377] | 845 | {
|
---|
[22106] | 846 | fAddrMask = UINT64_MAX;
|
---|
[73460] | 847 | if (enmReturnType == RTDBGRETURNTYPE_INVALID)
|
---|
| 848 | pCur->enmReturnType = RTDBGRETURNTYPE_NEAR64;
|
---|
[73377] | 849 | }
|
---|
[1] | 850 | }
|
---|
[19291] | 851 |
|
---|
[73460] | 852 | if (enmReturnType == RTDBGRETURNTYPE_INVALID)
|
---|
[73377] | 853 | switch (pCur->AddrPC.fFlags & DBGFADDRESS_FLAGS_TYPE_MASK)
|
---|
| 854 | {
|
---|
[73460] | 855 | case DBGFADDRESS_FLAGS_FAR16: pCur->enmReturnType = RTDBGRETURNTYPE_NEAR16; break;
|
---|
| 856 | case DBGFADDRESS_FLAGS_FAR32: pCur->enmReturnType = RTDBGRETURNTYPE_NEAR32; break;
|
---|
| 857 | case DBGFADDRESS_FLAGS_FAR64: pCur->enmReturnType = RTDBGRETURNTYPE_NEAR64; break;
|
---|
[73377] | 858 | case DBGFADDRESS_FLAGS_RING0:
|
---|
[73460] | 859 | pCur->enmReturnType = HC_ARCH_BITS == 64 ? RTDBGRETURNTYPE_NEAR64 : RTDBGRETURNTYPE_NEAR32;
|
---|
[73377] | 860 | break;
|
---|
| 861 | default:
|
---|
[73460] | 862 | pCur->enmReturnType = RTDBGRETURNTYPE_NEAR32;
|
---|
[73377] | 863 | break;
|
---|
| 864 | }
|
---|
| 865 |
|
---|
| 866 |
|
---|
[19291] | 867 | if (pAddrStack)
|
---|
| 868 | pCur->AddrStack = *pAddrStack;
|
---|
[42449] | 869 | else if (enmCodeType != DBGFCODETYPE_GUEST)
|
---|
[73377] | 870 | DBGFR3AddrFromFlat(pUVM, &pCur->AddrStack, pCtx->rsp & fAddrMask);
|
---|
[19291] | 871 | else
|
---|
[73377] | 872 | rc = DBGFR3AddrFromSelOff(pUVM, idCpu, &pCur->AddrStack, pCtx->ss.Sel, pCtx->rsp & fAddrMask);
|
---|
[19291] | 873 |
|
---|
[73397] | 874 | Assert(!(pCur->fFlags & DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO));
|
---|
[19291] | 875 | if (pAddrFrame)
|
---|
| 876 | pCur->AddrFrame = *pAddrFrame;
|
---|
[73397] | 877 | else if (enmCodeType != DBGFCODETYPE_GUEST)
|
---|
| 878 | DBGFR3AddrFromFlat(pUVM, &pCur->AddrFrame, pCtx->rbp & fAddrMask);
|
---|
| 879 | else if (RT_SUCCESS(rc))
|
---|
| 880 | rc = DBGFR3AddrFromSelOff(pUVM, idCpu, &pCur->AddrFrame, pCtx->ss.Sel, pCtx->rbp & fAddrMask);
|
---|
| 881 |
|
---|
| 882 | /*
|
---|
[73471] | 883 | * Try unwind and get a better frame pointer and state.
|
---|
| 884 | */
|
---|
| 885 | if ( RT_SUCCESS(rc)
|
---|
| 886 | && dbgfR3UnwindCtxSetPcAndSp(&UnwindCtx, &pCur->AddrPC, &pCur->AddrStack)
|
---|
| 887 | && dbgfR3UnwindCtxDoOneFrame(&UnwindCtx))
|
---|
| 888 | {
|
---|
| 889 | pCur->enmReturnType = UnwindCtx.m_State.enmRetType;
|
---|
| 890 | pCur->fFlags |= DBGFSTACKFRAME_FLAGS_USED_UNWIND_INFO;
|
---|
| 891 | if (!UnwindCtx.m_fIsHostRing0)
|
---|
| 892 | rc = DBGFR3AddrFromSelOff(UnwindCtx.m_pUVM, UnwindCtx.m_idCpu, &pCur->AddrFrame,
|
---|
| 893 | UnwindCtx.m_State.u.x86.FrameAddr.sel, UnwindCtx.m_State.u.x86.FrameAddr.off);
|
---|
| 894 | else
|
---|
| 895 | DBGFR3AddrFromHostR0(&pCur->AddrFrame, UnwindCtx.m_State.u.x86.FrameAddr.off);
|
---|
| 896 | }
|
---|
| 897 | /*
|
---|
[73397] | 898 | * The first frame.
|
---|
| 899 | */
|
---|
| 900 | if (RT_SUCCESS(rc))
|
---|
| 901 | {
|
---|
| 902 | if (DBGFADDRESS_IS_VALID(&pCur->AddrPC))
|
---|
| 903 | {
|
---|
| 904 | pCur->pSymPC = DBGFR3AsSymbolByAddrA(pUVM, hAs, &pCur->AddrPC,
|
---|
| 905 | RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL | RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
|
---|
| 906 | NULL /*poffDisp*/, NULL /*phMod*/);
|
---|
| 907 | pCur->pLinePC = DBGFR3AsLineByAddrA(pUVM, hAs, &pCur->AddrPC, NULL /*poffDisp*/, NULL /*phMod*/);
|
---|
| 908 | }
|
---|
| 909 |
|
---|
| 910 | rc = dbgfR3StackWalk(&UnwindCtx, pCur, true /*fFirst*/);
|
---|
| 911 | }
|
---|
[1] | 912 | }
|
---|
[19291] | 913 | else
|
---|
| 914 | pCur->enmReturnType = enmReturnType;
|
---|
[13816] | 915 | if (RT_FAILURE(rc))
|
---|
[1] | 916 | {
|
---|
[19291] | 917 | DBGFR3StackWalkEnd(pCur);
|
---|
[1] | 918 | return rc;
|
---|
| 919 | }
|
---|
| 920 |
|
---|
| 921 | /*
|
---|
| 922 | * The other frames.
|
---|
| 923 | */
|
---|
| 924 | DBGFSTACKFRAME Next = *pCur;
|
---|
| 925 | while (!(pCur->fFlags & (DBGFSTACKFRAME_FLAGS_LAST | DBGFSTACKFRAME_FLAGS_MAX_DEPTH | DBGFSTACKFRAME_FLAGS_LOOP)))
|
---|
| 926 | {
|
---|
[73444] | 927 | Next.cSureRegs = 0;
|
---|
| 928 | Next.paSureRegs = NULL;
|
---|
| 929 |
|
---|
[1] | 930 | /* try walk. */
|
---|
[73397] | 931 | rc = dbgfR3StackWalk(&UnwindCtx, &Next, false /*fFirst*/);
|
---|
[13816] | 932 | if (RT_FAILURE(rc))
|
---|
[1] | 933 | break;
|
---|
| 934 |
|
---|
| 935 | /* add the next frame to the chain. */
|
---|
[44399] | 936 | PDBGFSTACKFRAME pNext = (PDBGFSTACKFRAME)MMR3HeapAllocU(pUVM, MM_TAG_DBGF_STACK, sizeof(*pNext));
|
---|
[1] | 937 | if (!pNext)
|
---|
| 938 | {
|
---|
[19291] | 939 | DBGFR3StackWalkEnd(pCur);
|
---|
[1] | 940 | return VERR_NO_MEMORY;
|
---|
| 941 | }
|
---|
| 942 | *pNext = Next;
|
---|
[19291] | 943 | pCur->pNextInternal = pNext;
|
---|
| 944 | pCur = pNext;
|
---|
| 945 | Assert(pCur->pNextInternal == NULL);
|
---|
[1] | 946 |
|
---|
| 947 | /* check for loop */
|
---|
[19291] | 948 | for (PCDBGFSTACKFRAME pLoop = pCur->pFirstInternal;
|
---|
| 949 | pLoop && pLoop != pCur;
|
---|
| 950 | pLoop = pLoop->pNextInternal)
|
---|
[1] | 951 | if (pLoop->AddrFrame.FlatPtr == pCur->AddrFrame.FlatPtr)
|
---|
| 952 | {
|
---|
| 953 | pCur->fFlags |= DBGFSTACKFRAME_FLAGS_LOOP;
|
---|
| 954 | break;
|
---|
| 955 | }
|
---|
| 956 |
|
---|
| 957 | /* check for insane recursion */
|
---|
| 958 | if (pCur->iFrame >= 2048)
|
---|
| 959 | pCur->fFlags |= DBGFSTACKFRAME_FLAGS_MAX_DEPTH;
|
---|
| 960 | }
|
---|
| 961 |
|
---|
[19291] | 962 | *ppFirstFrame = pCur->pFirstInternal;
|
---|
[1] | 963 | return rc;
|
---|
| 964 | }
|
---|
| 965 |
|
---|
| 966 |
|
---|
| 967 | /**
|
---|
[19291] | 968 | * Common worker for DBGFR3StackWalkBeginGuestEx, DBGFR3StackWalkBeginHyperEx,
|
---|
| 969 | * DBGFR3StackWalkBeginGuest and DBGFR3StackWalkBeginHyper.
|
---|
[1] | 970 | */
|
---|
[44399] | 971 | static int dbgfR3StackWalkBeginCommon(PUVM pUVM,
|
---|
[19291] | 972 | VMCPUID idCpu,
|
---|
[19572] | 973 | DBGFCODETYPE enmCodeType,
|
---|
[19291] | 974 | PCDBGFADDRESS pAddrFrame,
|
---|
| 975 | PCDBGFADDRESS pAddrStack,
|
---|
| 976 | PCDBGFADDRESS pAddrPC,
|
---|
[73460] | 977 | RTDBGRETURNTYPE enmReturnType,
|
---|
[19291] | 978 | PCDBGFSTACKFRAME *ppFirstFrame)
|
---|
[1] | 979 | {
|
---|
[19291] | 980 | /*
|
---|
| 981 | * Validate parameters.
|
---|
| 982 | */
|
---|
| 983 | *ppFirstFrame = NULL;
|
---|
[44399] | 984 | UVM_ASSERT_VALID_EXT_RETURN(pUVM, VERR_INVALID_VM_HANDLE);
|
---|
| 985 | PVM pVM = pUVM->pVM;
|
---|
[19291] | 986 | VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
|
---|
[22890] | 987 | AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
|
---|
[19291] | 988 | if (pAddrFrame)
|
---|
[44399] | 989 | AssertReturn(DBGFR3AddrIsValid(pUVM, pAddrFrame), VERR_INVALID_PARAMETER);
|
---|
[19291] | 990 | if (pAddrStack)
|
---|
[44399] | 991 | AssertReturn(DBGFR3AddrIsValid(pUVM, pAddrStack), VERR_INVALID_PARAMETER);
|
---|
[19291] | 992 | if (pAddrPC)
|
---|
[44399] | 993 | AssertReturn(DBGFR3AddrIsValid(pUVM, pAddrPC), VERR_INVALID_PARAMETER);
|
---|
[73460] | 994 | AssertReturn(enmReturnType >= RTDBGRETURNTYPE_INVALID && enmReturnType < RTDBGRETURNTYPE_END, VERR_INVALID_PARAMETER);
|
---|
[1] | 995 |
|
---|
[19291] | 996 | /*
|
---|
| 997 | * Get the CPUM context pointer and pass it on the specified EMT.
|
---|
| 998 | */
|
---|
[73377] | 999 | RTDBGAS hAs;
|
---|
| 1000 | PCCPUMCTX pCtx;
|
---|
[19575] | 1001 | switch (enmCodeType)
|
---|
| 1002 | {
|
---|
[19710] | 1003 | case DBGFCODETYPE_GUEST:
|
---|
[73377] | 1004 | pCtx = CPUMQueryGuestCtxPtr(VMMGetCpuById(pVM, idCpu));
|
---|
| 1005 | hAs = DBGF_AS_GLOBAL;
|
---|
[19710] | 1006 | break;
|
---|
| 1007 | case DBGFCODETYPE_HYPER:
|
---|
[73377] | 1008 | pCtx = CPUMQueryGuestCtxPtr(VMMGetCpuById(pVM, idCpu));
|
---|
| 1009 | hAs = DBGF_AS_RC_AND_GC_GLOBAL;
|
---|
[19710] | 1010 | break;
|
---|
| 1011 | case DBGFCODETYPE_RING0:
|
---|
[73377] | 1012 | pCtx = NULL; /* No valid context present. */
|
---|
| 1013 | hAs = DBGF_AS_R0;
|
---|
[19710] | 1014 | break;
|
---|
| 1015 | default:
|
---|
| 1016 | AssertFailedReturn(VERR_INVALID_PARAMETER);
|
---|
[19575] | 1017 | }
|
---|
[44399] | 1018 | return VMR3ReqPriorityCallWaitU(pUVM, idCpu, (PFNRT)dbgfR3StackWalkCtxFull, 10,
|
---|
[73377] | 1019 | pUVM, idCpu, pCtx, hAs, enmCodeType,
|
---|
[44399] | 1020 | pAddrFrame, pAddrStack, pAddrPC, enmReturnType, ppFirstFrame);
|
---|
[1] | 1021 | }
|
---|
| 1022 |
|
---|
| 1023 |
|
---|
| 1024 | /**
|
---|
[19291] | 1025 | * Begins a guest stack walk, extended version.
|
---|
[1] | 1026 | *
|
---|
[19291] | 1027 | * This will walk the current stack, constructing a list of info frames which is
|
---|
| 1028 | * returned to the caller. The caller uses DBGFR3StackWalkNext to traverse the
|
---|
| 1029 | * list and DBGFR3StackWalkEnd to release it.
|
---|
| 1030 | *
|
---|
[1] | 1031 | * @returns VINF_SUCCESS on success.
|
---|
| 1032 | * @returns VERR_NO_MEMORY if we're out of memory.
|
---|
[19291] | 1033 | *
|
---|
[44399] | 1034 | * @param pUVM The user mode VM handle.
|
---|
[19291] | 1035 | * @param idCpu The ID of the virtual CPU which stack we want to walk.
|
---|
[19572] | 1036 | * @param enmCodeType Code type
|
---|
[19291] | 1037 | * @param pAddrFrame Frame address to start at. (Optional)
|
---|
| 1038 | * @param pAddrStack Stack address to start at. (Optional)
|
---|
| 1039 | * @param pAddrPC Program counter to start at. (Optional)
|
---|
| 1040 | * @param enmReturnType The return address type. (Optional)
|
---|
| 1041 | * @param ppFirstFrame Where to return the pointer to the first info frame.
|
---|
[1] | 1042 | */
|
---|
[44399] | 1043 | VMMR3DECL(int) DBGFR3StackWalkBeginEx(PUVM pUVM,
|
---|
[19575] | 1044 | VMCPUID idCpu,
|
---|
| 1045 | DBGFCODETYPE enmCodeType,
|
---|
| 1046 | PCDBGFADDRESS pAddrFrame,
|
---|
| 1047 | PCDBGFADDRESS pAddrStack,
|
---|
| 1048 | PCDBGFADDRESS pAddrPC,
|
---|
[73460] | 1049 | RTDBGRETURNTYPE enmReturnType,
|
---|
[19575] | 1050 | PCDBGFSTACKFRAME *ppFirstFrame)
|
---|
[1] | 1051 | {
|
---|
[44399] | 1052 | return dbgfR3StackWalkBeginCommon(pUVM, idCpu, enmCodeType, pAddrFrame, pAddrStack, pAddrPC, enmReturnType, ppFirstFrame);
|
---|
[19291] | 1053 | }
|
---|
[18927] | 1054 |
|
---|
[1] | 1055 |
|
---|
[19291] | 1056 | /**
|
---|
| 1057 | * Begins a guest stack walk.
|
---|
| 1058 | *
|
---|
| 1059 | * This will walk the current stack, constructing a list of info frames which is
|
---|
| 1060 | * returned to the caller. The caller uses DBGFR3StackWalkNext to traverse the
|
---|
| 1061 | * list and DBGFR3StackWalkEnd to release it.
|
---|
| 1062 | *
|
---|
| 1063 | * @returns VINF_SUCCESS on success.
|
---|
| 1064 | * @returns VERR_NO_MEMORY if we're out of memory.
|
---|
| 1065 | *
|
---|
[44399] | 1066 | * @param pUVM The user mode VM handle.
|
---|
[19291] | 1067 | * @param idCpu The ID of the virtual CPU which stack we want to walk.
|
---|
[19572] | 1068 | * @param enmCodeType Code type
|
---|
[19291] | 1069 | * @param ppFirstFrame Where to return the pointer to the first info frame.
|
---|
| 1070 | */
|
---|
[44399] | 1071 | VMMR3DECL(int) DBGFR3StackWalkBegin(PUVM pUVM, VMCPUID idCpu, DBGFCODETYPE enmCodeType, PCDBGFSTACKFRAME *ppFirstFrame)
|
---|
[19291] | 1072 | {
|
---|
[73460] | 1073 | return dbgfR3StackWalkBeginCommon(pUVM, idCpu, enmCodeType, NULL, NULL, NULL, RTDBGRETURNTYPE_INVALID, ppFirstFrame);
|
---|
[19291] | 1074 | }
|
---|
[1] | 1075 |
|
---|
[19291] | 1076 | /**
|
---|
[1] | 1077 | * Gets the next stack frame.
|
---|
| 1078 | *
|
---|
[19291] | 1079 | * @returns Pointer to the info for the next stack frame.
|
---|
| 1080 | * NULL if no more frames.
|
---|
| 1081 | *
|
---|
| 1082 | * @param pCurrent Pointer to the current stack frame.
|
---|
| 1083 | *
|
---|
[1] | 1084 | */
|
---|
[19291] | 1085 | VMMR3DECL(PCDBGFSTACKFRAME) DBGFR3StackWalkNext(PCDBGFSTACKFRAME pCurrent)
|
---|
[1] | 1086 | {
|
---|
[19291] | 1087 | return pCurrent
|
---|
| 1088 | ? pCurrent->pNextInternal
|
---|
| 1089 | : NULL;
|
---|
[1] | 1090 | }
|
---|
| 1091 |
|
---|
| 1092 |
|
---|
| 1093 | /**
|
---|
| 1094 | * Ends a stack walk process.
|
---|
| 1095 | *
|
---|
| 1096 | * This *must* be called after a successful first call to any of the stack
|
---|
| 1097 | * walker functions. If not called we will leak memory or other resources.
|
---|
| 1098 | *
|
---|
[41783] | 1099 | * @param pFirstFrame The frame returned by one of the begin functions.
|
---|
[1] | 1100 | */
|
---|
[19291] | 1101 | VMMR3DECL(void) DBGFR3StackWalkEnd(PCDBGFSTACKFRAME pFirstFrame)
|
---|
[1] | 1102 | {
|
---|
[19291] | 1103 | if ( !pFirstFrame
|
---|
| 1104 | || !pFirstFrame->pFirstInternal)
|
---|
[1] | 1105 | return;
|
---|
| 1106 |
|
---|
[19291] | 1107 | PDBGFSTACKFRAME pFrame = (PDBGFSTACKFRAME)pFirstFrame->pFirstInternal;
|
---|
[1] | 1108 | while (pFrame)
|
---|
| 1109 | {
|
---|
| 1110 | PDBGFSTACKFRAME pCur = pFrame;
|
---|
[19291] | 1111 | pFrame = (PDBGFSTACKFRAME)pCur->pNextInternal;
|
---|
[1] | 1112 | if (pFrame)
|
---|
| 1113 | {
|
---|
| 1114 | if (pCur->pSymReturnPC == pFrame->pSymPC)
|
---|
| 1115 | pFrame->pSymPC = NULL;
|
---|
| 1116 | if (pCur->pSymReturnPC == pFrame->pSymReturnPC)
|
---|
| 1117 | pFrame->pSymReturnPC = NULL;
|
---|
| 1118 |
|
---|
| 1119 | if (pCur->pSymPC == pFrame->pSymPC)
|
---|
| 1120 | pFrame->pSymPC = NULL;
|
---|
| 1121 | if (pCur->pSymPC == pFrame->pSymReturnPC)
|
---|
| 1122 | pFrame->pSymReturnPC = NULL;
|
---|
| 1123 |
|
---|
| 1124 | if (pCur->pLineReturnPC == pFrame->pLinePC)
|
---|
| 1125 | pFrame->pLinePC = NULL;
|
---|
| 1126 | if (pCur->pLineReturnPC == pFrame->pLineReturnPC)
|
---|
| 1127 | pFrame->pLineReturnPC = NULL;
|
---|
| 1128 |
|
---|
| 1129 | if (pCur->pLinePC == pFrame->pLinePC)
|
---|
| 1130 | pFrame->pLinePC = NULL;
|
---|
| 1131 | if (pCur->pLinePC == pFrame->pLineReturnPC)
|
---|
| 1132 | pFrame->pLineReturnPC = NULL;
|
---|
| 1133 | }
|
---|
| 1134 |
|
---|
[22112] | 1135 | RTDbgSymbolFree(pCur->pSymPC);
|
---|
| 1136 | RTDbgSymbolFree(pCur->pSymReturnPC);
|
---|
[46165] | 1137 | RTDbgLineFree(pCur->pLinePC);
|
---|
| 1138 | RTDbgLineFree(pCur->pLineReturnPC);
|
---|
[1] | 1139 |
|
---|
[73444] | 1140 | if (pCur->paSureRegs)
|
---|
| 1141 | {
|
---|
| 1142 | MMR3HeapFree(pCur->paSureRegs);
|
---|
| 1143 | pCur->paSureRegs = NULL;
|
---|
| 1144 | pCur->cSureRegs = 0;
|
---|
| 1145 | }
|
---|
| 1146 |
|
---|
[19291] | 1147 | pCur->pNextInternal = NULL;
|
---|
| 1148 | pCur->pFirstInternal = NULL;
|
---|
[1] | 1149 | pCur->fFlags = 0;
|
---|
| 1150 | MMR3HeapFree(pCur);
|
---|
| 1151 | }
|
---|
| 1152 | }
|
---|
| 1153 |
|
---|