服务器——异常处理

╰半橙微兮° 2023-02-20 03:13 53阅读 0赞

### [服务器框架][Link 1] ###

## 一、前言 ##

服务器在运行过程如果出现数组越界访问、访问空指针、迭代器访问越界等等，可能会导致出现抛出异常，导致系统崩溃。怎样捕获异常并快速定位问题呢？

## 二、异常捕获和问题定位 ##

在window下可以用minidump将崩溃转存，通过生成的dmp可以快速定位到导致异常的地方。

### 2.1 异常捕获 ###

使用\_\_try \_\_except，捕获异常，通过函数MiniDumpWriteDump生成dmp文件

### 2.2 通过dmp文件定位异常 ###

打开dmp文件，设置符号路径选择pdb、dll文件所在目录，如果是在同一个目录可以不用设置，点击调试之后就可以看到抛异常的地方了。

## 三、实例演示 ##

### 3.1 异常捕获 ###

以下是一个简单的实例，用于捕获异常生成dmp文件.

StackWalkTest.h

#pragma once
    #include <Windows.h>
    
    #define MYTRY	__try{
    #define MYTRYCATCH }__except(CStackWalk::Instance()->filterFunc(GetExceptionCode(), GetExceptionInformation())){
    #define MYTRYCATCHEND	}
    
    class CStackWalk
    {
    public:
    	static CStackWalk* Instance()
    	{
    		static CStackWalk cd;
    		return &cd;
    	}
        
        // 创建dmp
    	static long WINAPI createMiniDump(PEXCEPTION_POINTERS pExceptionPointers);
        
        // __try __except 捕获的异常处理函数
        static int WINAPI filterFunc(int code, LPEXCEPTION_POINTERS pExceptionPtr);
    
        // 获取dump文件名
        // 这个只是本地测试，这里按照时间组合的文件名，实际项目可以自行设置文件名
        HANDLE  getDumpFile();
        
        // 创建dmp
    	long onCreateMiniDump(PEXCEPTION_POINTERS pExceptionPointers);
       
        // 设置dmp类型
    	void setDumpType(long dumpType);
    
    private:
    	CStackWalk();
    
    private:
    	long m_dumpType;    
    };

StackWalkTest.cpp

