深入理解Win32结构化异常处理（三）

拼搏现实的明天。 2022-08-09 00:55 186阅读 0赞

# 转载URL：http://www.cnblogs.com/salomon/archive/2012/06/20/2556349.html #

# [\[翻译\]深入理解Win32结构化异常处理（三）][Win32] #

\_\_except\_handler3 and the scopetable

我真的很希望让你看一看Visual C++运行时库源代码，让你自己好好研究一下\_\_except\_handler3函数，但是我办不到。因为 Microsoft并没有提供。在这里你就将就着看一下我为\_\_except\_handler3函数写的伪代码吧

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

int __except_handler3(
         struct _EXCEPTION_RECORD * pExceptionRecord,
         struct EXCEPTION_REGISTRATION * pRegistrationFrame,
         struct _CONTEXT *pContextRecord,
         void * pDispatcherContext )
     {
         LONG filterFuncRet
         LONG trylevel
         EXCEPTION_POINTERS exceptPtrs
         PSCOPETABLE pScopeTable
     
         CLD     // Clear the direction flag (make no assumptions!)
     
         // if neither the EXCEPTION_UNWINDING nor EXCEPTION_EXIT_UNWIND bit
         // is set...  This is true the first time through the handler (the
         // non-unwinding case)
     
         if ( ! (pExceptionRecord->ExceptionFlags
                 & (EXCEPTION_UNWINDING | EXCEPTION_EXIT_UNWIND)) )
         {
             // Build the EXCEPTION_POINTERS structure on the stack
             exceptPtrs.ExceptionRecord = pExceptionRecord;
             exceptPtrs.ContextRecord = pContextRecord;
     
             // Put the pointer to the EXCEPTION_POINTERS 4 bytes below the
             // establisher frame.  See ASM code for GetExceptionInformation
             *(PDWORD)((PBYTE)pRegistrationFrame - 4) = &exceptPtrs;
     
             // Get initial "trylevel" value
             trylevel = pRegistrationFrame->trylevel 
     
             // Get a pointer to the scopetable array
             scopeTable = pRegistrationFrame->scopetable;
     
     search_for_handler: 
     
             if ( pRegistrationFrame->trylevel != TRYLEVEL_NONE )
             {
                 if ( pRegistrationFrame->scopetable[trylevel].lpfnFilter )
                 {
                     PUSH EBP                        // Save this frame EBP
     
                     // !!!Very Important!!!  Switch to original EBP.  This is
                     // what allows all locals in the frame to have the same
                     // value as before the exception occurred.
                     EBP = &pRegistrationFrame->_ebp 
     
                     // Call the filter function
                     filterFuncRet = scopetable[trylevel].lpfnFilter();
     
                     POP EBP                         // Restore handler frame EBP
     
                     if ( filterFuncRet != EXCEPTION_CONTINUE_SEARCH )
                     {
                         if ( filterFuncRet < 0 ) // EXCEPTION_CONTINUE_EXECUTION
                             return ExceptionContinueExecution;
     
                         // If we get here, EXCEPTION_EXECUTE_HANDLER was specified
                         scopetable == pRegistrationFrame->scopetable
     
                         // Does the actual OS cleanup of registration frames
                         // Causes this function to recurse
                         __global_unwind2( pRegistrationFrame );
     
                         // Once we get here, everything is all cleaned up, except
                         // for the last frame, where we'll continue execution
                         EBP = &pRegistrationFrame->_ebp
                         
                         __local_unwind2( pRegistrationFrame, trylevel );
     
                         // NLG == "non-local-goto" (setjmp/longjmp stuff)
                         __NLG_Notify( 1 );  // EAX == scopetable->lpfnHandler
     
                         // Set the current trylevel to whatever SCOPETABLE entry
                         // was being used when a handler was found
                         pRegistrationFrame->trylevel = scopetable->previousTryLevel;
     
                         // Call the _except {} block.  Never returns.
                         pRegistrationFrame->scopetable[trylevel].lpfnHandler();
                     }
                 }
     
                 scopeTable = pRegistrationFrame->scopetable;
                 trylevel = scopeTable->previousTryLevel
     
                 goto search_for_handler;
             }
    
             else    // trylevel == TRYLEVEL_NONE
             {
                 retvalue == DISPOSITION_CONTINUE_SEARCH;
             }
         }
         else    // EXCEPTION_UNWINDING or EXCEPTION_EXIT_UNWIND flags are set
         {
             PUSH EBP    // Save EBP
             EBP = pRegistrationFrame->_ebp  // Set EBP for __local_unwind2
     
             __local_unwind2( pRegistrationFrame, TRYLEVEL_NONE )
     
             POP EBP     // Restore EBP
     
             retvalue == DISPOSITION_CONTINUE_SEARCH;
         }
     }

![复制代码][copycode.gif]

