让程序在崩溃时体面的退出之CallStack

        在我的那篇《让程序在崩溃时体面的退出之Unhandled Exception》中提供了一个捕捉程序崩溃事件的方法，可以添加代码在程序崩溃的时候做出适当的处理。不过，只知道程序在什么时候崩溃，但是不知道为什么崩溃，这对于程序开发者来说没有任何意义。因为如果不知道程序崩溃的原因，就没法去找到代码中的缺陷，当然就没法去修改代码而避免程序的崩溃。

        所有调试过代码的开发者都知道CallStack的重要性。如果在程序崩溃的时候得到CallStack，那么就能定位程序崩溃的具体位置，并最终找到解决方法。那么有没有什么方法在程序崩溃的时候得到CallStack呢？答案是肯定的。微软提供了一个DbgHelp.dll，里面包含了一系列的Windows API来供开发者调用。它是一个调试跟踪相关的模块，用于跟踪进程工作，在进程崩溃时收集程序产生异常时的堆栈信息，以供开发人员分析，从而很快找出使程序出现异常的原因。

        下面用具体的例子代码来说明怎样使用DbgHelp.dll中的Windows API来得到CallStack。代码里面有详细的注释来帮助理解。

        用VC创建一个名为Test的控制台程序，添加下面的代码。

[cpp] view
plaincopy

// 一个有函数调用的类  

//   

class CrashTest  

{  

public:  

    void Test()   

    {   

        Crash();   

    }  

  

private:  

    void Crash()   

    {   

        // 除零，人为的使程序崩溃  

        //  

        int i = 13;  

        int j = 0;  

        int m = i / j;  

    }  

};  

  

int _tmain(int argc, _TCHAR* argv[])  

{  

    CrashTest test;  

    test.Test();  

  

    return 0;  

}  

        编译上面的代码，到工程的Debug目录下找到编译好的Test.exe，双击运行，程序就会崩溃。从代码我们知道函数调用顺序是main() -> CrashTest::Test() -> CrashTest::Crash()。那么怎么在程序崩溃的时候得到CallStack呢？首先，先添加一些工具函数。

[cpp] view
plaincopy

#include <Windows.h>  

#include <DbgHelp.h>  

#include <iostream>  

#include <vector>  

  

// 添加对dbghelp.lib的编译依赖  

//  

#pragma comment(lib, "dbghelp.lib")  

  

using namespace std;  

  

const int MAX_ADDRESS_LENGTH = 32;  

const int MAX_NAME_LENGTH = 1024;  

  

// 崩溃信息  

//   

struct CrashInfo  

{  

    CHAR ErrorCode[MAX_ADDRESS_LENGTH];  

    CHAR Address[MAX_ADDRESS_LENGTH];  

    CHAR Flags[MAX_ADDRESS_LENGTH];  

};  

  

// CallStack信息  

//   

struct CallStackInfo  

{  

    CHAR ModuleName[MAX_NAME_LENGTH];  

    CHAR MethodName[MAX_NAME_LENGTH];  

    CHAR FileName[MAX_NAME_LENGTH];  

    CHAR LineNumber[MAX_NAME_LENGTH];  

};  

  

// 安全拷贝字符串函数  

//  

void SafeStrCpy(char* szDest, size_t nMaxDestSize, const char* szSrc)  

{  

    if (nMaxDestSize <= 0) return;  

    if (strlen(szSrc) < nMaxDestSize)  

    {  

        strcpy_s(szDest, nMaxDestSize, szSrc);  

    }  

    else  

    {  

        strncpy_s(szDest, nMaxDestSize, szSrc, nMaxDestSize);  

        szDest[nMaxDestSize-1] = '\0';  

    }  

}    

  

// 得到程序崩溃信息  

//  

CrashInfo GetCrashInfo(const EXCEPTION_RECORD *pRecord)  

{  

    CrashInfo crashinfo;  

    SafeStrCpy(crashinfo.Address, MAX_ADDRESS_LENGTH, "N/A");  

    SafeStrCpy(crashinfo.ErrorCode, MAX_ADDRESS_LENGTH, "N/A");  

    SafeStrCpy(crashinfo.Flags, MAX_ADDRESS_LENGTH, "N/A");  

  

    sprintf_s(crashinfo.Address, "%08X", pRecord->ExceptionAddress);  

    sprintf_s(crashinfo.ErrorCode, "%08X", pRecord->ExceptionCode);  

    sprintf_s(crashinfo.Flags, "%08X", pRecord->ExceptionFlags);  

  

    return crashinfo;  

}  

  

// 得到CallStack信息  

//  

vector<CallStackInfo> GetCallStack(const CONTEXT *pContext)  

