[转载]WINDOWS 2K Dll 加载过程

bini · 发表于 2007-11-16 12:16:34

来自:[url]http://www.whitecell.org/forums/viewthread.php?tid=34[/url]

WINDOWS 2K Dll 加载过程
jefong by 2005/03/30
这片文章是我在阅读完MSJ September 1999 Under the Hood后的总结。
在windows中exe可执行程序运行时都会调用一些DLL，例如KERNEL32.DLL和USER32.DLL等系统的dll。但是dll是怎么被加载的呢？通常，大家都知道在编写dll时会有一个DLLMain的入口函数，但是实际上这个函数并不是调用dll时最先的工作。首先dll需要被加载，然后要进行初始化分配，再之后才进入DLLMain。还有可能你的一个dll中还会调用另一各dll。那么dll到底是怎样加载和初始化的呢，我们来参考一下Platform SDK中的“Dynamic-Link Library Entry-Point Function”。
你的函数正在执行一个初始化任务，例如设置TLS，创建同步对象或打开一个文件。那么你在函数中一定不要调用LoadLibrary函数，因为dll加载命令会创建一个依赖循环。这点会导致在系统执行dll的初始化代码前就已经调用了dll的函数。例如，你不能在入口函数中调用FreeLibrary函数，因为这样会使系统在已经结束了dll后还调用dll中的操作，引起严重错误。
初始化任务时调用Win32函数也会引起错误，例如调用User，Shell和COM函数可能会引起存储无效的错误，因为dll中一些函数会调用LoadLibrary来加载别的系统组件。
  当你在你的DllMain函数中读一个注册表键值，这样做会被限制，因为在正常情况下ADVAPI32.DLL在你执行DllMain代码时还没被初始化，所以你调用的读注册表的函数会失败。
  在文档中初始化部分使用LoadLibrary函数是严格限制的，但是存在特殊的情况，在WindowsNT中USER32.DLL是忽略上面的限制的。这样一来好像与上面所说的相背了，在USER32.DLL的初始化部分出现了调用LoadLibrary加载dll的部分，但是没有出现问题。这是因为AppInit_Dlls的原因，AppInit_Dlls可以为任一个进程调用一个dll列表。所以，如果你的USER32.dll调用出现问题，那一定是AppInit_Dlls没有工作。
  接下来，我们来看看dll的加载和初始化是怎样完成的。操作系统有一个加载器，加载一个模块通常有两个步骤：1.把exe或dll映象到内存中，这时，加载器会检查模块的导入地址表(IAT)，看模块是否依赖于附加的dll。如果dll还没有被加载到进程中，那么加载器就把dll映象到内存。直到所有的未加载的模块都被映象到内存。2.初始化所有的dll。在windows NT中，系统调用exe和dll入口函数的程序会先调用LdrpRunInitializeRoutines函数，也就是说当你调用LoadLibrary时会调用LdrpRunInitializeRoutines，当调用LdrpRunInitializeRoutines时会首先检查已经映射到内存的dll是否已经被初始化。我们来看下面的代码（Matt的LdrpRunInitializeRoutines伪代码）：
//=============================================================================
// Matt Pietrek, September 1999 Microsoft Systems Journal
// 中文注释部分为jefong翻译
//
// Pseudocode for LdrpRunInitializeRoutines in NTDLL.DLL (NT 4, SP3)
//
// 当LdrpRunInitializeRoutines 在一个进程中第一次被调用时（这个进程的隐式链接模块已经被初始化），bImplicitLoad 参数是非零。当使用LoadLibrary调用dll时，bImplicitLoad 参数是零；
//=============================================================================

#include <ntexapi.h> // For HardError defines near the end

// Global symbols (name is accurate, and comes from NTDLL.DBG)
//  _NtdllBaseTag
//  _ShowSnaps
//  _SaveSp
//  _CurSp
//  _LdrpInLdrInit
//  _LdrpFatalHardErrorCount
//  _LdrpImageHasTls