虽然\_\_except\_handler3的代码看起来很多，但是记住一点：它只是一个我在文章开头讲过的异常处理回调函数。它同MYSEH.EXE和 MYSEH2.EXE中的异常回调函数都带有同样的四个参数。\_\_except\_handler3大体上可以由第一个if语句分为两部分。这是由于这个函数可以在两种情况下被调用，一次是正常调用，另一次是在展开阶段。其中大部分是在非展开阶段的回调。  
　　\_\_except\_handler3一开始就在堆栈上创建了一个EXCEPTION\_POINTERS结构，并用它的两个参数来对这个结构进行初始化。我在伪代码中把这个结构称为 exceptPrts，它的地址被放在\[EBP-14h\]处。你回忆一下前面我讲的编译器为 GetExceptionInformation和 GetExceptionCode 函数生成的汇编代码就会意识到，这实际上初始化了这两个函数使用的指针。  
　　接着，\_\_except\_handler3从EXCEPTION\_REGISTRATION帧中获取当前的trylevel（在\[EBP-04h\]处）。 trylevel变量实际是scopetable数组的索引，而正是这个数组才使得一个函数中的多个\_\_try块和嵌套的\_\_try块能够仅使用一个 EXCEPTION\_REGISTRATION结构

![ExpandedBlockStart.gif][]

typedef struct _SCOPETABLE
     {
         DWORD       previousTryLevel;
         DWORD       lpfnFilter
         DWORD       lpfnHandler
     } SCOPETABLE, *PSCOPETABLE;

SCOPETABLE结构中的第二个成员和第三个成员比较容易理解。它们分别是过滤器表达式代码的地址和相应的\_\_except块的地址。但是prviousTryLevel成员有点复杂。总之一句话，它用于嵌套的\_\_try块。这里的关键是函数中的每个\_\_try块都有一个相应的SCOPETABLE结构。  
　　正如我前面所说，当前的 trylevel 指定了要使用的scopetable数组的哪一个元素，最终也就是指定了过滤器表达式和\_\_except块的地址。现在想像一下两个\_\_try块嵌套的情形。如果内层\_\_try块的过滤器表达式不处理某个异常，那外层\_\_try块的过滤器表达式就必须处理它。那现在要问，\_\_except\_handler3是如何知道SCOPETABLE数组的哪个元素相应于外层的\_\_try块的呢？答案是：外层\_\_try块的索引由 SCOPETABLE结构的previousTryLevel域给出。利用这种机制，你可以嵌套任意层的\_\_try块。previousTryLevel 域就好像是一个函数中所有可能的异常处理程序构成的线性链表中的结点一样。如果trylevel的值为0xFFFFFFFF（实际上就是-1，这个值在 EXSUP.INC中被定义为TRYLEVEL\_NONE），标志着这个链表结束。  
　　回到\_\_except\_handler3的代码中。在获取了当前的trylevel之后，它就调用相应的SCOPETABLE结构中的过滤器表达式代码。如果过滤器表达式返回EXCEPTION\_CONTINUE\_SEARCH，\_\_exception\_handler3 移向SCOPETABLE数组中的下一个元素，这个元素的索引由previousTryLevel域给出。如果遍历完整个线性链表（还记得吗？这个链表是由于在一个函数内部嵌套使用\_\_try块而形成的）都没有找到处理这个异常的代码，\_\_except\_handler3返回DISPOSITION\_CONTINUE\_SEARCH（原文如此，但根据\_except\_handler函数的定义，这个返回值应该为ExceptionContinueSearch。实际上这两个常量的值是一样的。我在伪代码中已经将其改正过来了），这导致系统移向下一个EXCEPTION\_REGISTRATION帧（这个链表是由于函数嵌套调用而形成的）。  
　　如果过滤器表达式返回EXCEPTION\_EXECUTE\_HANDLER，这意味着异常应该由相应的\_\_except块处理。它同时也意味着所有前面的EXCEPTION\_REGISTRATION帧都应该从链表中移除，并且相应的\_\_except块都应该被执行。第一个任务通过调用\_\_global\_unwind2来完成的，后面我会讲到这个函数。跳过这中间的一些清理代码，流程离开\_\_except\_handler3转向\_\_except块。令人奇怪的是，流程并不从\_\_except块中返回，虽然是 \_\_except\_handler3使用CALL指令调用了它。  
　　当前的trylevel值是如何被设置的呢？它实际上是由编译器隐含处理的。编译器非常机灵地修改这个扩展的EXCEPTION\_REGISTRATION 结构中的trylevel域的值（实际上是生成修改这个域的值的代码）。如果你检查编译器为使用SEH的函数生成的汇编代码，就会在不同的地方都看到修改这个位于\[EBP-04h\]处的trylevel域的值的代码。  
　　\_\_except\_handler3是如何做到既通过CALL指令调用\_\_except块而又不让执行流程返回呢？由于CALL指令要向堆栈中压入了一个返回地址，你可以想象这有可能破坏堆栈。如果你检查一下编译器为\_\_except块生成的代码，你会发现它做的第一件事就是将EXCEPTION\_REGISTRATION结构下面8个字节处（即\[EBP-18H\]处）的一个DWORD值加载到ESP寄存器中（实际代码为MOV ESP,DWORD PTR \[EBP-18H\]）,这个值是在函数的 prolog 代码中被保存在这个位置的（实际代码为MOV DWORD PTR \[EBP-18H\],ESP）。