#include "StackWalk.h"
    #include <imagehlp.h>
    #include <Shlwapi.h>
    #include <time.h>
    #include <iostream>
    #include <tchar.h>
    #pragma comment(lib, "dbghelp.lib")
    #pragma comment(lib, "Shlwapi.lib")
    
    // 实际项目中日志，这里标准输出到窗口
    #define TraceErrorLn(s) { printf(s);printf("\n"); }
    
    CStackWalk::CStackWalk():m_dumpType(MiniDumpNormal)
    {
    	SetUnhandledExceptionFilter(createMiniDump);
    }
    
    // 设置dmp类型
    void CStackWalk::setDumpType(long dumpType)
    {
    	m_dumpType = dumpType;
    }
    
    // 获取dump文件名
    // 这个只是本地测试，这里按照时间组合的文件名，实际项目可以自行设置文件名
    HANDLE CStackWalk::getDumpFile()
    {
    	wchar_t szFileName[MAX_PATH];
    	HANDLE  hDumpFile = NULL;
    	memset(szFileName, 0x00, MAX_PATH);
    	GetModuleFileName(NULL, szFileName, MAX_PATH);
    	PathRemoveFileSpec(szFileName);
    	tm nowTM;
    	time_t now;
    	time(&now);
    	localtime_s(&nowTM, &now);
    
    	wchar_t timeStr[64];
    	_stprintf_s(timeStr, TEXT("\\%04d%02d%02d%02d%02d%02d.dmp"), nowTM.tm_year + 1900, nowTM.tm_mon + 1, nowTM.tm_mday, nowTM.tm_hour, nowTM.tm_min, nowTM.tm_sec);
    	_tcscat_s(szFileName, timeStr);
    	hDumpFile = CreateFile(szFileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
    		NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    
    	return hDumpFile;
    }
    
    // 创建dump
    long WINAPI CStackWalk::createMiniDump(PEXCEPTION_POINTERS pExceptionPointers)
    {
    	Instance()->onCreateMiniDump(pExceptionPointers);
    	return(0);
    }
    
    // 创建dump
    long CStackWalk::onCreateMiniDump(PEXCEPTION_POINTERS pExceptionPointers)
    {
    	TraceErrorLn("存储保护异常，CreateMiniDump");
    	if (pExceptionPointers == NULL)
    	{
    		// Generate exception to get proper context in dump
    		__try
    		{
    			// 抛出一个调用线程时发生的异常
    			RaiseException(EXCEPTION_BREAKPOINT, 0, 0, NULL);
    		}
    		__except (createMiniDump(GetExceptionInformation()),
    			EXCEPTION_CONTINUE_EXECUTION)
    		{
    		}
    	}
    	else
    	{
    		MINIDUMP_EXCEPTION_INFORMATION  mdei;
    		mdei.ThreadId = GetCurrentThreadId();
    		mdei.ExceptionPointers = pExceptionPointers;
    		mdei.ClientPointers = FALSE;
    
    		HANDLE hDumpFile = getDumpFile();
    		if (hDumpFile == INVALID_HANDLE_VALUE)
    		{
    			TraceErrorLn(("CreateFile Failed: %d\n"), GetLastError());
    			return -1;
    		}
    
    		bool bRetCode = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile, (MINIDUMP_TYPE)m_dumpType, &mdei, NULL, NULL);
    
    		CloseHandle(hDumpFile);
    
    		if (bRetCode != TRUE)
    			return(GetLastError());
    	}
    
    	return(0);
    }
    
    // __try __except 捕获的异常处理函数
    int CStackWalk::filterFunc(int code, LPEXCEPTION_POINTERS pExceptionPtr)
    {
        CStackWalk::Instance()->createMiniDump(pExceptionPtr);
        TraceErrorLn(("异常，错误代码：%x\n"), code);
        switch (code)
        {
        case EXCEPTION_ACCESS_VIOLATION:
            if (nullptr != pExceptionPtr && nullptr != pExceptionPtr->ExceptionRecord)
            {
                TraceErrorLn(("存储保护异常，错误代码：%x, 错误地址:%x"), code, pExceptionPtr->ExceptionRecord->ExceptionAddress);
            }
            else
            {
                TraceErrorLn(("存储保护异常，错误代码：%x"), code);
            }
            break;
        case EXCEPTION_DATATYPE_MISALIGNMENT:
            TraceErrorLn(("数据类型未对齐异常，错误代码：%x\n"), code);
            break;
        case EXCEPTION_BREAKPOINT:
            TraceErrorLn(("中断异常，错误代码：%x"), code);
            break;
        case EXCEPTION_SINGLE_STEP:
            TraceErrorLn(("单步中断异常，错误代码：%x"), code);
            break;
        case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
            TraceErrorLn(("数组越界异常，错误代码：%x"), code);
            break;
        case EXCEPTION_FLT_DENORMAL_OPERAND:
        case EXCEPTION_FLT_DIVIDE_BY_ZERO:
        case EXCEPTION_FLT_INEXACT_RESULT:
        case EXCEPTION_FLT_INVALID_OPERATION:
        case EXCEPTION_FLT_OVERFLOW:
        case EXCEPTION_FLT_STACK_CHECK:
        case EXCEPTION_FLT_UNDERFLOW:
            TraceErrorLn(("浮点数计算异常，错误代码：%x"), code);
            break;
        case EXCEPTION_INT_DIVIDE_BY_ZERO:
            TraceErrorLn(("被0除异常，错误代码：%x"), code);
            break;
        case EXCEPTION_INT_OVERFLOW:
            TraceErrorLn(("数据溢出异常，错误代码：%x"), code);
            break;
        case EXCEPTION_IN_PAGE_ERROR:
            TraceErrorLn(("页错误异常，错误代码：%x"), code);
            break;
        case EXCEPTION_ILLEGAL_INSTRUCTION:
            TraceErrorLn(("非法指令异常，错误代码：%x"), code);
            break;
        case EXCEPTION_STACK_OVERFLOW:
            TraceErrorLn(("堆栈溢出异常，错误代码：%x"), code);
            break;
        case EXCEPTION_INVALID_HANDLE:
            TraceErrorLn(("无效句病异常，错误代码：%x"), code);
            break;
        default:
            if (code & (1 << 29))
            {
                TraceErrorLn(("用户自定义的软件异常，错误代码：%x"), code);
            }
            else
            {
                TraceErrorLn(("其它异常，错误代码：%x"), code);
            }
            break;
        }
    
        return 1;
    }

