1. 动态链接的意义
2. 地址无关代码: PIC
3. 延迟版定(PLT Procedure Linkage Table)
4. 动态链接相关结构
5. 动态链接的步骤和实现
6. Linux动态链接器实现
7. 显式运行时链接
8. 共享库系统路径 && 默认加载顺序

1. 静态链接对内存和磁盘的浪费很严重，在静态链接中，C语言静态库是很典型的占用空间的例子
2. 静态链接对程序的更新、部署、发布会造成严重的麻烦

1. 多个进程使用到同一个动态链接库文件，只要在内存中映射一份ELF .SO文件即可，有效地减少了进程的内存消耗2. 减少物理页面的换入换出(减少page out、page in操作)3. 增加CPU缓存的命中率，因为不同进程间的数据和指令访问都集中在了同一个共享模块上4. 使程序的升级更加容易，在升级程序库或共享某个模块时，只要简单地将旧的目标文件覆盖掉，而无须将所有的程序再重新链接一遍。当程序下一次运行的时候，新版本的目标文件会被自动装载到内存并链接起来，程序就完成了升级的操作5. 程序可扩展性和兼容性
使用动态链接技术，程序在运行时可以动态地选择加载各种程序模块，即插件技术(Plug-in)1) 程序按照一定的规则制定好程序的接口，第三方开发者可以按照这种接口来编写符合要求的动态链接文件，该程序可以动态地载入各种由第三方开发的模块，在程序运行时动态地链接，实现程序功能的扩展。典型地如php的zend扩展、iis的filter/extension、apache的mod模块2) 动态链接还可以加强程序的兼容性。一个程序在不同的平台运行时可以动态地链接到由操作系统提供的动态链接库，这些动态链接库在程序和操作系统之间增加了一个中间层，从而消除了程序对不同平台之间依赖的差异性

1. Linux
在Linux系统中，ELF动态链接文件被称为动态共享对象(DSO Dynamic Shared Objects)，一般以".so"为扩展名
常用的C语言库的运行库glibc，它的动态链接形式的版本保存在"/lib/libc.so"、"/lib64/libc.so"。整个系统只保留一份C语言库的动态链接文件，而所有的由C语言编写的、动态链接的程序都可以在运行时使用它，当程序被装载时，系统的动态链接器会将程序所需的所有动态链接库(最基本的就是libc.so)装载到进程的地址空间，并且将程序中所有未决议的符号绑定到相应的动态链接库中，并进行重定位工作2. Windows
在Windows系统中，动态链接文件被称为动态链接库(Dynamic Linking Library)，一般以".dll"为扩展名

1. 可执行文件在编译时可以确定自己在进程虚拟地址空间中的位置，因为可执行文件往往都是第一个被加载的文件，它可以选择一个固定的位置1) Linux: 0x080400002) Windows: 0x00400002. 共享对象在编译时不能假设自己在进程虚拟地址空间中的位置

1. 链接时重定位(Link Time Relocation)
-shared -fPIC
在程序链接的时候就将代码中对绝对地址的引用重定位为实际的地址2. 装载时重定位(Load Time Relocation)
-shared
程序模块在编译时目标地址不确定而需要在装载时将模块重定位

/*
pic.c
*/
static int a;
extern int b;
extern void ext();void bar()
{//Type2: Inner-module data access(模块内数据访问)a = 1;//Tyep4: Inter-module data access(模块间数据访问)b = 2;
}void foo()
{//Type1: Inner-module call(模块内指令引用)
    bar();//Type3: Inter-module call()
    ext();
}

1. 模块内部1) 指令跳转、调用: 相对跳转和调用2) 数据访问: 相对地址访问
2. 模块外部1) 指令跳转、调用: 间接跳转和调用(GOT)2) 数据访问: 间接访问(GOT)

readelf -d hook.so | grep TEXTREL
/*
1. PIC
PIC的DSO是不会包含任何代码段重定位表的，TEXTREL表示代码段重定位表地址2. 非PIC
本条指令有任何输出，则hook.so就不是PIC
*/ 

1. 对于模块外部引用的全局变量和全局函数，用GOT表的表项内容作为地址来间接寻址
2. 对于本模块内的静态变量和静态函数，用GOT表的首地址作为一个基准，用相对于该基准的偏移量来引用，因为不论程序被加载到何种地址空间，模块内的静态变量和静态函数与GOT的距离是固定的，并且在链接阶段就可知晓其距离的大小

1. R_386_RELATIVE
2. R_386_GLOB_DAT
3. R_386_JMP_SLOT

1. GOT+4(即 GOT[1]): 设置动态库映射信息数据结构link_map地址
操作系统运行程序时，首先将解释器程序即动态链接器ld.so映射到一个合适的地址，然后启动 ld.so。ld.so 先完成自己的初始化工作，再从可执行文件的动态库依赖表中指定的路径名查找所需要的库，将其加载映射到内存。Linux用一个全局的库映射信息结构struct link_map链表来管理和控制所有动态库的加载，动态库的加载过程实际上是映射库文件到内存中，并填充库映射信息结构添加到链表中的过程。结构 struct link_map描述共享目标文件的加载映射信息，是动态链接器在运行时内部使用的一个结构，通过它保持对已装载的库和库中符号的跟踪
link_map使用双向链接中间件"l_next"和"l_prev"链接进程中所有加载的共享库。当动态链接器需要去查找符号的时候，可以向前或向后遍历这个链表，通过访问链表上的每一个库去搜索需要查找的符号
//Link_map链表的入口由每个可执行映像的全局偏移表的第2个入口(GOT[1])指向，查找符号时先从 GOT[1]读取 link_map 结点地址，然后沿着link-map 结点进行搜索 2. GOT+8(即 GOT[2]): 设置动态链接器符号解析函数的地址_dl_runtime_resolve
PLT的第1个入口PLT0是一段访问动态链接器的特殊代码。程序对PLT入口的第1次访问都转到了PLT0，最后跳入GOT[2]存储的地址执行符号解析函数。待完成符号解析后，将符号的实际地址存入相应的GOT项，这样以后调用函数时可直接跳到实际的函数地址，不必再执行符号解析函数

1. 动态链接器调用__mmap函数对动态库的所有PT_LOAD可加载段进行整体映射
/*
l_map_start=(ElfW(Addr))__mmap ((void *)0, maplength, prot, MAP_COPY | MAP_FILE, fd, mapoff);
*/
返回值 l_map_start 是实际映射的虚拟地址，和段结构成员，p_vaddr指定的虚拟地址不一定相同，这对于位置无关代码不会产生影响。但是对于数据段和link_map结构中其它相关的位置描述信息还要进行修正 2. 共享文件映射完毕，动态链接器处理共享库的PT_DYNAMIC动态段，将各项动态链接信息主要是哈希表、符号表、字符串表、重定位表、PLT 重定位项表等地址填写到link_map的l_info数组结构中。l_info是link_map最重要的字段之一，几乎所有与动态链接管理相关的内容都与l_info数组有关。动态链接器还要加载处理当前共享库的所有依赖库3. 由于实际的映射地址和指定的虚拟地址有可能不同，因此还要对动态库及其依赖库进行重定位。设置动态库的第1个和第2个GOT 表项
/*
Elf32_Addr *got = (Elf32_Addr *) lmap->l_info[DT_PLTGOT].d_un.d_ptr;
got[1]=lmap;
got[2]=&_dl_runtime_resolve;
*/
对动态库的所有重定位项进行重定位，在重定位项指定的偏移地址处加上修正值l_addr。动态项DT_REL给出了重定位表的地址，DT_RELSZ给出重定位表项的数目，映射完毕后，动态链接器调用共享库(包括所有相关的依赖库)自备的初始化函数进行初始化 

http://zhiwei.li/text/2009/04/elf%E7%9A%84got%E5%92%8Cplt%E4%BB%A5%E5%8F%8Apic/#comment-4235
http://www.programlife.net/linux-got-plt.html

1. 动态链接下对于全局和静态的数据访问都要进行复杂的的GOT定位，然后间接寻址，对于模块间的调用也要先定位GOT，然后再进行间接跳转
2. 动态链接的链接工作是在运行时完成的，动态链接器会寻找并装载所需要的共享对象，然后进行符号查找地址重定位工作等

不管是模块间的指令调用、还是跨模块的全局静态变量的引用，ELF使用了GOT间接跳转来实现，本质上是使用了"中间层技术"来屏蔽可能存在的外部模块引入的不确定性，中间层技术是实现兼容的一种很好的思考方式

1. 操作系统读取可执行文件的头部，检查文件的合法性
2. 从头部中的"Program Header"中读取每个"Segment"的虚拟地址、文件地址和属性，并将它们映射到进程虚拟空间的相对位置
3. 在静态链接情况下，这个时候操作系统就可以把控制权交给可执行文件的入口地址，然后程序开始执行

1. 操作系统同样通过映射的方式将它加载到进程的地址空间中
2. 操作系统在加载完动态链接器之后，就将控制权交给动态链接器的入口地址(与可执行文件一样，共享对象也有入口地址)
3. 当动态链接器得到控制权之后，它开始执行一系列自身的初始化操作，然后根据当前的环境参数，开始对可执行文件进行动态链接工作
4. 当所有动态链接工作完成之后，动态链接器会将控制权转交到可执行文件的入口地址，程序开始正式执行

objdump -s main

typedef struct dynamic
{Elf32_Sword d_tag;union{Elf32_Sword d_val;Elf32_Addr d_ptr;} d_un;
} Elf32_Dyn;typedef struct
{/* entry tag value : 类型值#define DT_NULL        0#define DT_NEEDED    1#define DT_PLTRELSZ    2#define DT_PLTGOT    3#define DT_HASH        4 : 动态链接哈希表地址，d_ptr表示".hash"的地址#define DT_STRTAB    5 : 动态链接字符串表的地址，d_ptr表示".dynstr"的地址#define DT_SYMTAB    6 : 动态链接符号表的地址，d_ptr表示".dynsym"的地址#define DT_RELA        7 : 动态链接重定位表地址#define DT_RELASZ    8#define DT_RELAENT    9#define DT_STRSZ    10 : 动态链接字符串表大小，d_val表示大小 #define DT_SYMENT    11#define DT_INIT        12 : 初始化代码地址#define DT_FINI        13 : 结束代码地址#define DT_SONAME    14 : 本共享对象的"SO-NAME"#define DT_RPATH     15 : 动态链接共享对象搜索路径#define DT_SYMBOLIC    16#define DT_REL            17#define DT_RELSZ    18#define DT_RELENT    19 : 动态重读位表入口数量#define DT_PLTREL    20#define DT_DEBUG    21#define DT_TEXTREL    22#define DT_JMPREL    23#define DT_ENCODING    32#define OLD_DT_LOOS    0x60000000#define DT_LOOS        0x6000000d#define DT_HIOS        0x6ffff000#define DT_VALRNGLO    0x6ffffd00#define DT_VALRNGHI    0x6ffffdff#define DT_ADDRRNGLO    0x6ffffe00#define DT_ADDRRNGHI    0x6ffffeff#define DT_VERSYM    0x6ffffff0#define DT_RELACOUNT    0x6ffffff9#define DT_RELCOUNT    0x6ffffffa#define DT_FLAGS_1    0x6ffffffb#define DT_VERDEF    0x6ffffffc#define    DT_VERDEFNUM    0x6ffffffd#define DT_VERNEED    0x6ffffffe#define    DT_VERNEEDNUM    0x6fffffff#define OLD_DT_HIOS     0x6fffffff#define DT_LOPROC    0x70000000#define DT_HIPROC    0x7fffffff*/Elf64_Sxword d_tag;        union {Elf64_Xword d_val;Elf64_Addr d_ptr;} d_un;
} Elf64_Dyn;

1. ".rel.dyn"
对数据引用的修正，它所修正的位置位于".got"以及数据段2. ".rel.plt"
对函数引用的修正，它所修正的位置位于".got.plt"

typedef struct
{/* Entry type #define AT_NULL 0 : 表示辅助信息数组结束#define AT_IGNORE 1 #define AT_EXECFD 2 : 表示可执行文件的文件句柄#define AT_PHDR 3 : 可执行文件中"程序头表(program header)"在进程中的地址#define AT_PHENT 4 : 可执行文件中程序头表每一个入口(entry)的大小#define AT_PHNUM 5 : 可执行文件头中程序头表中入口(entry)的数量#define AT_PAGESZ 6 #define AT_BASE 7 : 表示动态链接器本身的装载地址#define AT_FLAGS 8  #define AT_ENTRY 9 : 可执行文件入口地址，即启动地址#define AT_NOTELF 10 #define AT_UID 11   #define AT_EUID 12              #define AT_GID 13               #define AT_EGID 14              #define AT_CLKTCK 17              */u64 a_type;           union{u64 a_val;                /* Integer value */} a_un;
} Elf64_auxv_t;

#include <stdio.h>
#include <elf.h>int main(int argc, char* argv[])
{int* p = (int*)argv;int i;Elf32_auxv_t* aux;printf("Argument count: %d\n", *(p - 1));for(i = 0; i < *(p - 1); i++){printf("Argument %d: %s\n", i, *(p + 1));}p += i;p++;//skip 0
printf("Environment: \n");while(*p){printf("%s\n", *p);p++;}p++;//skip 0
printf("Auxiliary Vectors: \n");aux = (Elf32_auxv_t*)p;while(aux->a_type != AT_NULL){printf("Type: %02d Value: %x\n", aux->a_type, aux->a_un.a_val);aux++;}return 0;
}

1. 启动动态链接器本身(自举)
2. 装载所有需要的共享对象
3. 重定位、初始化

1. 普通DSO的重定位工作由动态链接器来完成
2. 普通DSO依赖的其他共享对象由动态链接器负责链接和装载

1. 动态链接器本身不可以依赖于其他任何共享对象
编写动态链接器时保证不使用任何系统库、运行库2. 动态链接器本身所需要的全局和静态变量的重定位工作由它本身完成

1. 动态链接器入口地址就是自举代码的入口，当操作系统将进程控制权交给动态链接器时，动态链接器的自举代码即开始执行
2. 自举代码会找到自己的GOT。而GOT的第一个入口保存的即是".dynamic"段的偏移地址，由此获得了动态链接器本身的".dynamic"段
3. 通过".dynamic"段中的信息，自举代码便可以获得动态链接器本身的重定位表和符号表等，从而得到动态链接器本身的重定位入口，先将它们全部重定位
4. 从这一步开始动态链接器代码中才可以开始使用自己的全局变量和静态变量

1. 链接器可以列出可执行文件所需要的所有共享对象，并将这些共享对象的名字放入到一个装载集合中
2. 然后链接器开始从集合里取一个所需要的共享对象的名字，找到相应的文件后打开该文件，读取相应的ELF文件头和".dynamic"段，然后将它相应的代码段和数据段映射到进程空间中
3. 如果这个ELF共享对象还依赖于其他共享对象，那么将所依赖的共享对象的名字放到装载集合中，如果循环知道所有依赖的共享对象都被装载进来为止
4. 链接器对共享对象的遍历过程本质上是一个图的遍历过程，链接器可能会使用深度优先、或者广度优先的顺序来进行
5. 当一个新的共享对象被装载进来的时候，它的符号表会被合并到全局符号表中，所以当所有的共享对象都被装载进来的时候，全局符号表里面将包含进程中所有动态链接锁需要的符号

1. 定义一个简单的输出demo函数(同名)
/*
a1.c
*/
#include <stdio.h>void a()
{printf("a1.c\n");
}/*
a2.c
*/
#include <stdio.h>void a()
{printf("a2.c\n");
}
可以看到，a1.c、a2.c中都定义了名为"a"的函数2. 显式指定依赖关系
/*
代码中调用a()
b1.c
*/
void a();void b1()
{a();
}/*
代码中调用a()
b2.c
*/
void a();void b2()
{a();
}3. 根据依赖关系进行编译
//b1.so依赖a1.so
gcc -fPIC -shared a1.c -o a1.so
gcc -fPIC -shared b1.c a1.so -o b1.so//b2.so依赖a2.so
gcc -fPIC -shared a2.c -o a2.so
gcc -fPIC -shared b2.c a2.so -o b2.so4. 同时引入b1.so、b2.so，模拟同名符号冲突的情况
/*
main.c
*/
#include <stdio.h>void b1();
void b2();int main()
{b1();b2();return 0;
}
gcc main.c b1.so b2.so -o main -Xlinker -rpath ./
./main

1. 当一个符号需要被加入到全局符号表时，如果相同的符号名已经存在，则后载入的符号被忽略
2. 按照广度优先的顺序进行加载
3. 如果优先引入的函数(符号)没有显式地进行调用链获取，并在完成自身逻辑后调用调用链上的下一个函数，则后引入的函数(符号)将被忽略
#define FN(ptr,type,name,args)  ptr = (type (*)args)dlsym (REAL_LIBC, name)

/lib64/ld-linux-x86-64.so.2

/* Initial entry point code for the dynamic linker.The C function `_dl_start' is the real entry point;its return value is the user program's entry point.  */#define RTLD_START asm ("\n\.text\n\.align 16\n\
0:    movl (%esp), %ebx\n\ret\n\.align 16\n\
.globl _start\n\
.globl _dl_start_user\n\
_start:\n\# Note that _dl_start gets the parameter in %eax.\n\movl %esp, %eax\n\call _dl_start\n\
_dl_start_user:\n\# Save the user entry point address in %edi.\n\movl %eax, %edi\n\# Point %ebx at the GOT.\n\call 0b\n\addl $_GLOBAL_OFFSET_TABLE_, %ebx\n\# See if we were run as a command with the executable file\n\# name as an extra leading argument.\n\movl _dl_skip_args@GOTOFF(%ebx), %eax\n\# Pop the original argument count.\n\popl %edx\n\# Adjust the stack pointer to skip _dl_skip_args words.\n\leal (%esp,%eax,4), %esp\n\# Subtract _dl_skip_args from argc.\n\subl %eax, %edx\n\# Push argc back on the stack.\n\push %edx\n\# The special initializer gets called with the stack just\n\# as the application's entry point will see it; it can\n\# switch stacks if it moves these contents over.\n\
" RTLD_START_SPECIAL_INIT "\n\# Load the parameters again.\n\# (eax, edx, ecx, *--esp) = (_dl_loaded, argc, argv, envp)\n\movl _rtld_local@GOTOFF(%ebx), %eax\n\leal 8(%esp,%edx,4), %esi\n\leal 4(%esp), %ecx\n\movl %esp, %ebp\n\# Make sure _dl_init is run with 16 byte aligned stack.\n\andl $-16, %esp\n\pushl %eax\n\pushl %eax\n\pushl %ebp\n\pushl %esi\n\# Clear %ebp, so that even constructors have terminated backchain.\n\xorl %ebp, %ebp\n\# Call the function to run the initializers.\n\call _dl_init_internal@PLT\n\# Pass our finalizer function to the user in %edx, as per ELF ABI.\n\leal _dl_fini@GOTOFF(%ebx), %edx\n\# Restore %esp _start expects.\n\movl (%esp), %esp\n\# Jump to the user's entry point.\n\jmp *%edi\n\.previous\n\
");

1. _start()调用_dl_start()函数
2. _dl_start()首先对ld-x.y.z.so进行重定位，因为ld-x.y.z.so自身是动态链接器，它必须自己完成重定位，即"自举"
3. 完成自举后就可以调用其他函数、并且访问全局变量了
4. 调用_dl_start_final()收集一些基本的运行数值，进入_dl_sysdep_start()
5. _dl_sysdep_start()进行了一些平台相关的处理之后就进入了_dl_main()，这是动态链接器的主函数