The ShowSEHFrames Program

如果你现在觉得已经被EXCEPTION\_REGISTRATION、scopetable、trylevel、过滤器表达式以及展开等等之类的词搞得晕头转向的话，那和我最初的感觉一样。但是编译器层面的结构化异常处理方面的知识并不适合一点一点的学。除非你从整体上理解它，否则有很多内容单独看并没有什么意义。当面对大堆的理论时，我最自然的做法就是写一些应用我学到的理论方面的程序。如果它能够按照预料的那样工作，我就知道我的理解（通常）是正确的。  
　　下面是ShowSEHFrame.EXE的源代码。它使用\_\_try/\_\_except块设置了好几个 Visual C++ SEH 帧。然后它显示每一个帧以及Visual C++为每个帧创建的scopetable的相关信息。这个程序本身并不生成也不依赖任何异常。相反，我使用了多个\_\_try块以强制Visual C++生成多个 EXCEPTION\_REGISTRATION 帧以及相应的 scopetable。

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

//==================================================
     // ShowSEHFrames - Matt Pietrek 1997
     // Microsoft Systems Journal, February 1997
     // FILE: ShowSEHFrames.CPP
     // To compile: CL ShowSehFrames.CPP
     //==================================================
     #define WIN32_LEAN_AND_MEAN
     #include <windows.h>
     #include <stdio.h>
     #pragma hdrstop
     
     //----------------------------------------------------------------------------
     // !!! WARNING !!!  This program only works with Visual C++, as the data
     // structures being shown are specific to Visual C++.
     //----------------------------------------------------------------------------
     
     #ifndef _MSC_VER
     #error Visual C++ Required (Visual C++ specific information is displayed)
     #endif
     
     //----------------------------------------------------------------------------
     // Structure Definitions
     //----------------------------------------------------------------------------
     
     // The basic, OS defined exception frame
     
     struct EXCEPTION_REGISTRATION
     {
         EXCEPTION_REGISTRATION* prev;
         FARPROC                 handler;
     };
     
     
     // Data structure(s) pointed to by Visual C++ extended exception frame
     
     struct scopetable_entry
     {
         DWORD       previousTryLevel;
         FARPROC     lpfnFilter;
         FARPROC     lpfnHandler;
     };
     
     // The extended exception frame used by Visual C++
     
     struct VC_EXCEPTION_REGISTRATION : EXCEPTION_REGISTRATION
     {
         scopetable_entry *  scopetable;
         int                 trylevel;
         int                 _ebp;
     };
     
     //----------------------------------------------------------------------------
     // Prototypes
     //----------------------------------------------------------------------------
     
     // __except_handler3 is a Visual C++ RTL function.  We want to refer to
     // it in order to print it's address.  However, we need to prototype it since
     // it doesn't appear in any header file.
     
     extern "C" int _except_handler3(PEXCEPTION_RECORD, EXCEPTION_REGISTRATION *,
                                     PCONTEXT, PEXCEPTION_RECORD);
     
     
     //----------------------------------------------------------------------------
     // Code
     //----------------------------------------------------------------------------
     
     //
     // Display the information in one exception frame, along with its scopetable
     //
     
     void ShowSEHFrame( VC_EXCEPTION_REGISTRATION * pVCExcRec )
     {
         printf( "Frame: %08X  Handler: %08X  Prev: %08X  Scopetable: %08X\n",
                 pVCExcRec, pVCExcRec->handler, pVCExcRec->prev,
                 pVCExcRec->scopetable );
     
         scopetable_entry * pScopeTableEntry = pVCExcRec->scopetable;
     
         for ( unsigned i = 0; i <= pVCExcRec->trylevel; i++ )
         {
             printf( "    scopetable[%u] PrevTryLevel: %08X  "
                     "filter: %08X  __except: %08X\n", i,
                     pScopeTableEntry->previousTryLevel,
                     pScopeTableEntry->lpfnFilter,
                     pScopeTableEntry->lpfnHandler );
     
             pScopeTableEntry++;
         }
     
         printf( "\n" );
     }   
     
     //
     // Walk the linked list of frames, displaying each in turn
     //
     
     void WalkSEHFrames( void )
     {
         VC_EXCEPTION_REGISTRATION * pVCExcRec;
     
         // Print out the location of the __except_handler3 function
         printf( "_except_handler3 is at address: %08X\n", _except_handler3 );
         printf( "\n" );
     
         // Get a pointer to the head of the chain at FS:[0]
         __asm   mov eax, FS:[0]
         __asm   mov [pVCExcRec], EAX
     
         // Walk the linked list of frames.  0xFFFFFFFF indicates the end of list
         while (  0xFFFFFFFF != (unsigned)pVCExcRec )
         {
             ShowSEHFrame( pVCExcRec );
             pVCExcRec = (VC_EXCEPTION_REGISTRATION *)(pVCExcRec->prev);
         }       
     }
     
     void Function1( void )
     {
    
         // Set up 3 nested _try levels (thereby forcing 3 scopetable entries)
         _try
         {
             _try
             {
                 _try
                 {
                     WalkSEHFrames();    // Now show all the exception frames
                 }
                 _except( EXCEPTION_CONTINUE_SEARCH )
                 {
                 }
             }
             _except( EXCEPTION_CONTINUE_SEARCH )
             {
             }
         }
         _except( EXCEPTION_CONTINUE_SEARCH )
         {
         }
     }
     
     int main()
     {
         int i;
     
         // Use two (non-nested) _try blocks.  This causes two scopetable entries
         // to be generated for the function.
     
         _try
         {
             i = 0x1234;     // Do nothing in particular
         }
         _except( EXCEPTION_CONTINUE_SEARCH )
         {
             i = 0x4321;     // Do nothing (in reverse)
         }
     
         _try
         {
             Function1();    // Call a function that sets up more exception frames
         }
         _except( EXCEPTION_EXECUTE_HANDLER )
         {
             // Should never get here, since we aren't expecting an exception
             printf( "Caught Exception in main\n" );
         }
     
         return 0;
     }

![复制代码][copycode.gif]

ShowSEHFrames程序中比较重要的函数是WalkSEHFrames和ShowSEHFrame。WalkSEHFrames函数首选打印出 \_\_except\_handler3的地址，打印它的原因很快就清楚了。接着，它从FS:\[0\]处获取异常链表的头指针，然后遍历该链表。此链表中每个结点都是一个VC\_EXCEPTION\_REGISTRATION类型的结构，它是我自己定义的，用于描述Visual C++的异常处理帧。对于这个链表中的每个结点，WalkSEHFrames都把指向这个结点的指针传递给ShowSEHFrame函数。  
　　ShowSEHFrame函数一开始就打印出异常处理帧的地址、异常处理回调函数的地址、前一个异常处理帧的地址以及scopetable的地址。接着，对于每个 scopetable数组中的元素，它都打印出其priviousTryLevel、过滤器表达式的地址以及相应的\_\_except块的地址。我是如何知道scopetable数组中有多少个元素的呢？其实我并不知道。但是我假定VC\_EXCEPTION\_REGISTRATION结构中的当前trylevel域的值比scopetable数组中的元素总数少1。  
　　图十一是 ShowSEHFrames 的运行结果。首先检查以“Frame:”开头的每一行，你会发现它们显示的异常处理帧在堆栈上的地址呈递增趋势，并且在前三个帧中，它们的异常处理程序的地址是一样的（都是004012A8）。再看输出的开始部分，你会发现这个004012A8不是别的，它正是 Visual C++运行时库函数\_\_except\_handler3的地址。这证明了我前面所说的单个回调函数处理所有异常这一点。

![2012062015541056.gif][]

你可能想知道为什么明明 ShowSEHFrames 程序只有两个函数使用SEH，但是却有三个异常处理帧使用\_\_except\_handler3作为它们的异常回调函数。实际上第三个帧来自 Visual C++ 运行时库。Visual C++ 运行时库源代码中的 CRT0.C 文件清楚地表明了对 main 或 WinMain 的调用也被一个\_\_try/\_\_except 块封装着。这个\_\_try 块的过滤器表达式代码可以在 WINXFLTR.C文 件中找到。 　　回到 ShowSEHFrames 程序，注意到最后一个帧的异常处理程序的地址是 77F3AB6C，这与其它三个不同。仔细观察一下，你会发现这个地址在 KERNEL32.DLL 中。这个特别的帧就是由 KERNEL32.DLL 中的 BaseProcessStart 函数安装的，这在前面

Unwinding

在挖掘展开（Unwinding）的实现代码之前让我们先来搞清楚它的意思。我在前面已经讲过所有可能的异常处理程序是如何被组织在一个由线程信息块的第一个DWORD（FS:\[0\]）所指向的链表中的。由于针对某个特定异常的处理程序可能不在这个链表的开头，因此就需要从链表中依次移除实际处理异常的那个异常处理程序之前的所有异常处理程序。

正如你在Visual C++的\_\_except\_handler3函数中看到的那样，展开是由\_\_global\_unwind2这个运行时库（RTL）函数来完成的。这个函数只是对RtlUnwind这个未公开的API进行了非常简单的封装。（现在这个API已经被公开了，但给出的信息极其简单，详细信息可以参考最新的Platform SDK文档。）

![复制代码][copycode.gif]

__global_unwind2(void * pRegistFrame)
     {
         _RtlUnwind( pRegistFrame,
                     &__ret_label,
                     0, 0 );
         __ret_label:
     }

![复制代码][copycode.gif]

虽然从技术上讲RtlUnwind是一个KERNEL32函数，但它只是转发到了NTDLL.DLL中的同名函数上。下面是我为此函数写的伪代码。

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

void _RtlUnwind( PEXCEPTION_REGISTRATION pRegistrationFrame,
                      PVOID returnAddr,  // Not used! (At least on i386)
                      PEXCEPTION_RECORD pExcptRec,
                      DWORD _eax_value ) 
     {
         DWORD   stackUserBase;
         DWORD   stackUserTop;
         PEXCEPTION_RECORD pExcptRec;
         EXCEPTION_RECORD  exceptRec;    
         CONTEXT context;
     
         // Get stack boundaries from FS:[4] and FS:[8]
         RtlpGetStackLimits( &stackUserBase, &stackUserTop );
     
         if ( 0 == pExcptRec )   // The normal case
         {
             pExcptRec = &excptRec;
     
             pExcptRec->ExceptionFlags = 0;
             pExcptRec->ExceptionCode = STATUS_UNWIND;
             pExcptRec->ExceptionRecord = 0;
             // Get return address off the stack
             pExcptRec->ExceptionAddress = RtlpGetReturnAddress();
             pExcptRec->ExceptionInformation[0] = 0;
         }
     
         if ( pRegistrationFrame )
             pExcptRec->ExceptionFlags |= EXCEPTION_UNWINDING;
         else
             pExcptRec->ExceptionFlags|=(EXCEPTION_UNWINDING|EXCEPTION_EXIT_UNWIND);
     
         context.ContextFlags =
             (CONTEXT_i486 | CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS);
     
         RtlpCaptureContext( &context );
     
         context.Esp += 0x10;
         context.Eax = _eax_value;
     
         PEXCEPTION_REGISTRATION pExcptRegHead;
     
         pExcptRegHead = RtlpGetRegistrationHead();  // Retrieve FS:[0]
     
         // Begin traversing the list of EXCEPTION_REGISTRATION
         while ( -1 != pExcptRegHead )
         {
             EXCEPTION_RECORD excptRec2;
     
             if ( pExcptRegHead == pRegistrationFrame )
             {
                 _NtContinue( &context, 0 );
             }
             else
             {
                 // If there's an exception frame, but it's lower on the stack
                 // then the head of the exception list, something's wrong!
                 if ( pRegistrationFrame && (pRegistrationFrame <= pExcptRegHead) )
                 {
                     // Generate an exception to bail out
                     excptRec2.ExceptionRecord = pExcptRec;
                     excptRec2.NumberParameters = 0;
                     excptRec2.ExceptionCode = STATUS_INVALID_UNWIND_TARGET;
                     excptRec2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;    
     
                     _RtlRaiseException( &exceptRec2 );
                 }
             }
     
             PVOID pStack = pExcptRegHead + 8; // 8==sizeof(EXCEPTION_REGISTRATION)
     
             if (    (stackUserBase <= pExcptRegHead )   // Make sure that
                 &&  (stackUserTop >= pStack )           // pExcptRegHead is in
                 &&  (0 == (pExcptRegHead & 3)) )        // range, and a multiple
             {                                           // of 4 (i.e., sane)
                 DWORD pNewRegistHead;
                 DWORD retValue;
     
                 retValue = RtlpExecutehandlerForUnwind(
                                 pExcptRec, pExcptRegHead, &context,
                                 &pNewRegistHead, pExceptRegHead->handler );
     
                 if ( retValue != DISPOSITION_CONTINUE_SEARCH )
                 {
                     if ( retValue != DISPOSITION_COLLIDED_UNWIND )
                     {
                         excptRec2.ExceptionRecord = pExcptRec;
                  excptRec2.NumberParameters = 0;
                         excptRec2.ExceptionCode = STATUS_INVALID_DISPOSITION;
                         excptRec2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;    
     
                         RtlRaiseException( &excptRec2 );
                     }
                     else
                         pExcptRegHead = pNewRegistHead;
                 }
     
                 PEXCEPTION_REGISTRATION pCurrExcptReg = pExcptRegHead;
                 pExcptRegHead = pExcptRegHead->prev;
     
                 RtlpUnlinkHandler( pCurrExcptReg );
             }
             else    // The stack looks goofy!  Raise an exception to bail out
             {
                 excptRec2.ExceptionRecord = pExcptRec;
                 excptRec2.NumberParameters = 0;
                 excptRec2.ExceptionCode = STATUS_BAD_STACK;
                 excptRec2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;    
     
                 RtlRaiseException( &excptRec2 );
             }
         }
     
         // If we get here, we reached the end of the EXCEPTION_REGISTRATION list.
         // This shouldn't happen normally.
     
         if ( -1 == pRegistrationFrame )
             NtContinue( &context, 0 );
         else
             NtRaiseException( pExcptRec, &context, 0 );
     
     }
     
     PEXCEPTION_REGISTRATION
     RtlpGetRegistrationHead( void )
     {
         return FS:[0];
     }
     
     _RtlpUnlinkHandler( PEXCEPTION_REGISTRATION pRegistrationFrame )
     {
         FS:[0] = pRegistrationFrame->prev;
     }
     
     void _RtlpCaptureContext( CONTEXT * pContext )
     {
         pContext->Eax = 0;
         pContext->Ecx = 0;
         pContext->Edx = 0;
         pContext->Ebx = 0;
         pContext->Esi = 0;
         pContext->Edi = 0;
         pContext->SegCs = CS;
         pContext->SegDs = DS;
         pContext->SegEs = ES;
         pContext->SegFs = FS;
         pContext->SegGs = GS;
         pContext->SegSs = SS;
         pContext->EFlags = flags; // __asm{ PUSHFD / pop [xxxxxxxx] }
         pContext->Eip = return address of the caller of the caller of this function
         pContext->Ebp = EBP of the caller of the caller of this function 
         pContext->Esp = Context.Ebp + 8
     }