{  

    HANDLE hProcess = GetCurrentProcess();  

  

    SymInitialize(hProcess, NULL, TRUE);  

  

    vector<CallStackInfo> arrCallStackInfo;  

  

    CONTEXT c = *pContext;  

  

    STACKFRAME64 sf;  

    memset(&sf, 0, sizeof(STACKFRAME64));  

    DWORD dwImageType = IMAGE_FILE_MACHINE_I386;  

  

    // 不同的CPU类型，具体信息可查询MSDN  

    //  

#ifdef _M_IX86  

    sf.AddrPC.Offset = c.Eip;  

    sf.AddrPC.Mode = AddrModeFlat;  

    sf.AddrStack.Offset = c.Esp;  

    sf.AddrStack.Mode = AddrModeFlat;  

    sf.AddrFrame.Offset = c.Ebp;  

    sf.AddrFrame.Mode = AddrModeFlat;  

#elif _M_X64  

    dwImageType = IMAGE_FILE_MACHINE_AMD64;  

    sf.AddrPC.Offset = c.Rip;  

    sf.AddrPC.Mode = AddrModeFlat;  

    sf.AddrFrame.Offset = c.Rsp;  

    sf.AddrFrame.Mode = AddrModeFlat;  

    sf.AddrStack.Offset = c.Rsp;  

    sf.AddrStack.Mode = AddrModeFlat;  

#elif _M_IA64  

    dwImageType = IMAGE_FILE_MACHINE_IA64;  

    sf.AddrPC.Offset = c.StIIP;  

    sf.AddrPC.Mode = AddrModeFlat;  

    sf.AddrFrame.Offset = c.IntSp;  

    sf.AddrFrame.Mode = AddrModeFlat;  

    sf.AddrBStore.Offset = c.RsBSP;  

    sf.AddrBStore.Mode = AddrModeFlat;  

    sf.AddrStack.Offset = c.IntSp;  

    sf.AddrStack.Mode = AddrModeFlat;  

#else  

    #error "Platform not supported!"  

#endif  

  

    HANDLE hThread = GetCurrentThread();  

  

    while (true)  

    {  

        // 该函数是实现这个功能的最重要的一个函数  

        // 函数的用法以及参数和返回值的具体解释可以查询MSDN  

        //  

        if (!StackWalk64(dwImageType, hProcess, hThread, &sf, &c, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))  

        {  

            break;  

        }  

  

        if (sf.AddrFrame.Offset == 0)  

        {  

            break;  

        }  

                  

        CallStackInfo callstackinfo;  

        SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, "N/A");  

        SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, "N/A");  

        SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, "N/A");  

        SafeStrCpy(callstackinfo.LineNumber, MAX_NAME_LENGTH, "N/A");  

  

        BYTE symbolBuffer[sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH];  

        IMAGEHLP_SYMBOL64 *pSymbol = (IMAGEHLP_SYMBOL64*)symbolBuffer;  

        memset(pSymbol, 0, sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH);  

  

        pSymbol->SizeOfStruct = sizeof(symbolBuffer);  

        pSymbol->MaxNameLength = MAX_NAME_LENGTH;  

  

        DWORD symDisplacement = 0;  

          

        // 得到函数名  

        //  

        if (SymGetSymFromAddr64(hProcess, sf.AddrPC.Offset, NULL, pSymbol))  

        {  

            SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, pSymbol->Name);  

        }  

  

        IMAGEHLP_LINE64 lineInfo;  

        memset(&lineInfo, 0, sizeof(IMAGEHLP_LINE64));  

  

        lineInfo.SizeOfStruct = sizeof(IMAGEHLP_LINE64);  

  

        DWORD dwLineDisplacement;  

  

        // 得到文件名和所在的代码行  

        //  

        if (SymGetLineFromAddr64(hProcess, sf.AddrPC.Offset, &dwLineDisplacement, &lineInfo))  

        {  

            SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, lineInfo.FileName);  

            sprintf_s(callstackinfo.LineNumber, "%d", lineInfo.LineNumber);  

        }  

  

        IMAGEHLP_MODULE64 moduleInfo;  

        memset(&moduleInfo, 0, sizeof(IMAGEHLP_MODULE64));  

  

        moduleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);  

  

        // 得到模块名  

        //  

        if (SymGetModuleInfo64(hProcess, sf.AddrPC.Offset, &moduleInfo))  

        {  

            SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, moduleInfo.ModuleName);  

        }  

  

        arrCallStackInfo.push_back(callstackinfo);  

    }  

  

    SymCleanup(hProcess);  

  

    return arrCallStackInfo;  

}  

        然后，就可以用《让程序在崩溃时体面的退出之Unhandled Exception》中提供的捕捉程序崩溃事件的方法添加一个回调函数，在这个函数里面调用上面的函数来得到程序崩溃时的CallStack。

[cpp] view
plaincopy

// 处理Unhandled Exception的回调函数  

//  

LONG ApplicationCrashHandler(EXCEPTION_POINTERS *pException)  

{     

    // 确保有足够的栈空间  

    //  

#ifdef _M_IX86  

    if (pException->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW)  

    {  

        static char TempStack[1024 * 128];  

        __asm mov eax,offset TempStack[1024 * 128];  

        __asm mov esp,eax;  

    }  

#endif    

  

    CrashInfo crashinfo = GetCrashInfo(pException->ExceptionRecord);  

  

    // 输出Crash信息  

    //  

    cout << "ErrorCode: " << crashinfo.ErrorCode << endl;  

    cout << "Address: " << crashinfo.Address << endl;  

    cout << "Flags: " << crashinfo.Flags << endl;  

      

    vector<CallStackInfo> arrCallStackInfo = GetCallStack(pException->ContextRecord);  

  

    // 输出CallStack  

    //  

    cout << "CallStack: " << endl;  

    for (vector<CallStackInfo>::iterator i = arrCallStackInfo.begin(); i != arrCallStackInfo.end(); ++i)  

    {  

        CallStackInfo callstackinfo = (*i);  

  

        cout << callstackinfo.MethodName << "() : [" << callstackinfo.ModuleName << "] (File: " << callstackinfo.FileName << " @Line " << callstackinfo.LineNumber << ")" << endl;  

    }  

  

    // 这里弹出一个错误对话框并退出程序  

    //  

    FatalAppExit(-1,  _T("*** Unhandled Exception! ***"));  

  

    return EXCEPTION_EXECUTE_HANDLER;  

}  

        最后，在main函数的开头添加下面的代码。

[cpp] view
plaincopy

// 设置处理Unhandled Exception的回调函数  

//   

SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)ApplicationCrashHandler);   

        编译上面的代码，到工程的Debug目录下找到编译好的Test.exe，双击运行，程序在崩溃的时候就会输出CallStack。