DBGFStack.cpp@ 106061

Last change on this file since 106061 was 106061, checked in by vboxsync, 2 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 45.9 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/VMM/VMMR3/DBGFStack.cpp@ 106061

Download in other formats: