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

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

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

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

__except_handler3 and the scopetable

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

ExpandedBlockStart.gif

复制代码

  1. int __except_handler3(
  2.      struct _EXCEPTION_RECORD * pExceptionRecord,
  3.      struct EXCEPTION_REGISTRATION * pRegistrationFrame,
  4.      struct _CONTEXT *pContextRecord,
  5.      void * pDispatcherContext )
  6.  {
  7.      LONG filterFuncRet
  8.      LONG trylevel
  9.      EXCEPTION_POINTERS exceptPtrs
  10.      PSCOPETABLE pScopeTable
  12.      CLD     // Clear the direction flag (make no assumptions!)
  14.      // if neither the EXCEPTION_UNWINDING nor EXCEPTION_EXIT_UNWIND bit
  15.      // is set...  This is true the first time through the handler (the
  16.      // non-unwinding case)
  18.      if ( ! (pExceptionRecord->ExceptionFlags
  19.              & (EXCEPTION_UNWINDING | EXCEPTION_EXIT_UNWIND)) )
  20.      {
  21.          // Build the EXCEPTION_POINTERS structure on the stack
  22.          exceptPtrs.ExceptionRecord = pExceptionRecord;
  23.          exceptPtrs.ContextRecord = pContextRecord;
  25.          // Put the pointer to the EXCEPTION_POINTERS 4 bytes below the
  26.          // establisher frame.  See ASM code for GetExceptionInformation
  27.          *(PDWORD)((PBYTE)pRegistrationFrame - 4) = &exceptPtrs;
  29.          // Get initial "trylevel" value
  30.          trylevel = pRegistrationFrame->trylevel 
  32.          // Get a pointer to the scopetable array
  33.          scopeTable = pRegistrationFrame->scopetable;
  35.  search_for_handler: 
  37.          if ( pRegistrationFrame->trylevel != TRYLEVEL_NONE )
  38.          {
  39.              if ( pRegistrationFrame->scopetable[trylevel].lpfnFilter )
  40.              {
  41.                  PUSH EBP                        // Save this frame EBP
  43.                  // !!!Very Important!!!  Switch to original EBP.  This is
  44.                  // what allows all locals in the frame to have the same
  45.                  // value as before the exception occurred.
  46.                  EBP = &pRegistrationFrame->_ebp 
  48.                  // Call the filter function
  49.                  filterFuncRet = scopetable[trylevel].lpfnFilter();
  51.                  POP EBP                         // Restore handler frame EBP
  53.                  if ( filterFuncRet != EXCEPTION_CONTINUE_SEARCH )
  54.                  {
  55.                      if ( filterFuncRet < 0 ) // EXCEPTION_CONTINUE_EXECUTION
  56.                          return ExceptionContinueExecution;
  58.                      // If we get here, EXCEPTION_EXECUTE_HANDLER was specified
  59.                      scopetable == pRegistrationFrame->scopetable
  61.                      // Does the actual OS cleanup of registration frames
  62.                      // Causes this function to recurse
  63.                      __global_unwind2( pRegistrationFrame );
  65.                      // Once we get here, everything is all cleaned up, except
  66.                      // for the last frame, where we'll continue execution
  67.                      EBP = &pRegistrationFrame->_ebp
  69.                      __local_unwind2( pRegistrationFrame, trylevel );
  71.                      // NLG == "non-local-goto" (setjmp/longjmp stuff)
  72.                      __NLG_Notify( 1 );  // EAX == scopetable->lpfnHandler
  74.                      // Set the current trylevel to whatever SCOPETABLE entry
  75.                      // was being used when a handler was found
  76.                      pRegistrationFrame->trylevel = scopetable->previousTryLevel;
  78.                      // Call the _except {} block.  Never returns.
  79.                      pRegistrationFrame->scopetable[trylevel].lpfnHandler();
  80.                  }
  81.              }
  83.              scopeTable = pRegistrationFrame->scopetable;
  84.              trylevel = scopeTable->previousTryLevel
  86.              goto search_for_handler;
  87.          }
  89.          else    // trylevel == TRYLEVEL_NONE
  90.          {
  91.              retvalue == DISPOSITION_CONTINUE_SEARCH;
  92.          }
  93.      }
  94.      else    // EXCEPTION_UNWINDING or EXCEPTION_EXIT_UNWIND flags are set
  95.      {
  96.          PUSH EBP    // Save EBP
  97.          EBP = pRegistrationFrame->_ebp  // Set EBP for __local_unwind2
  99.          __local_unwind2( pRegistrationFrame, TRYLEVEL_NONE )
  101.          POP EBP     // Restore EBP
  103.          retvalue == DISPOSITION_CONTINUE_SEARCH;
  104.      }
  105.  }

复制代码

虽然__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

  1. typedef struct _SCOPETABLE
  2.  {
  3.      DWORD       previousTryLevel;
  4.      DWORD       lpfnFilter
  5.      DWORD       lpfnHandler
  6.  } 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

复制代码

  1. //==================================================
  2.  // ShowSEHFrames - Matt Pietrek 1997
  3.  // Microsoft Systems Journal, February 1997
  4.  // FILE: ShowSEHFrames.CPP
  5.  // To compile: CL ShowSehFrames.CPP
  6.  //==================================================
  7.  #define WIN32_LEAN_AND_MEAN
  8.  #include <windows.h>
  9.  #include <stdio.h>
  10.  #pragma hdrstop
  12.  //----------------------------------------------------------------------------
  13.  // !!! WARNING !!!  This program only works with Visual C++, as the data
  14.  // structures being shown are specific to Visual C++.
  15.  //----------------------------------------------------------------------------
  17.  #ifndef _MSC_VER
  18.  #error Visual C++ Required (Visual C++ specific information is displayed)
  19.  #endif
  21.  //----------------------------------------------------------------------------
  22.  // Structure Definitions
  23.  //----------------------------------------------------------------------------
  25.  // The basic, OS defined exception frame
  27.  struct EXCEPTION_REGISTRATION
  28.  {
  29.      EXCEPTION_REGISTRATION* prev;
  30.      FARPROC                 handler;
  31.  };
  34.  // Data structure(s) pointed to by Visual C++ extended exception frame
  36.  struct scopetable_entry
  37.  {
  38.      DWORD       previousTryLevel;
  39.      FARPROC     lpfnFilter;
  40.      FARPROC     lpfnHandler;
  41.  };
  43.  // The extended exception frame used by Visual C++
  45.  struct VC_EXCEPTION_REGISTRATION : EXCEPTION_REGISTRATION
  46.  {
  47.      scopetable_entry *  scopetable;
  48.      int                 trylevel;
  49.      int                 _ebp;
  50.  };
  52.  //----------------------------------------------------------------------------
  53.  // Prototypes
  54.  //----------------------------------------------------------------------------
  56.  // __except_handler3 is a Visual C++ RTL function.  We want to refer to
  57.  // it in order to print it's address.  However, we need to prototype it since
  58.  // it doesn't appear in any header file.
  60.  extern "C" int _except_handler3(PEXCEPTION_RECORD, EXCEPTION_REGISTRATION *,
  61.                                  PCONTEXT, PEXCEPTION_RECORD);
  64.  //----------------------------------------------------------------------------
  65.  // Code
  66.  //----------------------------------------------------------------------------
  68.  //
  69.  // Display the information in one exception frame, along with its scopetable
  70.  //
  72.  void ShowSEHFrame( VC_EXCEPTION_REGISTRATION * pVCExcRec )
  73.  {
  74.      printf( "Frame: %08X  Handler: %08X  Prev: %08X  Scopetable: %08X\n",
  75.              pVCExcRec, pVCExcRec->handler, pVCExcRec->prev,
  76.              pVCExcRec->scopetable );
  78.      scopetable_entry * pScopeTableEntry = pVCExcRec->scopetable;
  80.      for ( unsigned i = 0; i <= pVCExcRec->trylevel; i++ )
  81.      {
  82.          printf( "    scopetable[%u] PrevTryLevel: %08X  "
  83.                  "filter: %08X  __except: %08X\n", i,
  84.                  pScopeTableEntry->previousTryLevel,
  85.                  pScopeTableEntry->lpfnFilter,
  86.                  pScopeTableEntry->lpfnHandler );
  88.          pScopeTableEntry++;
  89.      }
  91.      printf( "\n" );
  92.  }   
  94.  //
  95.  // Walk the linked list of frames, displaying each in turn
  96.  //
  98.  void WalkSEHFrames( void )
  99.  {
  100.      VC_EXCEPTION_REGISTRATION * pVCExcRec;
  102.      // Print out the location of the __except_handler3 function
  103.      printf( "_except_handler3 is at address: %08X\n", _except_handler3 );
  104.      printf( "\n" );
  106.      // Get a pointer to the head of the chain at FS:[0]
  107.      __asm   mov eax, FS:[0]
  108.      __asm   mov [pVCExcRec], EAX
  110.      // Walk the linked list of frames.  0xFFFFFFFF indicates the end of list
  111.      while (  0xFFFFFFFF != (unsigned)pVCExcRec )
  112.      {
  113.          ShowSEHFrame( pVCExcRec );
  114.          pVCExcRec = (VC_EXCEPTION_REGISTRATION *)(pVCExcRec->prev);
  115.      }       
  116.  }
  118.  void Function1( void )
  119.  {
  121.      // Set up 3 nested _try levels (thereby forcing 3 scopetable entries)
  122.      _try
  123.      {
  124.          _try
  125.          {
  126.              _try
  127.              {
  128.                  WalkSEHFrames();    // Now show all the exception frames
  129.              }
  130.              _except( EXCEPTION_CONTINUE_SEARCH )
  131.              {
  132.              }
  133.          }
  134.          _except( EXCEPTION_CONTINUE_SEARCH )
  135.          {
  136.          }
  137.      }
  138.      _except( EXCEPTION_CONTINUE_SEARCH )
  139.      {
  140.      }
  141.  }
  143.  int main()
  144.  {
  145.      int i;
  147.      // Use two (non-nested) _try blocks.  This causes two scopetable entries
  148.      // to be generated for the function.
  150.      _try
  151.      {
  152.          i = 0x1234;     // Do nothing in particular
  153.      }
  154.      _except( EXCEPTION_CONTINUE_SEARCH )
  155.      {
  156.          i = 0x4321;     // Do nothing (in reverse)
  157.      }
  159.      _try
  160.      {
  161.          Function1();    // Call a function that sets up more exception frames
  162.      }
  163.      _except( EXCEPTION_EXECUTE_HANDLER )
  164.      {
  165.          // Should never get here, since we aren't expecting an exception
  166.          printf( "Caught Exception in main\n" );
  167.      }
  169.      return 0;
  170.  }