NTSTATUS
LdrpRunInitializeRoutines( DWORD bImplicitLoad )
{
// 第一部分，得到可能需要初始化的模块的数目。一些模块可能已经被初始化过了
unsigned nRoutinesToRun = _LdrpClearLoadInProgress();

if ( nRoutinesToRun )
{
      // 如果有需要初始化的模块，为它们分配一个队列，用来装载各模块信息。
      pInitNodeArray = _RtlAllocateHeap(GetProcessHeap(),
                                          _NtdllBaseTag + 0x60000,
                                          nRoutinesToRun * 4 );

      if ( 0 == pInitNodeArray ) // Make sure allocation worked
         return STATUS_NO_MEMORY;
}
else
      pInitNodeArray = 0;

//第二部分；
//进程环境块（Peb），包含一个指向新加载模块的链接列表的指针。
pCurrNode = *(pCurrentPeb->ModuleLoaderInfoHead);
ModuleLoaderInfoHead = pCurrentPeb->ModuleLoaderInfoHead;

if ( _ShowSnaps )
{
      _DbgPrint( "LDR: Real INIT LIST\n" );
}

nModulesInitedSoFar = 0;

if ( pCurrNode != ModuleLoaderInfoHead ) //判断是否有新加载的模块
{

      while ( pCurrNode != ModuleLoaderInfoHead ) //遍历所有新加载的模块
      {
         ModuleLoaderInfo  pModuleLoaderInfo;

         //
         //一个ModuleLoaderInfo结构节点的大小为0X10字节
         pModuleLoaderInfo = &NextNode - 0x10;

         localVar3C = pModuleLoaderInfo;

         //
         // 如果模块已经被初始化，就忽略
         // X_LOADER_SAW_MODULE = 0x40 已被初始化
         if ( !(pModuleLoaderInfo->Flags35 & X_LOADER_SAW_MODULE) )
         {
            //
            // 模块没有被初始化，判断是否具有入口函数
            //
            if ( pModuleLoaderInfo->EntryPoint )
            {
                  //
                  // 具有初始化函数，添加到模块列表中，等待进行初始化
                  pInitNodeArray[nModulesInitedSoFar] =pModuleLoaderInfo;

                  // 如果ShowSnaps为非零，那么打印出模块的路径和入口函数的地址
   // 例如：
                  // C:\WINNT\system32\KERNEL32.dll init routine 77f01000
                  if ( _ShowSnaps )
                  {
                     _DbgPrint(  "%wZ init routine %x\n",
                                 &pModuleLoaderInfo->24,
                                 pModuleLoaderInfo->EntryPoint );
                  }

                  nModulesInitedSoFar++;
            }
         }

         // 设置模块的X_LOADER_SAW_MODULE标志。说明这个模块还没有被初始化。
         pModuleLoaderInfo->Flags35 &= X_LOADER_SAW_MODULE;

         // 处理下一个模块节点
         pCurrNode = pCurrNode->pNext
      }
}
else
{
      pModuleLoaderInfo = localVar3C;    // May not be initialized???
}

if ( 0 == pInitNodeArray )
      return STATUS_SUCCESS;

// ************************* MSJ Layout! *****************
// If you're going to split this code across pages, this is a great
// spot to split the code.  Just be sure to remove this comment
// ************************* MSJ Layout! *****************

//
// pInitNodeArray指针包含一个模块指针队列，这些模块还没有 DLL_PROCESS_ATTACH
// 第三部分，调用初始化部分
try    // Wrap all this in a try block, in case the init routine faults
{
      nModulesInitedSoFar = 0;  // Start at array element 0

      //
      // 遍历模块队列
      //
      while ( nModulesInitedSoFar < nRoutinesToRun )
      {
         // 获得模块指针
         pModuleLoaderInfo = pInitNodeArray[ nModulesInitedSoFar ];

         // This doesn't seem to do anything...
         localVar3C = pModuleLoaderInfo;

         nModulesInitedSoFar++;

         // 保存初始化程序入口指针
         pfnInitRoutine = pModuleLoaderInfo->EntryPoint;

         fBreakOnDllLoad = 0; // Default is to not break on load

         // 调试用
         // If this process is a debuggee, check to see if the loader
         // should break into a debugger before calling the initialization.
         //
         // DebuggerPresent (offset 2 in PEB) is what IsDebuggerPresent()
         // returns. IsDebuggerPresent is an NT only API.
         //
         if ( pCurrentPeb->DebuggerPresent || pCurrentPeb->1 )
         {
            LONG retCode;

            //
            // Query the "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\
            // Windows NT\CurrentVersion\Image File Execution Options"
            // registry key.  If a a subkey entry with the name of
            // the executable exists, check for the BreakOnDllLoad value.
            //
            retCode =
                  _LdrQueryImageFileExecutionOptions(
                              pModuleLoaderInfo->pwszDllName,
                              "BreakOnDllLoad",pInitNodeArray
                              REG_DWORD,
                              &fBreakOnDllLoad,
                              sizeof(DWORD),
                              0 );

            // If reg value not found (usually the case), then don't
            // break on this DLL init
            if ( retCode <= STATUS_SUCCESS )
                  fBreakOnDllLoad = 0;pInitNodeArray
         }

         if ( fBreakOnDllLoad )
         {
            if ( _ShowSnaps )
            {
                  // Inform the debug output stream of the module name
                  // and the init routine address before actually breaking
                  // into the debugger

                  _DbgPrint(  "LDR: %wZ loaded.",
                              &pModuleLoaderInfo->pModuleLoaderInfo );

                  _DbgPrint(  "- About to call init routine at %lx\n",
                              pfnInitRoutine )
            }

            // Break into the debugger
            _DbgBreakPoint(); // An INT 3, followed by a RET
         }
         else if ( _ShowSnaps && pfnInitRoutine )
         {
            // Inform the debug output stream of the module name
            // and the init routine address before calling it
            _DbgPrint(  "LDR: %wZ loaded.",
                        pModuleLoaderInfo->pModuleLoaderInfo );

            _DbgPrint("- Calling init routine at %lx\n", pfnInitRoutine);
         }

         if ( pfnInitRoutine )
         {
            // 设置DLL_PROCESS_ATTACH标志
            //
            // (Shouldn't this come *after* the actual call?)
            //
            // X_LOADER_CALLED_PROCESS_ATTACH = 0x8
            pModuleLoaderInfo->Flags36 |= X_LOADER_CALLED_PROCESS_ATTACH;

            //
            // If there's Thread Local Storage (TLS) for this module,
            // call the TLS init functions.  *** NOTE *** This only
            // occurs during the first time this code is called (when
            // implicitly loaded DLLs are initialized).  Dynamically
            // loaded DLLs shouldn't use TLS declared vars, as per the
            // SDK documentation
            // 如果模块需要分配TLS，调用TLS初始化函数
  // 注意只有在第一次调时（bImplicitLoad!=0）才会分配TLS，就是隐式dll加载时
  // 当动态加载时(bImplicitLoad==0)就不需要声明TLS变量
            if ( pModuleLoaderInfo->bHasTLS && bImplicitLoad )
            {
                  _LdrpCallTlsInitializers( pModuleLoaderInfo->hModDLL,
                                             DLL_PROCESS_ATTACH );
            }


            hModDLL = pModuleLoaderInfo->hModDLL

            MOV    ESI,ESP // Save off the ESP register into ESI

  // 设置入口函数指针
            MOV    EDI,DWORD PTR [pfnInitRoutine]

            // In C++ code, the following ASM would look like:
            //
            // initRetValue =
            // pfnInitRoutine(hInstDLL,DLL_PROCESS_ATTACH,bImplicitLoad);
            //

            PUSH DWORD PTR [bImplicitLoad]

            PUSH DLL_PROCESS_ATTACH

            PUSH DWORD PTR [hModDLL]

            CALL EDI    // 调用入口函数

            MOV    BYTE PTR [initRetValue],AL  // 保存入口函数返回值

            MOV    DWORD PTR [_SaveSp],ESI // Save stack values after the
            MOV    DWORD PTR [_CurSp],ESP  // entry point code returns

            MOV    ESP,ESI    // Restore ESP to value before the call

            //
            // 检查调用前后的ESP值是否一至
  //
            if ( _CurSP != _SavSP )
            {
                  hardErrorParam = pModuleLoaderInfo->FullDllPath;

                  hardErrorRetCode =
                     _NtRaiseHardError(
                        STATUS_BAD_DLL_ENTRYPOINT | 0x10000000,
                        1,  // Number of parameters
                        1,  // UnicodeStringParametersMask,
                        &hardErrorParam,
                        OptionYesNo, // Let user decide
                        &hardErrorResponse );

                  if ( _LdrpInLdrInit )
                     _LdrpFatalHardErrorCount++;

                  if ( (hardErrorRetCode >= STATUS_SUCCESS)
                     &&  (ResponseYes == hardErrorResponse) )
                  {
                     return STATUS_DLL_INIT_FAILED;
                  }
            }

            //
            // 入口函数返回0，错误
            //
            if ( 0 == initRetValue )
            {
                  DWORD hardErrorParam2;
                  DWORD hardErrorResponse2;

                  hardErrorParam2 = pModuleLoaderInfo->FullDllPath;

                  _NtRaiseHardError(  STATUS_DLL_INIT_FAILED,
                                    1,  // Number of parameters
                                    1,  // UnicodeStringParametersMask
                                    &hardErrorParam2,
                                    OptionOk, // OK is only response
                                    &hardErrorResponse2 );

                  if ( _LdrpInLdrInit )
                     _LdrpFatalHardErrorCount++;

                  return STATUS_DLL_INIT_FAILED;
            }
         }
      }

      //
      // 如果EXE已经拥有了TLS，那么调用TLS初始化函数，也是在进程第一次初始化dll时
      //
      if ( _LdrpImageHasTls && bImplicitLoad )
      {
         _LdrpCallTlsInitializers( pCurrentPeb->ProcessImageBase,
                                    DLL_PROCESS_ATTACH );
      }
}
__finally
{
      //
      // 第四部分；
      // 清除分配的内存
      _RtlFreeHeap( GetProcessHeap(), 0, pInitNodeArray );
}

return STATUS_SUCCESS;
}