![复制代码][copycode.gif]

虽然 RtlUnwind 函数的规模看起来很大，但是如果你按一定方法把它分开，其实并不难理解。它首先从FS:\[4\]和FS:\[8\]处获取当前线程堆栈的界限。它们对于后面要进行的合法性检查非常重要，以确保所有将要被展开的异常帧都在堆栈范围内。

RtlUnwind 接着在堆栈上创建了一个空的EXCEPTION\_RECORD结构并把STATUS\_UNWIND赋给它的ExceptionCode域，同时把 EXCEPTION\_UNWINDING标志赋给它的 ExceptionFlags 域。指向这个结构的指针作为其中一个参数被传递给每个异常回调函数。然后，这个函数调用RtlCaptureContext函数来创建一个空的CONTEXT结构，这个结构也变成了在展开阶段调用每个异常回调函数时传递给它们的一个参数。

RtlUnwind函数的其余部分遍历EXCEPTION\_REGISTRATION结构链表。对于其中的每个帧，它都调用 RtlpExecuteHandlerForUnwind 函数，后面我会讲到这个函数。正是这个函数带 EXCEPTION\_UNWINDING 标志调用了异常处理回调函数。每次回调之后，它调用RtlpUnlinkHandler 移除相应的异常帧。

RtlUnwind 函数的第一个参数是一个帧的地址，当它遍历到这个帧时就停止展开异常帧。上面所说的这些代码之间还有一些安全性检查代码，它们用来确保不出问题。如果出现任何问题，RtlUnwind 就引发一个异常，指示出了什么问题，并且这个异常带有EXCEPTION\_NONCONTINUABLE 标志。当一个进程被设置了这个标志时，它就不允许再运行，必须终止。

Unhandled Exceptions

在文章的前面，我并没有全面描述 UnhandledExceptionFilter 这个 API。通常情况下你并不直接调用它（尽管你可以这么做）。大多数情况下它都是由 KERNEL32 中进行默认异常处理的过滤器表达式代码调用。前面 BaseProcessStart 函数的伪代码已经表明了这一点。

图十三是我为 UnhandledExceptionFilter 函数写的伪代码。这个API有点奇怪（至少在我看来是这样）。如果异常的类型是 EXCEPTION\_ACCESS\_VIOLATION，它就调用\_BasepCheckForReadOnlyResource。虽然我没有提供这个函数的伪代码，但可以简要描述一下。如果是因为要对 EXE 或 DLL 的资源节（.rsrc）进行写操作而导致的异常，\_BasepCurrentTopLevelFilter 就改变出错页面正常的只读属性，以便允许进行写操作。如果是这种特殊的情况，UnhandledExceptionFilter 返回 EXCEPTION\_CONTINUE\_EXECUTION，使系统重新执行出错指令。

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