复制代码

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文档。）

复制代码

  1. __global_unwind2(void * pRegistFrame)
  2.  {
  3.      _RtlUnwind( pRegistFrame,
  4.                  &__ret_label,
  5.                  0, 0 );
  6.      __ret_label:
  7.  }

复制代码

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

ExpandedBlockStart.gif

复制代码

  1. void _RtlUnwind( PEXCEPTION_REGISTRATION pRegistrationFrame,
  2.                   PVOID returnAddr,  // Not used! (At least on i386)
  3.                   PEXCEPTION_RECORD pExcptRec,
  4.                   DWORD _eax_value ) 
  5.  {
  6.      DWORD   stackUserBase;
  7.      DWORD   stackUserTop;
  8.      PEXCEPTION_RECORD pExcptRec;
  9.      EXCEPTION_RECORD  exceptRec;    
  10.      CONTEXT context;
  12.      // Get stack boundaries from FS:[4] and FS:[8]
  13.      RtlpGetStackLimits( &stackUserBase, &stackUserTop );
  15.      if ( 0 == pExcptRec )   // The normal case
  16.      {
  17.          pExcptRec = &excptRec;
  19.          pExcptRec->ExceptionFlags = 0;
  20.          pExcptRec->ExceptionCode = STATUS_UNWIND;
  21.          pExcptRec->ExceptionRecord = 0;
  22.          // Get return address off the stack
  23.          pExcptRec->ExceptionAddress = RtlpGetReturnAddress();
  24.          pExcptRec->ExceptionInformation[0] = 0;
  25.      }
  27.      if ( pRegistrationFrame )
  28.          pExcptRec->ExceptionFlags |= EXCEPTION_UNWINDING;
  29.      else
  30.          pExcptRec->ExceptionFlags|=(EXCEPTION_UNWINDING|EXCEPTION_EXIT_UNWIND);
  32.      context.ContextFlags =
  33.          (CONTEXT_i486 | CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS);
  35.      RtlpCaptureContext( &context );
  37.      context.Esp += 0x10;
  38.      context.Eax = _eax_value;
  40.      PEXCEPTION_REGISTRATION pExcptRegHead;
  42.      pExcptRegHead = RtlpGetRegistrationHead();  // Retrieve FS:[0]
  44.      // Begin traversing the list of EXCEPTION_REGISTRATION
  45.      while ( -1 != pExcptRegHead )
  46.      {
  47.          EXCEPTION_RECORD excptRec2;
  49.          if ( pExcptRegHead == pRegistrationFrame )
  50.          {
  51.              _NtContinue( &context, 0 );
  52.          }
  53.          else
  54.          {
  55.              // If there's an exception frame, but it's lower on the stack
  56.              // then the head of the exception list, something's wrong!
  57.              if ( pRegistrationFrame && (pRegistrationFrame <= pExcptRegHead) )
  58.              {
  59.                  // Generate an exception to bail out
  60.                  excptRec2.ExceptionRecord = pExcptRec;
  61.                  excptRec2.NumberParameters = 0;
  62.                  excptRec2.ExceptionCode = STATUS_INVALID_UNWIND_TARGET;
  63.                  excptRec2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;    
  65.                  _RtlRaiseException( &exceptRec2 );
  66.              }
  67.          }
  69.          PVOID pStack = pExcptRegHead + 8; // 8==sizeof(EXCEPTION_REGISTRATION)
  71.          if (    (stackUserBase <= pExcptRegHead )   // Make sure that
  72.              &&  (stackUserTop >= pStack )           // pExcptRegHead is in
  73.              &&  (0 == (pExcptRegHead & 3)) )        // range, and a multiple
  74.          {                                           // of 4 (i.e., sane)
  75.              DWORD pNewRegistHead;
  76.              DWORD retValue;
  78.              retValue = RtlpExecutehandlerForUnwind(
  79.                              pExcptRec, pExcptRegHead, &context,
  80.                              &pNewRegistHead, pExceptRegHead->handler );
  82.              if ( retValue != DISPOSITION_CONTINUE_SEARCH )
  83.              {
  84.                  if ( retValue != DISPOSITION_COLLIDED_UNWIND )
  85.                  {
  86.                      excptRec2.ExceptionRecord = pExcptRec;
  87.               excptRec2.NumberParameters = 0;
  88.                      excptRec2.ExceptionCode = STATUS_INVALID_DISPOSITION;
  89.                      excptRec2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;    
  91.                      RtlRaiseException( &excptRec2 );
  92.                  }
  93.                  else
  94.                      pExcptRegHead = pNewRegistHead;
  95.              }
  97.              PEXCEPTION_REGISTRATION pCurrExcptReg = pExcptRegHead;
  98.              pExcptRegHead = pExcptRegHead->prev;
  100.              RtlpUnlinkHandler( pCurrExcptReg );
  101.          }
  102.          else    // The stack looks goofy!  Raise an exception to bail out
  103.          {
  104.              excptRec2.ExceptionRecord = pExcptRec;
  105.              excptRec2.NumberParameters = 0;
  106.              excptRec2.ExceptionCode = STATUS_BAD_STACK;
  107.              excptRec2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;    
  109.              RtlRaiseException( &excptRec2 );
  110.          }
  111.      }
  113.      // If we get here, we reached the end of the EXCEPTION_REGISTRATION list.
  114.      // This shouldn't happen normally.
  116.      if ( -1 == pRegistrationFrame )
  117.          NtContinue( &context, 0 );
  118.      else
  119.          NtRaiseException( pExcptRec, &context, 0 );
  121.  }
  123.  PEXCEPTION_REGISTRATION
  124.  RtlpGetRegistrationHead( void )
  125.  {
  126.      return FS:[0];
  127.  }
  129.  _RtlpUnlinkHandler( PEXCEPTION_REGISTRATION pRegistrationFrame )
  130.  {
  131.      FS:[0] = pRegistrationFrame->prev;
  132.  }
  134.  void _RtlpCaptureContext( CONTEXT * pContext )
  135.  {
  136.      pContext->Eax = 0;
  137.      pContext->Ecx = 0;
  138.      pContext->Edx = 0;
  139.      pContext->Ebx = 0;
  140.      pContext->Esi = 0;
  141.      pContext->Edi = 0;
  142.      pContext->SegCs = CS;
  143.      pContext->SegDs = DS;
  144.      pContext->SegEs = ES;
  145.      pContext->SegFs = FS;
  146.      pContext->SegGs = GS;
  147.      pContext->SegSs = SS;
  148.      pContext->EFlags = flags; // __asm{ PUSHFD / pop [xxxxxxxx] }
  149.      pContext->Eip = return address of the caller of the caller of this function
  150.      pContext->Ebp = EBP of the caller of the caller of this function 
  151.      pContext->Esp = Context.Ebp + 8
  152.  }

复制代码

虽然 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

复制代码

  1. UnhandledExceptionFilter( STRUCT _EXCEPTION_POINTERS *pExceptionPtrs )
  2.  {
  3.      PEXCEPTION_RECORD pExcptRec;
  4.      DWORD currentESP;
  5.      DWORD retValue;
  6.      DWORD DEBUGPORT;
  7.      DWORD   dwTemp2;
  8.      DWORD   dwUseJustInTimeDebugger;
  9.      CHAR    szDbgCmdFmt[256];   // Template string retrieved from AeDebug key
  10.      CHAR    szDbgCmdLine[256];  // Actual debugger string after filling in
  11.      STARTUPINFO startupinfo;
  12.      PROCESS_INFORMATION pi;
  13.      HARDERR_STRUCT  harderr;    // ???
  14.      BOOL fAeDebugAuto;
  15.      TIB * pTib;                 // Thread information block
  17.      pExcptRec = pExceptionPtrs->ExceptionRecord;
  19.      if (   (pExcptRec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
  20.          && (pExcptRec->ExceptionInformation[0]) )
  21.      {
  22.          retValue = 
  23.              _BasepCheckForReadOnlyResource(pExcptRec->ExceptionInformation[1]);
  25.          if ( EXCEPTION_CONTINUE_EXECUTION == retValue )
  26.              return EXCEPTION_CONTINUE_EXECUTION;
  27.       }
  29.      // See if this process is being run under a debugger...
  30.      retValue = NtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
  31.                                           &debugPort, sizeof(debugPort), 0 );
  33.      if ( (retValue >= 0) && debugPort )     // Let debugger have it
  34.          return EXCEPTION_CONTINUE_SEARCH;
  36.      // Did the user call SetUnhandledExceptionFilter?  If so, call their
  37.      // installed proc now.
  39.      if ( _BasepCurrentTopLevelFilter )
  40.      {
  41.          retValue = _BasepCurrentTopLevelFilter( pExceptionPtrs );
  43.          if ( EXCEPTION_EXECUTE_HANDLER == retValue )
  44.              return EXCEPTION_EXECUTE_HANDLER;
  46.          if ( EXCEPTION_CONTINUE_EXECUTION == retValue )
  47.              return EXCEPTION_CONTINUE_EXECUTION;
  49.          // Only EXCEPTION_CONTINUE_SEARCH goes on from here
  50.      }
  52.      // Has SetErrorMode(SEM_NOGPFAULTERRORBOX) been called?
  53.      if ( 0 == (GetErrorMode() & SEM_NOGPFAULTERRORBOX) )
  54.      {
  55.          harderr.elem0 = pExcptRec->ExceptionCode;
  56.          harderr.elem1 = pExcptRec->ExceptionAddress;
  58.          if ( EXCEPTION_IN_PAGE_ERROR == pExcptRec->ExceptionCode )
  59.              harderr.elem2 = pExcptRec->ExceptionInformation[2];
  60.          else
  61.              harderr.elem2 = pExcptRec->ExceptionInformation[0];
  63.          dwTemp2 = 1;
  64.          fAeDebugAuto = FALSE;
  66.          harderr.elem3 = pExcptRec->ExceptionInformation[1];
  68.          pTib = FS:[18h];
  70.          DWORD someVal = pTib->pProcess->0xC;
  72.          if ( pTib->threadID != someVal )
  73.          {
  74.              __try
  75.              {
  76.                  char szDbgCmdFmt[256]
  77.                  retValue = _GetProfileStringA( "AeDebug", "Debugger", 0,
  78.                                       szDbgCmdFmt, sizeof(szDbgCmdFmt)-1 );
  80.                  if ( retValue )
  81.                      dwTemp2 = 2;
  83.                  char szAuto[8]
  85.                  retValue = GetProfileStringA(   "AeDebug", "Auto", "0",
  86.                                                  szAuto, sizeof(szAuto)-1 );
  87.                  if ( retValue )
  88.                      if ( 0 == strcmp( szAuto, "1" ) )
  89.                          if ( 2 == dwTemp2 )
  90.                              fAeDebugAuto = TRUE;
  91.              }
  92.              __except( EXCEPTION_EXECUTE_HANDLER )
  93.              {
  94.                  ESP = currentESP;
  95.                  dwTemp2 = 1
  96.                  fAeDebugAuto = FALSE;
  97.              }
  98.          }
  100.          if ( FALSE == fAeDebugAuto )
  101.          {
  102.              retValue =  NtRaiseHardError(
  103.                                  STATUS_UNHANDLED_EXCEPTION | 0x10000000,
  104.                                  4, 0, &harderr,
  105.                                  _BasepAlreadyHadHardError ? 1 : dwTemp2,
  106.                                  &dwUseJustInTimeDebugger );
  107.          }
  108.          else
  109.          {
  110.              dwUseJustInTimeDebugger = 3;
  111.              retValue = 0;
  112.          }
  114.          if (    retValue >= 0 
  115.              &&  ( dwUseJustInTimeDebugger == 3)
  116.              &&  ( !_BasepAlreadyHadHardError )
  117.              &&  ( !_BaseRunningInServerProcess ) )
  118.          {
  119.              _BasepAlreadyHadHardError = 1;
  121.              SECURITY_ATTRIBUTES secAttr = { sizeof(secAttr), 0, TRUE };
  123.              HANDLE hEvent = CreateEventA( &secAttr, TRUE, 0, 0 );
  125.              memset( &startupinfo, 0, sizeof(startupinfo) );
  127.              sprintf(szDbgCmdLine, szDbgCmdFmt, GetCurrentProcessId(), hEvent);
  129.              startupinfo.cb = sizeof(startupinfo);
  130.              startupinfo.lpDesktop = "Winsta0\Default"
  132.              CsrIdentifyAlertableThread();   // ???
  134.              retValue = CreateProcessA(
  135.                              0,              // lpApplicationName
  136.                              szDbgCmdLine,   // Command line
  137.                              0, 0,           // process, thread security attrs
  138.                              1,              // bInheritHandles
  139.                              0, 0,           // creation flags, environment
  140.                              0,              // current directory.
  141.                              &statupinfo,    // STARTUPINFO
  142.                              &pi );          // PROCESS_INFORMATION
  144.              if ( retValue && hEvent )
  145.              {
  146.                  NtWaitForSingleObject( hEvent, 1, 0 );
  147.                  return EXCEPTION_CONTINUE_SEARCH;
  148.              }
  149.          }
  151.          if ( _BasepAlreadyHadHardError )
  152.              NtTerminateProcess(GetCurrentProcess(), pExcptRec->ExceptionCode);
  153.      }
  155.      return EXCEPTION_EXECUTE_HANDLER;
  156.  }
  158.  LPTOP_LEVEL_EXCEPTION_FILTER
  159.  SetUnhandledExceptionFilter(
  160.      LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter );   
  161.  { 
  162.      // _BasepCurrentTopLevelFilter is a KERNEL32.DLL global var
  163.      LPTOP_LEVEL_EXCEPTION_FILTER previous= _BasepCurrentTopLevelFilter;
  165.      // Set the new value
  166.      _BasepCurrentTopLevelFilter = lpTopLevelExceptionFilter;
  168.      return previous;    // return the old value
  169.  }

复制代码

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函数中还有一些其它的代码，我在这里只讲重要的。

发表评论

表情：
评论列表 （有 0 条评论，305人围观）

还没有评论，来说两句吧...

相关阅读