http://mirror.hust.edu.cn/gnu/glibc/

1. 共享对象是由动态链接器在程序启动之前负责装载和链接的，这一系列步骤都由动态链接器自动完成，对于程序本身是透明的2. 动态库的装载是通过一些列的动态链接器提供的API按成的
/*
#include <dlfcn.h>
/lib.lindl.so.2
*/

void * dlopen( const char * pathname, int mode);
1. pathname: 被加载动态库的路径
值得注意的是：
如果pathname传入是0，则dlopen返回的是全局符号表的句柄，也就是说我们可以在运行时找到全局符号表里面的任何一个符号，并且可以执行它们，这类似于高级语言中的反射(relection)特性
全局符号表包括了程序的可执行文件本身、被动态链接器加载到进程中的所有共享模块、运行时通过dlopen打开并且使用了RTLD_GLOBAL方式的模块中的符号2. mode:
mode是打开方式，其值有多个，不同操作系统上实现的功能有所不同，在linux下，按功能可分为三类：2.1 解析方式1) RTLD_LAZY: 在dlopen返回前，对于动态库中的未定义的符号不执行解析(只对函数引用有效，对于变量引用总是立即解析)2) RTLD_NOW: 需要在dlopen返回前，解析出所有未定义符号，如果解析不出来，在dlopen会返回NULL，错误为：: undefined symbol: xxxx.......2.2 作用范围: 可与解析方式通过"|"组合使用 1) RTLD_GLOBAL: 动态库中定义的符号可被其后打开的其它库解析 2) RTLD_LOCAL: 与RTLD_GLOBAL作用相反，动态库中定义的符号不能被其后打开的其它库重定位。如果没有指明是RTLD_GLOBAL还是RTLD_LOCAL，则缺省为RTLD_LOCAL 2.3 作用方式1) RTLD_NODELETE: 在dlclose()期间不卸载库，并且在以后使用dlopen()重新加载库时不初始化库中的静态变量。这个flag不是POSIX-2001标准 2) RTLD_NOLOAD: 不加载库。可用于测试库是否已加载(dlopen()返回NULL说明未加载，否则说明已加载），也可用于改变已加载库的flag，如：先前加载库的flag为RTLD_LOCAL，用dlopen(RTLD_NOLOAD|RTLD_GLOBAL)后flag将变成RTLD_GLOBAL。这个flag不是POSIX-2001标准 3) RTLD_DEEPBIND: 在搜索全局符号前先搜索库内的符号，避免同名符号的冲突。这个flag不是POSIX-2001标准

1. 查找环境变量LD_LIBRARY_PATH指定的一些列目录
2. 查找由/etc/ld.so.cache指定的共享库路径
3. /lib/、/usr/lib

#include <dlfcn.h>
void * dlsym(void *handle, constchar *symbol)

1. 全局符号的优先级
我们知道，在全局符号的引入中，不管是动态链接器在程序启动时引入依赖的动态共享库、LD_LIBRARY_PATH指定引入的动态共享库、还是程序在运行时中调用dlopen引入动态共享库。当发生多个同名符号冲突时，都遵循"先来后到"的原则，即先装入的符号优先，这种优先级方式称为"装载序列(Load Ordering)"2. dlsym()动态符号的优先级
dlsym()对符号的查找优先级分为两种1) 装载序列:在全局符号表中进行遵循装载序列的搜索: 在dlopen的时候pathname传入02) 依赖序列:从目标共享模块开始进行遵循依赖序列的搜索: 在dlopen的时候pathname传入目标模块路径，在dlsym的时候传入dlopen返回的句柄指针所谓依赖序列就是以被dlopen打开的那个共享对象为根节点，对它所有依赖的共享对象进行广度优先遍历，找到了就返回，如果没找到就继续找，直到找到符号为止

