VirtualBox

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

Last change on this file since 32274 was 31839, checked in by vboxsync, 14 years ago

build fix
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 27.2 KB
Line 
1/* $Id: VMMGuruMeditation.cpp 31839 2010-08-21 01:57:30Z vboxsync $ */
2/** @file
3 * VMM - The Virtual Machine Monitor, Guru Meditation Code.
4 */
5
6/*
7 * Copyright (C) 2006-2010 Oracle Corporation
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
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.
16 */
17
18/*******************************************************************************
19* Header Files *
20*******************************************************************************/
21#define LOG_GROUP LOG_GROUP_VMM
22#include <VBox/vmm.h>
23#include <VBox/pdmapi.h>
24#include <VBox/pdmcritsect.h>
25#include <VBox/trpm.h>
26#include <VBox/dbgf.h>
27#include "VMMInternal.h"
28#include <VBox/vm.h>
29#include <VBox/mm.h>
30#include <VBox/iom.h>
31#include <VBox/em.h>
32
33#include <VBox/err.h>
34#include <VBox/param.h>
35#include <VBox/version.h>
36#include <VBox/hwaccm.h>
37#include <iprt/assert.h>
38#include <iprt/time.h>
39#include <iprt/stream.h>
40#include <iprt/string.h>
41#include <iprt/stdarg.h>
42
43
44/*******************************************************************************
45* Structures and Typedefs *
46*******************************************************************************/
47/**
48 * Structure to pass to DBGFR3Info() and for doing all other
49 * output during fatal dump.
50 */
51typedef struct VMMR3FATALDUMPINFOHLP
52{
53 /** The helper core. */
54 DBGFINFOHLP Core;
55 /** The release logger instance. */
56 PRTLOGGER pRelLogger;
57 /** The saved release logger flags. */
58 uint32_t fRelLoggerFlags;
59 /** The logger instance. */
60 PRTLOGGER pLogger;
61 /** The saved logger flags. */
62 uint32_t fLoggerFlags;
63 /** The saved logger destination flags. */
64 uint32_t fLoggerDestFlags;
65 /** Whether to output to stderr or not. */
66 bool fStdErr;
67 /** Whether we're still recording the summary or not. */
68 bool fRecSummary;
69 /** Buffer for the summary. */
70 char szSummary[4096-2];
71 /** The current summary offset. */
72 size_t offSummary;
73} VMMR3FATALDUMPINFOHLP, *PVMMR3FATALDUMPINFOHLP;
74/** Pointer to a VMMR3FATALDUMPINFOHLP structure. */
75typedef const VMMR3FATALDUMPINFOHLP *PCVMMR3FATALDUMPINFOHLP;
76
77
78/**
79 * Print formatted string.
80 *
81 * @param pHlp Pointer to this structure.
82 * @param pszFormat The format string.
83 * @param ... Arguments.
84 */
85static DECLCALLBACK(void) vmmR3FatalDumpInfoHlp_pfnPrintf(PCDBGFINFOHLP pHlp, const char *pszFormat, ...)
86{
87 va_list args;
88 va_start(args, pszFormat);
89 pHlp->pfnPrintfV(pHlp, pszFormat, args);
90 va_end(args);
91}
92
93
94/**
95 * Print formatted string.
96 *
97 * @param pHlp Pointer to this structure.
98 * @param pszFormat The format string.
99 * @param args Argument list.
100 */
101static DECLCALLBACK(void) vmmR3FatalDumpInfoHlp_pfnPrintfV(PCDBGFINFOHLP pHlp, const char *pszFormat, va_list args)
102{
103 PVMMR3FATALDUMPINFOHLP pMyHlp = (PVMMR3FATALDUMPINFOHLP)pHlp;
104
105 if (pMyHlp->pRelLogger)
106 {
107 va_list args2;
108 va_copy(args2, args);
109 RTLogLoggerV(pMyHlp->pRelLogger, pszFormat, args2);
110 va_end(args2);
111 }
112 if (pMyHlp->pLogger)
113 {
114 va_list args2;
115 va_copy(args2, args);
116 RTLogLoggerV(pMyHlp->pLogger, pszFormat, args);
117 va_end(args2);
118 }
119 if (pMyHlp->fStdErr)
120 {
121 va_list args2;
122 va_copy(args2, args);
123 RTStrmPrintfV(g_pStdErr, pszFormat, args);
124 va_end(args2);
125 }
126 if (pMyHlp->fRecSummary)
127 {
128 size_t cchLeft = sizeof(pMyHlp->szSummary) - pMyHlp->offSummary;
129 if (cchLeft > 1)
130 {
131 va_list args2;
132 va_copy(args2, args);
133 size_t cch = RTStrPrintfV(&pMyHlp->szSummary[pMyHlp->offSummary], cchLeft, pszFormat, args);
134 va_end(args2);
135 Assert(cch <= cchLeft);
136 pMyHlp->offSummary += cch;
137 }
138 }
139}
140
141
142/**
143 * Initializes the fatal dump output helper.
144 *
145 * @param pHlp The structure to initialize.
146 */
147static void vmmR3FatalDumpInfoHlpInit(PVMMR3FATALDUMPINFOHLP pHlp)
148{
149 memset(pHlp, 0, sizeof(*pHlp));
150
151 pHlp->Core.pfnPrintf = vmmR3FatalDumpInfoHlp_pfnPrintf;
152 pHlp->Core.pfnPrintfV = vmmR3FatalDumpInfoHlp_pfnPrintfV;
153
154 /*
155 * The loggers.
156 */
157 pHlp->pRelLogger = RTLogRelDefaultInstance();
158#ifndef LOG_ENABLED
159 if (!pHlp->pRelLogger)
160#endif
161 pHlp->pLogger = RTLogDefaultInstance();
162
163 if (pHlp->pRelLogger)
164 {
165 pHlp->fRelLoggerFlags = pHlp->pRelLogger->fFlags;
166 pHlp->pRelLogger->fFlags &= ~(RTLOGFLAGS_BUFFERED | RTLOGFLAGS_DISABLED);
167 }
168
169 if (pHlp->pLogger)
170 {
171 pHlp->fLoggerFlags = pHlp->pLogger->fFlags;
172 pHlp->fLoggerDestFlags = pHlp->pLogger->fDestFlags;
173 pHlp->pLogger->fFlags &= ~(RTLOGFLAGS_BUFFERED | RTLOGFLAGS_DISABLED);
174#ifndef DEBUG_sandervl
175 pHlp->pLogger->fDestFlags |= RTLOGDEST_DEBUGGER;
176#endif
177 }
178
179 /*
180 * Check if we need write to stderr.
181 */
182 pHlp->fStdErr = (!pHlp->pRelLogger || !(pHlp->pRelLogger->fDestFlags & (RTLOGDEST_STDOUT | RTLOGDEST_STDERR)))
183 && (!pHlp->pLogger || !(pHlp->pLogger->fDestFlags & (RTLOGDEST_STDOUT | RTLOGDEST_STDERR)));
184#ifdef DEBUG_sandervl
185 pHlp->fStdErr = false; /* takes too long to display here */
186#endif
187
188 /*
189 * Init the summary recording.
190 */
191 pHlp->fRecSummary = true;
192 pHlp->offSummary = 0;
193 pHlp->szSummary[0] = '\0';
194}
195
196
197/**
198 * Deletes the fatal dump output helper.
199 *
200 * @param pHlp The structure to delete.
201 */
202static void vmmR3FatalDumpInfoHlpDelete(PVMMR3FATALDUMPINFOHLP pHlp)
203{
204 if (pHlp->pRelLogger)
205 {
206 RTLogFlush(pHlp->pRelLogger);
207 pHlp->pRelLogger->fFlags = pHlp->fRelLoggerFlags;
208 }
209
210 if (pHlp->pLogger)
211 {
212 RTLogFlush(pHlp->pLogger);
213 pHlp->pLogger->fFlags = pHlp->fLoggerFlags;
214 pHlp->pLogger->fDestFlags = pHlp->fLoggerDestFlags;
215 }
216}
217
218
219/**
220 * Dumps the VM state on a fatal error.
221 *
222 * @param pVM VM Handle.
223 * @param pVCpu VMCPU Handle.
224 * @param rcErr VBox status code.
225 */
226VMMR3DECL(void) VMMR3FatalDump(PVM pVM, PVMCPU pVCpu, int rcErr)
227{
228 /*
229 * Create our output helper and sync it with the log settings.
230 * This helper will be used for all the output.
231 */
232 VMMR3FATALDUMPINFOHLP Hlp;
233 PCDBGFINFOHLP pHlp = &Hlp.Core;
234 vmmR3FatalDumpInfoHlpInit(&Hlp);
235
236 /* Release owned locks to make sure other VCPUs can continue in case they were waiting for one. */
237 PDMR3CritSectLeaveAll(pVM);
238
239 /*
240 * Header.
241 */
242 pHlp->pfnPrintf(pHlp,
243 "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
244 "!!\n"
245 "!! Guru Meditation %d (%Rrc)\n"
246 "!!\n",
247 rcErr, rcErr);
248
249 /*
250 * Continue according to context.
251 */
252 bool fDoneHyper = false;
253 switch (rcErr)
254 {
255 /*
256 * Hypervisor errors.
257 */
258 case VERR_VMM_RING0_ASSERTION:
259 case VINF_EM_DBG_HYPER_ASSERTION:
260 case VERR_VMM_RING3_CALL_DISABLED:
261 {
262 const char *pszMsg1 = VMMR3GetRZAssertMsg1(pVM);
263 while (pszMsg1 && *pszMsg1 == '\n')
264 pszMsg1++;
265 const char *pszMsg2 = VMMR3GetRZAssertMsg2(pVM);
266 while (pszMsg2 && *pszMsg2 == '\n')
267 pszMsg2++;
268 pHlp->pfnPrintf(pHlp,
269 "%s"
270 "%s",
271 pszMsg1,
272 pszMsg2);
273 if ( !pszMsg2
274 || !*pszMsg2
275 || strchr(pszMsg2, '\0')[-1] != '\n')
276 pHlp->pfnPrintf(pHlp, "\n");
277 /* fall thru */
278 }
279 case VERR_TRPM_DONT_PANIC:
280 case VERR_TRPM_PANIC:
281 case VINF_EM_RAW_STALE_SELECTOR:
282 case VINF_EM_RAW_IRET_TRAP:
283 case VINF_EM_DBG_HYPER_BREAKPOINT:
284 case VINF_EM_DBG_HYPER_STEPPED:
285 case VERR_VMM_HYPER_CR3_MISMATCH:
286 {
287 /*
288 * Active trap? This is only of partial interest when in hardware
289 * assisted virtualization mode, thus the different messages.
290 */
291 uint32_t uEIP = CPUMGetHyperEIP(pVCpu);
292 TRPMEVENT enmType;
293 uint8_t u8TrapNo = 0xce;
294 RTGCUINT uErrorCode = 0xdeadface;
295 RTGCUINTPTR uCR2 = 0xdeadface;
296 int rc2 = TRPMQueryTrapAll(pVCpu, &u8TrapNo, &enmType, &uErrorCode, &uCR2);
297 if (!HWACCMIsEnabled(pVM))
298 {
299 if (RT_SUCCESS(rc2))
300 pHlp->pfnPrintf(pHlp,
301 "!! TRAP=%02x ERRCD=%RGv CR2=%RGv EIP=%RX32 Type=%d\n",
302 u8TrapNo, uErrorCode, uCR2, uEIP, enmType);
303 else
304 pHlp->pfnPrintf(pHlp,
305 "!! EIP=%RX32 NOTRAP\n",
306 uEIP);
307 }
308 else if (RT_SUCCESS(rc2))
309 pHlp->pfnPrintf(pHlp,
310 "!! ACTIVE TRAP=%02x ERRCD=%RGv CR2=%RGv PC=%RGr Type=%d (Guest!)\n",
311 u8TrapNo, uErrorCode, uCR2, CPUMGetGuestRIP(pVCpu), enmType);
312
313 /*
314 * Dump the relevant hypervisor registers and stack.
315 */
316 if (HWACCMIsEnabled(pVM))
317 {
318 if ( rcErr == VERR_VMM_RING0_ASSERTION /* fInRing3Call has already been cleared here. */
319 || pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call)
320 {
321 /* Dump the jmpbuf. */
322 pHlp->pfnPrintf(pHlp,
323 "!!\n"
324 "!! CallRing3JmpBuf:\n"
325 "!!\n");
326 pHlp->pfnPrintf(pHlp,
327 "SavedEsp=%RHv SavedEbp=%RHv SpResume=%RHv SpCheck=%RHv\n",
328 pVCpu->vmm.s.CallRing3JmpBufR0.SavedEsp,
329 pVCpu->vmm.s.CallRing3JmpBufR0.SavedEbp,
330 pVCpu->vmm.s.CallRing3JmpBufR0.SpResume,
331 pVCpu->vmm.s.CallRing3JmpBufR0.SpCheck);
332 pHlp->pfnPrintf(pHlp,
333 "pvSavedStack=%RHv cbSavedStack=%#x fInRing3Call=%RTbool\n",
334 pVCpu->vmm.s.CallRing3JmpBufR0.pvSavedStack,
335 pVCpu->vmm.s.CallRing3JmpBufR0.cbSavedStack,
336 pVCpu->vmm.s.CallRing3JmpBufR0.fInRing3Call);
337 pHlp->pfnPrintf(pHlp,
338 "cbUsedMax=%#x cbUsedAvg=%#x cbUsedTotal=%#llx cUsedTotal=%#llx\n",
339 pVCpu->vmm.s.CallRing3JmpBufR0.cbUsedMax,
340 pVCpu->vmm.s.CallRing3JmpBufR0.cbUsedAvg,
341 pVCpu->vmm.s.CallRing3JmpBufR0.cbUsedTotal,
342 pVCpu->vmm.s.CallRing3JmpBufR0.cUsedTotal);
343
344 /* Dump the resume register frame on the stack. */
345 PRTHCUINTPTR pBP;
346#ifdef VMM_R0_SWITCH_STACK
347 pBP = (PRTHCUINTPTR)&pVCpu->vmm.s.pbEMTStackR3[ pVCpu->vmm.s.CallRing3JmpBufR0.SavedEbp
348 - MMHyperCCToR0(pVM, pVCpu->vmm.s.pbEMTStackR3)];
349#else
350 pBP = (PRTHCUINTPTR)&pVCpu->vmm.s.pbEMTStackR3[ pVCpu->vmm.s.CallRing3JmpBufR0.cbSavedStack
351 - pVCpu->vmm.s.CallRing3JmpBufR0.SpCheck
352 + pVCpu->vmm.s.CallRing3JmpBufR0.SavedEbp];
353#endif
354#if HC_ARCH_BITS == 32
355 pHlp->pfnPrintf(pHlp,
356 "eax=volatile ebx=%08x ecx=volatile edx=volatile esi=%08x edi=%08x\n"
357 "eip=%08x esp=%08x ebp=%08x efl=%08x\n"
358 ,
359 pBP[-3], pBP[-2], pBP[-1],
360 pBP[1], pVCpu->vmm.s.CallRing3JmpBufR0.SavedEbp - 8, pBP[0], pBP[-4]);
361#else
362# ifdef RT_OS_WINDOWS
363 pHlp->pfnPrintf(pHlp,
364 "rax=volatile rbx=%016RX64 rcx=volatile rdx=volatile\n"
365 "rsi=%016RX64 rdi=%016RX64 r8=volatile r9=volatile \n"
366 "r10=volatile r11=volatile r12=%016RX64 r13=%016RX64\n"
367 "r14=%016RX64 r15=%016RX64\n"
368 "rip=%016RX64 rsp=%016RX64 rbp=%016RX64 rfl=%08RX64\n"
369 ,
370 pBP[-7],
371 pBP[-6], pBP[-5],
372 pBP[-4], pBP[-3],
373 pBP[-2], pBP[-1],
374 pBP[1], pVCpu->vmm.s.CallRing3JmpBufR0.SavedEbp - 16, pBP[0], pBP[-8]);
375# else
376 pHlp->pfnPrintf(pHlp,
377 "rax=volatile rbx=%016RX64 rcx=volatile rdx=volatile\n"
378 "rsi=volatile rdi=volatile r8=volatile r9=volatile \n"
379 "r10=volatile r11=volatile r12=%016RX64 r13=%016RX64\n"
380 "r14=%016RX64 r15=%016RX64\n"
381 "rip=%016RX64 rsp=%016RX64 rbp=%016RX64 rflags=%08RX64\n"
382 ,
383 pBP[-5],
384 pBP[-4], pBP[-3],
385 pBP[-2], pBP[-1],
386 pBP[1], pVCpu->vmm.s.CallRing3JmpBufR0.SavedEbp - 16, pBP[0], pBP[-6]);
387# endif
388#endif
389
390 /* Callstack. */
391 DBGFADDRESS pc;
392 pc.fFlags = DBGFADDRESS_FLAGS_RING0 | DBGFADDRESS_FLAGS_VALID;
393#if HC_ARCH_BITS == 64
394 pc.FlatPtr = pc.off = pVCpu->vmm.s.CallRing3JmpBufR0.rip;
395#else
396 pc.FlatPtr = pc.off = pVCpu->vmm.s.CallRing3JmpBufR0.eip;
397#endif
398 pc.Sel = DBGF_SEL_FLAT;
399
400 DBGFADDRESS ebp;
401 ebp.fFlags = DBGFADDRESS_FLAGS_RING0 | DBGFADDRESS_FLAGS_VALID;
402 ebp.FlatPtr = ebp.off = pVCpu->vmm.s.CallRing3JmpBufR0.SavedEbp;
403 ebp.Sel = DBGF_SEL_FLAT;
404
405 DBGFADDRESS esp;
406 esp.fFlags = DBGFADDRESS_FLAGS_RING0 | DBGFADDRESS_FLAGS_VALID;
407 esp.Sel = DBGF_SEL_FLAT;
408 esp.FlatPtr = esp.off = pVCpu->vmm.s.CallRing3JmpBufR0.SavedEsp;
409
410 PCDBGFSTACKFRAME pFirstFrame;
411 rc2 = DBGFR3StackWalkBeginEx(pVM, pVCpu->idCpu, DBGFCODETYPE_RING0, &ebp, &esp, &pc,
412 DBGFRETURNTYPE_INVALID, &pFirstFrame);
413 if (RT_SUCCESS(rc2))
414 {
415 pHlp->pfnPrintf(pHlp,
416 "!!\n"
417 "!! Call Stack:\n"
418 "!!\n");
419#if HC_ARCH_BITS == 32
420 pHlp->pfnPrintf(pHlp, "EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP Symbol [line]\n");
421#else
422 pHlp->pfnPrintf(pHlp, "RBP Ret RBP Ret RIP RIP Symbol [line]\n");
423#endif
424 for (PCDBGFSTACKFRAME pFrame = pFirstFrame;
425 pFrame;
426 pFrame = DBGFR3StackWalkNext(pFrame))
427 {
428#if HC_ARCH_BITS == 32
429 pHlp->pfnPrintf(pHlp,
430 "%RHv %RHv %04RX32:%RHv %RHv %RHv %RHv %RHv",
431 (RTHCUINTPTR)pFrame->AddrFrame.off,
432 (RTHCUINTPTR)pFrame->AddrReturnFrame.off,
433 (RTHCUINTPTR)pFrame->AddrReturnPC.Sel,
434 (RTHCUINTPTR)pFrame->AddrReturnPC.off,
435 pFrame->Args.au32[0],
436 pFrame->Args.au32[1],
437 pFrame->Args.au32[2],
438 pFrame->Args.au32[3]);
439 pHlp->pfnPrintf(pHlp, " %RTsel:%08RHv", pFrame->AddrPC.Sel, pFrame->AddrPC.off);
440#else
441 pHlp->pfnPrintf(pHlp,
442 "%RHv %RHv %RHv %RHv",
443 (RTHCUINTPTR)pFrame->AddrFrame.off,
444 (RTHCUINTPTR)pFrame->AddrReturnFrame.off,
445 (RTHCUINTPTR)pFrame->AddrReturnPC.off,
446 (RTHCUINTPTR)pFrame->AddrPC.off);
447#endif
448 if (pFrame->pSymPC)
449 {
450 RTGCINTPTR offDisp = pFrame->AddrPC.FlatPtr - pFrame->pSymPC->Value;
451 if (offDisp > 0)
452 pHlp->pfnPrintf(pHlp, " %s+%llx", pFrame->pSymPC->szName, (int64_t)offDisp);
453 else if (offDisp < 0)
454 pHlp->pfnPrintf(pHlp, " %s-%llx", pFrame->pSymPC->szName, -(int64_t)offDisp);
455 else
456 pHlp->pfnPrintf(pHlp, " %s", pFrame->pSymPC->szName);
457 }
458 if (pFrame->pLinePC)
459 pHlp->pfnPrintf(pHlp, " [%s @ 0i%d]", pFrame->pLinePC->szFilename, pFrame->pLinePC->uLineNo);
460 pHlp->pfnPrintf(pHlp, "\n");
461 }
462 DBGFR3StackWalkEnd(pFirstFrame);
463 }
464
465 /* raw stack */
466 Hlp.fRecSummary = false;
467 pHlp->pfnPrintf(pHlp,
468 "!!\n"
469 "!! Raw stack (mind the direction). \n"
470 "!! pbEMTStackR0=%RHv pbEMTStackBottomR0=%RHv VMM_STACK_SIZE=%#x\n"
471 "!! pbEmtStackR3=%p\n"
472 "!!\n"
473 "%.*Rhxd\n",
474 MMHyperCCToR0(pVM, pVCpu->vmm.s.pbEMTStackR3),
475 MMHyperCCToR0(pVM, pVCpu->vmm.s.pbEMTStackR3) + VMM_STACK_SIZE,
476 VMM_STACK_SIZE,
477 pVCpu->vmm.s.pbEMTStackR3,
478 VMM_STACK_SIZE, pVCpu->vmm.s.pbEMTStackR3);
479 }
480 else
481 {
482 pHlp->pfnPrintf(pHlp,
483 "!! Skipping ring-0 registers and stack, rcErr=%Rrc\n", rcErr);
484 }
485 }
486 else
487 {
488 /*
489 * Try figure out where eip is.
490 */
491 /* core code? */
492 if (uEIP - (RTGCUINTPTR)pVM->vmm.s.pvCoreCodeRC < pVM->vmm.s.cbCoreCode)
493 pHlp->pfnPrintf(pHlp,
494 "!! EIP is in CoreCode, offset %#x\n",
495 uEIP - (RTGCUINTPTR)pVM->vmm.s.pvCoreCodeRC);
496 else
497 { /* ask PDM */ /** @todo ask DBGFR3Sym later? */
498 char szModName[64];
499 RTRCPTR RCPtrMod;
500 char szNearSym1[260];
501 RTRCPTR RCPtrNearSym1;
502 char szNearSym2[260];
503 RTRCPTR RCPtrNearSym2;
504 int rc = PDMR3LdrQueryRCModFromPC(pVM, uEIP,
505 &szModName[0], sizeof(szModName), &RCPtrMod,
506 &szNearSym1[0], sizeof(szNearSym1), &RCPtrNearSym1,
507 &szNearSym2[0], sizeof(szNearSym2), &RCPtrNearSym2);
508 if (RT_SUCCESS(rc))
509 pHlp->pfnPrintf(pHlp,
510 "!! EIP in %s (%RRv) at rva %x near symbols:\n"
511 "!! %RRv rva %RRv off %08x %s\n"
512 "!! %RRv rva %RRv off -%08x %s\n",
513 szModName, RCPtrMod, (unsigned)(uEIP - RCPtrMod),
514 RCPtrNearSym1, RCPtrNearSym1 - RCPtrMod, (unsigned)(uEIP - RCPtrNearSym1), szNearSym1,
515 RCPtrNearSym2, RCPtrNearSym2 - RCPtrMod, (unsigned)(RCPtrNearSym2 - uEIP), szNearSym2);
516 else
517 pHlp->pfnPrintf(pHlp,
518 "!! EIP is not in any code known to VMM!\n");
519 }
520
521 /* Disassemble the instruction. */
522 char szInstr[256];
523 rc2 = DBGFR3DisasInstrEx(pVM, pVCpu->idCpu, 0, 0, DBGF_DISAS_FLAGS_CURRENT_HYPER | DBGF_DISAS_FLAGS_DEFAULT_MODE,
524 &szInstr[0], sizeof(szInstr), NULL);
525 if (RT_SUCCESS(rc2))
526 pHlp->pfnPrintf(pHlp,
527 "!! %s\n", szInstr);
528
529 /* Dump the hypervisor cpu state. */
530 pHlp->pfnPrintf(pHlp,
531 "!!\n"
532 "!!\n"
533 "!!\n");
534 rc2 = DBGFR3Info(pVM, "cpumhyper", "verbose", pHlp);
535 fDoneHyper = true;
536
537 /* Callstack. */
538 PCDBGFSTACKFRAME pFirstFrame;
539 rc2 = DBGFR3StackWalkBegin(pVM, pVCpu->idCpu, DBGFCODETYPE_HYPER, &pFirstFrame);
540 if (RT_SUCCESS(rc2))
541 {
542 pHlp->pfnPrintf(pHlp,
543 "!!\n"
544 "!! Call Stack:\n"
545 "!!\n"
546 "EBP Ret EBP Ret CS:EIP Arg0 Arg1 Arg2 Arg3 CS:EIP Symbol [line]\n");
547 for (PCDBGFSTACKFRAME pFrame = pFirstFrame;
548 pFrame;
549 pFrame = DBGFR3StackWalkNext(pFrame))
550 {
551 pHlp->pfnPrintf(pHlp,
552 "%08RX32 %08RX32 %04RX32:%08RX32 %08RX32 %08RX32 %08RX32 %08RX32",
553 (uint32_t)pFrame->AddrFrame.off,
554 (uint32_t)pFrame->AddrReturnFrame.off,
555 (uint32_t)pFrame->AddrReturnPC.Sel,
556 (uint32_t)pFrame->AddrReturnPC.off,
557 pFrame->Args.au32[0],
558 pFrame->Args.au32[1],
559 pFrame->Args.au32[2],
560 pFrame->Args.au32[3]);
561 pHlp->pfnPrintf(pHlp, " %RTsel:%08RGv", pFrame->AddrPC.Sel, pFrame->AddrPC.off);
562 if (pFrame->pSymPC)
563 {
564 RTGCINTPTR offDisp = pFrame->AddrPC.FlatPtr - pFrame->pSymPC->Value;
565 if (offDisp > 0)
566 pHlp->pfnPrintf(pHlp, " %s+%llx", pFrame->pSymPC->szName, (int64_t)offDisp);
567 else if (offDisp < 0)
568 pHlp->pfnPrintf(pHlp, " %s-%llx", pFrame->pSymPC->szName, -(int64_t)offDisp);
569 else
570 pHlp->pfnPrintf(pHlp, " %s", pFrame->pSymPC->szName);
571 }
572 if (pFrame->pLinePC)
573 pHlp->pfnPrintf(pHlp, " [%s @ 0i%d]", pFrame->pLinePC->szFilename, pFrame->pLinePC->uLineNo);
574 pHlp->pfnPrintf(pHlp, "\n");
575 }
576 DBGFR3StackWalkEnd(pFirstFrame);
577 }
578
579 /* raw stack */
580 Hlp.fRecSummary = false;
581 pHlp->pfnPrintf(pHlp,
582 "!!\n"
583 "!! Raw stack (mind the direction). pbEMTStackRC=%RRv pbEMTStackBottomRC=%RRv\n"
584 "!!\n"
585 "%.*Rhxd\n",
586 pVCpu->vmm.s.pbEMTStackRC, pVCpu->vmm.s.pbEMTStackBottomRC,
587 VMM_STACK_SIZE, pVCpu->vmm.s.pbEMTStackR3);
588 } /* !HWACCMIsEnabled */
589 break;
590 }
591
592 default:
593 {
594 break;
595 }
596
597 } /* switch (rcErr) */
598 Hlp.fRecSummary = false;
599
600
601 /*
602 * Generic info dumper loop.
603 */
604 static struct
605 {
606 const char *pszInfo;
607 const char *pszArgs;
608 } const aInfo[] =
609 {
610 { "mappings", NULL },
611 { "hma", NULL },
612 { "cpumguest", "verbose" },
613 { "cpumguestinstr", "verbose" },
614 { "cpumhyper", "verbose" },
615 { "cpumhost", "verbose" },
616 { "mode", "all" },
617 { "cpuid", "verbose" },
618 { "handlers", "phys virt hyper stats" },
619 { "timers", NULL },
620 { "activetimers", NULL },
621 };
622 for (unsigned i = 0; i < RT_ELEMENTS(aInfo); i++)
623 {
624 if (fDoneHyper && !strcmp(aInfo[i].pszInfo, "cpumhyper"))
625 continue;
626 pHlp->pfnPrintf(pHlp,
627 "!!\n"
628 "!! {%s, %s}\n"
629 "!!\n",
630 aInfo[i].pszInfo, aInfo[i].pszArgs);
631 DBGFR3Info(pVM, aInfo[i].pszInfo, aInfo[i].pszArgs, pHlp);
632 }
633
634 /* All other info items */
635 DBGFR3InfoMulti(pVM,
636 "*",
637 "mappings|hma|cpum|cpumguest|cpumguestinstr|cpumhyper|cpumhost|mode|cpuid"
638 "|pgmpd|pgmcr3|timers|activetimers|handlers|help",
639 "!!\n"
640 "!! {%s}\n"
641 "!!\n",
642 pHlp);
643
644
645 /* done */
646 pHlp->pfnPrintf(pHlp,
647 "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
648
649
650 /*
651 * Repeate the summary to stderr so we don't have to scroll half a mile up.
652 */
653 if (Hlp.szSummary[0])
654 RTStrmPrintf(g_pStdErr,
655 "%s"
656 "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n",
657 Hlp.szSummary);
658
659 /*
660 * Delete the output instance (flushing and restoring of flags).
661 */
662 vmmR3FatalDumpInfoHlpDelete(&Hlp);
663}
664
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette