static bool GetStackFrameInfo(str::Str<char>& s, STACKFRAME64 *stackFrame,
CONTEXT *ctx, HANDLE hThread)
{
#if defined(_WIN64)
int machineType = IMAGE_FILE_MACHINE_AMD64;
#else
int machineType = IMAGE_FILE_MACHINE_I386;
#endif
BOOL ok = _StackWalk64(machineType, GetCurrentProcess(), hThread,
stackFrame, ctx, NULL, _SymFunctionTableAccess64,
_SymGetModuleBase64, NULL);
if (!ok)
return false;
DWORD64 addr = stackFrame->AddrPC.Offset;
if (0 == addr)
return true;
if (addr == stackFrame->AddrReturn.Offset) {
s.Append("GetStackFrameInfo(): addr == stackFrame->AddrReturn.Offset");
return false;
}
GetAddressInfo(s, addr);
return true;
}
void GetExceptionInfo(str::Str<char>& s, EXCEPTION_POINTERS *excPointers)
{
if (!excPointers)
return;
EXCEPTION_RECORD *excRecord = excPointers->ExceptionRecord;
DWORD excCode = excRecord->ExceptionCode;
s.AppendFmt("Exception: %08X %s\r\n", (int)excCode, ExceptionNameFromCode(excCode));
s.AppendFmt("Faulting IP: ");
GetAddressInfo(s, (DWORD64)excRecord->ExceptionAddress);
if ((EXCEPTION_ACCESS_VIOLATION == excCode) ||
(EXCEPTION_IN_PAGE_ERROR == excCode))
{
int readWriteFlag = (int)excRecord->ExceptionInformation[0];
DWORD64 dataVirtAddr = (DWORD64)excRecord->ExceptionInformation[1];
if (0 == readWriteFlag) {
s.Append("Fault reading address "); AppendAddress(s, dataVirtAddr);
} else if (1 == readWriteFlag) {
s.Append("Fault writing address "); AppendAddress(s, dataVirtAddr);
} else if (8 == readWriteFlag) {
s.Append("DEP violation at address "); AppendAddress(s, dataVirtAddr);
} else {
s.Append("unknown readWriteFlag: %d", readWriteFlag);
}
s.Append("\r\n");
}
PCONTEXT ctx = excPointers->ContextRecord;
s.AppendFmt("\r\nRegisters:\r\n");
#ifdef _WIN64
s.AppendFmt("RAX:%016I64X RBX:%016I64X RCX:%016I64X\r\nRDX:%016I64X RSI:%016I64X RDI:%016I64X\r\n"
"R8: %016I64X\r\nR9: %016I64X\r\nR10:%016I64X\r\nR11:%016I64X\r\nR12:%016I64X\r\nR13:%016I64X\r\nR14:%016I64X\r\nR15:%016I64X\r\n",
ctx->Rax, ctx->Rbx, ctx->Rcx, ctx->Rdx, ctx->Rsi, ctx->Rdi,
ctx->R9,ctx->R10,ctx->R11,ctx->R12,ctx->R13,ctx->R14,ctx->R15);
s.AppendFmt("CS:RIP:%04X:%016I64X\r\n", ctx->SegCs, ctx->Rip);
s.AppendFmt("SS:RSP:%04X:%016X RBP:%08X\r\n", ctx->SegSs, ctx->Rsp, ctx->Rbp);
s.AppendFmt("DS:%04X ES:%04X FS:%04X GS:%04X\r\n", ctx->SegDs, ctx->SegEs, ctx->SegFs, ctx->SegGs);
s.AppendFmt("Flags:%08X\r\n", ctx->EFlags);
#else
s.AppendFmt("EAX:%08X EBX:%08X ECX:%08X\r\nEDX:%08X ESI:%08X EDI:%08X\r\n",
ctx->Eax, ctx->Ebx, ctx->Ecx, ctx->Edx, ctx->Esi, ctx->Edi);
s.AppendFmt("CS:EIP:%04X:%08X\r\n", ctx->SegCs, ctx->Eip);
s.AppendFmt("SS:ESP:%04X:%08X EBP:%08X\r\n", ctx->SegSs, ctx->Esp, ctx->Ebp);
s.AppendFmt("DS:%04X ES:%04X FS:%04X GS:%04X\r\n", ctx->SegDs, ctx->SegEs, ctx->SegFs, ctx->SegGs);
s.AppendFmt("Flags:%08X\r\n", ctx->EFlags);
#endif
s.Append("\r\nCrashed thread:\r\n");
// it's not really for current thread, but it seems to work
GetCallstack(s, *ctx, GetCurrentThread());
}
bool tcp_server::set_local_address()
{
int err;
int len = sizeof(m_local_addr);
err = uv_tcp_getsockname(m_uv_handle, (struct sockaddr*)&m_local_addr, &len);
if (err)
{
osd_printf_error("uv_tcp_getsockname() failed: %s\n", uv_strerror(err));
return false;
}
int family;
GetAddressInfo((const struct sockaddr*)&m_local_addr, &family, m_local_ip, &m_local_port);
return true;
}
void CExceptionParser::ParseCallStack(PCONTEXT pContextRecord,UINT MaxLoopCount)
{
if(m_hProcess==NULL)
return;
static HINSTANCE LastInstance=NULL;
static ADDRESS_INFO AddressInfo;
static STACKFRAME64 StackFrame;
ZeroMemory(&StackFrame,sizeof(StackFrame));
StackFrame.AddrPC.Offset=pContextRecord->Eip;
StackFrame.AddrPC.Mode=AddrModeFlat;
StackFrame.AddrStack.Offset=pContextRecord->Esp;
StackFrame.AddrStack.Mode=AddrModeFlat;
StackFrame.AddrFrame.Offset=pContextRecord->Ebp;
StackFrame.AddrFrame.Mode=AddrModeFlat;
while(MaxLoopCount&&StackWalk64(IMAGE_FILE_MACHINE_I386,m_hProcess,GetCurrentThread(),
&StackFrame,pContextRecord,0,SymFunctionTableAccess64,SymGetModuleBase64,0))
{
if(StackFrame.AddrFrame.Offset==0)
break;
if(GetAddressInfo(StackFrame.AddrPC.Offset,&AddressInfo))
{
if(LastInstance!=AddressInfo.hInstance)
{
LastInstance=AddressInfo.hInstance;
PrintLog("调用模块:%s",AddressInfo.ModuleName);
}
PrintLog("调用地址:0x%X",(DWORD)StackFrame.AddrPC.Offset);
PrintLog("地址描述:函数(%s),文件(%s)(%d)",AddressInfo.SymbolInfo.Name,AddressInfo.CppFileName,AddressInfo.LineNumber);
}
MaxLoopCount--;
}
}
void CExceptionParser::ParseException(LPEXCEPTION_POINTERS pException)
{
//CAutoLock Lock(m_CriticalSection);
LPCTSTR szModulePath=GetModulePath();
char szLogFileName[MAX_PATH];
SYSTEMTIME CurTime;
GetLocalTime(&CurTime);
sprintf(szLogFileName,"%s\\Exception%d-%02d-%02d %02d-%02d-%02d.txt",
(LPCTSTR)szModulePath,
CurTime.wYear,CurTime.wMonth,CurTime.wDay,
CurTime.wHour,CurTime.wMinute,CurTime.wSecond);
m_hLogFile=CreateFile(szLogFileName,GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
m_hProcess=GetCurrentProcess();
if(!SymInitialize(m_hProcess,(PSTR)szModulePath,TRUE))
{
if(!SymInitialize(m_hProcess,NULL,TRUE))
{
}
}
if(m_ExceptionCount>0)
{
PrintLog("发生多次异常捕捉%d",m_ExceptionCount);
return;
}
m_ExceptionCount++;
PrintLog("-----------------------------------------------------------------");
PrintLog("程序发生异常:类型: 0x%x 地址: 0x%x",
pException->ExceptionRecord->ExceptionCode ,pException->ExceptionRecord->ExceptionAddress);
if(pException->ExceptionRecord->ExceptionCode==EXCEPTION_ACCESS_VIOLATION)
{
PrintLog("地址:0x%x%s",
pException->ExceptionRecord->ExceptionInformation[1],
pException->ExceptionRecord->ExceptionInformation[0]?"不可写":"不可读");
}
static ADDRESS_INFO AddressInfo;
GetAddressInfo((DWORD64)pException->ExceptionRecord->ExceptionAddress,&AddressInfo);
PrintLog("地址描述:函数(%s),文件(%s)(%d)",AddressInfo.SymbolInfo.Name,AddressInfo.CppFileName,AddressInfo.LineNumber);
PrintLog("调用堆栈:");
ParseCallStack(pException->ContextRecord);
PrintLog("-----------------------------------------------------------------");
WriteDump(pException);
CloseHandle(m_hLogFile);
FILE *pFile = fopen("ExceptionDump.dump","a+");
if(pFile)
{
char tmp[] = "Begin write exception dump for the subsystem!";
tmp[sizeof(tmp)-1] = '\n';
fwrite(tmp,sizeof(tmp),1,pFile);
fflush(pFile);
for(int i=0;i<m_finalizerNr;i++)
{
m_ppFinalizers[i]->OnException(pFile);
}
fclose(pFile);
pFile = NULL;
}
}