/*
hook.c
*/
#include <stdio.h>
#include <string.h>
#include <dlfcn.h> int strcmp(const char *s1, const char *s2)
{ //这个hook函数只是简单地打印一句话printf("oops!!! hack function invoked\n");
}
gcc -fPIC -shared -o hook.so hook.c -ldl
cp hook.so /lib64//*
main.c
*/
#include <stdio.h>
#include <dlfcn.h>int main(int argc, char **argv)
{void *handle1, *handle2;int (*cosine1)(const char *, const char *);int (*cosine2)(const char *, const char *);char *error;//返回hook.so的模块句柄handle1 = dlopen ("hook.so", RTLD_LAZY);//返回全局符号表handle2 = dlopen (0, RTLD_LAZY);if (!handle1 | !handle2) {fprintf (stderr, "%s\n", dlerror());return 0;}//从刚才打开的句柄中搜索符号cosine1 = dlsym(handle1, "strcmp");//从全局符号表中搜索符号cosine2 = dlsym(handle2, "strcmp");if ((error = dlerror()) != NULL)  {fprintf (stderr, "%s\n", error);return 0;}//采用依赖序列(dependency ordering)优先级进行符号搜索，优先执行动态引入的hook.so的函数printf ("%f\n", (*cosine1)("aaa", "bbb"));//采用装载序列(load ordering)优先级啊进行符号搜索，动态引入的hook.so被忽略printf ("%f\n", (*cosine2)("aaa", "bbb"));dlclose(handle1);dlclose(handle2);return 0;
}
gcc -rdynamic -o main main.c -ldl

1. dlopen
计数器加12. dlclose
计数器减1
只有当计数器减到0时，模块才被真正地卸载掉，卸载的过程正好相反，先执行".finit"段代码，然后将相应的符号从符号表中去除，取消进程空间跟模块的映射关系，然后关闭模块文件

1. / : 第一层次结构的根，整个文件系统层次结构的根目录
2. /bin/ : 需要在单用户模式可用的必要命令(可执行文件)，例如 1) cat2) ls3) cp
3. /boot/ : 引导程序文件，例如 1) kernel2) initrd
4. /dev/ : 必要设备，例如  1) /dev/null
5. /etc/ : 系统范围内的配置文件
6. /home/ : 用户的工作目录，包含保存的文件、个人设置等
7. /lib/ : /bin/、/sbin/中二进制文件必要的库文件
8. /media/ : 可移除媒体(如CD-ROM)的挂载点(在FHS-2.3中出现)
9. /mnt/ : 临时挂载的文件系统
10. /opt/ : 可选应用软件包
11. /proc/ : 虚拟文件系统，将内核与进程状态归档为文本文件，例如 1) uptime2) network
在Linux中，对应Procfs格式挂载
12. /root/ : 超级用户的工作目录
13. /sbin/ : 必要的系统二进制文件，例如1) init2) ip3) mount
14. /srv/ : 站点的具体数据，由系统提供
15. /tmp/ : 临时文件(参见 /var/tmp)，在系统重启时目录中文件不会被保留
16. /usr/ : 用于存储用户数据，包含绝大多数的(多)用户工具和应用程序
17. /var/

1. /lib: 存放系统最关键和基础的共享库，例如1) 动态链接器2) C语言运行库3) 数学库
这些库主要是那些/bin、/sbin下的程序以及系统启动时所要用到的库2. /usr/lib: 存放一些非系统运行时所需要的关键性的共享库，只要是一些开发时用到的共享库3. /usr/local/lib: 存放一些跟操作系统本身并不十分相关的库，主要是一些第三方的应用程序的库

