VMMGuruMeditation.cpp@ 103583

Last change on this file since 103583 was 99051, checked in by vboxsync, 21 months ago
VMM: More ARMv8 x86/amd64 separation work, VBoxVMMArm compiles and links now, bugref:10385
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 27.3 KB

Line
1	/* $Id: VMMGuruMeditation.cpp 99051 2023-03-19 16:40:06Z vboxsync $ */
2	/** @file
3	* VMM - The Virtual Machine Monitor, Guru Meditation Code.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 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_VMM
33	#include <VBox/vmm/vmm.h>
34	#include <VBox/vmm/pdmapi.h>
35	#include <VBox/vmm/pdmcritsect.h>
36	#include <VBox/vmm/trpm.h>
37	#include <VBox/vmm/dbgf.h>
38	#include "VMMInternal.h"
39	#include <VBox/vmm/vm.h>
40	#include <VBox/vmm/mm.h>
41	#include <VBox/vmm/iom.h>
42	#include <VBox/vmm/em.h>
43
44	#include <VBox/err.h>
45	#include <VBox/param.h>
46	#include <VBox/version.h>
47	#include <VBox/vmm/hm.h>
48	#include <iprt/assert.h>
49	#include <iprt/dbg.h>
50	#include <iprt/time.h>
51	#include <iprt/stream.h>
52	#include <iprt/string.h>
53	#include <iprt/stdarg.h>
54
55
56	/*********************************************************************************************************************************
57	* Structures and Typedefs *
58	*********************************************************************************************************************************/
59	/**
60	* Structure to pass to DBGFR3Info() and for doing all other
61	* output during fatal dump.
62	*/
63	typedef struct VMMR3FATALDUMPINFOHLP
64	{
65	/** The helper core. */
66	DBGFINFOHLP Core;
67	/** The release logger instance. */
68	PRTLOGGER pRelLogger;
69	/** The saved release logger flags. */
70	uint32_t fRelLoggerFlags;
71	/** The logger instance. */
72	PRTLOGGER pLogger;
73	/** The saved logger flags. */
74	uint32_t fLoggerFlags;
75	/** The saved logger destination flags. */
76	uint32_t fLoggerDestFlags;
77	/** Whether to output to stderr or not. */
78	bool fStdErr;
79	/** Whether we're still recording the summary or not. */
80	bool fRecSummary;
81	/** Buffer for the summary. */
82	char szSummary[4096 - 2];
83	/** The current summary offset. */
84	size_t offSummary;
85	/** Standard error buffer. */
86	char achStdErrBuf[4096 - 8];
87	/** Standard error buffer offset. */
88	size_t offStdErrBuf;
89	} VMMR3FATALDUMPINFOHLP, *PVMMR3FATALDUMPINFOHLP;
90	/** Pointer to a VMMR3FATALDUMPINFOHLP structure. */
91	typedef const VMMR3FATALDUMPINFOHLP *PCVMMR3FATALDUMPINFOHLP;
92
93
94	/**
95	* Flushes the content of achStdErrBuf, setting offStdErrBuf to zero.
96	*
97	* @param pHlp The instance to flush.
98	*/
99	static void vmmR3FatalDumpInfoHlpFlushStdErr(PVMMR3FATALDUMPINFOHLP pHlp)
100	{
101	size_t cch = pHlp->offStdErrBuf;
102	if (cch)
103	{
104	RTStrmWrite(g_pStdErr, pHlp->achStdErrBuf, cch);
105	pHlp->offStdErrBuf = 0;
106	}
107	}
108
109	/**
110	* @callback_method_impl{FNRTSTROUTPUT, For buffering stderr output.}
111	*/
112	static DECLCALLBACK(size_t) vmmR3FatalDumpInfoHlp_BufferedStdErrOutput(void pvArg, const char pachChars, size_t cbChars)
113	{
114	PVMMR3FATALDUMPINFOHLP pHlp = (PVMMR3FATALDUMPINFOHLP)pvArg;
115	if (cbChars)
116	{
117	size_t offBuf = pHlp->offStdErrBuf;
118	if (cbChars < sizeof(pHlp->achStdErrBuf) - offBuf)
119	{ /* likely */ }
120	else
121	{
122	vmmR3FatalDumpInfoHlpFlushStdErr(pHlp);
123	if (cbChars < sizeof(pHlp->achStdErrBuf))
124	offBuf = 0;
125	else
126	{
127	RTStrmWrite(g_pStdErr, pachChars, cbChars);
128	return cbChars;
129	}
130	}
131	memcpy(&pHlp->achStdErrBuf[offBuf], pachChars, cbChars);
132	pHlp->offStdErrBuf = offBuf + cbChars;
133	}
134	return cbChars;
135	}
136
137
138	/**
139	* Print formatted string.
140	*
141	* @param pHlp Pointer to this structure.
142	* @param pszFormat The format string.
143	* @param ... Arguments.
144	*/
145	static DECLCALLBACK(void) vmmR3FatalDumpInfoHlp_pfnPrintf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
146	{
147	va_list args;
148	va_start(args, pszFormat);
149	pHlp->pfnPrintfV(pHlp, pszFormat, args);
150	va_end(args);
151	}
152
153	/**
154	* Print formatted string.
155	*
156	* @param pHlp Pointer to this structure.
157	* @param pszFormat The format string.
158	* @param args Argument list.
159	*/
160	static DECLCALLBACK(void) vmmR3FatalDumpInfoHlp_pfnPrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
161	{
162	PVMMR3FATALDUMPINFOHLP pMyHlp = (PVMMR3FATALDUMPINFOHLP)pHlp;
163
164	if (pMyHlp->pRelLogger)
165	{
166	va_list args2;
167	va_copy(args2, args);
168	RTLogLoggerV(pMyHlp->pRelLogger, pszFormat, args2);
169	va_end(args2);
170	}
171	if (pMyHlp->pLogger)
172	{
173	va_list args2;
174	va_copy(args2, args);
175	RTLogLoggerV(pMyHlp->pLogger, pszFormat, args);
176	va_end(args2);
177	}
178	if (pMyHlp->fStdErr)
179	{
180	va_list args2;
181	va_copy(args2, args);
182	RTStrFormatV(vmmR3FatalDumpInfoHlp_BufferedStdErrOutput, pMyHlp, NULL, NULL, pszFormat, args2);
183	//RTStrmPrintfV(g_pStdErr, pszFormat, args2);
184	va_end(args2);
185	}
186	if (pMyHlp->fRecSummary)
187	{
188	size_t cchLeft = sizeof(pMyHlp->szSummary) - pMyHlp->offSummary;
189	if (cchLeft > 1)
190	{
191	va_list args2;
192	va_copy(args2, args);
193	size_t cch = RTStrPrintfV(&pMyHlp->szSummary[pMyHlp->offSummary], cchLeft, pszFormat, args);
194	va_end(args2);
195	Assert(cch <= cchLeft);
196	pMyHlp->offSummary += cch;
197	}
198	}
199	}
200
201
202	/**
203	* Initializes the fatal dump output helper.
204	*
205	* @param pHlp The structure to initialize.
206	*/
207	static void vmmR3FatalDumpInfoHlpInit(PVMMR3FATALDUMPINFOHLP pHlp)
208	{
209	RT_BZERO(pHlp, sizeof(*pHlp));
210
211	pHlp->Core.pfnPrintf = vmmR3FatalDumpInfoHlp_pfnPrintf;
212	pHlp->Core.pfnPrintfV = vmmR3FatalDumpInfoHlp_pfnPrintfV;
213	pHlp->Core.pfnGetOptError = DBGFR3InfoGenericGetOptError;
214
215	/*
216	* The loggers.
217	*/
218	pHlp->pRelLogger = RTLogRelGetDefaultInstance();
219	#ifdef LOG_ENABLED
220	pHlp->pLogger = RTLogDefaultInstance();
221	#else
222	if (pHlp->pRelLogger)
223	pHlp->pLogger = RTLogGetDefaultInstance();
224	else
225	pHlp->pLogger = RTLogDefaultInstance();
226	#endif
227
228	if (pHlp->pRelLogger)
229	{
230	pHlp->fRelLoggerFlags = RTLogGetFlags(pHlp->pRelLogger);
231	RTLogChangeFlags(pHlp->pRelLogger, RTLOGFLAGS_BUFFERED, RTLOGFLAGS_DISABLED);
232	}
233
234	if (pHlp->pLogger)
235	{
236	pHlp->fLoggerFlags = RTLogGetFlags(pHlp->pLogger);
237	pHlp->fLoggerDestFlags = RTLogGetDestinations(pHlp->pLogger);
238	RTLogChangeFlags(pHlp->pLogger, RTLOGFLAGS_BUFFERED, RTLOGFLAGS_DISABLED);
239	#ifndef DEBUG_sandervl
240	RTLogChangeDestinations(pHlp->pLogger, RTLOGDEST_DEBUGGER, 0);
241	#endif
242	}
243
244	/*
245	* Check if we need write to stderr.
246	*/
247	pHlp->fStdErr = (!pHlp->pRelLogger \|\| !(RTLogGetDestinations(pHlp->pRelLogger) & (RTLOGDEST_STDOUT \| RTLOGDEST_STDERR)))
248	&& (!pHlp->pLogger \|\| !(RTLogGetDestinations(pHlp->pLogger) & (RTLOGDEST_STDOUT \| RTLOGDEST_STDERR)));
249	#ifdef DEBUG_sandervl
250	pHlp->fStdErr = false; /* takes too long to display here */
251	#endif
252	pHlp->offStdErrBuf = 0;
253
254	/*
255	* Init the summary recording.
256	*/
257	pHlp->fRecSummary = true;
258	pHlp->offSummary = 0;
259	pHlp->szSummary[0] = '\0';
260	}
261
262
263	/**
264	* Deletes the fatal dump output helper.
265	*
266	* @param pHlp The structure to delete.
267	*/
268	static void vmmR3FatalDumpInfoHlpDelete(PVMMR3FATALDUMPINFOHLP pHlp)
269	{
270	if (pHlp->pRelLogger)
271	{
272	RTLogFlush(pHlp->pRelLogger);
273	RTLogChangeFlags(pHlp->pRelLogger,
274	pHlp->fRelLoggerFlags & RTLOGFLAGS_DISABLED,
275	pHlp->fRelLoggerFlags & RTLOGFLAGS_BUFFERED);
276	}
277
278	if (pHlp->pLogger)
279	{
280	RTLogFlush(pHlp->pLogger);
281	RTLogChangeFlags(pHlp->pLogger,
282	pHlp->fLoggerFlags & RTLOGFLAGS_DISABLED,
283	pHlp->fLoggerFlags & RTLOGFLAGS_BUFFERED);
284	RTLogChangeDestinations(pHlp->pLogger, 0, pHlp->fLoggerDestFlags & RTLOGDEST_DEBUGGER);
285	}
286
287	if (pHlp->fStdErr)
288	vmmR3FatalDumpInfoHlpFlushStdErr(pHlp);
289	}
290
291
292	/**
293	* @callback_method_impl{FNVMMEMTRENDEZVOUS}
294	*/
295	static DECLCALLBACK(VBOXSTRICTRC) vmmR3FatalDumpRendezvousDoneCallback(PVM pVM, PVMCPU pVCpu, void *pvUser)
296	{
297	VM_FF_CLEAR(pVM, VM_FF_CHECK_VM_STATE);
298	RT_NOREF(pVCpu, pvUser);
299	return VINF_SUCCESS;
300	}
301
302
303	/**
304	* Dumps the VM state on a fatal error.
305	*
306	* @param pVM The cross context VM structure.
307	* @param pVCpu The cross context virtual CPU structure.
308	* @param rcErr VBox status code.
309	*/
310	VMMR3DECL(void) VMMR3FatalDump(PVM pVM, PVMCPU pVCpu, int rcErr)
311	{
312	/*
313	* Create our output helper and sync it with the log settings.
314	* This helper will be used for all the output.
315	*/
316	VMMR3FATALDUMPINFOHLP Hlp;
317	PCDBGFINFOHLP pHlp = &Hlp.Core;
318	vmmR3FatalDumpInfoHlpInit(&Hlp);
319
320	/* Release owned locks to make sure other VCPUs can continue in case they were waiting for one. */
321	PDMR3CritSectLeaveAll(pVM);
322
323	/*
324	* Header.
325	*/
326	pHlp->pfnPrintf(pHlp,
327	"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
328	"!!\n"
329	"!! VCPU%u: Guru Meditation %d (%Rrc)\n"
330	"!!\n",
331	pVCpu->idCpu, rcErr, rcErr);
332
333	/*
334	* Continue according to context.
335	*/
336	bool fDoneHyper = false;
337	bool fDoneImport = false;
338	switch (rcErr)
339	{
340	/*
341	* Hypervisor errors.
342	*/
343	case VERR_VMM_RING0_ASSERTION:
344	case VINF_EM_DBG_HYPER_ASSERTION:
345	case VERR_VMM_RING3_CALL_DISABLED:
346	case VERR_VMM_WRONG_HM_VMCPU_STATE:
347	case VERR_VMM_CONTEXT_HOOK_STILL_ENABLED:
348	{
349	const char *pszMsg1 = VMMR3GetRZAssertMsg1(pVM);
350	while (pszMsg1 && *pszMsg1 == '\n')
351	pszMsg1++;
352	const char *pszMsg2 = VMMR3GetRZAssertMsg2(pVM);
353	while (pszMsg2 && *pszMsg2 == '\n')
354	pszMsg2++;
355	pHlp->pfnPrintf(pHlp,
356	"%s"
357	"%s",
358	pszMsg1,
359	pszMsg2);
360	if ( !pszMsg2
361	\|\| !*pszMsg2
362	\|\| strchr(pszMsg2, '\0')[-1] != '\n')
363	pHlp->pfnPrintf(pHlp, "\n");
364	}
365	RT_FALL_THRU();
366	case VERR_TRPM_DONT_PANIC:
367	case VERR_TRPM_PANIC:
368	case VINF_EM_RAW_STALE_SELECTOR:
369	case VINF_EM_RAW_IRET_TRAP:
370	case VINF_EM_DBG_HYPER_BREAKPOINT:
371	case VINF_EM_DBG_HYPER_STEPPED:
372	case VINF_EM_TRIPLE_FAULT:
373	case VERR_VMM_HYPER_CR3_MISMATCH:
374	case VERR_VMM_LONG_JMP_ERROR:
375	{
376	#if defined(VBOX_VMM_TARGET_ARMV8)
377	AssertReleaseFailed();
378	#else
379	/*
380	* Active trap? This is only of partial interest when in hardware
381	* assisted virtualization mode, thus the different messages.
382	*/
383	TRPMEVENT enmType;
384	uint8_t u8TrapNo = 0xce;
385	uint32_t uErrorCode = 0xdeadface;
386	RTGCUINTPTR uCR2 = 0xdeadface;
387	uint8_t cbInstr = UINT8_MAX;
388	bool fIcebp = false;
389	int rc2 = TRPMQueryTrapAll(pVCpu, &u8TrapNo, &enmType, &uErrorCode, &uCR2, &cbInstr, &fIcebp);
390	if (RT_SUCCESS(rc2))
391	pHlp->pfnPrintf(pHlp,
392	"!! ACTIVE TRAP=%02x ERRCD=%RX32 CR2=%RGv PC=%RGr Type=%d cbInstr=%02x fIcebp=%RTbool (Guest!)\n",
393	u8TrapNo, uErrorCode, uCR2, CPUMGetGuestRIP(pVCpu), enmType, cbInstr, fIcebp);
394
395	/*
396	* Dump the relevant hypervisor registers and stack.
397	*/
398	if (rcErr == VERR_VMM_RING0_ASSERTION)
399	{
400	/* Dump the jmpbuf. */
401	pHlp->pfnPrintf(pHlp,
402	"!!\n"
403	"!! AssertJmpBuf:\n"
404	"!!\n");
405	pHlp->pfnPrintf(pHlp,
406	"UnwindSp=%RHv UnwindRetSp=%RHv UnwindBp=%RHv UnwindPc=%RHv\n",
407	pVCpu->vmm.s.AssertJmpBuf.UnwindSp,
408	pVCpu->vmm.s.AssertJmpBuf.UnwindRetSp,
409	pVCpu->vmm.s.AssertJmpBuf.UnwindBp,
410	pVCpu->vmm.s.AssertJmpBuf.UnwindPc);
411	pHlp->pfnPrintf(pHlp,
412	"UnwindRetPcValue=%RHv UnwindRetPcLocation=%RHv\n",
413	pVCpu->vmm.s.AssertJmpBuf.UnwindRetPcValue,
414	pVCpu->vmm.s.AssertJmpBuf.UnwindRetPcLocation);
415	pHlp->pfnPrintf(pHlp,
416	"pfn=%RHv pvUser1=%RHv pvUser2=%RHv\n",
417	pVCpu->vmm.s.AssertJmpBuf.pfn,
418	pVCpu->vmm.s.AssertJmpBuf.pvUser1,
419	pVCpu->vmm.s.AssertJmpBuf.pvUser2);
420
421	/* Dump the resume register frame on the stack. */
422	PRTHCUINTPTR const pBP = (PRTHCUINTPTR)&pVCpu->vmm.s.abAssertStack[ pVCpu->vmm.s.AssertJmpBuf.UnwindBp
423	- pVCpu->vmm.s.AssertJmpBuf.UnwindSp];
424	#if HC_ARCH_BITS == 32
425	pHlp->pfnPrintf(pHlp,
426	"eax=volatile ebx=%08x ecx=volatile edx=volatile esi=%08x edi=%08x\n"
427	"eip=%08x esp=%08x ebp=%08x efl=%08x\n"
428	,
429	pBP[-3], pBP[-2], pBP[-1],
430	pBP[1], pVCpu->vmm.s.AssertJmpBuf.SavedEbp - 8, pBP[0], pBP[-4]);
431	#else
432	# ifdef RT_OS_WINDOWS
433	pHlp->pfnPrintf(pHlp,
434	"rax=volatile rbx=%016RX64 rcx=volatile rdx=volatile\n"
435	"rsi=%016RX64 rdi=%016RX64 r8=volatile r9=volatile \n"
436	"r10=volatile r11=volatile r12=%016RX64 r13=%016RX64\n"
437	"r14=%016RX64 r15=%016RX64\n"
438	"rip=%016RX64 rsp=%016RX64 rbp=%016RX64 rfl=%08RX64\n"
439	,
440	pBP[-7],
441	pBP[-6], pBP[-5],
442	pBP[-4], pBP[-3],
443	pBP[-2], pBP[-1],
444	pBP[1], pVCpu->vmm.s.AssertJmpBuf.UnwindRetSp, pBP[0], pBP[-8]);
445	# else
446	pHlp->pfnPrintf(pHlp,
447	"rax=volatile rbx=%016RX64 rcx=volatile rdx=volatile\n"
448	"rsi=volatile rdi=volatile r8=volatile r9=volatile \n"
449	"r10=volatile r11=volatile r12=%016RX64 r13=%016RX64\n"
450	"r14=%016RX64 r15=%016RX64\n"
451	"rip=%016RX64 rsp=%016RX64 rbp=%016RX64 rflags=%08RX64\n"
452	,
453	pBP[-5],
454	pBP[-4], pBP[-3],
455	pBP[-2], pBP[-1],
456	pBP[1], pVCpu->vmm.s.AssertJmpBuf.UnwindRetSp, pBP[0], pBP[-6]);
457	# endif
458	#endif
459
460	/* Callstack. */
461	DBGFADDRESS AddrPc, AddrBp, AddrSp;
462	PCDBGFSTACKFRAME pFirstFrame;
463	rc2 = DBGFR3StackWalkBeginEx(pVM->pUVM, pVCpu->idCpu, DBGFCODETYPE_RING0,
464	DBGFR3AddrFromHostR0(&AddrBp, pVCpu->vmm.s.AssertJmpBuf.UnwindBp),
465	DBGFR3AddrFromHostR0(&AddrSp, pVCpu->vmm.s.AssertJmpBuf.UnwindSp),
466	DBGFR3AddrFromHostR0(&AddrPc, pVCpu->vmm.s.AssertJmpBuf.UnwindPc),
467	RTDBGRETURNTYPE_INVALID, &pFirstFrame);
468	if (RT_SUCCESS(rc2))
469	{
470	pHlp->pfnPrintf(pHlp,
471	"!!\n"
472	"!! Call Stack:\n"
473	"!!\n");
474	#if HC_ARCH_BITS == 32
475	pHlp->pfnPrintf(pHlp, "EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP Symbol [line]\n");
476	#else
477	pHlp->pfnPrintf(pHlp, "RBP Ret RBP Ret RIP RIP Symbol [line]\n");
478	#endif
479	for (PCDBGFSTACKFRAME pFrame = pFirstFrame;
480	pFrame;
481	pFrame = DBGFR3StackWalkNext(pFrame))
482	{
483	#if HC_ARCH_BITS == 32
484	pHlp->pfnPrintf(pHlp,
485	"%RHv %RHv %04RX32:%RHv %RHv %RHv %RHv %RHv",
486	(RTHCUINTPTR)pFrame->AddrFrame.off,
487	(RTHCUINTPTR)pFrame->AddrReturnFrame.off,
488	(RTHCUINTPTR)pFrame->AddrReturnPC.Sel,
489	(RTHCUINTPTR)pFrame->AddrReturnPC.off,
490	pFrame->Args.au32[0],
491	pFrame->Args.au32[1],
492	pFrame->Args.au32[2],
493	pFrame->Args.au32[3]);
494	pHlp->pfnPrintf(pHlp, " %RTsel:%08RHv", pFrame->AddrPC.Sel, pFrame->AddrPC.off);
495	#else
496	pHlp->pfnPrintf(pHlp,
497	"%RHv %RHv %RHv %RHv",
498	(RTHCUINTPTR)pFrame->AddrFrame.off,
499	(RTHCUINTPTR)pFrame->AddrReturnFrame.off,
500	(RTHCUINTPTR)pFrame->AddrReturnPC.off,
501	(RTHCUINTPTR)pFrame->AddrPC.off);
502	#endif
503	if (pFrame->pSymPC)
504	{
505	RTGCINTPTR offDisp = pFrame->AddrPC.FlatPtr - pFrame->pSymPC->Value;
506	if (offDisp > 0)
507	pHlp->pfnPrintf(pHlp, " %s+%llx", pFrame->pSymPC->szName, (int64_t)offDisp);
508	else if (offDisp < 0)
509	pHlp->pfnPrintf(pHlp, " %s-%llx", pFrame->pSymPC->szName, -(int64_t)offDisp);
510	else
511	pHlp->pfnPrintf(pHlp, " %s", pFrame->pSymPC->szName);
512	}
513	if (pFrame->pLinePC)
514	pHlp->pfnPrintf(pHlp, " [%s @ 0i%d]", pFrame->pLinePC->szFilename, pFrame->pLinePC->uLineNo);
515	pHlp->pfnPrintf(pHlp, "\n");
516	for (uint32_t iReg = 0; iReg < pFrame->cSureRegs; iReg++)
517	{
518	const char *pszName = pFrame->paSureRegs[iReg].pszName;
519	if (!pszName)
520	pszName = DBGFR3RegCpuName(pVM->pUVM, pFrame->paSureRegs[iReg].enmReg,
521	pFrame->paSureRegs[iReg].enmType);
522	char szValue[1024];
523	szValue[0] = '\0';
524	DBGFR3RegFormatValue(szValue, sizeof(szValue), &pFrame->paSureRegs[iReg].Value,
525	pFrame->paSureRegs[iReg].enmType, false);
526	pHlp->pfnPrintf(pHlp, " %-3s=%s\n", pszName, szValue);
527	}
528	}
529	DBGFR3StackWalkEnd(pFirstFrame);
530	}
531
532	/* Symbols on the stack. */
533	uint32_t const cbRawStack = RT_MIN(pVCpu->vmm.s.AssertJmpBuf.cbStackValid, sizeof(pVCpu->vmm.s.abAssertStack));
534	uintptr_t const * const pauAddr = (uintptr_t const *)&pVCpu->vmm.s.abAssertStack[0];
535	uint32_t const iEnd = cbRawStack / sizeof(uintptr_t);
536	uint32_t iAddr = 0;
537	pHlp->pfnPrintf(pHlp,
538	"!!\n"
539	"!! Addresses on the stack (iAddr=%#x, iEnd=%#x)\n"
540	"!!\n",
541	iAddr, iEnd);
542	while (iAddr < iEnd)
543	{
544	uintptr_t const uAddr = pauAddr[iAddr];
545	if (uAddr > X86_PAGE_SIZE)
546	{
547	DBGFADDRESS Addr;
548	DBGFR3AddrFromFlat(pVM->pUVM, &Addr, uAddr);
549	RTGCINTPTR offDisp = 0;
550	RTGCINTPTR offLineDisp = 0;
551	PRTDBGSYMBOL pSym = DBGFR3AsSymbolByAddrA(pVM->pUVM, DBGF_AS_R0, &Addr,
552	RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL
553	\| RTDBGSYMADDR_FLAGS_SKIP_ABS_IN_DEFERRED,
554	&offDisp, NULL);
555	PRTDBGLINE pLine = DBGFR3AsLineByAddrA(pVM->pUVM, DBGF_AS_R0, &Addr, &offLineDisp, NULL);
556	if (pLine \|\| pSym)
557	{
558	pHlp->pfnPrintf(pHlp, "%#06x: %p =>", iAddr * sizeof(uintptr_t), uAddr);
559	if (pSym)
560	pHlp->pfnPrintf(pHlp, " %s + %#x", pSym->szName, (intptr_t)offDisp);
561	if (pLine)
562	pHlp->pfnPrintf(pHlp, " [%s:%u + %#x]\n", pLine->szFilename, pLine->uLineNo, offLineDisp);
563	else
564	pHlp->pfnPrintf(pHlp, "\n");
565	RTDbgSymbolFree(pSym);
566	RTDbgLineFree(pLine);
567	}
568	}
569	iAddr++;
570	}
571
572	/* raw stack */
573	Hlp.fRecSummary = false;
574	pHlp->pfnPrintf(pHlp,
575	"!!\n"
576	"!! Raw stack (mind the direction).\n"
577	"!! pbEMTStackR0=%RHv cbRawStack=%#x\n"
578	"!! pbEmtStackR3=%p\n"
579	"!!\n"
580	"%.*Rhxd\n",
581	pVCpu->vmm.s.AssertJmpBuf.UnwindSp, cbRawStack,
582	&pVCpu->vmm.s.abAssertStack[0],
583	cbRawStack, &pVCpu->vmm.s.abAssertStack[0]);
584	}
585	else
586	{
587	pHlp->pfnPrintf(pHlp,
588	"!! Skipping ring-0 registers and stack, rcErr=%Rrc\n", rcErr);
589	}
590	#endif /* !VBOX_VMM_TARGET_ARMV8 */
591	break;
592	}
593
594	case VERR_IEM_INSTR_NOT_IMPLEMENTED:
595	case VERR_IEM_ASPECT_NOT_IMPLEMENTED:
596	case VERR_PATM_IPE_TRAP_IN_PATCH_CODE:
597	case VERR_EM_GUEST_CPU_HANG:
598	{
599	CPUMImportGuestStateOnDemand(pVCpu, CPUMCTX_EXTRN_ABSOLUTELY_ALL);
600	fDoneImport = true;
601
602	DBGFR3Info(pVM->pUVM, "cpumguest", NULL, pHlp);
603	DBGFR3Info(pVM->pUVM, "cpumguestinstr", NULL, pHlp);
604	DBGFR3Info(pVM->pUVM, "cpumguesthwvirt", NULL, pHlp);
605	break;
606	}
607
608	/*
609	* For some problems (e.g. VERR_INVALID_STATE in VMMR0.cpp), there could be
610	* additional details in the assertion messages.
611	*/
612	default:
613	{
614	const char *pszMsg1 = VMMR3GetRZAssertMsg1(pVM);
615	while (pszMsg1 && *pszMsg1 == '\n')
616	pszMsg1++;
617	if (pszMsg1 && *pszMsg1 != '\0')
618	pHlp->pfnPrintf(pHlp, "AssertMsg1: %s\n", pszMsg1);
619
620	const char *pszMsg2 = VMMR3GetRZAssertMsg2(pVM);
621	while (pszMsg2 && *pszMsg2 == '\n')
622	pszMsg2++;
623	if (pszMsg2 && *pszMsg2 != '\0')
624	pHlp->pfnPrintf(pHlp, "AssertMsg2: %s\n", pszMsg2);
625	break;
626	}
627
628	} /* switch (rcErr) */
629	Hlp.fRecSummary = false;
630
631
632	/*
633	* Generic info dumper loop.
634	*/
635	if (!fDoneImport)
636	CPUMImportGuestStateOnDemand(pVCpu, CPUMCTX_EXTRN_ABSOLUTELY_ALL);
637	static struct
638	{
639	const char *pszInfo;
640	const char *pszArgs;
641	} const aInfo[] =
642	{
643	{ "mappings", NULL },
644	{ "hma", NULL },
645	{ "cpumguest", "verbose" },
646	{ "cpumguesthwvirt", "verbose" },
647	{ "cpumguestinstr", "verbose" },
648	{ "cpumhyper", "verbose" },
649	{ "cpumhost", "verbose" },
650	{ "mode", "all" },
651	{ "cpuid", "verbose" },
652	{ "handlers", "phys virt hyper stats" },
653	{ "timers", NULL },
654	{ "activetimers", NULL },
655	};
656	for (unsigned i = 0; i < RT_ELEMENTS(aInfo); i++)
657	{
658	if (fDoneHyper && !strcmp(aInfo[i].pszInfo, "cpumhyper"))
659	continue;
660	pHlp->pfnPrintf(pHlp,
661	"!!\n"
662	"!! {%s, %s}\n"
663	"!!\n",
664	aInfo[i].pszInfo, aInfo[i].pszArgs);
665	DBGFR3Info(pVM->pUVM, aInfo[i].pszInfo, aInfo[i].pszArgs, pHlp);
666	}
667
668	/* All other info items */
669	DBGFR3InfoMulti(pVM,
670	"*",
671	"mappings\|hma\|cpum\|cpumguest\|cpumguesthwvirt\|cpumguestinstr\|cpumhyper\|cpumhost\|mode\|cpuid"
672	"\|pgmpd\|pgmcr3\|timers\|activetimers\|handlers\|help\|exithistory",
673	"!!\n"
674	"!! {%s}\n"
675	"!!\n",
676	pHlp);
677
678
679	/* done */
680	pHlp->pfnPrintf(pHlp,
681	"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
682
683
684	/*
685	* Repeat the summary to stderr so we don't have to scroll half a mile up.
686	*/
687	vmmR3FatalDumpInfoHlpFlushStdErr(&Hlp);
688	if (Hlp.szSummary[0])
689	RTStrmPrintf(g_pStdErr,
690	"%s\n"
691	"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n",
692	Hlp.szSummary);
693
694	/*
695	* Delete the output instance (flushing and restoring of flags).
696	*/
697	vmmR3FatalDumpInfoHlpDelete(&Hlp);
698
699	/*
700	* Rendezvous with the other EMTs and clear the VM_FF_CHECK_VM_STATE so we can
701	* stop burning CPU cycles.
702	*/
703	VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, vmmR3FatalDumpRendezvousDoneCallback, NULL);
704	}
705

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

source: vbox/trunk/src/VBox/VMM/VMMR3/VMMGuruMeditation.cpp@ 103583

Download in other formats: