You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
390 lines
9.5 KiB
390 lines
9.5 KiB
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
trap.c
|
|
|
|
Abstract:
|
|
|
|
WinDbg Extension Api
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include "i386.h"
|
|
#include "ia64.h"
|
|
#pragma hdrstop
|
|
|
|
extern ULONG64 STeip, STebp, STesp;
|
|
extern ULONG64 ThreadLastDump;
|
|
|
|
|
|
|
|
DECLARE_API( callback )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
|
|
Arguments:
|
|
|
|
args -
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG64 Address;
|
|
ULONG Flags;
|
|
ULONG result;
|
|
ULONG64 Thread;
|
|
ULONG64 prevCallout ;
|
|
INT calloutNum ;
|
|
INT whichCallout ;
|
|
ULONG64 InitialStack;
|
|
ULONG64 TrFr;
|
|
ULONG dwProcessor=0;
|
|
|
|
GetCurrentProcessor(Client, &dwProcessor, NULL);
|
|
|
|
Address = 0;
|
|
whichCallout = 0 ;
|
|
if (GetExpressionEx(args, &Address, &args)) {
|
|
if (!sscanf(args, "%ld", &whichCallout)) {
|
|
whichCallout = 0;
|
|
}
|
|
}
|
|
|
|
if (Address == 0) {
|
|
GetCurrentThreadAddr((USHORT)dwProcessor, &Address);
|
|
}
|
|
|
|
if (!DumpThreadEx(dwProcessor, "", Address, 0, Client))
|
|
return E_INVALIDARG;
|
|
|
|
GetFieldValue(Address, "ETHREAD", "Tcb.InitialStack", InitialStack);
|
|
|
|
/*
|
|
* now try and grab the contents of the stack
|
|
*/
|
|
if (GetFieldValue(InitialStack, "KCALLOUT_FRAME", "TrFr", TrFr)) {
|
|
dprintf("%08p: Unable to get callout frame\n", InitialStack);
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
if (TargetMachine == IMAGE_FILE_MACHINE_I386) {
|
|
/*
|
|
* Save eip, esp, ebp for quick backtrace from this callback in case
|
|
* they gave us a bogus callout frame.
|
|
*/
|
|
GetFieldValue(InitialStack, "KCALLOUT_FRAME", "Ret", STeip);
|
|
STesp = (ULONG) InitialStack ;
|
|
GetFieldValue(InitialStack, "KCALLOUT_FRAME", "Ebp", STebp);
|
|
}
|
|
|
|
/*
|
|
* Print the callout chain
|
|
*/
|
|
calloutNum = 0 ;
|
|
prevCallout = InitialStack ;
|
|
|
|
if (TargetMachine == IMAGE_FILE_MACHINE_I386) {
|
|
dprintf("Callout# ebp esp eip trapframe\n") ;
|
|
} else {
|
|
dprintf("Callout# esp trapframe\n") ;
|
|
}
|
|
|
|
while (prevCallout) {
|
|
|
|
if (TargetMachine == IMAGE_FILE_MACHINE_I386) {
|
|
ULONG Ret, Ebp;
|
|
|
|
GetFieldValue(prevCallout, "KCALLOUT_FRAME", "Ebp", Ebp);
|
|
GetFieldValue(prevCallout, "KCALLOUT_FRAME", "Ret", Ret);
|
|
|
|
dprintf(" %3d %08lx %08p %08lx %08lx",
|
|
calloutNum, Ebp, prevCallout,
|
|
Ret, TrFr) ;
|
|
if (calloutNum == whichCallout) {
|
|
STeip = Ret ;
|
|
STesp = (ULONG) prevCallout ;
|
|
STebp = Ebp ;
|
|
dprintf(" <-- !kb\n") ;
|
|
}
|
|
else
|
|
dprintf("\n") ;
|
|
} else {
|
|
dprintf(" %3d %08p %08lx",
|
|
calloutNum, prevCallout, TrFr) ;
|
|
}
|
|
|
|
|
|
/*
|
|
* advance to the next callout and try to read it
|
|
*/
|
|
calloutNum++ ;
|
|
|
|
GetFieldValue(prevCallout, "KCALLOUT_FRAME", "CbStk", prevCallout);
|
|
|
|
if (GetFieldValue(prevCallout, "KCALLOUT_FRAME", "TrFr", TrFr)) {
|
|
dprintf("%08p: Unable to get callout frame\n", prevCallout);
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
}
|
|
dprintf("\n") ;
|
|
|
|
if (calloutNum <= whichCallout) {
|
|
dprintf("#(%ld) is out of range. Frame #0 selected.\n", calloutNum) ;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
DECLARE_API( kb )
|
|
|
|
/*++
|
|
|
|
--*/
|
|
|
|
{
|
|
dprintf("\n");
|
|
dprintf(" \"!kb\" is no longer necessary as using \"kb\" after a \".cxr\" or \".trap\"\n");
|
|
dprintf(" command will give you the stack for the faulting thread.\n");
|
|
dprintf("\n");
|
|
dprintf(" Type \"!cxr\" or \"!trap\" for more help on this.\n");
|
|
dprintf("\n");
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
DECLARE_API( kv )
|
|
|
|
/*++
|
|
|
|
--*/
|
|
|
|
{
|
|
dprintf("\n");
|
|
dprintf(" \"!kv\" is no longer necessary as using \"kv\" after a \".cxr\" or \".trap\"\n");
|
|
dprintf(" command will give you the stack for the faulting thread.\n");
|
|
dprintf("\n");
|
|
dprintf(" Type \"!cxr\" or \"!trap\" for more help on this.\n");
|
|
dprintf("\n");
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
#define HIGH(x) ((ULONG) ((x>>32) & 0xFFFFFFFF))
|
|
#define LOW(x) ((ULONG) (x & 0xFFFFFFFF))
|
|
|
|
|
|
|
|
VOID
|
|
DisplayFullEmRegField(
|
|
ULONG64 EmRegValue,
|
|
EM_REG_FIELD EmRegFields[],
|
|
ULONG Field
|
|
)
|
|
{
|
|
dprintf( "\n %3.3s : %I64x : %-s",
|
|
EmRegFields[Field].SubName,
|
|
(EmRegValue >> EmRegFields[Field].Shift) & ((1 << EmRegFields[Field].Length) - 1),
|
|
EmRegFields[Field].Name
|
|
);
|
|
return;
|
|
} // DisplayFullEmRegField()
|
|
|
|
VOID
|
|
DisplayFullEmReg(
|
|
IN ULONG64 Val,
|
|
IN EM_REG_FIELD EmRegFields[],
|
|
IN DISPLAY_MODE DisplayMode
|
|
)
|
|
{
|
|
ULONG i, j;
|
|
|
|
i = j = 0;
|
|
if ( DisplayMode >= DISPLAY_MAX ) {
|
|
while( j < EM_REG_BITS ) {
|
|
DisplayFullEmRegField( Val, EmRegFields, i );
|
|
j += EmRegFields[i].Length;
|
|
i++;
|
|
}
|
|
}
|
|
else {
|
|
while( j < EM_REG_BITS ) {
|
|
if ( !strstr(EmRegFields[i].Name, "reserved" ) &&
|
|
!strstr(EmRegFields[i].Name, "ignored" ) ) {
|
|
DisplayFullEmRegField( Val, EmRegFields, i );
|
|
}
|
|
j += EmRegFields[i].Length;
|
|
i++;
|
|
}
|
|
}
|
|
dprintf("\n");
|
|
|
|
return;
|
|
|
|
} // DisplayFullEmReg()
|
|
|
|
|
|
#if 0
|
|
|
|
//
|
|
// ISR codes for General Exceptions: ISR{7:4}
|
|
//
|
|
|
|
#define ISR_ILLEGAL_OP 0 // Illegal operation fault
|
|
#define ISR_PRIV_OP 1 // Privileged operation fault
|
|
#define ISR_PRIV_REG 2 // Privileged register fault
|
|
#define ISR_RESVD_REG 3 // Reserved register/field fault
|
|
#define ISR_ILLEGAL_ISA 4 // Disabled instruction set transition fault
|
|
#define ISR_ILLEGAL_HAZARD 8 // Illegal hazard fault
|
|
|
|
//
|
|
// ISR codes for Nat Consumption Faults: ISR{7:4}
|
|
//
|
|
|
|
#define ISR_NAT_REG 1 // Nat Register Consumption fault
|
|
#define ISR_NAT_PAGE 2 // Nat Page Consumption fault
|
|
|
|
//
|
|
// For Traps ISR{4:0}
|
|
//
|
|
|
|
// FP trap
|
|
#define ISR_FP_TRAP 0
|
|
// Lower privilege transfer trap
|
|
#define ISR_LP_TRAP 1
|
|
// Taken branch trap
|
|
#define ISR_TB_TRAP 2
|
|
// Single step trap
|
|
#define ISR_SS_TRAP 3
|
|
// Unimplemented instruction address trap
|
|
#define ISR_UI_TRAP 4
|
|
|
|
ISR Settings for Non-Access Instructions
|
|
Instruction ISR fields
|
|
code{3:0} na r w
|
|
tpa 0 1 0 0
|
|
fc 1 1 1 0
|
|
probe 2 1 0 or 1 a 0 or 1 a
|
|
tak 3 1 0 0
|
|
lfetch, lfetch.fault 4 1 1 0
|
|
probe.fault 5 1 0 or 1 a 0 or 1 a
|
|
a. Sets r or w or both to 1 depending on the probe form.
|
|
|
|
#endif // 0
|
|
|
|
EM_REG_FIELD EmIsrFields[] = {
|
|
{ "code", "interruption Code" , 0x10, 0 }, // 0-15
|
|
{ "vector", "IA32 exception vector number" , 0x8, 16 }, // 16-23
|
|
{ "rv", "reserved0", 0x8, 24 }, // 24-31
|
|
{ "x", "eXecute exception", 0x1, 32 }, // 32
|
|
{ "w", "Write exception", 0x1, 33 }, // 33
|
|
{ "r", "Read exception", 0x1, 34 }, // 34
|
|
{ "na", "Non-Access exception", 0x1, 35 }, // 35
|
|
{ "sp", "Speculative load exception", 0x1, 36 }, // 36
|
|
{ "rs", "Register Stack", 0x1, 37 }, // 37
|
|
{ "ir", "Invalid Register frame", 0x1, 38 }, // 38
|
|
{ "ni", "Nested Interruption", 0x1, 39 }, // 39
|
|
{ "so", "IA32 Supervisor Override", 0x1, 40 }, // 40
|
|
{ "ei", "Exception IA64 Instruction", 0x2, 41 }, // 41-42
|
|
{ "ed", "Exception Deferral", 0x1, 43 }, // 43
|
|
{ "rv", "reserved1", 0x14, 44 } // 44-63
|
|
};
|
|
|
|
VOID
|
|
DisplayIsrIA64(
|
|
IN const PCHAR Header,
|
|
IN EM_ISR EmIsr,
|
|
IN DISPLAY_MODE DisplayMode
|
|
)
|
|
{
|
|
dprintf("%s", Header ? Header : "" );
|
|
if ( DisplayMode >= DISPLAY_MED ) {
|
|
DisplayFullEmReg( EM_ISRToULong64(EmIsr), EmIsrFields, DisplayMode );
|
|
}
|
|
else {
|
|
dprintf(
|
|
"ed ei so ni ir rs sp na r w x vector code\n\t\t "
|
|
"%1I64x %1I64x %1I64x %1I64x %1I64x %1I64x %1I64x %1I64x %1I64x %1I64x %1I64x %I64x %I64x\n",
|
|
EmIsr.ed,
|
|
EmIsr.ei,
|
|
EmIsr.so,
|
|
EmIsr.ni,
|
|
EmIsr.ir,
|
|
EmIsr.rs,
|
|
EmIsr.sp,
|
|
EmIsr.na,
|
|
EmIsr.r,
|
|
EmIsr.w,
|
|
EmIsr.x,
|
|
EmIsr.vector,
|
|
EmIsr.code
|
|
);
|
|
}
|
|
|
|
return;
|
|
|
|
} // DisplayIsrIA64()
|
|
|
|
|
|
DECLARE_API( isr )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
|
|
Arguments:
|
|
|
|
args -
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG64 isrValue;
|
|
ULONG result;
|
|
ULONG flags = 0;
|
|
char *header;
|
|
|
|
if (!GetExpressionEx(args,&isrValue, &args)) {
|
|
dprintf("USAGE: !isr 0xValue [display_mode:0,1,2]\n");
|
|
dprintf("USAGE: !isr @isr [display_mode:0,1,2]\n");
|
|
return E_INVALIDARG;
|
|
} else {
|
|
flags = (ULONG) GetExpression(args);
|
|
}
|
|
|
|
header = (flags > DISPLAY_MIN) ? NULL : "\tisr:\t";
|
|
|
|
if (TargetMachine != IMAGE_FILE_MACHINE_IA64)
|
|
{
|
|
dprintf("!isr not implemented for this architecture.\n");
|
|
}
|
|
else
|
|
{
|
|
DisplayIsrIA64( header, ULong64ToEM_ISR(isrValue), (DISPLAY_MODE) flags );
|
|
}
|
|
|
|
return S_OK;
|
|
|
|
} // !isr
|