1. 根据ELF文件中的配置信息
任何一个动态链接的模块所依赖的模块路径保存在".dynamic"段中，由DT_NEED类型的项表示，动态链接器会按照这个路径去查找DT_RPATH所指定的路径，编译目标代码时，可以对gcc加入链接参数"-Wl,-rpath"指定动态库搜索路径 2. DT_NEED段中保存的是绝对路径，则动态链接器直接按照这个路径进行直接加载3. 根据LD_PRELOAD中指定的路径加载共享库、目标文件/*
4. /etc/ld.so.cache
到了这一步，如果动态链接器(/lib/ld-linux.so.X)没有得到可以直接打开的绝对路径，则需要开始根据相对路径进行共享库的搜索
Linux为了加速这个搜索过程，在系统中建立了一个ldconfig程序，这个程序负责1) 将共享库下的各个共享库维护一个SO-NAME(一一对应的符号链接)，这样每个共享库的SO-NAME就能够指向正确的共享库文件2) 将全部SO-NAME收集起来，集中放到/etc/ld.so.cache文件里面，并建立一个SO-NAME的缓存
当动态链接器要查找共享库时，它可以直接从/etc/ld.so.cache里面查找所以，如果我们在系统指定的共享库目录下添加、删除或更新任何一个共享库，或者我们更改了/etc/ld.so.conf、/etc/ld.preload的配置，都应该运行一次ldconfig这个程序，以便更新SO-NAME和/etc/ld.so.cache
很多软件包的安装程序在结束共享库安装以后都会调用ldconfig
*/5. 根据/etc/ld.so.preload中的配置进行搜索
这个配置文件中保存了需要搜索的共享库路径，Linux动态共享库加载器根据顺序进行逐行广度搜索6. 根据环境变量LD_LIBRARY_PATH指定的动态库搜索路径 7. DT_NEED段中保存的是相对路径，动态链接器会在按照一个约定的顺序进行库文件查找1) /lib2) /usr/lib3) 由/etc/ld.so.conf中配置指定的搜索路径

1. LD_LIBRARY_PATH=/home/user/ /bin/ls
2. /lib64/ld-linux.so.2 -library-path /home/user /bin/ls

18745:    18745:    file=/usr/local/$LIB/aegis_monitor.so [0];  needed by ./killme [0]18745:    file=/usr/local/$LIB/aegis_monitor.so [0];  generating link map18745:      dynamic: 0x00007f981c8d9cd0  base: 0x00007f981c6d8000   size: 0x0000000000201f7818745:        entry: 0x00007f981c6d8be0  phdr: 0x00007f981c6d8040  phnum:                  518745:    18745:    18745:    file=libc.so.6 [0];  needed by ./killme [0]18745:    file=libc.so.6 [0];  generating link map18745:      dynamic: 0x00007f981c6c3b40  base: 0x00007f981c336000   size: 0x000000000039390818745:        entry: 0x00007f981c354e70  phdr: 0x00007f981c336040  phnum:                 1018745:    18745:    18745:    file=libdl.so.2 [0];  needed by /usr/local/lib64/aegis_monitor.so [0]18745:    file=libdl.so.2 [0];  generating link map18745:      dynamic: 0x00007f981c334da0  base: 0x00007f981c132000   size: 0x000000000020310018745:        entry: 0x00007f981c132de0  phdr: 0x00007f981c132040  phnum:                  918745:    18745:    18745:    calling init: /lib64/libc.so.618745:    18745:    18745:    calling init: /lib64/libdl.so.218745:    18745:    18745:    calling init: /usr/local/lib64/aegis_monitor.so18745:    18745:    18745:    initialize program: ./killme18745:    18745:    18745:    transferring control: ./killme18745:    18745:    18745:    calling fini: ./killme [0]18745:    18745:    18745:    calling fini: /usr/local/lib64/aegis_monitor.so [0]18745:    18745:    18745:    calling fini: /lib64/libdl.so.2 [0]18745:    18745:    18745:    calling fini: /lib64/libc.so.6 [0]18745:    

1. bindings: 显示动态链接的符号绑定过程
2. libs: 显示共享库的查找过程
3. versions: 显示符号的版本依赖关系
4. reloc: 显示重定位过程
5. symbols: 显示符号表查找过程
6. statistics: 显示动态链接过程中的各种统计信息
7. all: 显示以上所有信息
8. help: 显示上面的各种可选值的帮助信息

http://en.wikipedia.org/wiki/Filesystem_Hierarchy_Standard