|
|
来自:[url]http://www.whitecell.org/forums/viewthread.php?tid=34[/url]
; A- P2 _5 v* P% K% _1 L
1 Z5 U% y4 b9 A p$ P: CWINDOWS 2K Dll 加载过程3 y$ h" H$ Q: R* @. a9 q) \
jefong by 2005/03/30! Y2 g! w/ R9 \3 ^$ y8 ~% b- z
这片文章是我在阅读完MSJ September 1999 Under the Hood后的总结。
) C2 {* H x4 m8 S( K9 r1 y在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”。. l; ?; C- d Z' z9 U7 r- y
你的函数正在执行一个初始化任务,例如设置TLS,创建同步对象或打开一个文件。那么你在函数中一定不要调用LoadLibrary函数,因为dll加载命令会创建一个依赖循环。这点会导致在系统执行dll的初始化代码前就已经调用了dll的函数。例如,你不能在入口函数中调用FreeLibrary函数,因为这样会使系统在已经结束了dll后还调用dll中的操作,引起严重错误。
5 a1 v8 ?5 @4 W: _+ R3 z初始化任务时调用Win32函数也会引起错误,例如调用User,Shell和COM函数可能会引起存储无效的错误,因为dll中一些函数会调用LoadLibrary来加载别的系统组件。) c/ n- Q4 R( z1 V0 s" N; `. }
当你在你的DllMain函数中读一个注册表键值,这样做会被限制,因为在正常情况下ADVAPI32.DLL在你执行DllMain代码时还没被初始化,所以你调用的读注册表的函数会失败。
( F8 S+ k. k9 `: v8 G 在文档中初始化部分使用LoadLibrary函数是严格限制的,但是存在特殊的情况,在WindowsNT中USER32.DLL是忽略上面的限制的。这样一来好像与上面所说的相背了,在USER32.DLL的初始化部分出现了调用LoadLibrary加载dll的部分,但是没有出现问题。这是因为AppInit_Dlls的原因,AppInit_Dlls可以为任一个进程调用一个dll列表。所以,如果你的USER32.dll调用出现问题,那一定是AppInit_Dlls没有工作。5 f3 _: n- i( M. P
接下来,我们来看看dll的加载和初始化是怎样完成的。操作系统有一个加载器,加载一个模块通常有两个步骤:1.把exe或dll映象到内存中,这时,加载器会检查模块的导入地址表(IAT),看模块是否依赖于附加的dll。如果dll还没有被加载到进程中,那么加载器就把dll映象到内存。直到所有的未加载的模块都被映象到内存。2.初始化所有的dll。在windows NT中,系统调用exe和dll入口函数的程序会先调用LdrpRunInitializeRoutines函数,也就是说当你调用LoadLibrary时会调用LdrpRunInitializeRoutines,当调用LdrpRunInitializeRoutines时会首先检查已经映射到内存的dll是否已经被初始化。我们来看下面的代码(Matt的LdrpRunInitializeRoutines伪代码):- g) G' N5 C# ^, V
//=============================================================================
. ^& Z/ c) y4 d5 S0 U0 e( H. ?// Matt Pietrek, September 1999 Microsoft Systems Journal3 E7 G4 `+ C: I9 M, K2 f* [
// 中文注释部分为jefong翻译" x S! _3 K% i6 X1 n) K9 D5 M
//% z4 p2 ?$ g3 M
// Pseudocode for LdrpRunInitializeRoutines in NTDLL.DLL (NT 4, SP3)
% {7 O$ K/ v$ J4 e6 T5 N4 @5 W, f//
' W/ \) B- t& Z! _1 b// 当LdrpRunInitializeRoutines 在一个进程中第一次被调用时(这个进程的隐式链接模块已经被初始化),bImplicitLoad 参数是非零。当使用LoadLibrary调用dll时,bImplicitLoad 参数是零;
) [ t; g$ Z' ^# [//=============================================================================
" U- g6 X5 k! c1 G. ^+ [7 r8 B, r8 w* C
#include <ntexapi.h> // For HardError defines near the end
# u8 _* Q* v. h# d/ a7 o3 Z# s; T7 r' E+ y) a" x7 J
// Global symbols (name is accurate, and comes from NTDLL.DBG)3 c$ ]# s# C) T* F
// _NtdllBaseTag: ~2 j5 l; x( v
// _ShowSnaps3 D4 C6 e4 X' x8 q; Z: y$ E
// _SaveSp
; y$ \0 w' O q3 o// _CurSp
$ K3 x/ ?' { f0 h7 C% A// _LdrpInLdrInit
5 t9 @$ \9 B: I" ^. x// _LdrpFatalHardErrorCount5 a# v5 s6 B2 |3 H
// _LdrpImageHasTls5 D* v& j6 s V( K2 M' |
* u R: x# ]/ v! n
NTSTATUS4 W! i- M6 G: Y, J. h
LdrpRunInitializeRoutines( DWORD bImplicitLoad )
# O4 a; n9 r. K5 g* |. B{6 H0 ]# [0 e) u% _& K5 z8 N
// 第一部分,得到可能需要初始化的模块的数目。一些模块可能已经被初始化过了& \7 V; K9 J7 F4 A* v
unsigned nRoutinesToRun = _LdrpClearLoadInProgress();3 l: c& n* z, ]; M; e$ A
. k, w, p2 _0 _+ R5 |7 Y3 Z
if ( nRoutinesToRun )
9 x# I% o/ e; k' r3 o, Y {
0 ?# ?- N3 }, g/ c' R& h // 如果有需要初始化的模块,为它们分配一个队列,用来装载各模块信息。
3 t- Y4 P l! k0 q1 N pInitNodeArray = _RtlAllocateHeap(GetProcessHeap(),
8 T% B9 D( x+ Z3 N _NtdllBaseTag + 0x60000,4 V3 N. U& n& _0 o$ T
nRoutinesToRun * 4 );6 K" H7 k5 f# E9 c0 p! C$ S
5 C z6 w! y3 J
if ( 0 == pInitNodeArray ) // Make sure allocation worked+ ~7 n2 D8 @% o1 q6 k+ J5 m
return STATUS_NO_MEMORY;( t- q5 c& c& T% ^5 ^0 U) ^$ T
}
1 ~2 M0 H: M" [0 ?/ G4 A! T else
- n* V+ u; o! U pInitNodeArray = 0;& l p+ ?( i, O9 A* T7 s
6 o: j6 x3 ?: w# L* g //第二部分;2 H/ y: i& }, a2 w
//进程环境块(Peb),包含一个指向新加载模块的链接列表的指针。& {; [( O$ O q) z% D2 P: M
pCurrNode = *(pCurrentPeb->ModuleLoaderInfoHead);; q/ {5 p7 |9 K! z3 r7 `& Y0 S5 H
ModuleLoaderInfoHead = pCurrentPeb->ModuleLoaderInfoHead;
% H+ E$ W6 o8 y! `7 R4 b4 k" Q 0 J) a$ r) d. S9 t* ?, v1 g
if ( _ShowSnaps )) ]2 D$ U. N8 Z
{ O5 t0 c% E/ L9 z7 c( o
_DbgPrint( "LDR: Real INIT LIST\n" );4 s( ]( l, Z9 W" e* x# ]; q! h2 p
}5 e6 v+ g( g: N3 l$ m$ i& b" V
+ Z9 H; k: U2 f; B7 V! P nModulesInitedSoFar = 0;
4 K# a: s3 v: ~# \( p6 N% }$ p: h o
if ( pCurrNode != ModuleLoaderInfoHead ) //判断是否有新加载的模块1 p& B# _; n# r; v7 o1 m2 b, e8 v
{& n& y2 b. p0 P
: {: B# U. G, M" z
while ( pCurrNode != ModuleLoaderInfoHead ) //遍历所有新加载的模块" z) {, t8 O+ A8 x1 ]$ t: U8 ?
{
1 f$ f% [! L1 g# ^) i8 i c& K2 E ModuleLoaderInfo pModuleLoaderInfo;
1 J$ U" o( ~; K" ?
. J8 }. _ j6 n: m //
# x2 c e$ S$ H3 z" x$ q //一个ModuleLoaderInfo结构节点的大小为0X10字节# H2 o: ?" R' R$ V3 I+ o" o0 V
pModuleLoaderInfo = &NextNode - 0x10;! c/ C! B2 b5 G1 G+ e5 Y8 c# _
( a. n3 [$ D# [5 I# j
localVar3C = pModuleLoaderInfo;
# ~" S: K. ]* u, f% y% q- @# N4 X5 l" D: K& b c8 T
//
/ B; M) s, V- G) D9 o // 如果模块已经被初始化,就忽略
& c* }" V- ]# V! F) R. R7 U // X_LOADER_SAW_MODULE = 0x40 已被初始化' V0 u: }0 e4 p
if ( !(pModuleLoaderInfo->Flags35 & X_LOADER_SAW_MODULE) )( V, g" f: b j" z+ N5 b# W) x
{
Y8 e/ T8 R ^( N4 E* }) B //* p% t" r( M I9 M
// 模块没有被初始化,判断是否具有入口函数
4 }6 L8 ^& l3 l* w' m# q% U1 I% | //
2 M) v& }5 K3 @+ S if ( pModuleLoaderInfo->EntryPoint )
$ q$ \1 H# m9 E" k: M- ]6 X G {1 u2 U/ i5 E1 ~6 v
//
7 J/ W# h( ?) ~* N% e // 具有初始化函数,添加到模块列表中,等待进行初始化8 g j9 @3 ~. j4 I9 K3 C( K: T
pInitNodeArray[nModulesInitedSoFar] =pModuleLoaderInfo;' @6 B' o4 j1 B. l5 V! t
4 F' j: V0 r" h // 如果ShowSnaps为非零,那么打印出模块的路径和入口函数的地址# P! T# j$ l( Z8 Y4 b: q
// 例如:( N" N5 Y2 N2 n3 U3 ^: V- ?# s
// C:\WINNT\system32\KERNEL32.dll init routine 77f01000
: r6 h) s( P8 D9 S: E if ( _ShowSnaps )
- Q* P+ |; ^9 q) ~ n+ |$ R H' a5 U( C {
2 d. P5 j, [; J" V5 N _DbgPrint( "%wZ init routine %x\n",) C1 M; Z% W7 m1 Y) G) z' u
&pModuleLoaderInfo->24,4 E' G* B& e2 v4 n& Y; |
pModuleLoaderInfo->EntryPoint );
+ a* \2 a8 s7 p+ ~ }# |3 u4 L. p6 ~, f, D
: `' Y: I& \% _8 j/ K nModulesInitedSoFar++;7 y: a- `1 z# O! e/ E% m9 y) g* g
}
' F" n L, C+ ~9 P1 G }
! F/ C& s# z5 L$ k* j1 v1 F
2 P" ^- D3 }, r* w+ Y' @) Z6 W8 T // 设置模块的X_LOADER_SAW_MODULE标志。说明这个模块还没有被初始化。
# ^8 v- |8 E8 B& |& A pModuleLoaderInfo->Flags35 &= X_LOADER_SAW_MODULE;
5 f6 u0 u1 d# D7 w) X: g1 s9 |* s
// 处理下一个模块节点
, H! v1 Q" T0 r) f0 ]3 ` pCurrNode = pCurrNode->pNext; O1 x- ?: c; J2 e! L9 m4 u7 S
}3 }5 a3 q$ \% a0 Z
}4 ]% b% `4 x+ ^9 \( B3 q, H
else
& N$ V! m, a9 g: X0 ~0 ] [ {
) p4 N& M# D; w4 |' ` pModuleLoaderInfo = localVar3C; // May not be initialized???# e P. W$ b8 A5 v* c, I- M6 I
}
, m8 b# Z# F/ r# v v
) h" ?$ J: q9 z3 t if ( 0 == pInitNodeArray )
" W b& u8 k% k% F+ s8 y return STATUS_SUCCESS; }; R, [: B, z* k+ E) C
& R/ @; ]/ x5 x
// ************************* MSJ Layout! *****************
. `. V) K8 t6 \& o H! T. t // If you're going to split this code across pages, this is a great1 @/ \8 d; s! d
// spot to split the code. Just be sure to remove this comment/ b6 O- U' m/ ?# r+ G5 `
// ************************* MSJ Layout! *****************# c7 y+ y* ^" I- F
& c, D7 [; \" m& r$ x
// Z; P5 E6 o" J5 K7 D$ H% s
// pInitNodeArray指针包含一个模块指针队列,这些模块还没有 DLL_PROCESS_ATTACH( N- r @0 I5 k# c
// 第三部分,调用初始化部分9 L j. ]0 M+ |4 B( \# f
try // Wrap all this in a try block, in case the init routine faults
0 E. Q+ {6 H e' @ G* u {# N/ o+ ~8 N8 Y: V/ N" ]
nModulesInitedSoFar = 0; // Start at array element 0; \& _2 `3 [* o1 d0 V8 L
; _$ u! q& ~ M U/ C- D, P7 l- {
//
/ B4 e, S% m8 [ // 遍历模块队列
* e0 R* v4 X! r" y. [) X //+ Z/ {' K2 n% g
while ( nModulesInitedSoFar < nRoutinesToRun ), n0 G. ^2 ?2 d" H1 u
{
; r* y3 ] T! N. D4 e // 获得模块指针
6 P* v8 I8 }( D4 @# @* K: F+ B pModuleLoaderInfo = pInitNodeArray[ nModulesInitedSoFar ];1 ~: O0 E- s! Y2 G* w) N
. u# T6 N# q$ T& G // This doesn't seem to do anything... K1 `5 n- `# C: S
localVar3C = pModuleLoaderInfo;
+ k a1 B1 ]- o/ o 0 p, W7 F7 B6 F3 T8 u0 l1 B2 R
nModulesInitedSoFar++;6 N! \& b8 ^7 ~" X
: i- S V3 e; F0 ^8 }9 o // 保存初始化程序入口指针
+ ^' ^) ?+ F$ N0 q9 Y! n! S pfnInitRoutine = pModuleLoaderInfo->EntryPoint;
$ s$ d; E: g& K3 _& c* L/ n ( M: J7 v# h8 b
fBreakOnDllLoad = 0; // Default is to not break on load$ ^3 D2 N) W' B4 n1 a
% p, b4 g# w. u4 c6 D! ^
// 调试用
. y7 E. F j, T2 Z$ G // If this process is a debuggee, check to see if the loader
3 J8 O) P- X" E9 I // should break into a debugger before calling the initialization.
2 g! O4 w* O9 @0 t6 [ //* K) p; u1 Z! \. k) n
// DebuggerPresent (offset 2 in PEB) is what IsDebuggerPresent()' A% @9 _% s1 o
// returns. IsDebuggerPresent is an NT only API.
7 z3 X a! y: [. h //$ }; G/ B5 B- j7 O& O! q+ X7 A7 }
if ( pCurrentPeb->DebuggerPresent || pCurrentPeb->1 )
! S7 b$ U! w. K( R- D {
7 q# o9 ^7 b2 L3 _ e LONG retCode;" x/ H4 p' R6 x
% ~3 P' Y4 t6 ^3 w4 F //
" D% k; `) B6 _& p, f- ]* i // Query the "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\
) U: C. _9 x" q& Z T; Z I6 u9 }5 m // Windows NT\CurrentVersion\Image File Execution Options"
( a+ A0 ~9 p0 ?* ` // registry key. If a a subkey entry with the name of
$ U- Y: a0 R8 _7 C+ C // the executable exists, check for the BreakOnDllLoad value.
3 c' C. P% Y! D' q //
3 s* t& t: n( M7 d retCode =
' T0 H! T D6 R b, W1 a _LdrQueryImageFileExecutionOptions(
/ ^+ c1 J# ?: q- ^, H pModuleLoaderInfo->pwszDllName,1 m) q& W% r ?" }. x! o3 H. P+ ^. C
"BreakOnDllLoad",pInitNodeArray, d t, o3 {7 `8 v1 X
REG_DWORD," R0 }: T! f6 y: d& M3 _# _
&fBreakOnDllLoad,
9 i* r/ z1 G$ X( L" T3 P# d sizeof(DWORD),2 ]: m8 {3 x) ]( B( s; O, d4 g5 V
0 );3 j$ w# A" P" h7 {
' N8 R4 x# Q9 k8 q& S* X
// If reg value not found (usually the case), then don't
& Y$ y: m. L( g/ R. y // break on this DLL init
( ]/ |8 n$ Z2 X7 y2 w9 ~ if ( retCode <= STATUS_SUCCESS )
7 |+ J7 j1 q. V1 T; l fBreakOnDllLoad = 0;pInitNodeArray# S4 m6 S: M: @7 B$ u; k7 M1 P
}, \7 E* }( r1 H. Q- t2 u" W* ^0 C1 c
, G% M* \4 ^0 \1 y$ p* \3 [7 n
if ( fBreakOnDllLoad )0 U8 V# H( A# I& l/ N" `( e7 }: ]
{
# T4 `, c! E% e$ z+ d9 H if ( _ShowSnaps ); K0 r; g- A3 u) c
{3 ?5 C7 e! ~) l( H/ P
// Inform the debug output stream of the module name
6 g# G0 s8 n3 y+ u# K* P // and the init routine address before actually breaking
1 S7 t s9 {7 H1 G | // into the debugger( t1 A/ M K- s$ u5 ~
5 D* N& \6 L: z5 f5 i5 _3 b
_DbgPrint( "LDR: %wZ loaded.",# B3 r: l5 n' w4 k
&pModuleLoaderInfo->pModuleLoaderInfo );& i7 j5 r7 [& F* n1 D
4 e6 Q+ n7 v9 }6 Y" E1 m _DbgPrint( "- About to call init routine at %lx\n"," \7 I4 l( |7 F* X6 o }
pfnInitRoutine )
! B9 c2 d, v9 F7 A/ @: W/ F }/ \$ }5 @/ A8 F) \6 ?$ [4 `: ]
$ i+ z: m( z" o# w // Break into the debugger
8 [- i3 l; }% C7 `2 `5 | _DbgBreakPoint(); // An INT 3, followed by a RET
* t: X$ A. x. W2 H6 m4 R A6 y3 p }
( J9 i# x. u3 {# h/ A6 C/ q else if ( _ShowSnaps && pfnInitRoutine )
! f! T$ L9 W/ [( X n {4 r5 l" X5 ^1 s; [9 Y+ X. p2 R
// Inform the debug output stream of the module name
. v" [+ H& i' W: B" n/ r3 K _5 o2 y! [; g // and the init routine address before calling it
; l7 V$ G/ ?6 l# b# d: W, S& s _DbgPrint( "LDR: %wZ loaded.",1 W& d. d' H5 b0 K2 S1 a6 d
pModuleLoaderInfo->pModuleLoaderInfo );: H3 u8 L& s8 E' g
: T3 u4 e& N1 F _DbgPrint("- Calling init routine at %lx\n", pfnInitRoutine);4 T- K9 J% x) s- P2 M/ v* C l& c
}
" }% e+ K3 [: L( {' h
* {; O/ t3 ~! W2 H if ( pfnInitRoutine )3 \+ N) \) M! k* g% a
{: y6 i# W* M' c: N: K( O
// 设置DLL_PROCESS_ATTACH标志
1 s# X" q4 i; L8 |0 E, B //
6 R$ v2 j* C7 _7 q" |$ P // (Shouldn't this come *after* the actual call?): N1 R, N r$ d2 s" r
//
8 M7 l# W# I( u8 L" c7 m: V // X_LOADER_CALLED_PROCESS_ATTACH = 0x8
( q6 O# B8 D6 U" x$ L pModuleLoaderInfo->Flags36 |= X_LOADER_CALLED_PROCESS_ATTACH;
1 B0 [6 Q2 _) n) \) c8 b$ ]1 A2 E
/ y6 z" o8 s/ J4 P/ _ //
: R/ q3 ^# S) u! K7 E/ a4 Y // If there's Thread Local Storage (TLS) for this module,
$ ]& e* J! x/ { // call the TLS init functions. *** NOTE *** This only
# W# e( ~' [3 E1 l& J% c) x // occurs during the first time this code is called (when8 o( X& {: w$ X3 H9 m: s* X# O* ~
// implicitly loaded DLLs are initialized). Dynamically
! Y/ t" a; ^/ Y% l* c // loaded DLLs shouldn't use TLS declared vars, as per the
6 J5 G: d& N$ N, k // SDK documentation
8 c: `6 |$ s% ]5 K/ S7 {6 B // 如果模块需要分配TLS,调用TLS初始化函数5 g0 [ I+ k8 d, E8 f% Q$ h' d
// 注意只有在第一次调时(bImplicitLoad!=0)才会分配TLS,就是隐式dll加载时
6 h* ^3 o9 {1 Y& R7 @ // 当动态加载时(bImplicitLoad==0)就不需要声明TLS变量
% `0 u+ N+ ?, ^4 k3 c- {0 G; K if ( pModuleLoaderInfo->bHasTLS && bImplicitLoad )
: o7 Z" H! R4 r( g4 p! b$ f! \ {: P+ ]) b3 q0 n8 L- G$ a
_LdrpCallTlsInitializers( pModuleLoaderInfo->hModDLL," @' s! r$ c( j0 C" @1 Z
DLL_PROCESS_ATTACH );
4 c# r+ e5 k5 W( p/ q& F0 x5 O }
! t7 b/ [3 d+ ^/ f1 F2 S
$ X* i% @( X: F1 F( L, {, o9 u# a! }$ c! _; K3 ]" a+ B2 }
hModDLL = pModuleLoaderInfo->hModDLL
. q! @- t6 R5 @. Z/ A1 h' @: ?0 C
MOV ESI,ESP // Save off the ESP register into ESI
) s$ e& y" h# k/ E1 m
, Q6 | U z% ]9 L // 设置入口函数指针 7 N4 p6 W6 @' P8 E7 _5 |
MOV EDI,DWORD PTR [pfnInitRoutine] & Y. \% k& D O0 I/ S
/ w, j+ l: h3 B! | // In C++ code, the following ASM would look like:
" ^6 O6 e. }# M- b4 X/ `: C7 \8 k //
4 Q8 n) Y0 Y( O- m, r4 F // initRetValue =
$ s& J5 P1 x% o% g( g9 c7 r // pfnInitRoutine(hInstDLL,DLL_PROCESS_ATTACH,bImplicitLoad);2 I( O, p; w# T
//
$ h9 Z u0 h% p4 m
% ~0 w0 `) V5 S8 o V PUSH DWORD PTR [bImplicitLoad]
4 i* t. X/ B' d, L7 b
( r6 y% S- D9 E& d" z4 R PUSH DLL_PROCESS_ATTACH
: K( ^6 {0 P' @0 P$ W& t 1 T( r8 t6 v7 J. g# s
PUSH DWORD PTR [hModDLL]! s) w# G# E: G' [
; s4 P9 }; t/ t6 L
CALL EDI // 调用入口函数
+ J( b' w: o; \; N% N8 K: ` 3 Q% o8 Q7 r I/ N
MOV BYTE PTR [initRetValue],AL // 保存入口函数返回值" |3 n: ~; u( F- j/ b7 ^
O6 a1 q0 q, E2 d) Z MOV DWORD PTR [_SaveSp],ESI // Save stack values after the
9 {6 I8 o) F' T7 h MOV DWORD PTR [_CurSp],ESP // entry point code returns
6 _/ t9 L& T+ t
! }- E5 b |* Y0 L, Y MOV ESP,ESI // Restore ESP to value before the call! @3 a+ r8 g; ?& x1 J
# z% o5 G7 L6 d; k7 q. a2 q
//8 f8 q. r0 v( h
// 检查调用前后的ESP值是否一至5 A1 b1 ~; c# }, V; s+ c
//
" g8 B; d3 Q/ Q. Q if ( _CurSP != _SavSP ), t2 L+ _4 C |1 p8 W3 D8 H; S
{
, W* H0 b5 a( G( ~" O. ^ T hardErrorParam = pModuleLoaderInfo->FullDllPath;: N2 _! W5 [9 q
% B \ ]% W8 R$ A8 E- n& _ hardErrorRetCode = 5 n; c* ~" c. b% F
_NtRaiseHardError(
2 {2 f+ @2 H- ]8 [5 \ STATUS_BAD_DLL_ENTRYPOINT | 0x10000000,
b h) o# E7 z% w4 }# X 1, // Number of parameters
7 t1 N! B$ U4 S! O6 @& B; ? 1, // UnicodeStringParametersMask,
5 l' f/ p: Z' m6 K &hardErrorParam,8 o! r8 m' ^3 O4 m
OptionYesNo, // Let user decide6 C; E+ t( Y$ f/ S3 q3 z
&hardErrorResponse );
6 ]. m" }( Z( F3 {; o4 D , K% y+ e; X. K9 T( Z5 Q, C; l6 j3 y
if ( _LdrpInLdrInit )6 |% O7 ?5 y- W$ ?- ~& ~
_LdrpFatalHardErrorCount++;! y6 I3 ]. f: s3 P# p
4 d5 A4 i, K: |, q- V! J if ( (hardErrorRetCode >= STATUS_SUCCESS)* H+ q! H: f$ p
&& (ResponseYes == hardErrorResponse) )
- ^& Q) o. ^& [' J1 K {
9 F- m! o D, E3 X" ^ return STATUS_DLL_INIT_FAILED;. O. x, w$ \" s3 G+ g
}
0 P$ ?3 n+ i, ^ L4 k2 X }! o7 n+ X2 H# v+ E. U6 u
$ m' p* e! r; C- c2 f, D O
//
4 n6 A+ M5 y) K0 H2 |/ u // 入口函数返回0,错误
1 E% t: h& A5 d C //1 E* Q, _& C' Z6 `: {: z3 e# g x
if ( 0 == initRetValue )
9 i8 B2 R f5 n9 p* @( | {1 m; h4 q0 B, d5 { v! v
DWORD hardErrorParam2; K/ N! M; U( Y9 C
DWORD hardErrorResponse2;
. D) ?. \& C1 ~. K2 V. ~$ g' W
1 W& l5 W2 V' ?% Z hardErrorParam2 = pModuleLoaderInfo->FullDllPath;
; r0 V3 U: p/ v0 i* h0 F ! i; f6 X' O! f; {: M* L9 e
_NtRaiseHardError( STATUS_DLL_INIT_FAILED,
+ X' X+ d" B! Q- I/ U1 {4 b 1, // Number of parameters
9 r e$ n3 @/ X& ?! } 1, // UnicodeStringParametersMask: v; W, H; ]5 o8 `5 x. u$ a9 p
&hardErrorParam2,# h( u5 |; x, L
OptionOk, // OK is only response2 n4 w( I/ W) s: H$ H" ~
&hardErrorResponse2 );
i* t6 x0 C! g5 k5 W& N 4 l2 @/ m. y# O- r
if ( _LdrpInLdrInit )% v7 N3 F4 t8 [4 d$ Q6 y' i
_LdrpFatalHardErrorCount++;
( t1 P& k: Y9 x7 k1 s! A. y9 ], v% P* l- p8 y J& l# i
return STATUS_DLL_INIT_FAILED;
+ s+ H8 \8 T; h9 X& b3 C B }
4 ?4 \* w4 @% t. V0 X }
, g" t4 u! Q/ G8 K" F }% K0 q) _8 B' M
3 t8 a I! M$ C
//
i' }( ]) z) K2 V // 如果EXE已经拥有了TLS,那么调用TLS初始化函数,也是在进程第一次初始化dll时) z, {. ^9 m+ t. m0 T
// 7 P I$ J% @4 K3 w5 F5 U# A1 J) C
if ( _LdrpImageHasTls && bImplicitLoad )
( F, B. P+ l, W1 S4 _9 v {
T& e0 e9 [! u* \+ l0 A _LdrpCallTlsInitializers( pCurrentPeb->ProcessImageBase, H+ ^1 |; J/ X& B
DLL_PROCESS_ATTACH );
* L( Y& @( `# E1 a& ]. @9 d6 b+ } }
+ K5 p! m3 ~- `4 \ }) ~3 O2 |6 C |$ i; t$ M3 Q
__finally/ ~, D6 D2 ]8 i1 h( D7 e6 N
{) S2 g" u$ E. Y/ S
//
/ q: K+ L4 V4 [1 [& ~" n& j0 H // 第四部分;6 P" u+ _$ f# c s# X
// 清除分配的内存
% i6 v$ w2 P0 I' Y _RtlFreeHeap( GetProcessHeap(), 0, pInitNodeArray );
$ u5 P; F6 O1 A7 j% Y }& ?9 _! r$ g# L, j# c" k" N% P) y
" B8 F, x5 B8 f v) r% L+ v return STATUS_SUCCESS;3 o& x# F; @! C$ _8 l
}
1 s1 v" }4 u) w, P; B3 ]- _4 h2 Y9 Z3 W
这个函数分为四个主要部分:
+ e& w* N, d X3 N一:第一部分调用_LdrpClearLoadInProgress函数,这个NTDLL函数返回已经被映象到内存的dll的个数。例如,你的进程调用exm.dll,而exm.dll又调用exm1.dll和exm2.dll,那么_LdrpClearLoadInProgress会返回3。得到dll个数后,调用_RtlAllocateHeap,它会返回一个内存的队列指针。伪码中的队列指针为pInitNodeArray。队列中的每个节点指针都指向一个新加载的dll的结构信息。' e a X0 E7 n% P( R9 P# B0 z' G
二:第二部分的代码通过进程内部的数据结构获得一个新加载dll的链接列表。并且检查dll是否有入口指针,如果有,就把模块信息指针加入pInitNodeArray中。伪码中的模块信息指针为pModuleLoaderInfo。但是有的dll是资源文件,并不具有入口函数。所以pInitNodeArray中节点比_LdrpClearLoadInProgress返回的数目要少。
8 u0 W* u6 q- Y三:第三部分的代码枚举了pInitNodeArray中的对象,并且调用了入口函数。因为这部分的初始化代码有可能出现错误,所以使用了_try异常扑获功能。这就是为什么在DllMain中出现错误后不会使整个进程终止。
5 p! ~7 v7 a |4 b另外,在调用入口函数时还会对TLS进行初始化,当用 __declspec来声明TLS变量时,链接器包含的数据可以进行触发。在调用dll的入口函数时,LdrpRunInitializeRoutines函数会检查是否需要初始化一个TLS,如果需要,就调用_LdrpCallTlsInitializers。5 X2 f: S4 b) P0 S
在最后的伪代码部分使用汇编语言来进行dll的入口函数调用。主要的命令时CALL EDI;EDI中就是入口函数的指针。当此命令返回后,dll的初始化工作就完成了。对于C++写的dll,DllMain已经执行完成了它的DLL_PROCESS_ATTACH代码。注意一下入口函数的第三个参数pvReserved,当exe或dll隐式调用dll时这个参数是非零,当使用LoadLibrary调用时是零。在入口函数调用以后,加载器会检查调用入口函数前和后的ESP的值,如果不同,dll的初始化函数就会报错。检查完ESP后,还会检查入口函数的返回值,如果是零,说明初始化的时候出现了什么问题。并且系统会报错并停止调用dll。在第三部分的最后,在初始化完成后,如果exe进程已经拥有了TLS,并且隐式调用的dll已经被初始化,那么会调用_LdrpCallTlsInitializers。
; {. O$ f/ F* A6 @& _; z( W四:第四部分代码是清理代码,象_RtlAllocateHeap 分配的pInitNodeArray的内存需要被释放。释放代码出现在_finally块中,调用了_RtlFreeHeap 。 |
|