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.
3028 lines
80 KiB
3028 lines
80 KiB
//----------------------------------------------------------------------------
|
|
//
|
|
// Extension DLL support.
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1997-2002.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "ntsdp.hpp"
|
|
#include <time.h>
|
|
|
|
/*
|
|
* _NT_DEBUG_OPTIONS support. Each option in g_EnvDbgOptionNames must have a
|
|
* corresponding OPTION_* define, in the same order.
|
|
*/
|
|
DWORD g_EnvDbgOptions;
|
|
char* g_EnvDbgOptionNames[OPTION_COUNT] =
|
|
{
|
|
"NOEXTWARNING",
|
|
"NOVERSIONCHECK",
|
|
};
|
|
|
|
EXTDLL *g_ExtDlls;
|
|
LPTSTR g_BaseExtensionSearchPath = NULL;
|
|
|
|
ULONG64 g_ExtThread;
|
|
|
|
ULONG g_ExtGetExpressionRemainderIndex;
|
|
BOOL g_ExtGetExpressionSuccess;
|
|
|
|
WOW64EXTSPROC g_Wow64exts;
|
|
EXTDLL* g_Wow64ExtDll;
|
|
|
|
WMI_FORMAT_TRACE_DATA g_WmiFormatTraceData;
|
|
EXTDLL* g_WmiExtDll;
|
|
|
|
DEBUG_SCOPE g_ExtThreadSavedScope;
|
|
BOOL g_ExtThreadScopeSaved;
|
|
|
|
//
|
|
// Functions prototyped specifically for compatibility with extension
|
|
// callback prototypes.
|
|
//
|
|
|
|
VOID WDBGAPIV
|
|
ExtOutput64(
|
|
PCSTR lpFormat,
|
|
...
|
|
);
|
|
|
|
VOID WDBGAPIV
|
|
ExtOutput32(
|
|
PCSTR lpFormat,
|
|
...
|
|
);
|
|
|
|
ULONG64
|
|
ExtGetExpression(
|
|
PCSTR CommandString
|
|
);
|
|
|
|
ULONG
|
|
ExtGetExpression32(
|
|
PCSTR CommandString
|
|
);
|
|
|
|
void
|
|
ExtGetSymbol(
|
|
ULONG64 Offset,
|
|
PCHAR Buffer,
|
|
PULONG64 Displacement
|
|
);
|
|
|
|
void
|
|
ExtGetSymbol32(
|
|
ULONG Offset,
|
|
PCHAR Buffer,
|
|
PULONG Displacement
|
|
);
|
|
|
|
DWORD
|
|
ExtDisasm(
|
|
PULONG64 lpOffset,
|
|
PCSTR lpBuffer,
|
|
ULONG fShowEA
|
|
);
|
|
|
|
DWORD
|
|
ExtDisasm32(
|
|
PULONG lpOffset,
|
|
PCSTR lpBuffer,
|
|
ULONG fShowEA
|
|
);
|
|
|
|
BOOL
|
|
ExtReadVirtualMemory(
|
|
IN ULONG64 Address,
|
|
OUT PUCHAR Buffer,
|
|
IN ULONG Length,
|
|
OUT PULONG BytesRead
|
|
);
|
|
|
|
BOOL
|
|
ExtReadVirtualMemory32(
|
|
IN ULONG Address,
|
|
OUT PUCHAR Buffer,
|
|
IN ULONG Length,
|
|
OUT PULONG BytesRead
|
|
);
|
|
|
|
ULONG
|
|
ExtWriteVirtualMemory(
|
|
IN ULONG64 Address,
|
|
IN LPCVOID Buffer,
|
|
IN ULONG Length,
|
|
OUT PULONG BytesWritten
|
|
);
|
|
|
|
ULONG
|
|
ExtWriteVirtualMemory32(
|
|
IN ULONG Address,
|
|
IN LPCVOID Buffer,
|
|
IN ULONG Length,
|
|
OUT PULONG BytesWritten
|
|
);
|
|
|
|
BOOL ExtGetThreadContext(DWORD Processor,
|
|
PVOID Context,
|
|
DWORD SizeOfContext);
|
|
BOOL ExtSetThreadContext(DWORD Processor,
|
|
PVOID Context,
|
|
DWORD SizeOfContext);
|
|
|
|
BOOL
|
|
ExtIoctl(
|
|
USHORT IoctlType,
|
|
LPVOID lpvData,
|
|
DWORD cbSize
|
|
);
|
|
|
|
BOOL
|
|
ExtIoctl32(
|
|
USHORT IoctlType,
|
|
LPVOID lpvData,
|
|
DWORD cbSize
|
|
);
|
|
|
|
DWORD
|
|
ExtCallStack(
|
|
DWORD64 FramePointer,
|
|
DWORD64 StackPointer,
|
|
DWORD64 ProgramCounter,
|
|
PEXTSTACKTRACE64 StackFrames,
|
|
DWORD Frames
|
|
);
|
|
|
|
DWORD
|
|
ExtCallStack32(
|
|
DWORD FramePointer,
|
|
DWORD StackPointer,
|
|
DWORD ProgramCounter,
|
|
PEXTSTACKTRACE32 StackFrames,
|
|
DWORD Frames
|
|
);
|
|
|
|
BOOL
|
|
ExtReadPhysicalMemory(
|
|
ULONGLONG Address,
|
|
PVOID Buffer,
|
|
ULONG Length,
|
|
PULONG BytesRead
|
|
);
|
|
|
|
BOOL
|
|
ExtWritePhysicalMemory(
|
|
ULONGLONG Address,
|
|
LPCVOID Buffer,
|
|
ULONG Length,
|
|
PULONG BytesWritten
|
|
);
|
|
|
|
WINDBG_EXTENSION_APIS64 g_WindbgExtensions64 =
|
|
{
|
|
sizeof(g_WindbgExtensions64),
|
|
ExtOutput64,
|
|
ExtGetExpression,
|
|
ExtGetSymbol,
|
|
ExtDisasm,
|
|
CheckUserInterrupt,
|
|
(PWINDBG_READ_PROCESS_MEMORY_ROUTINE64)ExtReadVirtualMemory,
|
|
ExtWriteVirtualMemory,
|
|
(PWINDBG_GET_THREAD_CONTEXT_ROUTINE)ExtGetThreadContext,
|
|
(PWINDBG_SET_THREAD_CONTEXT_ROUTINE)ExtSetThreadContext,
|
|
(PWINDBG_IOCTL_ROUTINE)ExtIoctl,
|
|
ExtCallStack
|
|
};
|
|
|
|
WINDBG_EXTENSION_APIS32 g_WindbgExtensions32 =
|
|
{
|
|
sizeof(g_WindbgExtensions32),
|
|
ExtOutput32,
|
|
ExtGetExpression32,
|
|
ExtGetSymbol32,
|
|
ExtDisasm32,
|
|
CheckUserInterrupt,
|
|
(PWINDBG_READ_PROCESS_MEMORY_ROUTINE32)ExtReadVirtualMemory32,
|
|
ExtWriteVirtualMemory32,
|
|
(PWINDBG_GET_THREAD_CONTEXT_ROUTINE)ExtGetThreadContext,
|
|
(PWINDBG_SET_THREAD_CONTEXT_ROUTINE)ExtSetThreadContext,
|
|
(PWINDBG_IOCTL_ROUTINE)ExtIoctl32,
|
|
ExtCallStack32
|
|
};
|
|
|
|
WINDBG_OLDKD_EXTENSION_APIS g_KdExtensions =
|
|
{
|
|
sizeof(g_KdExtensions),
|
|
ExtOutput32,
|
|
ExtGetExpression32,
|
|
ExtGetSymbol32,
|
|
ExtDisasm32,
|
|
CheckUserInterrupt,
|
|
(PWINDBG_READ_PROCESS_MEMORY_ROUTINE32)ExtReadVirtualMemory32,
|
|
ExtWriteVirtualMemory32,
|
|
(PWINDBG_OLDKD_READ_PHYSICAL_MEMORY)ExtReadPhysicalMemory,
|
|
(PWINDBG_OLDKD_WRITE_PHYSICAL_MEMORY)ExtWritePhysicalMemory
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Callback functions for extensions.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
VOID WDBGAPIV
|
|
ExtOutput64(
|
|
PCSTR lpFormat,
|
|
...
|
|
)
|
|
{
|
|
va_list Args;
|
|
va_start(Args, lpFormat);
|
|
MaskOutVa(DEBUG_OUTPUT_NORMAL, lpFormat, Args, TRUE);
|
|
va_end(Args);
|
|
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
}
|
|
|
|
VOID WDBGAPIV
|
|
ExtOutput32(
|
|
PCSTR lpFormat,
|
|
...
|
|
)
|
|
{
|
|
va_list Args;
|
|
va_start(Args, lpFormat);
|
|
MaskOutVa(DEBUG_OUTPUT_NORMAL, lpFormat, Args, FALSE);
|
|
va_end(Args);
|
|
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
}
|
|
|
|
ULONG64
|
|
ExtGetExpression(
|
|
PCSTR CommandString
|
|
)
|
|
{
|
|
g_ExtGetExpressionSuccess = FALSE;
|
|
|
|
if (CommandString == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
ULONG64 ReturnValue;
|
|
PSTR SaveCommand = g_CurCmd;
|
|
PSTR SaveStart = g_CommandStart;
|
|
|
|
if (IS_USER_TARGET(g_Target))
|
|
{
|
|
if ( strcmp(CommandString, "WOW_BIG_BDE_HACK") == 0 )
|
|
{
|
|
return( (ULONG_PTR)(&segtable[0]) );
|
|
}
|
|
|
|
//
|
|
// this is because the kdexts MUST include the address-of operator
|
|
// on all getexpression calls for windbg/c expression evaluators
|
|
//
|
|
if (*CommandString == '&')
|
|
{
|
|
CommandString++;
|
|
}
|
|
}
|
|
|
|
g_CurCmd = (PSTR)CommandString;
|
|
g_CommandStart = (PSTR)CommandString;
|
|
g_DisableErrorPrint++;
|
|
|
|
EvalExpression* RelChain = g_EvalReleaseChain;
|
|
g_EvalReleaseChain = NULL;
|
|
|
|
__try
|
|
{
|
|
// ntsd/windbg extensions always use the MASM-style
|
|
// expression evaluator for compatibility.
|
|
EvalExpression* Eval = GetEvaluator(DEBUG_EXPR_MASM, FALSE);
|
|
ReturnValue = Eval->EvalCurNum();
|
|
ReleaseEvaluator(Eval);
|
|
g_ExtGetExpressionSuccess = TRUE;
|
|
}
|
|
__except(CommandExceptionFilter(GetExceptionInformation()))
|
|
{
|
|
ReturnValue = 0;
|
|
}
|
|
g_ExtGetExpressionRemainderIndex =
|
|
(ULONG)(g_CurCmd - g_CommandStart);
|
|
g_EvalReleaseChain = RelChain;
|
|
g_DisableErrorPrint--;
|
|
g_CurCmd = SaveCommand;
|
|
g_CommandStart = SaveStart;
|
|
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
ULONG
|
|
ExtGetExpression32(
|
|
LPCSTR CommandString
|
|
)
|
|
{
|
|
return (ULONG)ExtGetExpression(CommandString);
|
|
}
|
|
|
|
void
|
|
ExtGetSymbol (
|
|
ULONG64 offset,
|
|
PCHAR pchBuffer,
|
|
PULONG64 pDisplacement
|
|
)
|
|
{
|
|
// No way to know how much space we're given, so
|
|
// just assume 256, which many extensions pass in
|
|
GetSymbol(offset, pchBuffer, 256, pDisplacement);
|
|
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
}
|
|
|
|
void
|
|
ExtGetSymbol32(
|
|
ULONG offset,
|
|
PCHAR pchBuffer,
|
|
PULONG pDisplacement
|
|
)
|
|
{
|
|
ULONG64 Displacement;
|
|
|
|
// No way to know how much space we're given, so
|
|
// just assume 256, which many extensions pass in
|
|
GetSymbol(EXTEND64(offset), pchBuffer, 256, &Displacement);
|
|
*pDisplacement = (ULONG)Displacement;
|
|
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
}
|
|
|
|
DWORD
|
|
ExtDisasm(
|
|
ULONG64 *lpOffset,
|
|
PCSTR lpBuffer,
|
|
ULONG fShowEA
|
|
)
|
|
{
|
|
if (!IS_CUR_MACHINE_ACCESSIBLE())
|
|
{
|
|
ErrOut("ExtDisasm called before debugger initialized\n");
|
|
return FALSE;
|
|
}
|
|
|
|
ADDR tempAddr;
|
|
BOOL ret;
|
|
|
|
Type(tempAddr) = ADDR_FLAT | FLAT_COMPUTED;
|
|
Off(tempAddr) = Flat(tempAddr) = *lpOffset;
|
|
ret = g_Machine->
|
|
Disassemble(g_Process, &tempAddr, (PSTR)lpBuffer, (BOOL) fShowEA);
|
|
*lpOffset = Flat(tempAddr);
|
|
return ret;
|
|
}
|
|
|
|
DWORD
|
|
ExtDisasm32(
|
|
ULONG *lpOffset,
|
|
PCSTR lpBuffer,
|
|
ULONG fShowEA
|
|
)
|
|
{
|
|
ULONG64 Offset = EXTEND64(*lpOffset);
|
|
DWORD rval = ExtDisasm(&Offset, lpBuffer, fShowEA);
|
|
*lpOffset = (ULONG)Offset;
|
|
return rval;
|
|
}
|
|
|
|
BOOL
|
|
ExtGetThreadContext(DWORD Processor,
|
|
PVOID Context,
|
|
DWORD SizeOfContext)
|
|
{
|
|
if (!IS_CUR_MACHINE_ACCESSIBLE())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// This get may be getting the context of the thread
|
|
// currently cached by the register code. Make sure
|
|
// the cache is flushed.
|
|
g_Target->FlushRegContext();
|
|
|
|
CROSS_PLATFORM_CONTEXT TargetContext;
|
|
|
|
g_Target->m_Machine->
|
|
InitializeContextFlags(&TargetContext, g_Target->m_SystemVersion);
|
|
if (g_Target->GetContext(IS_KERNEL_TARGET(g_Target) ?
|
|
VIRTUAL_THREAD_HANDLE(Processor) : Processor,
|
|
&TargetContext) == S_OK &&
|
|
g_Machine->ConvertContextTo(&TargetContext, g_Target->m_SystemVersion,
|
|
SizeOfContext, Context) == S_OK)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
ExtSetThreadContext(DWORD Processor,
|
|
PVOID Context,
|
|
DWORD SizeOfContext)
|
|
{
|
|
if (!IS_CUR_MACHINE_ACCESSIBLE())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL Status;
|
|
|
|
// This set may be setting the context of the thread
|
|
// currently cached by the register code. Make sure
|
|
// the cache is invalidated.
|
|
g_Target->ChangeRegContext(NULL);
|
|
|
|
CROSS_PLATFORM_CONTEXT TargetContext;
|
|
if (g_Machine->
|
|
ConvertContextFrom(&TargetContext, g_Target->m_SystemVersion,
|
|
SizeOfContext, Context) == S_OK &&
|
|
g_Target->SetContext(IS_KERNEL_TARGET(g_Target) ?
|
|
VIRTUAL_THREAD_HANDLE(Processor) : Processor,
|
|
&TargetContext) == S_OK)
|
|
{
|
|
Status = TRUE;
|
|
}
|
|
else
|
|
{
|
|
Status = FALSE;
|
|
}
|
|
|
|
// Reset the current thread.
|
|
g_Target->ChangeRegContext(g_Thread);
|
|
|
|
return Status;
|
|
}
|
|
|
|
BOOL
|
|
ExtReadVirtualMemory(
|
|
IN ULONG64 pBufSrc,
|
|
OUT PUCHAR pBufDest,
|
|
IN ULONG count,
|
|
OUT PULONG pcTotalBytesRead
|
|
)
|
|
{
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
|
|
ULONG BytesTemp;
|
|
return g_Target->
|
|
ReadVirtual(g_Process,
|
|
pBufSrc, pBufDest, count, pcTotalBytesRead != NULL ?
|
|
pcTotalBytesRead : &BytesTemp) == S_OK;
|
|
}
|
|
|
|
BOOL
|
|
ExtReadVirtualMemory32(
|
|
IN ULONG pBufSrc,
|
|
OUT PUCHAR pBufDest,
|
|
IN ULONG count,
|
|
OUT PULONG pcTotalBytesRead
|
|
)
|
|
{
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
|
|
ULONG BytesTemp;
|
|
return g_Target->
|
|
ReadVirtual(g_Process, EXTEND64(pBufSrc), pBufDest, count,
|
|
pcTotalBytesRead != NULL ?
|
|
pcTotalBytesRead : &BytesTemp) == S_OK;
|
|
}
|
|
|
|
DWORD
|
|
ExtWriteVirtualMemory(
|
|
IN ULONG64 addr,
|
|
IN LPCVOID buffer,
|
|
IN ULONG count,
|
|
OUT PULONG pcBytesWritten
|
|
)
|
|
{
|
|
ULONG BytesTemp;
|
|
|
|
return (g_Target->WriteVirtual(g_Process, addr, (PVOID)buffer, count,
|
|
pcBytesWritten != NULL ?
|
|
pcBytesWritten : &BytesTemp) == S_OK);
|
|
}
|
|
|
|
ULONG
|
|
ExtWriteVirtualMemory32 (
|
|
IN ULONG addr,
|
|
IN LPCVOID buffer,
|
|
IN ULONG count,
|
|
OUT PULONG pcBytesWritten
|
|
)
|
|
{
|
|
ULONG BytesTemp;
|
|
return (g_Target->WriteVirtual(g_Process, EXTEND64(addr),
|
|
(PVOID)buffer, count,
|
|
pcBytesWritten != NULL ?
|
|
pcBytesWritten : &BytesTemp) == S_OK);
|
|
}
|
|
|
|
BOOL
|
|
ExtReadPhysicalMemory(
|
|
ULONGLONG pBufSrc,
|
|
PVOID pBufDest,
|
|
ULONG count,
|
|
PULONG TotalBytesRead
|
|
)
|
|
{
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
|
|
if (ARGUMENT_PRESENT(TotalBytesRead))
|
|
{
|
|
*TotalBytesRead = 0;
|
|
}
|
|
|
|
ULONG BytesTemp;
|
|
return g_Target->ReadPhysical(pBufSrc, pBufDest, count,
|
|
PHYS_FLAG_DEFAULT,
|
|
TotalBytesRead != NULL ?
|
|
TotalBytesRead : &BytesTemp) == S_OK;
|
|
}
|
|
|
|
BOOL
|
|
ExtWritePhysicalMemory (
|
|
ULONGLONG pBufDest,
|
|
LPCVOID pBufSrc,
|
|
ULONG count,
|
|
PULONG TotalBytesWritten
|
|
)
|
|
{
|
|
if (ARGUMENT_PRESENT(TotalBytesWritten))
|
|
{
|
|
*TotalBytesWritten = 0;
|
|
}
|
|
|
|
ULONG BytesTemp;
|
|
return g_Target->WritePhysical(pBufDest, (PVOID)pBufSrc, count,
|
|
PHYS_FLAG_DEFAULT,
|
|
TotalBytesWritten != NULL ?
|
|
TotalBytesWritten : &BytesTemp) == S_OK;
|
|
}
|
|
|
|
BOOL
|
|
ExtReadPhysicalMemoryWithFlags(
|
|
ULONGLONG pBufSrc,
|
|
PVOID pBufDest,
|
|
ULONG count,
|
|
ULONG Flags,
|
|
PULONG TotalBytesRead
|
|
)
|
|
{
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
|
|
if (ARGUMENT_PRESENT(TotalBytesRead))
|
|
{
|
|
*TotalBytesRead = 0;
|
|
}
|
|
|
|
ULONG BytesTemp;
|
|
return g_Target->ReadPhysical(pBufSrc, pBufDest, count, Flags,
|
|
TotalBytesRead != NULL ?
|
|
TotalBytesRead : &BytesTemp) == S_OK;
|
|
}
|
|
|
|
BOOL
|
|
ExtWritePhysicalMemoryWithFlags(
|
|
ULONGLONG pBufDest,
|
|
LPCVOID pBufSrc,
|
|
ULONG count,
|
|
ULONG Flags,
|
|
PULONG TotalBytesWritten
|
|
)
|
|
{
|
|
if (ARGUMENT_PRESENT(TotalBytesWritten))
|
|
{
|
|
*TotalBytesWritten = 0;
|
|
}
|
|
|
|
ULONG BytesTemp;
|
|
return g_Target->WritePhysical(pBufDest, (PVOID)pBufSrc, count, Flags,
|
|
TotalBytesWritten != NULL ?
|
|
TotalBytesWritten : &BytesTemp) == S_OK;
|
|
}
|
|
|
|
DWORD
|
|
ExtCallStack(
|
|
DWORD64 FramePointer,
|
|
DWORD64 StackPointer,
|
|
DWORD64 ProgramCounter,
|
|
PEXTSTACKTRACE64 ExtStackFrames,
|
|
DWORD Frames
|
|
)
|
|
{
|
|
PDEBUG_STACK_FRAME StackFrames;
|
|
DWORD FrameCount;
|
|
DWORD i;
|
|
|
|
StackFrames = (PDEBUG_STACK_FRAME)
|
|
malloc( sizeof(StackFrames[0]) * Frames );
|
|
if (!StackFrames)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
ULONG PtrDef =
|
|
(!ProgramCounter ? STACK_INSTR_DEFAULT : 0) |
|
|
(!StackPointer ? STACK_STACK_DEFAULT : 0) |
|
|
(!FramePointer ? STACK_FRAME_DEFAULT : 0);
|
|
|
|
FrameCount = StackTrace( NULL,
|
|
FramePointer, StackPointer, ProgramCounter,
|
|
PtrDef, StackFrames, Frames,
|
|
g_ExtThread, 0, FALSE );
|
|
|
|
for (i = 0; i < FrameCount; i++)
|
|
{
|
|
ExtStackFrames[i].FramePointer = StackFrames[i].FrameOffset;
|
|
ExtStackFrames[i].ProgramCounter = StackFrames[i].InstructionOffset;
|
|
ExtStackFrames[i].ReturnAddress = StackFrames[i].ReturnOffset;
|
|
ExtStackFrames[i].Args[0] = StackFrames[i].Params[0];
|
|
ExtStackFrames[i].Args[1] = StackFrames[i].Params[1];
|
|
ExtStackFrames[i].Args[2] = StackFrames[i].Params[2];
|
|
ExtStackFrames[i].Args[3] = StackFrames[i].Params[3];
|
|
}
|
|
|
|
free( StackFrames );
|
|
|
|
if (g_ExtThreadScopeSaved)
|
|
{
|
|
PopScope(&g_ExtThreadSavedScope);
|
|
g_ExtThreadScopeSaved = FALSE;
|
|
}
|
|
|
|
g_ExtThread = 0;
|
|
|
|
return FrameCount;
|
|
}
|
|
|
|
DWORD
|
|
ExtCallStack32(
|
|
DWORD FramePointer,
|
|
DWORD StackPointer,
|
|
DWORD ProgramCounter,
|
|
PEXTSTACKTRACE32 ExtStackFrames,
|
|
DWORD Frames
|
|
)
|
|
{
|
|
PDEBUG_STACK_FRAME StackFrames;
|
|
DWORD FrameCount;
|
|
DWORD i;
|
|
|
|
StackFrames = (PDEBUG_STACK_FRAME)
|
|
malloc( sizeof(StackFrames[0]) * Frames );
|
|
if (!StackFrames)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
ULONG PtrDef =
|
|
(!ProgramCounter ? STACK_INSTR_DEFAULT : 0) |
|
|
(!StackPointer ? STACK_STACK_DEFAULT : 0) |
|
|
(!FramePointer ? STACK_FRAME_DEFAULT : 0);
|
|
|
|
FrameCount = StackTrace(NULL,
|
|
EXTEND64(FramePointer),
|
|
EXTEND64(StackPointer),
|
|
EXTEND64(ProgramCounter),
|
|
PtrDef,
|
|
StackFrames,
|
|
Frames,
|
|
g_ExtThread,
|
|
0,
|
|
FALSE);
|
|
|
|
for (i=0; i<FrameCount; i++)
|
|
{
|
|
ExtStackFrames[i].FramePointer = (ULONG)StackFrames[i].FrameOffset;
|
|
ExtStackFrames[i].ProgramCounter = (ULONG)StackFrames[i].InstructionOffset;
|
|
ExtStackFrames[i].ReturnAddress = (ULONG)StackFrames[i].ReturnOffset;
|
|
ExtStackFrames[i].Args[0] = (ULONG)StackFrames[i].Params[0];
|
|
ExtStackFrames[i].Args[1] = (ULONG)StackFrames[i].Params[1];
|
|
ExtStackFrames[i].Args[2] = (ULONG)StackFrames[i].Params[2];
|
|
ExtStackFrames[i].Args[3] = (ULONG)StackFrames[i].Params[3];
|
|
}
|
|
|
|
free( StackFrames );
|
|
if (g_ExtThreadScopeSaved)
|
|
{
|
|
PopScope(&g_ExtThreadSavedScope);
|
|
g_ExtThreadScopeSaved = FALSE;
|
|
}
|
|
|
|
g_ExtThread = 0;
|
|
|
|
return FrameCount;
|
|
}
|
|
|
|
BOOL
|
|
ExtIoctl(
|
|
USHORT IoctlType,
|
|
LPVOID lpvData,
|
|
DWORD cbSize
|
|
)
|
|
{
|
|
HRESULT Status;
|
|
BOOL Bool;
|
|
DWORD cb = 0;
|
|
PPHYSICAL phy;
|
|
PPHYSICAL_WITH_FLAGS phyf;
|
|
PIOSPACE64 is;
|
|
PIOSPACE_EX64 isex;
|
|
PBUSDATA busdata;
|
|
PREAD_WRITE_MSR msr;
|
|
PREADCONTROLSPACE64 prc;
|
|
PPROCESSORINFO pi;
|
|
PSEARCHMEMORY psr;
|
|
PSYM_DUMP_PARAM pSym;
|
|
PGET_CURRENT_THREAD_ADDRESS pct;
|
|
PGET_CURRENT_PROCESS_ADDRESS pcp;
|
|
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
|
|
if (!g_Target)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
switch( IoctlType )
|
|
{
|
|
case IG_KD_CONTEXT:
|
|
if (!g_Target)
|
|
{
|
|
return FALSE;
|
|
}
|
|
pi = (PPROCESSORINFO) lpvData;
|
|
pi->Processor = (USHORT)CURRENT_PROC;
|
|
pi->NumberProcessors = (USHORT) g_Target->m_NumProcessors;
|
|
return TRUE;
|
|
|
|
case IG_READ_CONTROL_SPACE:
|
|
// KSPECIAL_REGISTER content is kept in control space
|
|
// so accessing control space may touch data that's
|
|
// cached in the current machine KSPECIAL_REGISTERS.
|
|
// Flush the current machine to maintain consistency.
|
|
if (IS_CUR_MACHINE_ACCESSIBLE())
|
|
{
|
|
g_Target->FlushRegContext();
|
|
}
|
|
|
|
prc = (PREADCONTROLSPACE64)lpvData;
|
|
Status = g_Target->ReadControl( prc->Processor,
|
|
prc->Address,
|
|
prc->Buf,
|
|
prc->BufLen,
|
|
&cb
|
|
);
|
|
prc->BufLen = cb;
|
|
return Status == S_OK;
|
|
|
|
case IG_WRITE_CONTROL_SPACE:
|
|
// KSPECIAL_REGISTER content is kept in control space
|
|
// so accessing control space may touch data that's
|
|
// cached in the current machine KSPECIAL_REGISTERS.
|
|
// Flush the current machine to maintain consistency.
|
|
if (IS_CUR_MACHINE_ACCESSIBLE())
|
|
{
|
|
g_Target->FlushRegContext();
|
|
}
|
|
|
|
prc = (PREADCONTROLSPACE64)lpvData;
|
|
Status = g_Target->WriteControl( prc->Processor,
|
|
prc->Address,
|
|
prc->Buf,
|
|
prc->BufLen,
|
|
&cb
|
|
);
|
|
prc->BufLen = cb;
|
|
return Status == S_OK;
|
|
|
|
case IG_READ_IO_SPACE:
|
|
is = (PIOSPACE64)lpvData;
|
|
Status = g_Target->ReadIo( Isa, 0, 1, is->Address, &is->Data,
|
|
is->Length, &cb );
|
|
return Status == S_OK;
|
|
|
|
case IG_WRITE_IO_SPACE:
|
|
is = (PIOSPACE64)lpvData;
|
|
Status = g_Target->WriteIo( Isa, 0, 1, is->Address, &is->Data,
|
|
is->Length, &cb );
|
|
return Status == S_OK;
|
|
|
|
case IG_READ_IO_SPACE_EX:
|
|
isex = (PIOSPACE_EX64)lpvData;
|
|
Status = g_Target->ReadIo( isex->InterfaceType,
|
|
isex->BusNumber,
|
|
isex->AddressSpace,
|
|
isex->Address,
|
|
&isex->Data,
|
|
isex->Length,
|
|
&cb
|
|
);
|
|
return Status == S_OK;
|
|
|
|
case IG_WRITE_IO_SPACE_EX:
|
|
isex = (PIOSPACE_EX64)lpvData;
|
|
Status = g_Target->WriteIo( isex->InterfaceType,
|
|
isex->BusNumber,
|
|
isex->AddressSpace,
|
|
isex->Address,
|
|
&isex->Data,
|
|
isex->Length,
|
|
&cb
|
|
);
|
|
return Status == S_OK;
|
|
|
|
case IG_READ_PHYSICAL:
|
|
phy = (PPHYSICAL)lpvData;
|
|
Bool =
|
|
ExtReadPhysicalMemory( phy->Address, phy->Buf, phy->BufLen, &cb );
|
|
phy->BufLen = cb;
|
|
return Bool;
|
|
|
|
case IG_WRITE_PHYSICAL:
|
|
phy = (PPHYSICAL)lpvData;
|
|
Bool =
|
|
ExtWritePhysicalMemory( phy->Address, phy->Buf, phy->BufLen, &cb );
|
|
phy->BufLen = cb;
|
|
return Bool;
|
|
|
|
case IG_READ_PHYSICAL_WITH_FLAGS:
|
|
phyf = (PPHYSICAL_WITH_FLAGS)lpvData;
|
|
Bool =
|
|
ExtReadPhysicalMemoryWithFlags( phyf->Address, phyf->Buf,
|
|
phyf->BufLen, phyf->Flags,
|
|
&cb );
|
|
phyf->BufLen = cb;
|
|
return Bool;
|
|
|
|
case IG_WRITE_PHYSICAL_WITH_FLAGS:
|
|
phyf = (PPHYSICAL_WITH_FLAGS)lpvData;
|
|
Bool =
|
|
ExtWritePhysicalMemoryWithFlags( phyf->Address, phyf->Buf,
|
|
phyf->BufLen, phyf->Flags,
|
|
&cb );
|
|
phyf->BufLen = cb;
|
|
return Bool;
|
|
|
|
case IG_LOWMEM_CHECK:
|
|
Status = g_Target->CheckLowMemory();
|
|
return Status == S_OK;
|
|
|
|
case IG_SEARCH_MEMORY:
|
|
psr = (PSEARCHMEMORY)lpvData;
|
|
Status = g_Target->SearchVirtual(g_Process,
|
|
psr->SearchAddress,
|
|
psr->SearchLength,
|
|
psr->Pattern,
|
|
psr->PatternLength,
|
|
1,
|
|
&psr->FoundAddress);
|
|
return Status == S_OK;
|
|
|
|
case IG_SET_THREAD:
|
|
Bool = FALSE;
|
|
if (IS_KERNEL_TARGET(g_Target))
|
|
{
|
|
// Turn off engine notifications since this setthread is temporary
|
|
g_EngNotify++;
|
|
PushScope(&g_ExtThreadSavedScope);
|
|
g_ExtThread = *(PULONG64)lpvData;
|
|
Bool = SetScopeContextFromThreadData(g_ExtThread, FALSE) == S_OK;
|
|
g_ExtThreadScopeSaved = TRUE;
|
|
g_EngNotify--;
|
|
}
|
|
return Bool;
|
|
|
|
case IG_READ_MSR:
|
|
msr = (PREAD_WRITE_MSR)lpvData;
|
|
Status = g_Target->ReadMsr(msr->Msr, (PULONG64)&msr->Value);
|
|
return Status == S_OK;
|
|
|
|
case IG_WRITE_MSR:
|
|
msr = (PREAD_WRITE_MSR)lpvData;
|
|
Status = g_Target->WriteMsr(msr->Msr, msr->Value);
|
|
return Status == S_OK;
|
|
|
|
case IG_GET_KERNEL_VERSION:
|
|
if (!g_Target)
|
|
{
|
|
return FALSE;
|
|
}
|
|
*((PDBGKD_GET_VERSION64)lpvData) = g_Target->m_KdVersion;
|
|
return TRUE;
|
|
|
|
case IG_GET_BUS_DATA:
|
|
busdata = (PBUSDATA)lpvData;
|
|
Status = g_Target->ReadBusData( busdata->BusDataType,
|
|
busdata->BusNumber,
|
|
busdata->SlotNumber,
|
|
busdata->Offset,
|
|
busdata->Buffer,
|
|
busdata->Length,
|
|
&cb
|
|
);
|
|
busdata->Length = cb;
|
|
return Status == S_OK;
|
|
|
|
case IG_SET_BUS_DATA:
|
|
busdata = (PBUSDATA)lpvData;
|
|
Status = g_Target->WriteBusData( busdata->BusDataType,
|
|
busdata->BusNumber,
|
|
busdata->SlotNumber,
|
|
busdata->Offset,
|
|
busdata->Buffer,
|
|
busdata->Length,
|
|
&cb
|
|
);
|
|
busdata->Length = cb;
|
|
return Status == S_OK;
|
|
|
|
case IG_GET_CURRENT_THREAD:
|
|
if (!g_Target)
|
|
{
|
|
return FALSE;
|
|
}
|
|
pct = (PGET_CURRENT_THREAD_ADDRESS) lpvData;
|
|
return g_Target->
|
|
GetThreadInfoDataOffset(NULL,
|
|
VIRTUAL_THREAD_HANDLE(pct->Processor),
|
|
&pct->Address) == S_OK;
|
|
|
|
case IG_GET_CURRENT_PROCESS:
|
|
if (!g_Target)
|
|
{
|
|
return FALSE;
|
|
}
|
|
pcp = (PGET_CURRENT_PROCESS_ADDRESS) lpvData;
|
|
return g_Target->
|
|
GetProcessInfoDataOffset(NULL,
|
|
pcp->Processor,
|
|
pcp->CurrentThread,
|
|
&pcp->Address) == S_OK;
|
|
|
|
case IG_GET_DEBUGGER_DATA:
|
|
if (!IS_KERNEL_TARGET(g_Target) ||
|
|
!g_Target ||
|
|
((PDBGKD_DEBUG_DATA_HEADER64)lpvData)->OwnerTag != KDBG_TAG)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Don't refresh if asking for the kernel header.
|
|
|
|
memcpy(lpvData, &g_Target->m_KdDebuggerData,
|
|
min(sizeof(g_Target->m_KdDebuggerData), cbSize));
|
|
return TRUE;
|
|
|
|
case IG_RELOAD_SYMBOLS:
|
|
PCSTR ArgsRet;
|
|
return g_Target->Reload(g_Thread, (PCHAR)lpvData, &ArgsRet) == S_OK;
|
|
|
|
case IG_GET_SET_SYMPATH:
|
|
PGET_SET_SYMPATH pgs;
|
|
pgs = (PGET_SET_SYMPATH)lpvData;
|
|
ChangeSymPath((PCHAR)pgs->Args, FALSE, (PCHAR)pgs->Result,
|
|
pgs->Length);
|
|
return TRUE;
|
|
|
|
case IG_IS_PTR64:
|
|
if (!g_Target)
|
|
{
|
|
return FALSE;
|
|
}
|
|
*((PBOOL)lpvData) = g_Target->m_Machine->m_Ptr64;
|
|
return TRUE;
|
|
|
|
case IG_DUMP_SYMBOL_INFO:
|
|
if (!g_Process)
|
|
{
|
|
return FALSE;
|
|
}
|
|
pSym = (PSYM_DUMP_PARAM) lpvData;
|
|
SymbolTypeDump(g_Process->m_SymHandle,
|
|
g_Process->m_ImageHead,
|
|
pSym, (PULONG)&Status);
|
|
return (BOOL)(ULONG)Status;
|
|
|
|
case IG_GET_TYPE_SIZE:
|
|
if (!g_Process)
|
|
{
|
|
return FALSE;
|
|
}
|
|
pSym = (PSYM_DUMP_PARAM) lpvData;
|
|
return SymbolTypeDump(g_Process->m_SymHandle,
|
|
g_Process->m_ImageHead,
|
|
pSym, (PULONG)&Status);
|
|
|
|
case IG_GET_TEB_ADDRESS:
|
|
if (!g_Target)
|
|
{
|
|
return FALSE;
|
|
}
|
|
PGET_TEB_ADDRESS pTeb;
|
|
pTeb = (PGET_TEB_ADDRESS) lpvData;
|
|
return g_Target->
|
|
GetThreadInfoTeb(g_Thread,
|
|
CURRENT_PROC,
|
|
0,
|
|
&pTeb->Address) == S_OK;
|
|
|
|
case IG_GET_PEB_ADDRESS:
|
|
if (!g_Target)
|
|
{
|
|
return FALSE;
|
|
}
|
|
PGET_PEB_ADDRESS pPeb;
|
|
pPeb = (PGET_PEB_ADDRESS) lpvData;
|
|
return g_Target->
|
|
GetProcessInfoPeb(g_Thread,
|
|
CURRENT_PROC,
|
|
pPeb->CurrentThread,
|
|
&pPeb->Address) == S_OK;
|
|
|
|
case IG_GET_CURRENT_PROCESS_HANDLE:
|
|
if (!g_Process)
|
|
{
|
|
return FALSE;
|
|
}
|
|
*(PHANDLE)lpvData = OS_HANDLE(g_Process->m_SysHandle);
|
|
return TRUE;
|
|
|
|
case IG_GET_INPUT_LINE:
|
|
PGET_INPUT_LINE Gil;
|
|
Gil = (PGET_INPUT_LINE)lpvData;
|
|
Gil->InputSize = GetInput(Gil->Prompt, Gil->Buffer, Gil->BufferSize,
|
|
GETIN_LOG_INPUT_LINE);
|
|
return TRUE;
|
|
|
|
case IG_GET_EXPRESSION_EX:
|
|
PGET_EXPRESSION_EX Gee;
|
|
Gee = (PGET_EXPRESSION_EX)lpvData;
|
|
Gee->Value = ExtGetExpression(Gee->Expression);
|
|
Gee->Remainder = Gee->Expression + g_ExtGetExpressionRemainderIndex;
|
|
return g_ExtGetExpressionSuccess;
|
|
|
|
case IG_TRANSLATE_VIRTUAL_TO_PHYSICAL:
|
|
if (!IS_CUR_MACHINE_ACCESSIBLE())
|
|
{
|
|
return FALSE;
|
|
}
|
|
PTRANSLATE_VIRTUAL_TO_PHYSICAL Tvtp;
|
|
Tvtp = (PTRANSLATE_VIRTUAL_TO_PHYSICAL)lpvData;
|
|
ULONG Levels, PfIndex;
|
|
return g_Machine->
|
|
GetVirtualTranslationPhysicalOffsets(g_Thread,
|
|
Tvtp->Virtual, NULL, 0,
|
|
&Levels, &PfIndex,
|
|
&Tvtp->Physical) == S_OK;
|
|
|
|
case IG_GET_CACHE_SIZE:
|
|
if (!g_Process)
|
|
{
|
|
return FALSE;
|
|
}
|
|
PULONG64 pCacheSize;
|
|
|
|
pCacheSize = (PULONG64)lpvData;
|
|
if (IS_KERNEL_TARGET(g_Target))
|
|
{
|
|
*pCacheSize = g_Process->m_VirtualCache.m_MaxSize;
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
|
|
case IG_POINTER_SEARCH_PHYSICAL:
|
|
if (!IS_CUR_MACHINE_ACCESSIBLE())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
PPOINTER_SEARCH_PHYSICAL Psp;
|
|
Psp = (PPOINTER_SEARCH_PHYSICAL)lpvData;
|
|
return g_Target->PointerSearchPhysical(Psp->Offset,
|
|
Psp->Length,
|
|
Psp->PointerMin,
|
|
Psp->PointerMax,
|
|
Psp->Flags,
|
|
Psp->MatchOffsets,
|
|
Psp->MatchOffsetsSize,
|
|
&Psp->MatchOffsetsCount) ==
|
|
S_OK;
|
|
|
|
case IG_GET_COR_DATA_ACCESS:
|
|
if (cbSize != sizeof(void*) ||
|
|
!g_Process ||
|
|
g_Process->LoadCorDebugDll() != S_OK)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
*(ICorDataAccess**)lpvData = g_Process->m_CorAccess;
|
|
return TRUE;
|
|
|
|
default:
|
|
ErrOut( "\n*** Bad IOCTL request from an extension [%d]\n\n",
|
|
IoctlType );
|
|
return FALSE;
|
|
}
|
|
|
|
// NOTREACHED.
|
|
DBG_ASSERT(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
ExtIoctl32(
|
|
USHORT IoctlType,
|
|
LPVOID lpvData,
|
|
DWORD cbSize
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the extension Ioctl routine for backward compatibility with
|
|
old extension dlls. This routine is frozen, and new ioctl support
|
|
should not be added to it.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
HRESULT Status;
|
|
DWORD cb = 0;
|
|
PIOSPACE32 is;
|
|
PIOSPACE_EX32 isex;
|
|
PREADCONTROLSPACE prc;
|
|
PDBGKD_GET_VERSION32 pv32;
|
|
PKDDEBUGGER_DATA32 pdbg32;
|
|
|
|
// Make sure output for long-running extensions appears regularly.
|
|
TimedFlushCallbacks();
|
|
|
|
switch( IoctlType )
|
|
{
|
|
case IG_READ_CONTROL_SPACE:
|
|
// KSPECIAL_REGISTER content is kept in control space
|
|
// so accessing control space may touch data that's
|
|
// cached in the current machine KSPECIAL_REGISTERS.
|
|
// Flush the current machine to maintain consistency.
|
|
if (IS_CUR_MACHINE_ACCESSIBLE())
|
|
{
|
|
g_Target->FlushRegContext();
|
|
}
|
|
|
|
prc = (PREADCONTROLSPACE)lpvData;
|
|
Status = g_Target->ReadControl( prc->Processor,
|
|
prc->Address,
|
|
prc->Buf,
|
|
prc->BufLen,
|
|
&cb
|
|
);
|
|
prc->BufLen = cb;
|
|
return Status == S_OK;
|
|
|
|
case IG_WRITE_CONTROL_SPACE:
|
|
// KSPECIAL_REGISTER content is kept in control space
|
|
// so accessing control space may touch data that's
|
|
// cached in the current machine KSPECIAL_REGISTERS.
|
|
// Flush the current machine to maintain consistency.
|
|
if (IS_CUR_MACHINE_ACCESSIBLE())
|
|
{
|
|
g_Target->FlushRegContext();
|
|
}
|
|
|
|
prc = (PREADCONTROLSPACE)lpvData;
|
|
Status = g_Target->WriteControl( prc->Processor,
|
|
prc->Address,
|
|
prc->Buf,
|
|
prc->BufLen,
|
|
&cb
|
|
);
|
|
prc->BufLen = cb;
|
|
return Status == S_OK;
|
|
|
|
case IG_READ_IO_SPACE:
|
|
is = (PIOSPACE32)lpvData;
|
|
Status = g_Target->ReadIo( Isa, 0, 1, is->Address, &is->Data,
|
|
is->Length, &cb );
|
|
return Status == S_OK;
|
|
|
|
case IG_WRITE_IO_SPACE:
|
|
is = (PIOSPACE32)lpvData;
|
|
Status = g_Target->WriteIo( Isa, 0, 1, is->Address, &is->Data,
|
|
is->Length, &cb );
|
|
return Status == S_OK;
|
|
|
|
case IG_READ_IO_SPACE_EX:
|
|
isex = (PIOSPACE_EX32)lpvData;
|
|
Status = g_Target->ReadIo( isex->InterfaceType,
|
|
isex->BusNumber,
|
|
isex->AddressSpace,
|
|
isex->Address,
|
|
&isex->Data,
|
|
isex->Length,
|
|
&cb
|
|
);
|
|
return Status == S_OK;
|
|
|
|
case IG_WRITE_IO_SPACE_EX:
|
|
isex = (PIOSPACE_EX32)lpvData;
|
|
Status = g_Target->WriteIo( isex->InterfaceType,
|
|
isex->BusNumber,
|
|
isex->AddressSpace,
|
|
isex->Address,
|
|
&isex->Data,
|
|
isex->Length,
|
|
&cb
|
|
);
|
|
return Status == S_OK;
|
|
|
|
case IG_SET_THREAD:
|
|
if (IS_KERNEL_TARGET(g_Target))
|
|
{
|
|
g_EngNotify++; // Turn off engine notifications since this setthread is temporary
|
|
g_ExtThread = EXTEND64(*(PULONG)lpvData);
|
|
PushScope(&g_ExtThreadSavedScope);
|
|
SetScopeContextFromThreadData(g_ExtThread, FALSE);
|
|
g_ExtThreadScopeSaved = TRUE;
|
|
g_EngNotify--;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
case IG_GET_KERNEL_VERSION:
|
|
if (!g_Target)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Convert to 32 bit
|
|
//
|
|
|
|
pv32 = (PDBGKD_GET_VERSION32)lpvData;
|
|
|
|
pv32->MajorVersion = g_Target->m_KdVersion.MajorVersion;
|
|
pv32->MinorVersion = g_Target->m_KdVersion.MinorVersion;
|
|
pv32->ProtocolVersion = g_Target->m_KdVersion.ProtocolVersion;
|
|
pv32->Flags = g_Target->m_KdVersion.Flags;
|
|
|
|
pv32->KernBase =
|
|
(ULONG)g_Target->m_KdVersion.KernBase;
|
|
pv32->PsLoadedModuleList =
|
|
(ULONG)g_Target->m_KdVersion.PsLoadedModuleList;
|
|
pv32->MachineType =
|
|
g_Target->m_KdVersion.MachineType;
|
|
pv32->DebuggerDataList =
|
|
(ULONG)g_Target->m_KdVersion.DebuggerDataList;
|
|
|
|
pv32->ThCallbackStack = g_Target->m_KdDebuggerData.ThCallbackStack;
|
|
pv32->NextCallback = g_Target->m_KdDebuggerData.NextCallback;
|
|
pv32->FramePointer = g_Target->m_KdDebuggerData.FramePointer;
|
|
|
|
pv32->KiCallUserMode =
|
|
(ULONG)g_Target->m_KdDebuggerData.KiCallUserMode;
|
|
pv32->KeUserCallbackDispatcher =
|
|
(ULONG)g_Target->m_KdDebuggerData.KeUserCallbackDispatcher;
|
|
pv32->BreakpointWithStatus =
|
|
(ULONG)g_Target->m_KdDebuggerData.BreakpointWithStatus;
|
|
return TRUE;
|
|
|
|
case IG_GET_DEBUGGER_DATA:
|
|
if (!IS_KERNEL_TARGET(g_Target) ||
|
|
!g_Target ||
|
|
((PDBGKD_DEBUG_DATA_HEADER32)lpvData)->OwnerTag != KDBG_TAG)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Don't refresh if asking for the kernel header.
|
|
|
|
pdbg32 = (PKDDEBUGGER_DATA32)lpvData;
|
|
|
|
pdbg32->Header.List.Flink =
|
|
(ULONG)g_Target->m_KdDebuggerData.Header.List.Flink;
|
|
pdbg32->Header.List.Blink =
|
|
(ULONG)g_Target->m_KdDebuggerData.Header.List.Blink;
|
|
pdbg32->Header.OwnerTag = KDBG_TAG;
|
|
pdbg32->Header.Size = sizeof(KDDEBUGGER_DATA32);
|
|
|
|
#undef UIP
|
|
#undef CP
|
|
#define UIP(f) pdbg32->f = (ULONG)(g_Target->m_KdDebuggerData.f)
|
|
#define CP(f) pdbg32->f = (g_Target->m_KdDebuggerData.f)
|
|
|
|
UIP(KernBase);
|
|
UIP(BreakpointWithStatus);
|
|
UIP(SavedContext);
|
|
CP(ThCallbackStack);
|
|
CP(NextCallback);
|
|
CP(FramePointer);
|
|
CP(PaeEnabled);
|
|
UIP(KiCallUserMode);
|
|
UIP(KeUserCallbackDispatcher);
|
|
UIP(PsLoadedModuleList);
|
|
UIP(PsActiveProcessHead);
|
|
UIP(PspCidTable);
|
|
UIP(ExpSystemResourcesList);
|
|
UIP(ExpPagedPoolDescriptor);
|
|
UIP(ExpNumberOfPagedPools);
|
|
UIP(KeTimeIncrement);
|
|
UIP(KeBugCheckCallbackListHead);
|
|
UIP(KiBugcheckData);
|
|
UIP(IopErrorLogListHead);
|
|
UIP(ObpRootDirectoryObject);
|
|
UIP(ObpTypeObjectType);
|
|
UIP(MmSystemCacheStart);
|
|
UIP(MmSystemCacheEnd);
|
|
UIP(MmSystemCacheWs);
|
|
UIP(MmPfnDatabase);
|
|
UIP(MmSystemPtesStart);
|
|
UIP(MmSystemPtesEnd);
|
|
UIP(MmSubsectionBase);
|
|
UIP(MmNumberOfPagingFiles);
|
|
UIP(MmLowestPhysicalPage);
|
|
UIP(MmHighestPhysicalPage);
|
|
UIP(MmNumberOfPhysicalPages);
|
|
UIP(MmMaximumNonPagedPoolInBytes);
|
|
UIP(MmNonPagedSystemStart);
|
|
UIP(MmNonPagedPoolStart);
|
|
UIP(MmNonPagedPoolEnd);
|
|
UIP(MmPagedPoolStart);
|
|
UIP(MmPagedPoolEnd);
|
|
UIP(MmPagedPoolInformation);
|
|
UIP(MmPageSize);
|
|
UIP(MmSizeOfPagedPoolInBytes);
|
|
UIP(MmTotalCommitLimit);
|
|
UIP(MmTotalCommittedPages);
|
|
UIP(MmSharedCommit);
|
|
UIP(MmDriverCommit);
|
|
UIP(MmProcessCommit);
|
|
UIP(MmPagedPoolCommit);
|
|
UIP(MmExtendedCommit);
|
|
UIP(MmZeroedPageListHead);
|
|
UIP(MmFreePageListHead);
|
|
UIP(MmStandbyPageListHead);
|
|
UIP(MmModifiedPageListHead);
|
|
UIP(MmModifiedNoWritePageListHead);
|
|
UIP(MmAvailablePages);
|
|
UIP(MmResidentAvailablePages);
|
|
UIP(PoolTrackTable);
|
|
UIP(NonPagedPoolDescriptor);
|
|
UIP(MmHighestUserAddress);
|
|
UIP(MmSystemRangeStart);
|
|
UIP(MmUserProbeAddress);
|
|
UIP(KdPrintCircularBuffer);
|
|
UIP(KdPrintCircularBufferEnd);
|
|
UIP(KdPrintWritePointer);
|
|
UIP(KdPrintRolloverCount);
|
|
UIP(MmLoadedUserImageList);
|
|
//
|
|
// DO NOT ADD ANY FIELDS HERE
|
|
// The 32 bit structure should not be changed
|
|
//
|
|
return TRUE;
|
|
|
|
case IG_KD_CONTEXT:
|
|
case IG_READ_PHYSICAL:
|
|
case IG_WRITE_PHYSICAL:
|
|
case IG_READ_PHYSICAL_WITH_FLAGS:
|
|
case IG_WRITE_PHYSICAL_WITH_FLAGS:
|
|
case IG_LOWMEM_CHECK:
|
|
case IG_SEARCH_MEMORY:
|
|
case IG_READ_MSR:
|
|
case IG_WRITE_MSR:
|
|
case IG_GET_BUS_DATA:
|
|
case IG_SET_BUS_DATA:
|
|
case IG_GET_CURRENT_THREAD:
|
|
case IG_GET_CURRENT_PROCESS:
|
|
case IG_RELOAD_SYMBOLS:
|
|
case IG_GET_SET_SYMPATH:
|
|
case IG_IS_PTR64:
|
|
case IG_DUMP_SYMBOL_INFO:
|
|
case IG_GET_TYPE_SIZE:
|
|
case IG_GET_TEB_ADDRESS:
|
|
case IG_GET_PEB_ADDRESS:
|
|
case IG_GET_INPUT_LINE:
|
|
case IG_GET_EXPRESSION_EX:
|
|
case IG_TRANSLATE_VIRTUAL_TO_PHYSICAL:
|
|
case IG_POINTER_SEARCH_PHYSICAL:
|
|
case IG_GET_COR_DATA_ACCESS:
|
|
// All of these ioctls are handled identically for
|
|
// 32 and 64 bits. Avoid duplicating all the code.
|
|
return ExtIoctl(IoctlType, lpvData, cbSize);
|
|
|
|
default:
|
|
ErrOut( "\n*** Bad IOCTL32 request from an extension [%d]\n\n",
|
|
IoctlType );
|
|
return FALSE;
|
|
}
|
|
|
|
// NOTREACHED.
|
|
DBG_ASSERT(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Extension management.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DebugClient*
|
|
FindExtClient(void)
|
|
{
|
|
DebugClient* Client;
|
|
|
|
//
|
|
// Try to find the most appropriate client for
|
|
// executing an extension command on. The first
|
|
// choice is the session client, then any local
|
|
// primary client, then any primary client.
|
|
//
|
|
|
|
if (!(Client = FindClient(g_SessionThread, CLIENT_PRIMARY, 0)) &&
|
|
!(Client = FindClient(0, CLIENT_PRIMARY, CLIENT_REMOTE)) &&
|
|
!(Client = FindClient(0, CLIENT_PRIMARY, 0)))
|
|
{
|
|
Client = g_Clients;
|
|
}
|
|
|
|
return Client;
|
|
}
|
|
|
|
LONG
|
|
ExtensionExceptionFilter(struct _EXCEPTION_POINTERS *ExceptionInfo,
|
|
PCSTR Module,
|
|
PCSTR Func)
|
|
{
|
|
// Any references to objects will be leaked.
|
|
// There's not much the engine can do about this, although
|
|
// it would be possible to record old refcounts and
|
|
// try to restore them.
|
|
|
|
if (Module != NULL && Func != NULL)
|
|
{
|
|
ErrOut("%08x Exception in %s.%s debugger extension.\n",
|
|
ExceptionInfo->ExceptionRecord->ExceptionCode,
|
|
Module,
|
|
Func
|
|
);
|
|
}
|
|
else
|
|
{
|
|
ErrOut("%08x Exception in debugger client %s callback.\n",
|
|
ExceptionInfo->ExceptionRecord->ExceptionCode,
|
|
Func
|
|
);
|
|
}
|
|
|
|
ErrOut(" PC: %s VA: %s R/W: %x Parameter: %s\n",
|
|
FormatAddr64((ULONG_PTR)ExceptionInfo->ExceptionRecord->ExceptionAddress),
|
|
FormatAddr64(ExceptionInfo->ExceptionRecord->ExceptionInformation[1]),
|
|
ExceptionInfo->ExceptionRecord->ExceptionInformation[0],
|
|
FormatAddr64(ExceptionInfo->ExceptionRecord->ExceptionInformation[2])
|
|
);
|
|
|
|
return EXCEPTION_EXECUTE_HANDLER;
|
|
}
|
|
|
|
BOOL
|
|
CallExtension(DebugClient* Client,
|
|
EXTDLL *Ext,
|
|
PSTR Func,
|
|
PCSTR Args,
|
|
HRESULT* ExtStatus)
|
|
{
|
|
FARPROC Routine;
|
|
ADDR TempAddr;
|
|
|
|
if (IS_KERNEL_TARGET(g_Target))
|
|
{
|
|
_strlwr(Func);
|
|
}
|
|
|
|
Routine = GetProcAddress(Ext->Dll, Func);
|
|
if (Routine == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (!(g_EnvDbgOptions & OPTION_NOVERSIONCHECK) && Ext->CheckVersionRoutine)
|
|
{
|
|
Ext->CheckVersionRoutine();
|
|
}
|
|
|
|
if (IS_KERNEL_TARGET(g_Target) && !strcmp(Func, "version"))
|
|
{
|
|
//
|
|
// This is a bit of a hack to avoid a problem with the
|
|
// extension version checking. Extension version checking
|
|
// comes before the KD connection is established so there's
|
|
// no register context. If the version checking fails it
|
|
// prints out version information, which tries to call
|
|
// version extensions, which will get here when there's
|
|
// no register context.
|
|
//
|
|
// To work around this, just pass zero to the version extension
|
|
// function since it presumably doesn't care about the
|
|
// address.
|
|
//
|
|
ADDRFLAT(&TempAddr, 0);
|
|
}
|
|
else if (IS_CONTEXT_POSSIBLE(g_Target))
|
|
{
|
|
g_Machine->GetPC(&TempAddr);
|
|
}
|
|
else
|
|
{
|
|
if (!IS_LOCAL_KERNEL_TARGET(g_Target))
|
|
{
|
|
WarnOut("Extension called without current PC\n");
|
|
}
|
|
|
|
ADDRFLAT(&TempAddr, 0);
|
|
}
|
|
|
|
*ExtStatus = S_OK;
|
|
|
|
__try
|
|
{
|
|
HANDLE ProcHandle, ThreadHandle;
|
|
|
|
if (g_Process)
|
|
{
|
|
ProcHandle = OS_HANDLE(g_Process->m_SysHandle);
|
|
}
|
|
else
|
|
{
|
|
ProcHandle = NULL;
|
|
}
|
|
if (g_Thread)
|
|
{
|
|
ThreadHandle = OS_HANDLE(g_Thread->m_Handle);
|
|
}
|
|
else
|
|
{
|
|
ThreadHandle = NULL;
|
|
}
|
|
|
|
switch(Ext->ExtensionType)
|
|
{
|
|
case NTSD_EXTENSION_TYPE:
|
|
//
|
|
// NOTE:
|
|
// Eventhough this type should receive an NTSD_EXTENSION_API
|
|
// structure, ntsdexts.dll (and possibly others) depend on
|
|
// receiving the WinDBG version of the extensions, because they
|
|
// check the size of the structure, and actually use some of the
|
|
// newer exports. This works because the WinDBG extension API was
|
|
// a superset of the NTSD version.
|
|
//
|
|
|
|
((PNTSD_EXTENSION_ROUTINE)Routine)
|
|
(ProcHandle,
|
|
ThreadHandle,
|
|
(ULONG)Flat(TempAddr),
|
|
g_Target->m_Machine->m_Ptr64 ?
|
|
(PNTSD_EXTENSION_APIS)&g_WindbgExtensions64 :
|
|
(PNTSD_EXTENSION_APIS)&g_WindbgExtensions32,
|
|
(PSTR)Args
|
|
);
|
|
break;
|
|
|
|
case DEBUG_EXTENSION_TYPE:
|
|
if (Client == NULL)
|
|
{
|
|
Client = FindExtClient();
|
|
}
|
|
if (Client == NULL)
|
|
{
|
|
ErrOut("Unable to call client-style extension "
|
|
"without a client\n");
|
|
}
|
|
else
|
|
{
|
|
*ExtStatus = ((PDEBUG_EXTENSION_CALL)Routine)
|
|
((PDEBUG_CLIENT)(IDebugClientN *)Client, Args);
|
|
}
|
|
break;
|
|
|
|
case WINDBG_EXTENSION_TYPE:
|
|
//
|
|
// Support Windbg type extensions for ntsd too
|
|
//
|
|
if (Ext->ApiVersion.Revision < 6 )
|
|
{
|
|
((PWINDBG_EXTENSION_ROUTINE32)Routine) (
|
|
ProcHandle,
|
|
ThreadHandle,
|
|
(ULONG)Flat(TempAddr),
|
|
CURRENT_PROC,
|
|
Args
|
|
);
|
|
}
|
|
else
|
|
{
|
|
((PWINDBG_EXTENSION_ROUTINE64)Routine) (
|
|
ProcHandle,
|
|
ThreadHandle,
|
|
Flat(TempAddr),
|
|
CURRENT_PROC,
|
|
Args
|
|
);
|
|
}
|
|
break;
|
|
|
|
case WINDBG_OLDKD_EXTENSION_TYPE:
|
|
((PWINDBG_OLDKD_EXTENSION_ROUTINE)Routine) (
|
|
(ULONG)Flat(TempAddr),
|
|
&g_KdExtensions,
|
|
Args
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
__except(ExtensionExceptionFilter(GetExceptionInformation(),
|
|
Ext->Name, Func))
|
|
{
|
|
;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
LinkExtensionDll(EXTDLL* Ext)
|
|
{
|
|
// Put user-loaded DLLs before default DLLs.
|
|
if (Ext->UserLoaded)
|
|
{
|
|
Ext->Next = g_ExtDlls;
|
|
g_ExtDlls = Ext;
|
|
}
|
|
else
|
|
{
|
|
EXTDLL* Prev;
|
|
EXTDLL* Cur;
|
|
|
|
Prev = NULL;
|
|
for (Cur = g_ExtDlls; Cur != NULL; Cur = Cur->Next)
|
|
{
|
|
if (!Cur->UserLoaded)
|
|
{
|
|
break;
|
|
}
|
|
|
|
Prev = Cur;
|
|
}
|
|
|
|
Ext->Next = Cur;
|
|
if (Prev == NULL)
|
|
{
|
|
g_ExtDlls = Ext;
|
|
}
|
|
else
|
|
{
|
|
Prev->Next = Ext;
|
|
}
|
|
}
|
|
}
|
|
|
|
EXTDLL *
|
|
AddExtensionDll(char *Name, BOOL UserLoaded, TargetInfo* Target,
|
|
char **End)
|
|
{
|
|
EXTDLL *Ext;
|
|
ULONG Len;
|
|
char *Last;
|
|
|
|
while (*Name == ' ' || *Name == '\t')
|
|
{
|
|
Name++;
|
|
}
|
|
if (*Name == 0)
|
|
{
|
|
ErrOut("No extension DLL name provided\n");
|
|
return NULL;
|
|
}
|
|
|
|
Len = strlen(Name);
|
|
if (End != NULL)
|
|
{
|
|
*End = Name + Len;
|
|
}
|
|
|
|
Last = Name + (Len - 1);
|
|
while (Last >= Name && (*Last == ' ' || *Last == '\t'))
|
|
{
|
|
Last--;
|
|
}
|
|
Len = (ULONG)((Last + 1) - Name);
|
|
|
|
// See if it's already in the list.
|
|
for (Ext = g_ExtDlls; Ext != NULL; Ext = Ext->Next)
|
|
{
|
|
if ((!Target || Target == Ext->Target) &&
|
|
strlen(Ext->Name) == Len &&
|
|
!_memicmp(Name, Ext->Name, Len))
|
|
{
|
|
return Ext;
|
|
}
|
|
}
|
|
|
|
Ext = (EXTDLL *)malloc(sizeof(EXTDLL) + Len);
|
|
if (Ext == NULL)
|
|
{
|
|
ErrOut("Unable to allocate memory for extension DLL\n");
|
|
return NULL;
|
|
}
|
|
|
|
ZeroMemory(Ext, sizeof(EXTDLL) + Len);
|
|
memcpy(Ext->Name, Name, Len + 1);
|
|
Ext->UserLoaded = UserLoaded;
|
|
Ext->Target = Target;
|
|
|
|
LinkExtensionDll(Ext);
|
|
|
|
NotifyChangeEngineState(DEBUG_CES_EXTENSIONS, 0, TRUE);
|
|
return Ext;
|
|
}
|
|
|
|
PCTSTR
|
|
BuildExtensionSearchPath(TargetInfo* Target)
|
|
{
|
|
DWORD Size;
|
|
DWORD TotalSize;
|
|
CHAR ExeDir[MAX_PATH];
|
|
int ExeRootLen;
|
|
PSTR OsDirPath;
|
|
CHAR OsDirTail[32];
|
|
BOOL PriPaths = FALSE;
|
|
BOOL WinPaths = FALSE;
|
|
PSTR NewPath;
|
|
|
|
//
|
|
// If we are not connected, don't build a path, since we have to pick
|
|
// up extensions based on the OS version.
|
|
//
|
|
if (Target && Target->m_ActualSystemVersion == SVER_INVALID)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// If we already have a search path, do not rebuild it.
|
|
//
|
|
|
|
if (Target)
|
|
{
|
|
if (Target->m_ExtensionSearchPath)
|
|
{
|
|
return Target->m_ExtensionSearchPath;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (g_BaseExtensionSearchPath)
|
|
{
|
|
return g_BaseExtensionSearchPath;
|
|
}
|
|
}
|
|
|
|
// Get the directory the debugger executable is in.
|
|
// -8 because we assume we're adding \w2kfre to the path.
|
|
if (!GetEngineDirectory(ExeDir, MAX_PATH - 8))
|
|
{
|
|
// Error. Using the current directory.
|
|
ExeRootLen = 1;
|
|
}
|
|
else
|
|
{
|
|
if (ExeDir[0] == '\\' && ExeDir[1] == '\\')
|
|
{
|
|
PSTR ExeRootEnd;
|
|
|
|
// UNC path root.
|
|
ExeRootEnd = strchr(ExeDir + 2, '\\');
|
|
if (ExeRootEnd != NULL)
|
|
{
|
|
ExeRootEnd = strchr(ExeRootEnd + 1, '\\');
|
|
}
|
|
if (ExeRootEnd == NULL)
|
|
{
|
|
ExeRootLen = strlen(ExeDir);
|
|
}
|
|
else
|
|
{
|
|
ExeRootLen = (int)(ExeRootEnd - ExeDir);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Drive letter and colon root.
|
|
ExeRootLen = 2;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Calc how much space we will need to use.
|
|
//
|
|
// Leave extra room for the current directory, path, and directory of
|
|
// where debugger extensions are located.
|
|
//
|
|
|
|
TotalSize = GetEnvironmentVariable("PATH", NULL, 0) +
|
|
GetEnvironmentVariable("_NT_DEBUGGER_EXTENSION_PATH",
|
|
NULL, 0) + MAX_PATH * 4;
|
|
|
|
NewPath = (LPTSTR)calloc(TotalSize, sizeof(TCHAR));
|
|
if (!NewPath)
|
|
{
|
|
return NULL;
|
|
}
|
|
*NewPath = 0;
|
|
|
|
//
|
|
// 1 - User specified search path
|
|
//
|
|
|
|
if (GetEnvironmentVariable("_NT_DEBUGGER_EXTENSION_PATH",
|
|
NewPath, TotalSize - 2))
|
|
{
|
|
CatString(NewPath, ";", TotalSize);
|
|
}
|
|
|
|
// Generate default path for the exe dir
|
|
// Skip root as it is already taken from ExeDir.
|
|
OsDirPath = ExeDir + ExeRootLen;
|
|
if (*OsDirPath == '\\')
|
|
{
|
|
OsDirPath++;
|
|
}
|
|
|
|
//
|
|
// Figure out whether we need NT6, or NT5/NT4 free or checked extensions
|
|
//
|
|
|
|
if (!Target)
|
|
{
|
|
OsDirPath = "";
|
|
OsDirTail[0] = 0;
|
|
}
|
|
else if (Target->m_ActualSystemVersion > BIG_SVER_START &&
|
|
Target->m_ActualSystemVersion < BIG_SVER_END)
|
|
{
|
|
OsDirPath = "DbgExt";
|
|
strcpy(OsDirTail, "BIG");
|
|
}
|
|
else if (Target->m_ActualSystemVersion > XBOX_SVER_START &&
|
|
Target->m_ActualSystemVersion < XBOX_SVER_END)
|
|
{
|
|
OsDirPath = "DbgExt";
|
|
strcpy(OsDirTail, "XBox");
|
|
}
|
|
else if (Target->m_ActualSystemVersion > NTBD_SVER_START &&
|
|
Target->m_ActualSystemVersion < NTBD_SVER_END)
|
|
{
|
|
OsDirPath = "DbgExt";
|
|
strcpy(OsDirTail, "NtBd");
|
|
}
|
|
else if (Target->m_ActualSystemVersion > EFI_SVER_START &&
|
|
Target->m_ActualSystemVersion < EFI_SVER_END)
|
|
{
|
|
OsDirPath = "DbgExt";
|
|
strcpy(OsDirTail, "EFI");
|
|
}
|
|
else if (Target->m_ActualSystemVersion > W9X_SVER_START &&
|
|
Target->m_ActualSystemVersion < W9X_SVER_END)
|
|
{
|
|
strcpy(OsDirTail, "Win9X");
|
|
WinPaths = TRUE;
|
|
}
|
|
else if (Target->m_ActualSystemVersion > WCE_SVER_START &&
|
|
Target->m_ActualSystemVersion < WCE_SVER_END)
|
|
{
|
|
strcpy(OsDirTail, "WinCE");
|
|
WinPaths = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Treat everything else as an NT system. Use
|
|
// the translated system version now rather than
|
|
// the actual system version.
|
|
|
|
PriPaths = TRUE;
|
|
WinPaths = TRUE;
|
|
|
|
if (Target->m_SystemVersion > NT_SVER_W2K)
|
|
{
|
|
strcpy(OsDirTail, "WINXP");
|
|
}
|
|
else
|
|
{
|
|
if (Target->m_SystemVersion <= NT_SVER_NT4)
|
|
{
|
|
strcpy(OsDirTail, "NT4");
|
|
}
|
|
else
|
|
{
|
|
strcpy(OsDirTail, "W2K");
|
|
}
|
|
|
|
if (0xC == Target->m_CheckedBuild)
|
|
{
|
|
strcat(OsDirTail, "Chk");
|
|
}
|
|
else
|
|
{
|
|
strcat(OsDirTail, "Fre");
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// 2 - OS specific subdirectories from where we launched the debugger.
|
|
// 3 - pri subdirectory from where we launched the debugger.
|
|
// 4 - Directory from where we launched the debugger.
|
|
//
|
|
|
|
PSTR End;
|
|
|
|
Size = strlen(NewPath);
|
|
End = NewPath + Size;
|
|
memcpy(End, ExeDir, ExeRootLen);
|
|
End += ExeRootLen;
|
|
TotalSize -= Size + ExeRootLen;
|
|
if (*OsDirPath)
|
|
{
|
|
if (TotalSize)
|
|
{
|
|
*End++ = '\\';
|
|
TotalSize--;
|
|
}
|
|
CopyString(End, OsDirPath, TotalSize);
|
|
Size = strlen(End);
|
|
End += Size;
|
|
TotalSize -= Size;
|
|
}
|
|
if (WinPaths)
|
|
{
|
|
PrintString(End, TotalSize, "\\winext;%s", ExeDir);
|
|
Size = strlen(End);
|
|
End += Size;
|
|
TotalSize -= Size;
|
|
}
|
|
if (*OsDirTail)
|
|
{
|
|
PrintString(End, TotalSize, "\\%s;%s", OsDirTail, ExeDir);
|
|
Size = strlen(End);
|
|
End += Size;
|
|
TotalSize -= Size;
|
|
}
|
|
if (PriPaths)
|
|
{
|
|
PrintString(End, TotalSize, "\\pri;%s", ExeDir);
|
|
Size = strlen(End);
|
|
End += Size;
|
|
TotalSize -= Size;
|
|
}
|
|
|
|
if (*--End == ':')
|
|
{
|
|
*++End = '\\';
|
|
}
|
|
else
|
|
{
|
|
TotalSize--;
|
|
}
|
|
|
|
if (TotalSize > 1)
|
|
{
|
|
*++End = ';';
|
|
*++End = 0;
|
|
TotalSize -= 2;
|
|
}
|
|
|
|
//
|
|
// 4 - Copy environment path
|
|
//
|
|
|
|
GetEnvironmentVariable("PATH", End, TotalSize);
|
|
|
|
if (Target)
|
|
{
|
|
Target->m_ExtensionSearchPath = NewPath;
|
|
}
|
|
else
|
|
{
|
|
g_BaseExtensionSearchPath = NewPath;
|
|
}
|
|
return NewPath;
|
|
}
|
|
|
|
BOOL
|
|
IsAbsolutePath(PCTSTR Path)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Is this path an absolute path? Does not guarentee that the path exists. The
|
|
method is:
|
|
|
|
"\\<anything>" is an absolute path
|
|
|
|
"{char}:\<anything>" is an absolute path
|
|
|
|
anything else is not
|
|
--*/
|
|
|
|
{
|
|
BOOL Ret;
|
|
|
|
if ( (Path [0] == '\\' && Path [1] == '\\') ||
|
|
(isalpha ( Path [0] ) && Path [1] == ':' && Path [ 2 ] == '\\') )
|
|
{
|
|
Ret = TRUE;
|
|
}
|
|
else
|
|
{
|
|
Ret = FALSE;
|
|
}
|
|
|
|
return Ret;
|
|
}
|
|
|
|
void
|
|
FreeExtensionLibrary(EXTDLL* Ext)
|
|
{
|
|
FreeLibrary(Ext->Dll);
|
|
Ext->Dll = NULL;
|
|
|
|
if (Ext == g_Wow64ExtDll)
|
|
{
|
|
g_Wow64exts = NULL;
|
|
g_Wow64ExtDll = NULL;
|
|
}
|
|
|
|
if (Ext == g_WmiExtDll)
|
|
{
|
|
g_WmiFormatTraceData = NULL;
|
|
g_WmiExtDll = NULL;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
LoadExtensionDll(TargetInfo* Target, EXTDLL *Ext)
|
|
{
|
|
BOOL Found;
|
|
CHAR ExtPath[_MAX_PATH];
|
|
|
|
if (Ext->Dll != NULL)
|
|
{
|
|
// Extension is already loaded.
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Do not allow extensions to be loaded via arbitrary UNC
|
|
// paths when in secure mode.
|
|
//
|
|
|
|
if ((g_SymOptions & SYMOPT_SECURE) &&
|
|
((IS_SLASH(Ext->Name[0]) && IS_SLASH(Ext->Name[1])) ||
|
|
IsUrlPathComponent(Ext->Name)))
|
|
{
|
|
ErrOut("SECURE: UNC paths not allowed for extension DLLs - %s\n",
|
|
Ext->Name);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// If we are not allowing network paths, verify that the extension will
|
|
// not be loaded from a network path.
|
|
//
|
|
|
|
if (g_EngOptions & DEBUG_ENGOPT_DISALLOW_NETWORK_PATHS)
|
|
{
|
|
DWORD NetCheck;
|
|
|
|
NetCheck = NetworkPathCheck(BuildExtensionSearchPath(Target));
|
|
|
|
//
|
|
// Check full path of the extension.
|
|
//
|
|
|
|
if (NetCheck != ERROR_FILE_OFFLINE)
|
|
{
|
|
CHAR Drive [ _MAX_DRIVE + 1];
|
|
CHAR Dir [ _MAX_DIR + 1];
|
|
CHAR Path [ _MAX_PATH + 1];
|
|
|
|
*Drive = '\000';
|
|
*Dir = '\000';
|
|
_splitpath (Ext->Name, Drive, Dir, NULL, NULL);
|
|
_makepath (Path, Drive, Dir, NULL, NULL);
|
|
|
|
NetCheck = NetworkPathCheck (Path);
|
|
}
|
|
|
|
if (NetCheck == ERROR_FILE_OFFLINE)
|
|
{
|
|
ErrOut("ERROR: extension search path contains "
|
|
"network references.\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
Found = SearchPath(BuildExtensionSearchPath(Target),
|
|
Ext->Name,
|
|
".dll",
|
|
DIMA(ExtPath),
|
|
ExtPath,
|
|
NULL);
|
|
|
|
UINT OldMode = SetErrorMode(SEM_FAILCRITICALERRORS);
|
|
|
|
if ( Found )
|
|
{
|
|
Ext->Dll = LoadLibrary(ExtPath);
|
|
}
|
|
else if (IsAbsolutePath(Ext->Name))
|
|
{
|
|
Ext->Dll = LoadLibrary(Ext->Name);
|
|
}
|
|
|
|
SetErrorMode(OldMode);
|
|
|
|
if (Ext->Dll == NULL)
|
|
{
|
|
HRESULT Status = WIN32_LAST_STATUS();
|
|
|
|
ErrOut("The call to LoadLibrary(%s) failed, %s\n \"%s\"\n"
|
|
"Please check your debugger configuration "
|
|
"and/or network access.\n",
|
|
Ext->Name, FormatStatusCode(Status), FormatStatus(Status));
|
|
return FALSE;
|
|
}
|
|
|
|
PCSTR ExtPathTail = PathTail(Ext->Name);
|
|
|
|
if (!_stricmp(ExtPathTail, "wow64exts.dll") ||
|
|
!_stricmp(ExtPathTail, "wow64exts"))
|
|
{
|
|
g_Wow64exts = (WOW64EXTSPROC)GetProcAddress(Ext->Dll,"Wow64extsfn");
|
|
DBG_ASSERT(g_Wow64exts);
|
|
g_Wow64ExtDll = Ext;
|
|
}
|
|
|
|
if (!_stricmp(ExtPathTail, "wmitrace.dll") ||
|
|
!_stricmp(ExtPathTail, "wmitrace"))
|
|
{
|
|
g_WmiFormatTraceData = (WMI_FORMAT_TRACE_DATA)
|
|
GetProcAddress(Ext->Dll, "WmiFormatTraceData");
|
|
g_WmiExtDll = Ext;
|
|
}
|
|
|
|
if (!g_QuietMode)
|
|
{
|
|
VerbOut("Loaded %s extension DLL\n", Ext->Name);
|
|
}
|
|
|
|
//
|
|
// Now that the extension is loaded, refresh it.
|
|
//
|
|
|
|
Ext->Uninit = NULL;
|
|
|
|
PDEBUG_EXTENSION_INITIALIZE EngExt;
|
|
|
|
EngExt = (PDEBUG_EXTENSION_INITIALIZE)
|
|
GetProcAddress(Ext->Dll, "DebugExtensionInitialize");
|
|
if (EngExt != NULL)
|
|
{
|
|
ULONG Version, Flags;
|
|
HRESULT Status;
|
|
|
|
// This is an engine extension. Initialize it.
|
|
|
|
Status = EngExt(&Version, &Flags);
|
|
if (Status != S_OK)
|
|
{
|
|
ErrOut("%s!DebugExtensionInitialize failed with 0x%08lX\n",
|
|
Ext->Name, Status);
|
|
goto EH_Free;
|
|
}
|
|
|
|
Ext->ApiVersion.MajorVersion = HIWORD(Version);
|
|
Ext->ApiVersion.MinorVersion = LOWORD(Version);
|
|
Ext->ApiVersion.Revision = 0;
|
|
|
|
Ext->Notify = (PDEBUG_EXTENSION_NOTIFY)
|
|
GetProcAddress(Ext->Dll, "DebugExtensionNotify");
|
|
Ext->Uninit = (PDEBUG_EXTENSION_UNINITIALIZE)
|
|
GetProcAddress(Ext->Dll, "DebugExtensionUninitialize");
|
|
|
|
Ext->ExtensionType = DEBUG_EXTENSION_TYPE;
|
|
Ext->Init = NULL;
|
|
Ext->ApiVersionRoutine = NULL;
|
|
Ext->CheckVersionRoutine = NULL;
|
|
|
|
goto VersionCheck;
|
|
}
|
|
|
|
Ext->Init = (PWINDBG_EXTENSION_DLL_INIT64)
|
|
GetProcAddress(Ext->Dll, "WinDbgExtensionDllInit");
|
|
// Windbg Api
|
|
if (Ext->Init != NULL)
|
|
{
|
|
Ext->ExtensionType = WINDBG_EXTENSION_TYPE;
|
|
Ext->ApiVersionRoutine = (PWINDBG_EXTENSION_API_VERSION)
|
|
GetProcAddress(Ext->Dll, "ExtensionApiVersion");
|
|
if (Ext->ApiVersionRoutine == NULL)
|
|
{
|
|
ErrOut("%s is not a valid windbg extension DLL\n",
|
|
Ext->Name);
|
|
goto EH_Free;
|
|
}
|
|
Ext->CheckVersionRoutine = (PWINDBG_CHECK_VERSION)
|
|
GetProcAddress(Ext->Dll, "CheckVersion");
|
|
|
|
Ext->ApiVersion = *(Ext->ApiVersionRoutine());
|
|
|
|
if (Ext->ApiVersion.Revision >= 6)
|
|
{
|
|
(Ext->Init)(&g_WindbgExtensions64,
|
|
Target ? (USHORT)Target->m_CheckedBuild : 0,
|
|
Target ? (USHORT)Target->m_BuildNumber : 0);
|
|
}
|
|
else
|
|
{
|
|
(Ext->Init)((PWINDBG_EXTENSION_APIS64)&g_WindbgExtensions32,
|
|
Target ? (USHORT)Target->m_CheckedBuild : 0,
|
|
Target ? (USHORT)Target->m_BuildNumber : 0);
|
|
}
|
|
}
|
|
else if (g_SymOptions & SYMOPT_SECURE)
|
|
{
|
|
ErrOut("SECURE: Cannot determine extension DLL type - %s\n",
|
|
Ext->Name);
|
|
goto EH_Free;
|
|
}
|
|
else
|
|
{
|
|
Ext->ApiVersion.Revision = EXT_API_VERSION_NUMBER;
|
|
Ext->ApiVersionRoutine = NULL;
|
|
Ext->CheckVersionRoutine = NULL;
|
|
if (GetProcAddress(Ext->Dll, "NtsdExtensionDllInit"))
|
|
{
|
|
Ext->ExtensionType = NTSD_EXTENSION_TYPE;
|
|
}
|
|
else
|
|
{
|
|
Ext->ExtensionType = IS_KERNEL_TARGET(g_Target) ?
|
|
WINDBG_OLDKD_EXTENSION_TYPE : NTSD_EXTENSION_TYPE;
|
|
}
|
|
}
|
|
|
|
VersionCheck:
|
|
|
|
#if 0
|
|
// Temporarily remove this print statements.
|
|
|
|
if (!(g_EnvDbgOptions & OPTION_NOVERSIONCHECK))
|
|
{
|
|
if (Ext->ApiVersion.Revision < 6)
|
|
{
|
|
dprintf("%s uses the old 32 bit extension API and may not be fully\n", Ext->Name);
|
|
dprintf("compatible with current systems.\n");
|
|
}
|
|
else if (Ext->ApiVersion.Revision < EXT_API_VERSION_NUMBER)
|
|
{
|
|
dprintf("%s uses an earlier version of the extension API than that\n", Ext->Name);
|
|
dprintf("supported by this debugger, and should work properly, but there\n");
|
|
dprintf("may be unexpected incompatibilities.\n");
|
|
}
|
|
else if (Ext->ApiVersion.Revision > EXT_API_VERSION_NUMBER)
|
|
{
|
|
dprintf("%s uses a later version of the extension API than that\n", Ext->Name);
|
|
dprintf("supported by this debugger, and might not function correctly.\n");
|
|
dprintf("You should use the debugger from the SDK or DDK which was used\n");
|
|
dprintf("to build the extension library.\n");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// If the extension has a notification routine send
|
|
// notifications appropriate to the current state.
|
|
if (Ext->Notify != NULL)
|
|
{
|
|
__try
|
|
{
|
|
if (IS_MACHINE_SET(g_Target))
|
|
{
|
|
Ext->Notify(DEBUG_NOTIFY_SESSION_ACTIVE, 0);
|
|
}
|
|
if (IS_CUR_MACHINE_ACCESSIBLE())
|
|
{
|
|
Ext->Notify(DEBUG_NOTIFY_SESSION_ACCESSIBLE, 0);
|
|
}
|
|
}
|
|
__except(ExtensionExceptionFilter(GetExceptionInformation(),
|
|
Ext->Name,
|
|
"DebugExtensionNotify"))
|
|
{
|
|
// Empty.
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
EH_Free:
|
|
FreeExtensionLibrary(Ext);
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
UnlinkExtensionDll(EXTDLL* Match)
|
|
{
|
|
EXTDLL *Ext;
|
|
EXTDLL *Prev;
|
|
|
|
Prev = NULL;
|
|
for (Ext = g_ExtDlls; Ext != NULL; Ext = Ext->Next)
|
|
{
|
|
if (Match == Ext)
|
|
{
|
|
break;
|
|
}
|
|
|
|
Prev = Ext;
|
|
}
|
|
|
|
if (Ext == NULL)
|
|
{
|
|
ErrOut("! Extension DLL list inconsistency !\n");
|
|
}
|
|
else if (Prev == NULL)
|
|
{
|
|
g_ExtDlls = Ext->Next;
|
|
}
|
|
else
|
|
{
|
|
Prev->Next = Ext->Next;
|
|
}
|
|
}
|
|
|
|
void
|
|
DeferExtensionDll(EXTDLL *Ext, BOOL Verbose)
|
|
{
|
|
if (Ext->Dll == NULL)
|
|
{
|
|
// Already deferred.
|
|
return;
|
|
}
|
|
|
|
Ext->Init = NULL;
|
|
Ext->Notify = NULL;
|
|
Ext->ApiVersionRoutine = NULL;
|
|
Ext->CheckVersionRoutine = NULL;
|
|
|
|
if (Ext->Uninit != NULL)
|
|
{
|
|
Ext->Uninit();
|
|
Ext->Uninit = NULL;
|
|
}
|
|
|
|
if (Ext->Dll != NULL)
|
|
{
|
|
if (Verbose)
|
|
{
|
|
dprintf("Unloading %s extension DLL\n", Ext->Name);
|
|
}
|
|
else if (!g_QuietMode)
|
|
{
|
|
VerbOut("Unloading %s extension DLL\n", Ext->Name);
|
|
}
|
|
|
|
FreeExtensionLibrary(Ext);
|
|
}
|
|
}
|
|
|
|
void
|
|
UnloadExtensionDll(EXTDLL *Ext, BOOL Verbose)
|
|
{
|
|
UnlinkExtensionDll(Ext);
|
|
DeferExtensionDll(Ext, Verbose);
|
|
free(Ext);
|
|
NotifyChangeEngineState(DEBUG_CES_EXTENSIONS, 0, TRUE);
|
|
}
|
|
|
|
void
|
|
MoveExtensionToHead(EXTDLL* Ext)
|
|
{
|
|
UnlinkExtensionDll(Ext);
|
|
LinkExtensionDll(Ext);
|
|
}
|
|
|
|
void
|
|
UnloadTargetExtensionDlls(TargetInfo* Target)
|
|
{
|
|
EXTDLL* Ext;
|
|
|
|
for (;;)
|
|
{
|
|
for (Ext = g_ExtDlls; Ext != NULL; Ext = Ext->Next)
|
|
{
|
|
if (Ext->Target == Target)
|
|
{
|
|
UnloadExtensionDll(Ext, FALSE);
|
|
// Force a loop around as the list has
|
|
// changed.
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!Ext)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
DeferAllExtensionDlls(void)
|
|
{
|
|
EXTDLL* Ext;
|
|
|
|
for (Ext = g_ExtDlls; Ext != NULL; Ext = Ext->Next)
|
|
{
|
|
DeferExtensionDll(Ext, FALSE);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
CallAnyExtension(DebugClient* Client,
|
|
EXTDLL* Ext, PSTR Function, PCSTR Arguments,
|
|
BOOL ModuleSpecified, BOOL ShowWarnings,
|
|
HRESULT* ExtStatus)
|
|
{
|
|
if (Ext == NULL)
|
|
{
|
|
Ext = g_ExtDlls;
|
|
}
|
|
|
|
// Walk through the list of extension DLLs and attempt to
|
|
// call the given extension function on them.
|
|
while (Ext != NULL)
|
|
{
|
|
//
|
|
// hack : only dbghelp extensions or analyzebugcheck
|
|
// will work on minidump files right now.
|
|
//
|
|
|
|
// Let all the extensions run on minidumps since there is more data
|
|
// in the dumps now.
|
|
//
|
|
// char Name[_MAX_FNAME + 1];
|
|
//
|
|
// _splitpath(Ext->Name, NULL, NULL, Name, NULL);
|
|
//
|
|
// if (!IS_KERNEL_TRIAGE_DUMP(g_Target) ||
|
|
// !_stricmp(Name, "dbghelp") ||
|
|
// !_stricmp(Name, "dbgtstext") || // used by the test team
|
|
// !_stricmp(Name, "dt_exts") || // used by the test team
|
|
// !_stricmp(Name, "ext"))
|
|
{
|
|
if ((!Ext->Target || Ext->Target == g_Target) &&
|
|
LoadExtensionDll(g_Target, Ext))
|
|
{
|
|
BOOL DidCall;
|
|
|
|
DidCall = CallExtension(Client, Ext, Function, Arguments,
|
|
ExtStatus);
|
|
if (DidCall &&
|
|
*ExtStatus != DEBUG_EXTENSION_CONTINUE_SEARCH)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
if (!DidCall && ModuleSpecified)
|
|
{
|
|
// If a DLL was explicitly specified then the
|
|
// missing function is an error.
|
|
if (ShowWarnings &&
|
|
!(g_EnvDbgOptions & OPTION_NOEXTWARNING))
|
|
{
|
|
MaskOut(DEBUG_OUTPUT_EXTENSION_WARNING,
|
|
"%s has no %s export\n", Ext->Name, Function);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ext = Ext->Next;
|
|
}
|
|
|
|
if (ShowWarnings && !(g_EnvDbgOptions & OPTION_NOEXTWARNING))
|
|
{
|
|
MaskOut(DEBUG_OUTPUT_EXTENSION_WARNING,
|
|
"No export %s found\n", Function);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
OutputModuleIdInfo(HMODULE Mod, PSTR ModFile, LPEXT_API_VERSION ApiVer)
|
|
{
|
|
WCHAR FileBuf[MAX_IMAGE_PATH];
|
|
char *File;
|
|
time_t TimeStamp;
|
|
char *TimeStr;
|
|
char VerStr[64];
|
|
|
|
if (Mod == NULL)
|
|
{
|
|
Mod = GetModuleHandle(ModFile);
|
|
}
|
|
|
|
if (MultiByteToWideChar(CP_ACP, 0, ModFile, -1,
|
|
FileBuf, DIMA(FileBuf)) &&
|
|
GetFileStringFileInfo(FileBuf, "ProductVersion",
|
|
VerStr, sizeof(VerStr)))
|
|
{
|
|
dprintf("image %s, ", VerStr);
|
|
}
|
|
|
|
if (ApiVer != NULL)
|
|
{
|
|
dprintf("API %d.%d.%d, ",
|
|
ApiVer->MajorVersion,
|
|
ApiVer->MinorVersion,
|
|
ApiVer->Revision);
|
|
}
|
|
|
|
TimeStamp = GetTimestampForLoadedLibrary(Mod);
|
|
TimeStr = ctime(&TimeStamp);
|
|
// Delete newline.
|
|
TimeStr[strlen(TimeStr) - 1] = 0;
|
|
|
|
if (GetModuleFileName(Mod, (PSTR)FileBuf, DIMA(FileBuf) - 1) == 0)
|
|
{
|
|
File = "Unable to get filename";
|
|
}
|
|
else
|
|
{
|
|
File = (PSTR)FileBuf;
|
|
}
|
|
|
|
dprintf("built %s\n [path: %s]\n", TimeStr, File);
|
|
}
|
|
|
|
void
|
|
OutputExtensions(DebugClient* Client, BOOL Versions)
|
|
{
|
|
if ((g_Target && g_Target->m_ExtensionSearchPath) ||
|
|
(!g_Target && g_BaseExtensionSearchPath))
|
|
{
|
|
dprintf("Extension DLL search Path:\n %s\n",
|
|
g_Target ?
|
|
g_Target->m_ExtensionSearchPath : g_BaseExtensionSearchPath);
|
|
}
|
|
else
|
|
{
|
|
dprintf("Default extension DLLs are not loaded until "
|
|
"after initial connection\n");
|
|
if (g_ExtDlls == NULL)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
dprintf("Extension DLL chain:\n");
|
|
if (g_ExtDlls == NULL)
|
|
{
|
|
dprintf(" <Empty>\n");
|
|
return;
|
|
}
|
|
|
|
EXTDLL *Ext;
|
|
|
|
for (Ext = g_ExtDlls; Ext != NULL; Ext = Ext->Next)
|
|
{
|
|
if (Ext->Target && Ext->Target != g_Target)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (Versions & (Ext->Dll == NULL))
|
|
{
|
|
LoadExtensionDll(g_Target, Ext);
|
|
}
|
|
|
|
dprintf(" %s: ", Ext->Name);
|
|
if (Ext->Dll != NULL)
|
|
{
|
|
LPEXT_API_VERSION ApiVer;
|
|
|
|
if ((Ext->ExtensionType == DEBUG_EXTENSION_TYPE) ||
|
|
(Ext->ApiVersionRoutine != NULL))
|
|
{
|
|
ApiVer = &Ext->ApiVersion;
|
|
}
|
|
else
|
|
{
|
|
ApiVer = NULL;
|
|
}
|
|
|
|
OutputModuleIdInfo(Ext->Dll, Ext->Name, ApiVer);
|
|
|
|
if (Versions)
|
|
{
|
|
HRESULT ExtStatus;
|
|
|
|
CallExtension(Client, Ext, "version", "", &ExtStatus);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dprintf("(Not loaded)\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
NotifyExtensions(ULONG Notify, ULONG64 Argument)
|
|
{
|
|
EXTDLL *Ext;
|
|
|
|
// This routine deliberately does not provoke
|
|
// a DLL load.
|
|
for (Ext = g_ExtDlls; Ext != NULL; Ext = Ext->Next)
|
|
{
|
|
if ((!Ext->Target || Ext->Target == g_Target) &&
|
|
Ext->Notify != NULL)
|
|
{
|
|
__try
|
|
{
|
|
Ext->Notify(Notify, Argument);
|
|
}
|
|
__except(ExtensionExceptionFilter(GetExceptionInformation(),
|
|
Ext->Name,
|
|
"DebugExtensionNotify"))
|
|
{
|
|
// Empty.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Built-in extension commands.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
VOID
|
|
ParseBangCmd(DebugClient* Client,
|
|
BOOL BuiltInOnly)
|
|
{
|
|
PSTR Cmd, Scan;
|
|
PSTR ModName;
|
|
PSTR FnName;
|
|
EXTDLL* Ext;
|
|
char CmdCopy[MAX_COMMAND];
|
|
char Save;
|
|
PSTR FnArgs;
|
|
|
|
//
|
|
// Shell escape always consumes the entire string.
|
|
//
|
|
|
|
if (*g_CurCmd == '!')
|
|
{
|
|
g_CurCmd++;
|
|
DotShell(NULL, Client);
|
|
*g_CurCmd = 0;
|
|
return;
|
|
}
|
|
|
|
PeekChar();
|
|
|
|
// Make a copy of the command string so that modifications
|
|
// do not change the actual command string the debugger is processing.
|
|
CopyString(CmdCopy, g_CurCmd, DIMA(CmdCopy));
|
|
|
|
//
|
|
// Syntax is [path-without-spaces]module.function argument-string.
|
|
//
|
|
|
|
ModName = CmdCopy;
|
|
FnName = NULL;
|
|
|
|
Cmd = CmdCopy;
|
|
while (*Cmd != ' ' && *Cmd != '\t' && *Cmd &&
|
|
*Cmd != ';' && *Cmd != '"')
|
|
{
|
|
Cmd++;
|
|
}
|
|
|
|
Scan = Cmd;
|
|
if (*Cmd && *Cmd != ';' && *Cmd != '"')
|
|
{
|
|
*Cmd = 0;
|
|
Cmd++;
|
|
}
|
|
|
|
while (*Scan != '.' && Scan != ModName)
|
|
{
|
|
Scan--;
|
|
}
|
|
|
|
if (*Scan == '.' && !BuiltInOnly)
|
|
{
|
|
*Scan = 0;
|
|
Scan++;
|
|
FnName = Scan;
|
|
}
|
|
else
|
|
{
|
|
FnName = ModName;
|
|
ModName = NULL;
|
|
}
|
|
|
|
if ((FnArgs = BufferStringValue(&Cmd,
|
|
STRV_ESCAPED_CHARACTERS |
|
|
STRV_ALLOW_EMPTY_STRING,
|
|
NULL, &Save)) == NULL)
|
|
{
|
|
ErrOut("Syntax error in extension string\n");
|
|
return;
|
|
}
|
|
|
|
// Update the real command string pointer to account for
|
|
// the characters parsed in the copy.
|
|
g_CurCmd += Cmd - CmdCopy;
|
|
|
|
//
|
|
// ModName -> Name of module
|
|
// FnName -> Name of command to process
|
|
// FnArgs -> argument to command
|
|
//
|
|
|
|
if (ModName != NULL)
|
|
{
|
|
Ext = AddExtensionDll(ModName, TRUE, NULL, NULL);
|
|
if (Ext == NULL)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Ext = g_ExtDlls;
|
|
}
|
|
|
|
if (!_stricmp(FnName, "load"))
|
|
{
|
|
if (ModName == NULL)
|
|
{
|
|
Ext = AddExtensionDll(FnArgs, TRUE, NULL, NULL);
|
|
if (Ext == NULL)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
LoadExtensionDll(g_Target, Ext);
|
|
return;
|
|
}
|
|
else if (!_stricmp(FnName, "setdll"))
|
|
{
|
|
if (ModName == NULL)
|
|
{
|
|
Ext = AddExtensionDll(FnArgs, TRUE, NULL, NULL);
|
|
if (Ext == NULL)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
MoveExtensionToHead(Ext);
|
|
if (ModName != NULL && Ext->Dll == NULL)
|
|
{
|
|
dprintf("Added %s to extension DLL chain\n", Ext->Name);
|
|
}
|
|
return;
|
|
}
|
|
else if (!_stricmp(FnName, "unload"))
|
|
{
|
|
if (ModName == NULL)
|
|
{
|
|
if (*FnArgs == '\0')
|
|
{
|
|
Ext = g_ExtDlls;
|
|
}
|
|
else
|
|
{
|
|
Ext = AddExtensionDll(FnArgs, TRUE, NULL, NULL);
|
|
}
|
|
if (Ext == NULL)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
if (Ext != NULL)
|
|
{
|
|
UnloadExtensionDll(Ext, TRUE);
|
|
}
|
|
return;
|
|
}
|
|
else if (!_stricmp(FnName, "unloadall"))
|
|
{
|
|
g_EngNotify++;
|
|
while (g_ExtDlls != NULL)
|
|
{
|
|
UnloadExtensionDll(g_ExtDlls, TRUE);
|
|
}
|
|
g_EngNotify--;
|
|
NotifyChangeEngineState(DEBUG_CES_EXTENSIONS, 0, TRUE);
|
|
return;
|
|
}
|
|
|
|
if (BuiltInOnly)
|
|
{
|
|
error(SYNTAX);
|
|
}
|
|
|
|
HRESULT ExtStatus;
|
|
|
|
CallAnyExtension(Client, Ext, FnName, FnArgs, ModName != NULL, TRUE,
|
|
&ExtStatus);
|
|
}
|
|
|
|
void
|
|
ReadDebugOptions (BOOL fQuiet, char * pszOptionsStr)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Parses an options string (see g_EnvDbgOptionNames) and maps
|
|
it to OPTION_ flags (in g_EnvDbgOptions).
|
|
|
|
Arguments:
|
|
|
|
fQuiet - If TRUE, do not print option settings.
|
|
pszOptionsStr - Options string; if NULL, get it from _NT_DEBUG_OPTIONS
|
|
|
|
Return Value:
|
|
|
|
None
|
|
--*/
|
|
{
|
|
BOOL fInit;
|
|
char ** ppszOption;
|
|
char * psz;
|
|
DWORD dwMask;
|
|
int iOptionCount;
|
|
|
|
fInit = (pszOptionsStr == NULL);
|
|
if (fInit)
|
|
{
|
|
g_EnvDbgOptions = 0;
|
|
pszOptionsStr = getenv("_NT_DEBUG_OPTIONS");
|
|
}
|
|
if (pszOptionsStr == NULL)
|
|
{
|
|
if (!fQuiet)
|
|
{
|
|
dprintf("_NT_DEBUG_OPTIONS is not defined\n");
|
|
}
|
|
return;
|
|
}
|
|
psz = pszOptionsStr;
|
|
while (*psz != '\0')
|
|
{
|
|
*psz = (char)toupper(*psz);
|
|
psz++;
|
|
}
|
|
ppszOption = g_EnvDbgOptionNames;
|
|
for (iOptionCount = 0;
|
|
iOptionCount < OPTION_COUNT;
|
|
iOptionCount++, ppszOption++)
|
|
{
|
|
if ((strstr(pszOptionsStr, *ppszOption) == NULL))
|
|
{
|
|
continue;
|
|
}
|
|
dwMask = (1 << iOptionCount);
|
|
if (fInit)
|
|
{
|
|
g_EnvDbgOptions |= dwMask;
|
|
}
|
|
else
|
|
{
|
|
g_EnvDbgOptions ^= dwMask;
|
|
}
|
|
}
|
|
if (!fQuiet)
|
|
{
|
|
dprintf("Debug Options:");
|
|
if (g_EnvDbgOptions == 0)
|
|
{
|
|
dprintf(" <none>\n");
|
|
}
|
|
else
|
|
{
|
|
dwMask = g_EnvDbgOptions;
|
|
ppszOption = g_EnvDbgOptionNames;
|
|
while (dwMask != 0)
|
|
{
|
|
if (dwMask & 0x1)
|
|
{
|
|
dprintf(" %s", *ppszOption);
|
|
}
|
|
dwMask >>= 1;
|
|
ppszOption++;
|
|
}
|
|
dprintf("\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// LoadWow64ExtsIfNeeded
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
VOID
|
|
LoadWow64ExtsIfNeeded(ULONG64 Process)
|
|
{
|
|
LONG_PTR Wow64Info;
|
|
NTSTATUS Status;
|
|
EXTDLL * Extension;
|
|
|
|
// wx86 only runs on NT.
|
|
if (g_DebuggerPlatformId != VER_PLATFORM_WIN32_NT)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// if New process is a Wx86 process, load in the wx86 extensions
|
|
// dll. This will stay loaded until ntsd exits.
|
|
//
|
|
|
|
Status = g_NtDllCalls.NtQueryInformationProcess(OS_HANDLE(Process),
|
|
ProcessWow64Information,
|
|
&Wow64Info,
|
|
sizeof(Wow64Info),
|
|
NULL
|
|
);
|
|
|
|
if (NT_SUCCESS(Status) && Wow64Info)
|
|
{
|
|
Extension = AddExtensionDll("wow64exts", FALSE, g_Target, NULL);
|
|
|
|
//
|
|
// Force load it so we get the entry point the debugger needs
|
|
//
|
|
LoadExtensionDll(g_Target, Extension);
|
|
}
|
|
}
|