这个函数分为四个主要部分：
一：第一部分调用_LdrpClearLoadInProgress函数，这个NTDLL函数返回已经被映象到内存的dll的个数。例如，你的进程调用exm.dll,而exm.dll又调用exm1.dll和exm2.dll，那么_LdrpClearLoadInProgress会返回3。得到dll个数后，调用_RtlAllocateHeap，它会返回一个内存的队列指针。伪码中的队列指针为pInitNodeArray。队列中的每个节点指针都指向一个新加载的dll的结构信息。
二：第二部分的代码通过进程内部的数据结构获得一个新加载dll的链接列表。并且检查dll是否有入口指针，如果有，就把模块信息指针加入pInitNodeArray中。伪码中的模块信息指针为pModuleLoaderInfo。但是有的dll是资源文件，并不具有入口函数。所以pInitNodeArray中节点比_LdrpClearLoadInProgress返回的数目要少。
三：第三部分的代码枚举了pInitNodeArray中的对象，并且调用了入口函数。因为这部分的初始化代码有可能出现错误，所以使用了_try异常扑获功能。这就是为什么在DllMain中出现错误后不会使整个进程终止。
另外，在调用入口函数时还会对TLS进行初始化，当用 __declspec来声明TLS变量时，链接器包含的数据可以进行触发。在调用dll的入口函数时，LdrpRunInitializeRoutines函数会检查是否需要初始化一个TLS，如果需要，就调用_LdrpCallTlsInitializers。
在最后的伪代码部分使用汇编语言来进行dll的入口函数调用。主要的命令时CALL EDI；EDI中就是入口函数的指针。当此命令返回后，dll的初始化工作就完成了。对于C++写的dll，DllMain已经执行完成了它的DLL_PROCESS_ATTACH代码。注意一下入口函数的第三个参数pvReserved，当exe或dll隐式调用dll时这个参数是非零，当使用LoadLibrary调用时是零。在入口函数调用以后，加载器会检查调用入口函数前和后的ESP的值，如果不同，dll的初始化函数就会报错。检查完ESP后，还会检查入口函数的返回值，如果是零，说明初始化的时候出现了什么问题。并且系统会报错并停止调用dll。在第三部分的最后，在初始化完成后，如果exe进程已经拥有了TLS，并且隐式调用的dll已经被初始化，那么会调用_LdrpCallTlsInitializers。
四：第四部分代码是清理代码，象_RtlAllocateHeap 分配的pInitNodeArray的内存需要被释放。释放代码出现在_finally块中，调用了_RtlFreeHeap 。

		自动登录	找回密码
密码			加入计匠网