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 。
本文地址：http://com.8s8s.com/it/it22662.htm