UnhandledExceptionFilter( STRUCT _EXCEPTION_POINTERS *pExceptionPtrs )
     {
         PEXCEPTION_RECORD pExcptRec;
         DWORD currentESP;
         DWORD retValue;
         DWORD DEBUGPORT;
         DWORD   dwTemp2;
         DWORD   dwUseJustInTimeDebugger;
         CHAR    szDbgCmdFmt[256];   // Template string retrieved from AeDebug key
         CHAR    szDbgCmdLine[256];  // Actual debugger string after filling in
         STARTUPINFO startupinfo;
         PROCESS_INFORMATION pi;
         HARDERR_STRUCT  harderr;    // ???
         BOOL fAeDebugAuto;
         TIB * pTib;                 // Thread information block
     
         pExcptRec = pExceptionPtrs->ExceptionRecord;
     
         if (   (pExcptRec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
             && (pExcptRec->ExceptionInformation[0]) )
         {
             retValue = 
                 _BasepCheckForReadOnlyResource(pExcptRec->ExceptionInformation[1]);
     
             if ( EXCEPTION_CONTINUE_EXECUTION == retValue )
                 return EXCEPTION_CONTINUE_EXECUTION;
          }
     
         // See if this process is being run under a debugger...
         retValue = NtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
                                              &debugPort, sizeof(debugPort), 0 );
     
         if ( (retValue >= 0) && debugPort )     // Let debugger have it
             return EXCEPTION_CONTINUE_SEARCH;
     
         // Did the user call SetUnhandledExceptionFilter?  If so, call their
         // installed proc now.
     
         if ( _BasepCurrentTopLevelFilter )
         {
             retValue = _BasepCurrentTopLevelFilter( pExceptionPtrs );
     
             if ( EXCEPTION_EXECUTE_HANDLER == retValue )
                 return EXCEPTION_EXECUTE_HANDLER;
             
             if ( EXCEPTION_CONTINUE_EXECUTION == retValue )
                 return EXCEPTION_CONTINUE_EXECUTION;
     
             // Only EXCEPTION_CONTINUE_SEARCH goes on from here
         }
     
         // Has SetErrorMode(SEM_NOGPFAULTERRORBOX) been called?
         if ( 0 == (GetErrorMode() & SEM_NOGPFAULTERRORBOX) )
         {
             harderr.elem0 = pExcptRec->ExceptionCode;
             harderr.elem1 = pExcptRec->ExceptionAddress;
     
             if ( EXCEPTION_IN_PAGE_ERROR == pExcptRec->ExceptionCode )
                 harderr.elem2 = pExcptRec->ExceptionInformation[2];
             else
                 harderr.elem2 = pExcptRec->ExceptionInformation[0];
     
             dwTemp2 = 1;
             fAeDebugAuto = FALSE;
     
             harderr.elem3 = pExcptRec->ExceptionInformation[1];
     
             pTib = FS:[18h];
     
             DWORD someVal = pTib->pProcess->0xC;
     
             if ( pTib->threadID != someVal )
             {
                 __try
                 {
                     char szDbgCmdFmt[256]
                     retValue = _GetProfileStringA( "AeDebug", "Debugger", 0,
                                          szDbgCmdFmt, sizeof(szDbgCmdFmt)-1 );
     
                     if ( retValue )
                         dwTemp2 = 2;
     
                     char szAuto[8]
     
                     retValue = GetProfileStringA(   "AeDebug", "Auto", "0",
                                                     szAuto, sizeof(szAuto)-1 );
                     if ( retValue )
                         if ( 0 == strcmp( szAuto, "1" ) )
                             if ( 2 == dwTemp2 )
                                 fAeDebugAuto = TRUE;
                 }
                 __except( EXCEPTION_EXECUTE_HANDLER )
                 {
                     ESP = currentESP;
                     dwTemp2 = 1
                     fAeDebugAuto = FALSE;
                 }
             }
     
             if ( FALSE == fAeDebugAuto )
             {
                 retValue =  NtRaiseHardError(
                                     STATUS_UNHANDLED_EXCEPTION | 0x10000000,
                                     4, 0, &harderr,
                                     _BasepAlreadyHadHardError ? 1 : dwTemp2,
                                     &dwUseJustInTimeDebugger );
             }
             else
             {
                 dwUseJustInTimeDebugger = 3;
                 retValue = 0;
             }
     
             if (    retValue >= 0 
                 &&  ( dwUseJustInTimeDebugger == 3)
                 &&  ( !_BasepAlreadyHadHardError )
                 &&  ( !_BaseRunningInServerProcess ) )
             {
                 _BasepAlreadyHadHardError = 1;
     
                 SECURITY_ATTRIBUTES secAttr = { sizeof(secAttr), 0, TRUE };
     
                 HANDLE hEvent = CreateEventA( &secAttr, TRUE, 0, 0 );
     
                 memset( &startupinfo, 0, sizeof(startupinfo) );
     
                 sprintf(szDbgCmdLine, szDbgCmdFmt, GetCurrentProcessId(), hEvent);
     
                 startupinfo.cb = sizeof(startupinfo);
                 startupinfo.lpDesktop = "Winsta0\Default"
     
                 CsrIdentifyAlertableThread();   // ???
     
                 retValue = CreateProcessA(
                                 0,              // lpApplicationName
                                 szDbgCmdLine,   // Command line
                                 0, 0,           // process, thread security attrs
                                 1,              // bInheritHandles
                                 0, 0,           // creation flags, environment
                                 0,              // current directory.
                                 &statupinfo,    // STARTUPINFO
                                 &pi );          // PROCESS_INFORMATION
     
                 if ( retValue && hEvent )
                 {
                     NtWaitForSingleObject( hEvent, 1, 0 );
                     return EXCEPTION_CONTINUE_SEARCH;
                 }
             }
     
             if ( _BasepAlreadyHadHardError )
                 NtTerminateProcess(GetCurrentProcess(), pExcptRec->ExceptionCode);
         }
     
         return EXCEPTION_EXECUTE_HANDLER;
     }
     
     LPTOP_LEVEL_EXCEPTION_FILTER
     SetUnhandledExceptionFilter(
         LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter );   
     { 
         // _BasepCurrentTopLevelFilter is a KERNEL32.DLL global var
         LPTOP_LEVEL_EXCEPTION_FILTER previous= _BasepCurrentTopLevelFilter;
     
         // Set the new value
         _BasepCurrentTopLevelFilter = lpTopLevelExceptionFilter;
     
         return previous;    // return the old value
     }

