708 lines
22 KiB
C
708 lines
22 KiB
C
/*++
|
|
|
|
|
|
Copyright (c) 1998 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
crash.c
|
|
|
|
Abstract:
|
|
|
|
This file contains the code necessary to generate a
|
|
a user mode dump of the current app. The code will essentially
|
|
take a non-fatal snapshot and allow the debugging session
|
|
to continue.
|
|
|
|
|
|
Author:
|
|
|
|
Carlos Klapp (Sept. 24, 98)
|
|
|
|
Environment:
|
|
|
|
Win32, User Mode
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#include <crash.h>
|
|
#include "dbugexcp.h"
|
|
|
|
|
|
/************************** Data declaration *************************/
|
|
#define MEM_SIZE (64*1024)
|
|
|
|
/****** Publics ********/
|
|
|
|
extern LPPD LppdCommand;
|
|
extern LPTD LptdCommand;
|
|
extern LPSHF Lpshf; // vector table for symbol handler
|
|
|
|
|
|
|
|
/****** Externs from ??? *******/
|
|
|
|
|
|
// these are here only so that we can link
|
|
// with crashlib. they are only referenced
|
|
// when reading a kernel mode crash dump
|
|
|
|
extern "C" {
|
|
ULONG64 KiProcessors[1];
|
|
ULONG64 KiPcrBaseAddress[1];
|
|
};
|
|
|
|
|
|
/************************** Private Structures *************************/
|
|
|
|
typedef struct _tagMODULELIST {
|
|
LPMODULE_LIST pModList;
|
|
LPMODULE_ENTRY pModEntry;
|
|
DWORD dwModIdx;
|
|
BOOL bFinished;
|
|
} MODULELIST_WCRASH, * PMODULELIST_WCRASH;
|
|
|
|
|
|
// private data structure use for communcating
|
|
// crash dump data to the callback function
|
|
|
|
typedef struct _tagDEBUGPACKET {
|
|
//HWND hwnd;
|
|
//HANDLE hEvent;
|
|
//OPTIONS options;
|
|
//DWORD dwPidToDebug;
|
|
//HANDLE hEventToSignal;
|
|
//DWORD dwProcessId;
|
|
HPID hpid;
|
|
HTID htid;
|
|
TCHAR szProcessName[_MAX_PATH];
|
|
DWORD dwBaseOfImage;
|
|
DWORD dwImageSize;
|
|
LPTD lptdThreadListHead;
|
|
//LIST_ENTRY ThreadList;
|
|
|
|
|
|
//PTHREADCONTEXT tctx;
|
|
//DWORD stackBase;
|
|
//DWORD stackRA;
|
|
DEBUG_EVENT DebugEvent;
|
|
//DWORD ExitStatus;
|
|
} DEBUGPACKET, *PDEBUGPACKET;
|
|
|
|
typedef struct _CRASH_DUMP_INFO {
|
|
// TRUE - stop all processing
|
|
// FALSE - continue processing
|
|
BOOL bFatalError;
|
|
|
|
// Module specific data
|
|
MODULELIST_WCRASH modlst;
|
|
|
|
DEBUGPACKET dp;
|
|
EXCEPTION_DEBUG_INFO *pExceptionInfo;
|
|
DWORD MemoryCount;
|
|
DWORD_PTR Address;
|
|
PUCHAR pMemoryData;
|
|
MEMORY_BASIC_INFORMATION mbi;
|
|
SIZE_T MbiOffset;
|
|
SIZE_T MbiRemaining;
|
|
LPTD lptdCurThread; // LIST_ENTRY ThreadList;
|
|
PCRASH_MODULE CrashModule;
|
|
} CRASH_DUMP_INFO, *PCRASH_DUMP_INFO;
|
|
|
|
|
|
|
|
// Used by the sort algorithm to make sure that the
|
|
// main module is the first in the list
|
|
|
|
static TCHAR szMainModule[MAX_PATH];
|
|
|
|
|
|
/******************* Func Declarations *************************/
|
|
|
|
BOOL GetThreadContext_CrashDump(LPTD, LPCONTEXT, UINT);
|
|
|
|
void ConvertMemInfoFromOSDFmtToSysFmt(MEMORY_BASIC_INFORMATION *, MEMINFO *);
|
|
int __cdecl SkewedSortModEntryByAddress(const void *, const void *);
|
|
|
|
UINT WINAPI DHGetDebuggeeBytes(ADDR addr, UINT cb, void * lpb);
|
|
|
|
|
|
/************************** Code *************************/
|
|
|
|
BOOL
|
|
WindbgCrashDumpCallback(
|
|
DWORD dwDataType,
|
|
PVOID *ppvDumpData,
|
|
LPDWORD pdwDumpDataLength,
|
|
PVOID pvData
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is the callback used by crashlib.
|
|
Its purpose is to provide data to DmpCreateUserDump()
|
|
for writting to the crashdump file.
|
|
|
|
Arguments:
|
|
|
|
dwDataType - requested data type
|
|
|
|
ppvDumpData - pointer to a pointer to the data
|
|
|
|
pdwDumpDataLength - pointer to the data length
|
|
|
|
CrashdumpInfo - DrWatson private data
|
|
|
|
Return Value:
|
|
|
|
TRUE - continue calling back for the requested data type
|
|
FALSE - stop calling back and go on to the next data type
|
|
|
|
--*/
|
|
{
|
|
PCRASH_DUMP_INFO pCrashdumpInfo = (PCRASH_DUMP_INFO) pvData;
|
|
DWORD cb;
|
|
|
|
if (pCrashdumpInfo->bFatalError) {
|
|
*pdwDumpDataLength = 0;
|
|
return FALSE;
|
|
}
|
|
|
|
switch( dwDataType ) {
|
|
case DMP_DEBUG_EVENT:
|
|
Assert(sizeof(pCrashdumpInfo->dp.DebugEvent) == sizeof(DEBUG_EVENT));
|
|
|
|
*ppvDumpData = &pCrashdumpInfo->dp.DebugEvent;
|
|
*pdwDumpDataLength = sizeof(DEBUG_EVENT);
|
|
break;
|
|
|
|
case DMP_THREAD_STATE:
|
|
{
|
|
static CRASH_THREAD CrashThread;
|
|
TST tst = {0};
|
|
|
|
|
|
// BUGBUG no 64 bit support
|
|
|
|
*ppvDumpData = &CrashThread;
|
|
|
|
if (pCrashdumpInfo->lptdCurThread == NULL) {
|
|
pCrashdumpInfo->lptdCurThread = pCrashdumpInfo->dp.lptdThreadListHead;
|
|
} else {
|
|
pCrashdumpInfo->lptdCurThread = pCrashdumpInfo->lptdCurThread->lptdNext;
|
|
}
|
|
|
|
if (NULL == pCrashdumpInfo->lptdCurThread) {
|
|
pCrashdumpInfo->lptdCurThread = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
ZeroMemory(&CrashThread, sizeof(CrashThread));
|
|
CrashThread.ThreadId = HandleToUlong(pCrashdumpInfo->lptdCurThread->htid);
|
|
|
|
if (xosdNone != OSDGetThreadStatus(
|
|
pCrashdumpInfo->lptdCurThread->lppd->hpid,
|
|
pCrashdumpInfo->lptdCurThread->htid, &tst)) {
|
|
|
|
CmdLogFmt("Crash warning: No status for thread %d\r\n",
|
|
pCrashdumpInfo->lptdCurThread->itid);
|
|
CrashThread.SuspendCount = (DWORD) -1;
|
|
} else {
|
|
CrashThread.SuspendCount = tst.dwSuspendCount;
|
|
/*if (CrashThread.SuspendCount != (DWORD)-1) {
|
|
ResumeThread(ptctx->hThread);
|
|
}*/
|
|
// BUGBUG 64 bit
|
|
CrashThread.Teb = (DWORD)tst.dwTeb;
|
|
|
|
Assert(tst.dwPriorityMax <= 31);
|
|
if (tst.dwPriorityMax < 16) {
|
|
|
|
// NOT realtime
|
|
if (tst.dwPriority <= 6) {
|
|
CrashThread.PriorityClass = IDLE_PRIORITY_CLASS;
|
|
CrashThread.Priority = tst.dwPriority - 4;
|
|
} else if (tst.dwPriority <= 11) {
|
|
CrashThread.PriorityClass = NORMAL_PRIORITY_CLASS;
|
|
CrashThread.Priority = tst.dwPriority - 9;
|
|
} else if (tst.dwPriority <= 15) {
|
|
CrashThread.PriorityClass = HIGH_PRIORITY_CLASS;
|
|
if (15 == tst.dwPriority) {
|
|
CrashThread.Priority = THREAD_PRIORITY_TIME_CRITICAL;
|
|
} else {
|
|
CrashThread.Priority = tst.dwPriority - 13;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
CrashThread.PriorityClass = REALTIME_PRIORITY_CLASS;
|
|
|
|
if (15 == tst.dwPriority) {
|
|
CrashThread.Priority = THREAD_PRIORITY_TIME_CRITICAL;
|
|
} else {
|
|
CrashThread.Priority = tst.dwPriority - 4;
|
|
}
|
|
}
|
|
}
|
|
*pdwDumpDataLength = sizeof(CRASH_THREAD);
|
|
}
|
|
break;
|
|
|
|
case DMP_MEMORY_BASIC_INFORMATION:
|
|
while( TRUE ) {
|
|
MEMINFO meminfo = {0};
|
|
|
|
pCrashdumpInfo->Address += pCrashdumpInfo->mbi.RegionSize;
|
|
|
|
meminfo.addr.addr.off = pCrashdumpInfo->Address;
|
|
|
|
if (xosdNone != OSDGetMemoryInformation(pCrashdumpInfo->dp.hpid,
|
|
NULL, &meminfo)) {
|
|
return FALSE;
|
|
}
|
|
|
|
ConvertMemInfoFromOSDFmtToSysFmt(&pCrashdumpInfo->mbi, &meminfo);
|
|
|
|
if ((pCrashdumpInfo->mbi.AllocationProtect & PAGE_GUARD) ||
|
|
(pCrashdumpInfo->mbi.AllocationProtect & PAGE_NOACCESS)) {
|
|
continue;
|
|
}
|
|
if ((pCrashdumpInfo->mbi.State & MEM_FREE) ||
|
|
(pCrashdumpInfo->mbi.State & MEM_RESERVE)) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
*ppvDumpData = &pCrashdumpInfo->mbi;
|
|
*pdwDumpDataLength = sizeof(MEMORY_BASIC_INFORMATION);
|
|
break;
|
|
|
|
case DMP_THREAD_CONTEXT:
|
|
{
|
|
static CONTEXT context;
|
|
|
|
if (pCrashdumpInfo->lptdCurThread == NULL) {
|
|
pCrashdumpInfo->lptdCurThread = pCrashdumpInfo->dp.lptdThreadListHead;
|
|
} else {
|
|
pCrashdumpInfo->lptdCurThread = pCrashdumpInfo->lptdCurThread->lptdNext;
|
|
}
|
|
|
|
if (NULL == pCrashdumpInfo->lptdCurThread) {
|
|
pCrashdumpInfo->lptdCurThread = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
ZeroMemory(&context, sizeof(context));
|
|
if (!GetThreadContext_CrashDump(pCrashdumpInfo->lptdCurThread, &context,
|
|
sizeof(context))) {
|
|
CmdLogFmt("!!!Crash error: No context for thread %d\r\n",
|
|
pCrashdumpInfo->lptdCurThread->itid);
|
|
pCrashdumpInfo->bFatalError = TRUE;
|
|
}
|
|
|
|
*ppvDumpData = &context;
|
|
*pdwDumpDataLength = sizeof(CONTEXT);
|
|
}
|
|
break;
|
|
|
|
case DMP_MODULE:
|
|
|
|
// Initialize module list
|
|
|
|
if (!pCrashdumpInfo->modlst.pModList) {
|
|
if (xosdNone != OSDGetModuleList( LppdCur->hpid,
|
|
LptdCur->htid, NULL, &pCrashdumpInfo->modlst.pModList)) {
|
|
|
|
|
|
// Error obtaining mod list
|
|
|
|
CmdLogFmt("!!!Crash error: Unable to obtain module list\r\n");
|
|
pCrashdumpInfo->bFatalError = TRUE;
|
|
// Fall thru to cleanup
|
|
pCrashdumpInfo->modlst.bFinished = TRUE;
|
|
} else {
|
|
|
|
|
|
// Obtained mod list
|
|
|
|
if (ModuleListCount(pCrashdumpInfo->modlst.pModList) > 0) {
|
|
// Necessary for everything to function. This sort will
|
|
// always place the process before the modules. It then
|
|
// sorts the modules by mem address.
|
|
qsort(FirstModuleEntry(pCrashdumpInfo->modlst.pModList),
|
|
ModuleListCount(pCrashdumpInfo->modlst.pModList),
|
|
sizeof(MODULE_ENTRY), SkewedSortModEntryByAddress);
|
|
|
|
// Get the first module entry
|
|
pCrashdumpInfo->modlst.pModEntry =
|
|
FirstModuleEntry(pCrashdumpInfo->modlst.pModList);
|
|
pCrashdumpInfo->modlst.dwModIdx = 0;
|
|
} else {
|
|
CmdLogFmt("!!!Crash error: Module list is empty\r\n");
|
|
pCrashdumpInfo->bFatalError = TRUE;
|
|
// Fall thru to cleanup
|
|
pCrashdumpInfo->modlst.bFinished = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Cleanup ??
|
|
|
|
if (pCrashdumpInfo->modlst.bFinished) {
|
|
// Cleanup
|
|
if (pCrashdumpInfo->modlst.pModList) {
|
|
MHFree(pCrashdumpInfo->modlst.pModList);
|
|
}
|
|
ZeroMemory(&pCrashdumpInfo->modlst, sizeof(pCrashdumpInfo->modlst));
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Process the current module
|
|
|
|
// BUGBUG 64 bit
|
|
pCrashdumpInfo->CrashModule->BaseOfImage = (DWORD)ModuleEntryBase(pCrashdumpInfo->modlst.pModEntry);
|
|
pCrashdumpInfo->CrashModule->SizeOfImage = (DWORD)ModuleEntryLimit(pCrashdumpInfo->modlst.pModEntry);
|
|
|
|
// Get module name
|
|
{
|
|
PSTR pszImgName = SHGetExeName( (HEXE)ModuleEntryEmi(pCrashdumpInfo->modlst.pModEntry) );
|
|
Assert(pszImgName);
|
|
|
|
pCrashdumpInfo->CrashModule->ImageNameLength = strlen(pszImgName) + 1;
|
|
strcpy(pCrashdumpInfo->CrashModule->ImageName, pszImgName);
|
|
|
|
}
|
|
*pdwDumpDataLength = sizeof(CRASH_MODULE) + pCrashdumpInfo->CrashModule->ImageNameLength;
|
|
*ppvDumpData = pCrashdumpInfo->CrashModule;
|
|
|
|
|
|
// Get the next module
|
|
|
|
pCrashdumpInfo->modlst.dwModIdx++;
|
|
if (pCrashdumpInfo->modlst.dwModIdx < ModuleListCount(pCrashdumpInfo->modlst.pModList)) {
|
|
pCrashdumpInfo->modlst.pModEntry = NextModuleEntry(pCrashdumpInfo->modlst.pModEntry);
|
|
} else {
|
|
pCrashdumpInfo->modlst.bFinished = TRUE;
|
|
}
|
|
break;
|
|
|
|
case DMP_MEMORY_DATA:
|
|
{
|
|
MEMINFO meminfo = {0};
|
|
|
|
if (!pCrashdumpInfo->MemoryCount) {
|
|
pCrashdumpInfo->Address = 0;
|
|
pCrashdumpInfo->MbiOffset = 0;
|
|
pCrashdumpInfo->MbiRemaining = 0;
|
|
ZeroMemory( &pCrashdumpInfo->mbi, sizeof(MEMORY_BASIC_INFORMATION) );
|
|
pCrashdumpInfo->pMemoryData = (PUCHAR) VirtualAlloc(
|
|
NULL,
|
|
MEM_SIZE,
|
|
MEM_COMMIT,
|
|
PAGE_READWRITE
|
|
);
|
|
}
|
|
if (!pCrashdumpInfo->MbiRemaining) {
|
|
while( TRUE ) {
|
|
|
|
pCrashdumpInfo->Address += pCrashdumpInfo->mbi.RegionSize;
|
|
|
|
meminfo.addr.addr.off = pCrashdumpInfo->Address;
|
|
|
|
if (xosdNone != OSDGetMemoryInformation(pCrashdumpInfo->dp.hpid,
|
|
NULL, &meminfo)) {
|
|
|
|
if (pCrashdumpInfo->pMemoryData) {
|
|
VirtualFree( pCrashdumpInfo->pMemoryData, MEM_SIZE, MEM_RELEASE );
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
ConvertMemInfoFromOSDFmtToSysFmt(&pCrashdumpInfo->mbi, &meminfo);
|
|
|
|
if ((pCrashdumpInfo->mbi.Protect & PAGE_GUARD) ||
|
|
(pCrashdumpInfo->mbi.Protect & PAGE_NOACCESS)) {
|
|
continue;
|
|
}
|
|
if ((pCrashdumpInfo->mbi.State & MEM_FREE) ||
|
|
(pCrashdumpInfo->mbi.State & MEM_RESERVE)) {
|
|
continue;
|
|
}
|
|
pCrashdumpInfo->MbiOffset = 0;
|
|
pCrashdumpInfo->MbiRemaining = pCrashdumpInfo->mbi.RegionSize;
|
|
pCrashdumpInfo->MemoryCount += 1;
|
|
break;
|
|
}
|
|
}
|
|
*pdwDumpDataLength = (DWORD)__min( pCrashdumpInfo->MbiRemaining, MEM_SIZE );
|
|
pCrashdumpInfo->MbiRemaining -= *pdwDumpDataLength;
|
|
|
|
meminfo.addr.addr.off = ((UOFFSET)pCrashdumpInfo->mbi.BaseAddress + pCrashdumpInfo->MbiOffset);
|
|
if (xosdNone != OSDReadMemory(pCrashdumpInfo->dp.hpid,
|
|
pCrashdumpInfo->dp.htid, &meminfo.addr,
|
|
pCrashdumpInfo->pMemoryData, *pdwDumpDataLength, &cb)) {
|
|
|
|
CmdLogFmt( "Crash warning: could not read memory at 0x%I64X\n", meminfo.addr.addr.off);
|
|
}
|
|
|
|
*ppvDumpData = pCrashdumpInfo->pMemoryData;
|
|
pCrashdumpInfo->MbiOffset += *pdwDumpDataLength;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
LOGERR
|
|
LogCrash(
|
|
LPSTR pszFileNameArg,
|
|
DWORD /*dwUnused*/
|
|
)
|
|
{
|
|
LOGERR logerr = LOGERROR_NOERROR;
|
|
PTSTR pszDumpName = NULL;
|
|
|
|
|
|
// This should have been handled by the "LogDotCommand" function
|
|
|
|
Assert(!g_contWorkspace_WkSp.m_bKernelDebugger);
|
|
|
|
|
|
// Error checking
|
|
|
|
CmdInsertInit();
|
|
|
|
// don't generate a dump of a dump
|
|
if (g_contWorkspace_WkSp.m_bUserCrashDump ||
|
|
(g_contWorkspace_WkSp.m_bKernelDebugger && g_contKernelDbgPreferences_WkSp.m_bUseCrashDump)) {
|
|
CmdLogFmt( "Crash: <.crash> is not allowed for crash dumps\n" );
|
|
return LOGERROR_QUIET;
|
|
}
|
|
|
|
// Process must be stopped
|
|
if (IsProcRunning( LppdCur )) {
|
|
CmdLogFmt( "Crash: process must first be stopped\n" );
|
|
return LOGERROR_QUIET;
|
|
}
|
|
|
|
PreRunInvalid();
|
|
|
|
PDWildInvalid();
|
|
TDWildInvalid();
|
|
|
|
// debuggee has to be active
|
|
if (!DebuggeeActive()) {
|
|
CmdLogFmt("Crash: There is not process to dump\r\n");
|
|
return LOGERROR_QUIET;
|
|
}
|
|
|
|
// Skip over any leading blanks
|
|
pszDumpName = CPSkipWhitespace(pszFileNameArg);
|
|
|
|
// Check for no argument
|
|
if (!*pszDumpName) {
|
|
CmdLogFmt("Crash: Must specify a file name\r\n");
|
|
return LOGERROR_QUIET;
|
|
}
|
|
|
|
|
|
|
|
// We finally get to do something
|
|
|
|
|
|
|
|
// Initialize structures
|
|
|
|
CRASH_DUMP_INFO CrashdumpInfo = {0};
|
|
|
|
|
|
// Init CrashdumpInfo
|
|
*szMainModule = NULL;
|
|
|
|
// Get the stopped thread
|
|
{
|
|
TCHAR szExt[_MAX_EXT] = {0};
|
|
LPTD lptd = LppdCur->lptdList;
|
|
|
|
for (; lptd; lptd = lptd->lptdNext) {
|
|
if (tsStopped == lptd->tstate || tsException2 == lptd->tstate) {
|
|
CrashdumpInfo.dp.hpid = lptd->lppd->hpid;;
|
|
CrashdumpInfo.dp.htid = lptd->htid;
|
|
CrashdumpInfo.dp.lptdThreadListHead = lptd->lppd->lptdList;
|
|
|
|
_tsplitpath(lptd->lppd->lpBaseExeName, NULL, NULL, szMainModule, szExt);
|
|
_tcscat(szMainModule, szExt);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (NULL == CrashdumpInfo.dp.hpid) {
|
|
CmdLogFmt("Crash error: There is no stopped thread on which to base the dump\r\n");
|
|
goto CLEANUP;
|
|
}
|
|
}
|
|
|
|
// Get the last debug event for the stopped thread
|
|
{
|
|
PIOCTLGENERIC pig;
|
|
DWORD dw;
|
|
|
|
pig = (PIOCTLGENERIC)calloc(sizeof(IOCTLGENERIC) + sizeof(DEBUG_EVENT), 1);
|
|
if (!pig) {
|
|
CmdLogFmt("!!!!!Crash error: Unable to allocate memory\r\n");
|
|
logerr = LOGERROR_QUIET;
|
|
goto CLEANUP;
|
|
}
|
|
|
|
pig->ioctlSubType = IG_DEBUG_EVENT;
|
|
pig->length = sizeof(DEBUG_EVENT);
|
|
if (xosdNone != OSDSystemService( CrashdumpInfo.dp.hpid,
|
|
CrashdumpInfo.dp.htid,
|
|
(SSVC) ssvcGeneric,
|
|
(LPV)pig,
|
|
sizeof(IOCTLGENERIC) + sizeof(DEBUG_EVENT),
|
|
&dw
|
|
)) {
|
|
CmdLogFmt("!!!!!Crash error: Unable to obtain debug event\r\n");
|
|
logerr = LOGERROR_QUIET;
|
|
goto CLEANUP;
|
|
}
|
|
|
|
Assert(sizeof(DEBUG_EVENT) == pig->length);
|
|
memcpy(&CrashdumpInfo.dp.DebugEvent, pig->data, sizeof(DEBUG_EVENT));
|
|
free( pig );
|
|
}
|
|
|
|
CrashdumpInfo.pExceptionInfo = &CrashdumpInfo.dp.DebugEvent.u.Exception;
|
|
CrashdumpInfo.CrashModule = (PCRASH_MODULE) calloc( 4096, 1);
|
|
|
|
|
|
|
|
// Write the dump file out
|
|
|
|
CmdLogFmt("Crash: generating dump file. This could take a while.\r\n");
|
|
if (DmpCreateUserDump(pszDumpName, WindbgCrashDumpCallback, &CrashdumpInfo)) {
|
|
|
|
CmdLogFmt("Crash: success\r\n");
|
|
|
|
} else {
|
|
|
|
CmdLogFmt("Crash: error generating dump file\r\n");
|
|
logerr = LOGERROR_QUIET;
|
|
|
|
}
|
|
|
|
CLEANUP:
|
|
if (CrashdumpInfo.CrashModule) {
|
|
free(CrashdumpInfo.CrashModule);
|
|
}
|
|
|
|
*szMainModule = NULL;
|
|
return logerr;
|
|
}
|
|
|
|
BOOL
|
|
GetThreadContext_CrashDump(
|
|
LPTD lptd,
|
|
LPCONTEXT lpContext,
|
|
UINT uSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function gets thread context.
|
|
|
|
Arguments:
|
|
|
|
lpContext - Supplies pointer to CONTEXT strructure.
|
|
|
|
cbSizeOfContext - Supplies the size of CONTEXT structure.
|
|
|
|
Return Value:
|
|
|
|
TRUE for success; FALSE for failure.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD dw = 0;
|
|
|
|
Assert(uSize < ULONG_MAX);
|
|
|
|
return OSDSystemService( lptd->lppd->hpid,
|
|
lptd->htid,
|
|
(SSVC) ssvcGetThreadContext,
|
|
lpContext,
|
|
(DWORD) uSize,
|
|
&dw
|
|
) == xosdNone;
|
|
|
|
Assert(dw == uSize);
|
|
}
|
|
|
|
|
|
void
|
|
ConvertMemInfoFromOSDFmtToSysFmt(
|
|
MEMORY_BASIC_INFORMATION * pmiSys,
|
|
MEMINFO * pmiOSD
|
|
)
|
|
{
|
|
Assert(pmiOSD);
|
|
Assert(pmiSys);
|
|
|
|
ZeroMemory(pmiSys, sizeof(*pmiSys));
|
|
|
|
// BUGBUG 64 bit
|
|
pmiSys->BaseAddress = (PVOID) pmiOSD->addr.addr.off;
|
|
pmiSys->AllocationBase = (PVOID) pmiOSD->addrAllocBase.addr.off;
|
|
pmiSys->RegionSize = (DWORD)pmiOSD->uRegionSize;
|
|
pmiSys->Protect = pmiOSD->dwProtect;
|
|
pmiSys->State = pmiOSD->dwState;
|
|
pmiSys->Type = pmiOSD->dwType;
|
|
pmiSys->AllocationProtect = pmiOSD->dwAllocationProtect;
|
|
}
|
|
|
|
int __cdecl
|
|
SkewedSortModEntryByAddress(
|
|
const void *pMod1,
|
|
const void *pMod2
|
|
)
|
|
/*++
|
|
The main module will always be first
|
|
--*/
|
|
{
|
|
TCHAR szFullName[_MAX_PATH] = {0};
|
|
TCHAR szExt[_MAX_EXT] = {0};
|
|
|
|
// Build the full name of the modules
|
|
_tsplitpath(SHGetExeName( (HEXE)ModuleEntryEmi((LPMODULE_ENTRY)pMod1) ),
|
|
NULL, NULL, szFullName, szExt);
|
|
_tcscat(szFullName, szExt);
|
|
|
|
// Found the main module?
|
|
if (!_tcsicmp(szMainModule, szFullName)) {
|
|
return -1;
|
|
}
|
|
|
|
_tsplitpath(SHGetExeName( (HEXE)ModuleEntryEmi((LPMODULE_ENTRY)pMod2) ),
|
|
NULL, NULL, szFullName, szExt);
|
|
_tcscat(szFullName, szExt);
|
|
|
|
// Found the main module?
|
|
if (!_tcsicmp(szMainModule, szFullName)) {
|
|
return 1;
|
|
}
|
|
|
|
return ModuleEntryBase((LPMODULE_ENTRY)pMod1) < ModuleEntryBase((LPMODULE_ENTRY)pMod2) ? -1 : 1;
|
|
}
|