Android 的加载/链接器linker 主要用于实现共享库的加载与链接。它支持应用程序对库函数的隐式和显式调用。对于隐式调用，应用程序的编译与静态库大致相同，只是在静态链接的时候通过--dynamic-linker /system/bin/linker 指定动态链接器，（该信息将被存放在ELF文件的.interp节中，内核执行目标映像文件前将通过该信息加载并运行相应的解释器程序linker.）并链接相应的共享库。与ld.so不同的是，Linker目前没有提供Lazy Binding机制，所有外部过程引用都在映像执行之前解析。对于显式调用，可以同过linker中提供的接口dlopen，dlsym,dlerror和dlclose来动态加载和链接共享库。
Android中的共享库和可执行映像都默认采用ELF格式的文件，其基本格式如下：
每个ELF文件的开始部分都包含一个ELF头，其中包含了整个文件的基本信息，包括目标代码的格式，体系结构，各程序头或节头的偏移和大小，组织结构和访问权限等信息。
程序头表包含了加载到内存中的各种段的索引及属性信息，它将告诉加载器如何加载映像。每个段中有包含了一个或几个节区，每个节区应是唯一的。无论是可执行程序还是共享库都包含以下几个的节区： 1. GOT表和PLT表： 不同映像间的函数和数据引用都是通过它们实现的。GOT（全局偏移表）给出了映像中所有被引用符号（函数或变量）的值。每个普通PLT表项相当于一个函数的桩函数（stub），支持懒绑定的情况下，当发生对外部函数的调用时，程序会通过PLT表将控制交给动态连接器，后者解析出函数的绝对地址，修改GOT中相应的值，之后的调用将不再需要连接器的绑定。由于linker是不支持懒绑定的，所以在进程初始化时，动态链接器首先解析出外部过程引用的绝对地址，一次性的修改所有相应的GOT表项。对共享对象来说，由于GOT，PLT节以及代码段和数据段之间的相对位置是固定的，所有引用都是基于一个固定地址（GOT）的偏移量，所以实现了PIC代码，重定位时只需要修改可写段中的GOT表。而可执行程序在连接过程中则可能发生对不可写段的修改。如果只读段和可写段不是以固定的相对位置加载的，那么在重定位是还需要修改所有指向GOT的指针。 2. dynamic节： 与重定位有关的基本目录结构，例如： [Asm] 纯文本查看 复制代码 Dynamic section at offset 0x61014 contains 20 entries:
Tag Type Name/Value
0x00000001 (NEEDED) Shared library: [libc.so.6]
0x0000000c (INIT) 0xb8a8
0x0000000d (FINI) 0x555c4
0x00000004 (HASH) 0x8128
0x00000005 (STRTAB) 0xa004
0x00000006 (SYMTAB) 0x8aa4
0x0000000a (STRSZ) 2902 (bytes)
0x0000000b (SYMENT) 16 (bytes)
0x00000015 (DEBUG) 0x0
0x00000003 (PLTGOT) 0x710dc
0x00000002 (PLTRELSZ) 2464 (bytes)
0x00000014 (PLTREL) REL
0x00000017 (JMPREL) 0xaf08
0x00000011 (REL) 0xae98
0x00000012 (RELSZ) 112 (bytes)
0x00000013 (RELENT) 8 (bytes) 3. dynsym和dynstr节： 与重定位有关的符号表和字符串表： [Asm] 纯文本查看 复制代码 Symbol table '.dynsym' contains 69 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 00000000 0 NOTYPE LOCAL DEFAULT UND
……
6: 00002568 28 FUNC GLOBAL DEFAULT 7 __ashldi3
7: 00000001 58 FUNC GLOBAL DEFAULT UND _ZNK7android7RefBase9decS
8: 00000001 32 FUNC GLOBAL DEFAULT UND ioctl
9: 00000001 18 FUNC GLOBAL DEFAULT UND _ZN7android7String8D1Ev
10: 00000001 16 FUNC GLOBAL DEFAULT UND _ZNK7android8EventHub16ge
11: 00000001 32 FUNC GLOBAL DEFAULT UND strerror
12: 00003024 0 NOTYPE GLOBAL DEFAULT ABS __exidx_end4. .rel.dyn和.rel.plt节： .rel.dyn节的表项对应了出外部过程调用的符号以外的所有重定位对象，.rel.plt则对应所有外部过程调用的重定位信息。每个重定位项记录了符号的符号表索引，重定位的操作地址，重定位类型的信息（见3.3节）。重定位所在的节区往往与重定位类型有关，例如： [Asm] 纯文本查看 复制代码 Relocation section '.rel.plt' at offset 0x2f08 contains 308 entries:
Offset Info Type Sym.Value Sym. Name
000710e8 00000116 R_ARM_JUMP_SLOT 0000b8d0 fileno
000710ec 00000216 R_ARM_JUMP_SLOT 0000b8dc getpagesize
000710f0 00000316 R_ARM_JUMP_SLOT 0000b8e8 fputs
000710f4 00000416 R_ARM_JUMP_SLOT 0000b8f4 abort
000710f8 00000516 R_ARM_JUMP_SLOT 0000b900 __errno_location
Relocation section'.rel.dyn' at offset 0x2e98 contains 14 entries:
Offset Info Type Sym.Value Sym. Name
000715b8 00001e15 R_ARM_GLOB_DAT 00071000 __fini_array_end
000715bc 00002f15 R_ARM_GLOB_DAT 00000000 __gmon_start__
000715c8 0000f515 R_ARM_GLOB_DAT 00071000 __fini_array_start
000715cc 00010015 R_ARM_GLOB_DAT 00071000 __init_array_end
000715d0 00012e15 R_ARM_GLOB_DAT 00071000 __init_array_start
00072a00 00002714 R_ARM_COPY 00072a00 __timezone
00072a04 00005514 R_ARM_COPY 00072a04 __daylight R_ARM_JUMP_SLOT和R_ARM_GLOB_DAT属性的重定位地址一般位于GOT表，R_ARM_COPY和R_ARM_ABS32属性的重定位一般位于.data节或.text节中。 Linker的加载与启动
Linker是共享库的加载/链接器，也可以称为解释器(interpreter)。共享库以ELF文件的形式保存在文件系统中，核心的load_elf_binary会首先将其映像文件映射到内存，然后映射并执行其解释器也就是linker的代码。linker的代码段是进程间共享的，但数据段为各进程私有。 linker执行完后会自动跳转到目标映像的入口地址。 [C] 纯文本查看 复制代码 /*in sys_execve->do_execve->search_binary_handler->load_elf_binary*/[/align] elf_entry = load_elf_interp(&loc->interp_elf_ex,interpreter,&interp_map_addr, load_bias);
………..
start_thread(regs, elf_entry, bprm->p); //start to execute linker 在android中,linker代码的运行域由地址0xb0000100开始(see /bionic/linker/Android.mk)，直接从_start开始执行。do_execve会预先将应用程序参数(argc,argv[],envc和envp[]还有一些"辅助向量(Auxiliary Vector)"等（see load_elf_binary>create_elf_tables）)存放在分配好的用户空间堆栈中，通过堆栈将这些参数和指针(位于linux_binprm结构体bprm中)传递给用户空间的目标进程。 Linker会提取出它所需要的信息，例如目标映像中程序头表在用户空间的地址以及应用程序入口等。
[C] 纯文本查看 复制代码 /*in __linker_init()*/
/* extract information passed from the kernel */
while(vecs[0] != 0){
switch(vecs[0]){
case AT_PHDR:
si->phdr = (Elf32_Phdr*) vecs[1];
break;
case AT_PHNUM:
si->phnum = (int) vecs[1];
break;
case AT_ENTRY:
si->entry = vecs[1]; /*entry of the executable image.*/
break;
}
vecs += 2;
} [C] 纯文本查看 复制代码 si = alloc_info(argv[0]); /*name of exe */
if(si == 0) {
exit(-1);
}
………
si->flags |= FLAG_EXE; /*exe not share library*/ [C] 纯文本查看 复制代码 for(d = si->dynamic; *d; d += 2) {[/align] f(d[0] == DT_NEEDED){ //it ‘s a needed share library.
soinfo *lsi = find_library(si->strtab + d[1]); //get soinfo by name
if(lsi == 0) {
goto fail;
}
lsi->refcount++; // Increment it’s referenced count
}
}3. 根据已获得的起始地址和总空间大小，调用alloc_mem_region预先为共享库分配一段内存空间。这段空间是通过系统调用mmap实现的，其访问属性是PROT_READ | PROT_EXEC和 MAP_PRIVATE | MAP_ANONYMOUS,文件描述符为-1，匿名私有的内存映射意味着，内核将为该库分配虚拟线性区，保留给后边进行内存映射文件的操作。 [C] 纯文本查看 复制代码 while(libbase < LIBLAST) { //LIBLAST=0x90000000
base = mmap((void*) libbase, sz, PROT_READ | PROT_EXEC,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if(((unsigned)base) == libbase) {
return base;
}
if(base != MAP_FAILED)
munmap(base, sz);
libbase += LIBINC; // LIBINC = 0x00100000，再进行一次映射。
}[C] 纯文本查看 复制代码 pbase = mmap(tmp, len, PFLAGS_TO_PROT(phdr->p_flags),MAP_PRIVATE | MAP_FIXED, fd,phdr->p_offset & (~PAGE_MASK)); [C] 纯文本查看 复制代码 if (si->flags & FLAG_EXE) {
……
if (!(phdr->p_flags & PF_W)) {
if ((unsigned)pbase < si->wrprotect_start)
si->wrprotect_start = (unsigned)pbase;
if (((unsigned)pbase + len) > si->wrprotect_end)
si->wrprotect_end = (unsigned)pbase + len;
mprotect(pbase, len,PFLAGS_TO_PROT(phdr->p_flags) | PROT_WRITE);
}
……
} 如果bss段的区间中包含页边界，则对超出的部分作另外的匿名映射， private anonymous mappings意味着当这些内存映射被取消映射时，内存会真的 将其释放给系统。 [C] 纯文本查看 复制代码 if (tmp < (base + phdr->p_vaddr + phdr->p_memsz)) {[/align] extra_base = mmap((void *)tmp, extra_len，PFLAGS_TO_PROT(phdr->p_flags), MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0);[C] 纯文本查看 复制代码 typedef struct elf32_rel {
Elf32_Addr r_offset; //重定位偏移量，以目标文件加载地址为基准
Elf32_Word r_info; //包含了重定位类型和在符号表中的索引
} Elf32_Rel;[Asm] 纯文本查看 复制代码 /*in myandroid/build/core/armelf.xsc*/
.rel.dyn :
{
*(.rel.init)
*(.rel.text .rel.text.* .rel.gnu.linkonce.t.*)
*(.rel.fini)
*(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*)
*(.rel.data.rel.ro* .rel.gnu.linkonce.d.rel.ro.*)
*(.rel.data .rel.data.* .rel.gnu.linkonce.d.*)
*(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*)
*(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*)
*(.rel.ctors)
*(.rel.dtors)
*(.rel.got)
*(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*)
}
.rel.plt : { *(.rel.plt) }[Asm] 纯文本查看 复制代码 /*in link_image()*/
if(si->plt_rel) { /*it ‘s a .rel.plt (DT_JMPREL) section*/
if(reloc_library(si, si->plt_rel, si->plt_rel_count))//binding all the external func
goto fail;
}
if(si->rel) { /*it ‘s a .rel.dyn (DT_REL)section*/
if(reloc_library(si, si->rel, si->rel_count))
goto fail;
} Linker中符号的绑定过程大致如下： 首先在reloc_library中队重定位节的每个Rel表项的rel->r_info成员依次进行解析，得到该重定位符号在本地符号表中的索引，该符号的重定位类型以及应进行修改的位置。根据符号索引在字符串表中找到相应的符号字符串，调用_do_lookup函数在soinfo链表对应的共享库中查找该符号。
[C] 纯文本查看 复制代码 /*in reloc_library ()*/
for (idx = 0; idx < count; ++idx) { //count = si->plt_rel_count.
unsigned type = ELF32_R_TYPE(rel->r_info);
unsigned sym = ELF32_R_SYM(rel->r_info);
unsigned reloc = (unsigned)(rel->r_offset + si->base);
if(sym != 0) {
/*search symbol within solist*/
s = _do_lookup(si, strtab + symtab[sym].st_name, &base);
if ((s->st_shndx == SHN_UNDEF) && (s->st_value != 0)) {return -1;}
}[C] 纯文本查看 复制代码 /* in _do_lookup（）*/
for(si = solist; (s == NULL) && (si != NULL); si = si->next)
{
if((si->flags & FLAG_ERROR) || (si == user_si))
continue;
s = _do_lookup_in_so(si, name, &elf_hash);
if (s != NULL) {
*base = si->base;
break;
}
}[C++] 纯文本查看 复制代码 static Elf32_Sym *_elf_lookup(soinfo *si, unsigned hash, const char *name)
{
Elf32_Sym *s;
Elf32_Sym *symtab = si->symtab;
const char *strtab = si->strtab;
unsigned n;
n = hash % si->nbucket;
for(n = si->bucket[hash % si->nbucket]; n != 0; n = si->chain[n]){
s = symtab + n;
if(strcmp(strtab + s->st_name, name)) continue; /* only concern ourselves with global symbols */
switch(ELF32_ST_BIND(s->st_info)){
case STB_GLOBAL:
if(s->st_shndx == 0) continue; /* no section == undefined */
case STB_WEAK:
return s;
}
}
return 0;
}[C++] 纯文本查看 复制代码 /*in reloc_library*/
……..
sym_addr = (unsigned)(s->st_value + base); /*get the actual address.*/
sym_name = (char *)(strtab + symtab[sym].st_name);
}
switch(type){
case R_ARM_JUMP_SLOT:
case R_ARM_GLOB_DAT:
case R_ARM_ABS32:
*((unsigned*)reloc) = sym_addr;
break;
case R_ARM_RELATIVE:
if(sym){return -1; }
*((unsigned*)reloc) += si->base;
break;
case R_ARM_COPY:
memcpy((void*)reloc, (void*)sym_addr, s->st_size); /*object in RW seg*/
break;
default: return -1;
}
rel++;
}
return 0;
}[C++] 纯文本查看 复制代码 if (si->wrprotect_start != 0xffffffff && si->wrprotect_end != 0) {
mprotect((void *)si->wrprotect_start, si->wrprotect_end - si->wrprotect_start, PROT_READ | PROT_EXEC);
}[Asm] 纯文本查看 复制代码 /* begin.S */
_start:
……….
bl __linker_init /* linker init returns the _entry address in the main image */
mov pc, r0linker中定义了dl_unwind_find_exidx函数，该函数将通过dl.so导出给libc.so的__gnu_Unwind_Find_exidx函数，该函数可以根据PC计数器的值返回相应共享库中指向ARM_EXIDX段的指针（位于soinfo结构中），该段用于栈退回(stack unwinding)机制，确保C++在异常被抛出、捕获并处理后，所有生命期已结束的对象都会被正确地析构，它们所占用的空间会被正确地回收。可执行映像及共享库的soinfo结构用于栈退回的数据结构分别在link_image和load_library中被赋值。 Unload_library用于卸载指定的共享库并卸载其依赖库中可以被卸载的库。 如果采用显式调用的方法动态链接使用共享库的例程，应用程序需要使用linker提供的外部接口，libdl.so中包含了所有这些接口，链接时在命令行加入-ldl，这样可执行映像的依赖库中将只包含libdl.so。dlopen是加载共享库的接口，它会调用find_library找到并加载共享库。dlsym会调用_do_lookup返回符号地址,dlerror用于错误检查,dlclose调用unload_library动态卸载共享库(进程退出时不会自动卸载不用的共享库)。用户也可以通过系统调用sys_uselib在核心态加载共享库，但该函数只支持固定地址加载。
生成共享库的基本方法与linux相同。在编译链接时在命令行加入 -shared 和 –fPIC，android共享库链接脚本为armelf.xcs。例如： $ arm-none-linux-gnueabi-gcc -fpic -nostdlib -Wl,-T,armelf.xsc, -shared, -Bsymbolic -o libhello.so hello.c /*create shared object*/ 在编译动态链接的可执行文件时使用--dynamic-linker ,-nostdlib, -rpath ,–L….指定解释器，共享库及搜索路径。例如：
$ arm-none-linux-gnueabi-gcc -c start.c
$ arm-none-linux-gnueabi-gcc -c main.c
$ arm-none-linux-gnueabi-ld --dynamic-linker /system/bin/linker -nostdlib /
-rpath /system/lib -rpath ~/tmp/android/system/lib -L . /
-L ~/tmp/android/system/lib -lc -lhello -o hello2 start.o main.o
另外有两个特别的工具mklibs和apriori。mklib可用于查找并复制程序用到的最小的共享库集，apriori可以预先为若干共享库确定加载地址，并为有依赖关系的共享库做静态重定位和连接,解释器会在共享库加载时(see load_library)调用is_prelinked查看该库是否时prelink的并在alloc_mem_region中检查目的地址是否被占用。
Reference
[1] 漫谈兼容内核之八: ELF映像的装入毛德操
[2] Linkers and loaders.
[3] How to write shared libraries.
[4] C++异常机制的实现方式和开销分析
文章转载自：
http://blog.csdn.net/dinuliang/article/details/5509009
|
