找回密码
 加入计匠网
搜索
热搜: BIOS ACPI CPU Windows
查看: 14627|回复: 0

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

[复制链接]
发表于 2007-11-16 12:16:34 | 显示全部楼层 |阅读模式
来自:[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 。
您需要登录后才可以回帖 登录 | 加入计匠网

本版积分规则

Archiver|手机版|小黑屋|计匠网

GMT+8, 2026-11-22 05:07 , Processed in 0.067167 second(s), 17 queries .

Powered by Discuz! X3.5

© 2001-2025 Discuz! Team.

快速回复 返回顶部 返回列表