![复制代码][copycode.gif]

UnhandledExceptionFilter接下来的任务是确定进程是否运行于Win32调试器下。也就是进程的创建标志中是否带有标志DEBUG\_PROCESS或DEBUG\_ONLY\_THIS\_PROCESS。它使用NtQueryInformationProcess函数来确定进程是否正在被调试，我在本月的Under the Hood专栏中讲解了这个函数。如果正在被调试，UnhandledExceptionFilter就返回 EXCEPTION\_CONTINUE\_SEARCH，这告诉系统去唤醒调试器并告诉它在被调试程序（debuggee）中产生了一个异常。

UnhandledExceptionFilter接下来调用用户安装的未处理异常过滤器（如果存在的话）。通常情况下，用户并没有安装回调函数，但是用户可以调用 SetUnhandledExceptionFilter这个API来安装。上面我也提供了这个API的伪代码。这个函数只是简单地用用户安装的回调函数的地址来替换一个全局变量，并返回替换前的值。

有了初步的准备之后，UnhandledExceptionFilter就开始做它的主要工作：用一个时髦的应用程序错误对话框来通知你犯了低级的编程错误。有两种方法可以避免出现这个对话框。第一种方法是调用SetErrorMode函数并指定SEM\_NOGPFAULTERRORBOX标志。另一种方法是将AeDebug子键下的Auto的值设为1。此时UnhandledExceptionFilter跳过应用程序错误对话框直接启动AeDebug 子键下的Debugger的值所指定的调试器。如果你熟悉“即时调试（Just In Time Debugging，JIT）”的话，这就是操作系统支持它的地方。接下来我会详细讲。

大多数情况下，上面的两个条件都为假。这样UnhandledExceptionFilter就调用NTDLL.DLL中的 NtRaiseHardError函数。正是这个函数产生了应用程序错误对话框。这个对话框等待你单击“确定”按钮来终止进程，或者单击“取消”按钮来调试它。（单击“取消”按钮而不是“确定”按钮来加载调试器好像有点颠倒了，可能这只是我个人的感觉吧。）

如果你单击“确定”，UnhandledExceptionFilter就返回EXCEPTION\_EXECUTE\_HANDLER。调用UnhandledExceptionFilter 的进程通常通过终止自身来作为响应（正像你在BaseProcessStart的伪代码中看到的那样）。这就产生了一个有趣的问题——大多数人都认为是系统终止了产生未处理异常的进程，而实际上更准确的说法应该是，系统进行了一些设置使得产生未处理异常的进程将自身终止掉了。

UnhandledExceptionFilter执行时真正有意思的部分是当你单击应用程序错误对话框中的“取消”按钮，此时系统将调试器附加（attach）到出错进程上。这段代码首先调用 CreateEvent来创建一个事件内核对象，调试器成功附加到出错进程之后会将此事件对象变成有信号状态。这个事件句柄以及出错进程的ID都被传到 sprintf函数，由它将其格式化成一个命令行，用来启动调试器。一切就绪之后，UnhandledExceptionFilter就调用 CreateProcess来启动调试器。如果CreateProcess成功，它就调用NtWaitForSingleObject来等待前面创建的那个事件对象。此时这个调用被阻塞，直到调试器进程将此事件变成有信号状态，以表明它已经成功附加到出错进程上。UnhandledExceptionFilter函数中还有一些其它的代码，我在这里只讲重要的。

[Win32]: http://www.cnblogs.com/salomon/archive/2012/06/20/2556349.html
[ExpandedBlockStart.gif]: /images/20220731/842f454aa7664bb4b98a54823601f262.png
[copycode.gif]: /images/20220731/5182e450c913481abf1010a9d820ac72.png
[2012062015541056.gif]: /images/20220731/54f17f8c340e4ffe91a37cc5f5fb897a.png