异常捕获测试

#pragma once
    #include "StackWalk.h"
    #include <iostream>
    #include <vector>
    using namespace std;
    
    #define NAMESPACE_STACKWALKTEST namespace NAME_STACKWALKTEST {
    #define NAMESPACE_STACKWALKTESTEND }
    NAMESPACE_STACKWALKTEST
    
    //
    // 测试 用例 START
    class ITest
    {
    public:
        virtual void testFun() = 0;
    };
    
    //typedef  void (*pFun)(); //函数指针的定义
    void test(const char* testName, ITest* p)
    {
        cout << "-------start: " << testName << " ------- " << endl;
        MYTRY
            p->testFun();
        MYTRYCATCH
            cout << "抛出异常" << endl;
        MYTRYCATCHEND
    
            cout << endl << endl;
    }
    
    // 测试用例
    // 访问空指针对象
    class Test1 : public ITest
    {
    public:
        void operator()() { test("Test1", static_cast<ITest*>(this)); }
        void testFun()
        {
            int* p = nullptr;
            cout << *p << endl;
        }
    };
    
    // 数组索引访问越界
    class Test2 : public ITest
    {
    public:
        void operator()() { test("Test2", static_cast<ITest*>(this)); }
        void testFun()
        {
            int arr[10] = { 0 };
            int sum = 0;
            for (int i = 0; i < 10000000; ++i)
            {
                sum += arr[i];
            }
    
            cout << sum << endl;
        }
    };
    
    // 迭代器失效
    class Test3 : public ITest
    {
    public:
        void operator()() { test("Test3", static_cast<ITest*>(this)); }
        void testFun()
        {
            for (int j = 0; j < 10; ++j)
            {
                vector<int> data = { 1,2,3,4,5 };
                for (auto it = data.begin(); it != data.end(); ++it)
                {
                    if (*it < 5)
                    {
                        data.push_back(10);
                    }
                }
            }
        }
    };
    
    NAMESPACE_STACKWALKTESTEND
    // 测试 用例 END
    //
    
    #define TESTTRYTEST(fun) {NAME_STACKWALKTEST::fun p; p();}
    void StackWalk_Test()
    {
        CStackWalk::Instance();	
        cout << "---------------------------StackWalk_Test start ---------------------------" << endl;
    	
        TESTTRYTEST(Test1);
        //TESTTRYTEST(Test2);
        //TESTTRYTEST(Test2);
    
        cout << "---------------------------StackWalk_Test endl ---------------------------" << endl;
    }

上面代码演示的是测试用例一，访问空指针对象，执行结果如下：

![20200622214523959.png][]

###  ###

### 3.2 dmp文件生成 ###

生成的dmp文件：

![20200622214606947.png][]

###  ###

### 3.3 dmp文件调试 ###

打开dmp文件之后可以看到调用了空指针。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pZTIzMTQ1NTA0NDE_size_16_color_FFFFFF_t_70][]

### 3.4 体面的崩溃 ###

CStackWalk::CStackWalk():m_dumpType(MiniDumpNormal)
    {
    	SetUnhandledExceptionFilter(createMiniDump);
    }

CStackWalk 构造函数中调用了SetUnhandledExceptionFilter函数，SetUnhandledExceptionFilter在程序崩溃前可以获得程序崩溃的信息，并生成dmp文件。

## 四、总结 ##

1.  在系统中在可能出现异常的地方加上异常捕获处理，框架里可以在内存申请、线程创建加上异常捕获，在应用层只需要在网络消息处理、定时前回调加上异常捕获。
2.  考虑到在没有加异常捕获的地方可能也会抛出异常，可以调用SetUnhandledExceptionFilter(createMiniDump)，在崩溃前生成dmp文件。

[Link 1]: https://blog.csdn.net/nie2314550441/article/details/105981967
[20200622214523959.png]: https://img-blog.csdnimg.cn/20200622214523959.png
[20200622214606947.png]: https://img-blog.csdnimg.cn/20200622214606947.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pZTIzMTQ1NTA0NDE_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200622215648816.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25pZTIzMTQ1NTA0NDE=,size_16,color_FFFFFF,t_70