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

时间：2023-03-09 08:25:33
[转]让程序在崩溃时体面的退出之CallStack

原文地址：http://blog.****.net/starlee/article/details/6618849

在我的那篇《让程序在崩溃时体面的退出之Unhandled Exception》中提供了一个捕捉程序崩溃事件的方法，可以添加代码在程序崩溃的时候做出适当的处理。不过，只知道程序在什么时候崩溃，但是不知道为什么崩溃，这对于程序开发者来说没有任何意义。因为如果不知道程序崩溃的原因，就没法去找到代码中的缺陷，当然就没法去修改代码而避免程序的崩溃。
        所有调试过代码的开发者都知道CallStack的重要性。如果在程序崩溃的时候得到CallStack，那么就能定位程序崩溃的具体位置，并最终找到解决方法。那么有没有什么方法在程序崩溃的时候得到CallStack呢？答案是肯定的。微软提供了一个DbgHelp.dll，里面包含了一系列的Windows API来供开发者调用。它是一个调试跟踪相关的模块，用于跟踪进程工作，在进程崩溃时收集程序产生异常时的堆栈信息，以供开发人员分析，从而很快找出使程序出现异常的原因。
        下面用具体的例子代码来说明怎样使用DbgHelp.dll中的Windows API来得到CallStack。代码里面有详细的注释来帮助理解。
        用VC创建一个名为Test的控制台程序，添加下面的代码。

  1. // 一个有函数调用的类
  2. //
  3. class CrashTest
  4. {
  5. public:
  6. void Test()
  7. {
  8. Crash();
  9. }
  10. private:
  11. void Crash()
  12. {
  13. // 除零，人为的使程序崩溃
  14. //
  15. int i = 13;
  16. int j = 0;
  17. int m = i / j;
  18. }
  19. };
  20. int _tmain(int argc, _TCHAR* argv[])
  21. {
  22. CrashTest test;
  23. test.Test();
  24. return 0;
  25. }

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

  1. #include <Windows.h>
  2. #include <DbgHelp.h>
  3. #include <iostream>
  4. #include <vector>
  5. // 添加对dbghelp.lib的编译依赖
  6. //
  7. #pragma comment(lib, "dbghelp.lib")
  8. using namespace std;
  9. const int MAX_ADDRESS_LENGTH = 32;
  10. const int MAX_NAME_LENGTH = 1024;
  11. // 崩溃信息
  12. //
  13. struct CrashInfo
  14. {
  15. CHAR ErrorCode[MAX_ADDRESS_LENGTH];
  16. CHAR Address[MAX_ADDRESS_LENGTH];
  17. CHAR Flags[MAX_ADDRESS_LENGTH];
  18. };
  19. // CallStack信息
  20. //
  21. struct CallStackInfo
  22. {
  23. CHAR ModuleName[MAX_NAME_LENGTH];
  24. CHAR MethodName[MAX_NAME_LENGTH];
  25. CHAR FileName[MAX_NAME_LENGTH];
  26. CHAR LineNumber[MAX_NAME_LENGTH];
  27. };
  28. // 安全拷贝字符串函数
  29. //
  30. void SafeStrCpy(char* szDest, size_t nMaxDestSize, const char* szSrc)
  31. {
  32. if (nMaxDestSize <= 0) return;
  33. if (strlen(szSrc) < nMaxDestSize)
  34. {
  35. strcpy_s(szDest, nMaxDestSize, szSrc);
  36. }
  37. else
  38. {
  39. strncpy_s(szDest, nMaxDestSize, szSrc, nMaxDestSize);
  40. szDest[nMaxDestSize-1] = '\0';
  41. }
  42. }
  43. // 得到程序崩溃信息
  44. //
  45. CrashInfo GetCrashInfo(const EXCEPTION_RECORD *pRecord)
  46. {
  47. CrashInfo crashinfo;
  48. SafeStrCpy(crashinfo.Address, MAX_ADDRESS_LENGTH, "N/A");
  49. SafeStrCpy(crashinfo.ErrorCode, MAX_ADDRESS_LENGTH, "N/A");
  50. SafeStrCpy(crashinfo.Flags, MAX_ADDRESS_LENGTH, "N/A");
  51. sprintf_s(crashinfo.Address, "%08X", pRecord->ExceptionAddress);
  52. sprintf_s(crashinfo.ErrorCode, "%08X", pRecord->ExceptionCode);
  53. sprintf_s(crashinfo.Flags, "%08X", pRecord->ExceptionFlags);
  54. return crashinfo;
  55. }
  56. // 得到CallStack信息
  57. //
  58. vector<CallStackInfo> GetCallStack(const CONTEXT *pContext)
  59. {
  60. HANDLE hProcess = GetCurrentProcess();
  61. SymInitialize(hProcess, NULL, TRUE);
  62. vector<CallStackInfo> arrCallStackInfo;
  63. CONTEXT c = *pContext;
  64. STACKFRAME64 sf;
  65. memset(&sf, 0, sizeof(STACKFRAME64));
  66. DWORD dwImageType = IMAGE_FILE_MACHINE_I386;
  67. // 不同的CPU类型，具体信息可查询MSDN
  68. //
  69. #ifdef _M_IX86
  70. sf.AddrPC.Offset = c.Eip;
  71. sf.AddrPC.Mode = AddrModeFlat;
  72. sf.AddrStack.Offset = c.Esp;
  73. sf.AddrStack.Mode = AddrModeFlat;
  74. sf.AddrFrame.Offset = c.Ebp;
  75. sf.AddrFrame.Mode = AddrModeFlat;
  76. #elif _M_X64
  77. dwImageType = IMAGE_FILE_MACHINE_AMD64;
  78. sf.AddrPC.Offset = c.Rip;
  79. sf.AddrPC.Mode = AddrModeFlat;
  80. sf.AddrFrame.Offset = c.Rsp;
  81. sf.AddrFrame.Mode = AddrModeFlat;
  82. sf.AddrStack.Offset = c.Rsp;
  83. sf.AddrStack.Mode = AddrModeFlat;
  84. #elif _M_IA64
  85. dwImageType = IMAGE_FILE_MACHINE_IA64;
  86. sf.AddrPC.Offset = c.StIIP;
  87. sf.AddrPC.Mode = AddrModeFlat;
  88. sf.AddrFrame.Offset = c.IntSp;
  89. sf.AddrFrame.Mode = AddrModeFlat;
  90. sf.AddrBStore.Offset = c.RsBSP;
  91. sf.AddrBStore.Mode = AddrModeFlat;
  92. sf.AddrStack.Offset = c.IntSp;
  93. sf.AddrStack.Mode = AddrModeFlat;
  94. #else
  95. #error "Platform not supported!"
  96. #endif
  97. HANDLE hThread = GetCurrentThread();
  98. while (true)
  99. {
  100. // 该函数是实现这个功能的最重要的一个函数
  101. // 函数的用法以及参数和返回值的具体解释可以查询MSDN
  102. //
  103. if (!StackWalk64(dwImageType, hProcess, hThread, &sf, &c, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))
  104. {
  105. break;
  106. }
  107. if (sf.AddrFrame.Offset == 0)
  108. {
  109. break;
  110. }
  111. CallStackInfo callstackinfo;
  112. SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, "N/A");
  113. SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, "N/A");
  114. SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, "N/A");
  115. SafeStrCpy(callstackinfo.LineNumber, MAX_NAME_LENGTH, "N/A");
  116. BYTE symbolBuffer[sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH];
  117. IMAGEHLP_SYMBOL64 *pSymbol = (IMAGEHLP_SYMBOL64*)symbolBuffer;
  118. memset(pSymbol, 0, sizeof(IMAGEHLP_SYMBOL64) + MAX_NAME_LENGTH);
  119. pSymbol->SizeOfStruct = sizeof(symbolBuffer);
  120. pSymbol->MaxNameLength = MAX_NAME_LENGTH;
  121. DWORD symDisplacement = 0;
  122. // 得到函数名
  123. //
  124. if (SymGetSymFromAddr64(hProcess, sf.AddrPC.Offset, NULL, pSymbol))
  125. {
  126. SafeStrCpy(callstackinfo.MethodName, MAX_NAME_LENGTH, pSymbol->Name);
  127. }
  128. IMAGEHLP_LINE64 lineInfo;
  129. memset(&lineInfo, 0, sizeof(IMAGEHLP_LINE64));
  130. lineInfo.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
  131. DWORD dwLineDisplacement;
  132. // 得到文件名和所在的代码行
  133. //
  134. if (SymGetLineFromAddr64(hProcess, sf.AddrPC.Offset, &dwLineDisplacement, &lineInfo))
  135. {
  136. SafeStrCpy(callstackinfo.FileName, MAX_NAME_LENGTH, lineInfo.FileName);
  137. sprintf_s(callstackinfo.LineNumber, "%d", lineInfo.LineNumber);
  138. }
  139. IMAGEHLP_MODULE64 moduleInfo;
  140. memset(&moduleInfo, 0, sizeof(IMAGEHLP_MODULE64));
  141. moduleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
  142. // 得到模块名
  143. //
  144. if (SymGetModuleInfo64(hProcess, sf.AddrPC.Offset, &moduleInfo))
  145. {
  146. SafeStrCpy(callstackinfo.ModuleName, MAX_NAME_LENGTH, moduleInfo.ModuleName);
  147. }
  148. arrCallStackInfo.push_back(callstackinfo);
  149. }
  150. SymCleanup(hProcess);
  151. return arrCallStackInfo;
  152. }

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

  1. // 处理Unhandled Exception的回调函数
  2. //
  3. LONG ApplicationCrashHandler(EXCEPTION_POINTERS *pException)
  4. {
  5. // 确保有足够的栈空间
  6. //
  7. #ifdef _M_IX86
  8. if (pException->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW)
  9. {
  10. static char TempStack[1024 * 128];
  11. __asm mov eax,offset TempStack[1024 * 128];
  12. __asm mov esp,eax;
  13. }
  14. #endif
  15. CrashInfo crashinfo = GetCrashInfo(pException->ExceptionRecord);
  16. // 输出Crash信息
  17. //
  18. cout << "ErrorCode: " << crashinfo.ErrorCode << endl;
  19. cout << "Address: " << crashinfo.Address << endl;
  20. cout << "Flags: " << crashinfo.Flags << endl;
  21. vector<CallStackInfo> arrCallStackInfo = GetCallStack(pException->ContextRecord);
  22. // 输出CallStack
  23. //
  24. cout << "CallStack: " << endl;
  25. for (vector<CallStackInfo>::iterator i = arrCallStackInfo.begin(); i != arrCallStackInfo.end(); ++i)
  26. {
  27. CallStackInfo callstackinfo = (*i);
  28. cout << callstackinfo.MethodName << "() : [" << callstackinfo.ModuleName << "] (File: " << callstackinfo.FileName << " @Line " << callstackinfo.LineNumber << ")" << endl;
  29. }
  30. // 这里弹出一个错误对话框并退出程序
  31. //
  32. FatalAppExit(-1,  _T("*** Unhandled Exception! ***"));
  33. return EXCEPTION_EXECUTE_HANDLER;
  34. }

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

  1. // 设置处理Unhandled Exception的回调函数
  2. //
  3. SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)ApplicationCrashHandler);

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

相关文章