主要函数调用：
sys_execve
| - do_execve
|
| - search_binary_handler
|- linux_binfmt= elf_format
|- elf_format-> load_elf_binary
| - elf_entry = load_elf_interp()
|-
| if (BAD_ADDR(elf_entry))
| force_sig(SIGSEGV, current);
| retval =-EINVAL;
binfmt_elf.c: line 1024
elf_entry = loc->elf_ex.e_entry;
if (BAD_ADDR(elf_entry)) {
force_sig(SIGSEGV, current);
retval = -EINVAL;
goto out_free_dentry;
}
内核中实际执行execv()或execve()系统调用的程序是do_execve()，这个函数先打开目标映像文件，并从目标文件的头部(从第一个字节开始)读入若干(128)字节，然后调用另一个函数search_binary_handler()，在那里面让各种可执行程序的处理程序前来认领和处理。内核所支持的每种可执行程序都有个struct linux_binfmt数据结构，通过向内核登记挂入一个队列。而search_binary_handler()，则扫描这个队列，让各个数据结构所提供的处理程序、即各种映像格式、逐一前来认领。如果某个格式的处理程序发现特征相符而，便执行该格式映像的装入和启动。
我们从ELF格式映像的linux_binfmt数据结构开始：
#define load_elf_binary load_elf32_binary
static struct linux_binfmt elf_format = {
.module = THIS_MODULE,
.load_binary = load_elf_binary,
.load_shlib = load_elf_library,
.core_dump = elf_core_dump,
.min_coredump = ELF_EXEC_PAGESIZE
};
ELF格式的二进制映像的认领、装入和启动是由load_elf_binary()完成的。而“共享库”、即动态连接库映像的装入则由load_elf_library()完成。实际上共享库的映像也是二进制的，但是一般说“二进制”映像是指带有main()函数的、可以独立运行并构成一个进程主体的可执行程序的二进制映像。
[sys_execve() > do_execve() > search_binary_handler() > load_elf_binary()]
//ELF文件头 from Linux2.6
typedef struct elf32_hdr{
unsigned char e_ident[EI_NIDENT]; //Magic: Class/Data/Version/Os_ABI/ABI Version
Elf32_Half e_type; //elf文件类型: 可重定位/可执行/共享目标/coredump
Elf32_Half e_machine; //elf的CPU平台属性
Elf32_Word e_version; //elf的版本号
Elf32_Addr e_entry; /* Entry point */ //入口地址
Elf32_Off e_phoff; //program header的起始位置
Elf32_Off e_shoff; //section header的起始位置
Elf32_Word e_flags; //标记位，标记平台相关属性
Elf32_Half e_ehsize; //elf文件头的大小
Elf32_Half e_phentsize; //program header的大小
Elf32_Half e_phnum; //program header的数目
Elf32_Half e_shentsize; //section header的大小
Elf32_Half e_shnum; //section header的数量
Elf32_Half e_shstrndx; //段表字符串表所在的段 在段表的 索引
} Elf32_Ehdr;整个ELF映像就是由文件头、区段头表、程序头表、一定数量的区段、以及一定数量的部构成，而ELF映像的装入/启动过程，则就是在各种头部信息的指引下将某些部或区段装入一个进程的用户空间，并为其运行做好准备(例如装入所需的共享库)，最后(在目标进程首次受调度运行时)让CPU进入其程序入口的过程。接着是对elf_bss 、elf_brk、start_code、end_code等等变量的初始化。这些变量分别纪录着当前(到此刻为止)目标映像的bss段、代码段、数据段、以及动态分配“堆” 在用户空间的位置。除start_code的初始值为0xffffffff外，其余均为0。随着映像内容的装入，这些变量也会逐步得到调整。
//ELF的 program header 结构体 from linux 2.6
typedef struct elf32_phdr{
Elf32_Word p_type; //类型， 可加载代码/动态链接
Elf32_Off p_offset; //本段在文件中的偏移量
Elf32_Addr p_vaddr; //映射段的虚拟地址
Elf32_Addr p_paddr; //物理地址，未使用
Elf32_Word p_filesz; //文件中的段大小
Elf32_Word p_memsz; //内存中的段大小
Elf32_Word p_flags; //读写标记位
Elf32_Word p_align; //对齐的要求
} Elf32_Phdr;
static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
{
....
unsigned long start_code, end_code, start_data, end_data;
unsigned long reloc_func_desc = 0;
int executable_stack = EXSTACK_DEFAULT;
unsigned long def_flags = 0;
struct {
struct elfhdr elf_ex;
struct elfhdr interp_elf_ex;
} *loc;
loc = kmalloc(sizeof(*loc), GFP_KERNEL);
if (!loc) {
retval = -ENOMEM;
goto out_ret;
}
/* Get the exec-header */
loc->elf_ex = *((struct elfhdr *)bprm->buf);
retval = -ENOEXEC;
/* First of all, some simple consistency checks */
if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
goto out;
//校验文件属性，是否可执行，是否是共享目标文件
if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
goto out;
if (!elf_check_arch(&loc->elf_ex))
goto out;
if (!bprm->file->f_op || !bprm->file->f_op->mmap)
goto out;
/* Now read in all of the header information */
if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))
goto out;
if (loc->elf_ex.e_phnum < 1 ||
loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
goto out;
size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);
retval = -ENOMEM;
elf_phdata = kmalloc(size, GFP_KERNEL);
if (!elf_phdata)
goto out;
retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,
(char *)elf_phdata, size);
if (retval != size) {
if (retval >= 0)
retval = -EIO;
goto out_free_ph;
}
elf_ppnt = elf_phdata;
elf_bss = 0;
elf_brk = 0;
start_code = ~0UL;
end_code = 0;
start_data = 0;
end_data = 0;
读入了程序头表，并对start_code等变量进行初始化以后，下面的第一步就是在程序头表中寻找“解释器”部、并加以处理的过程。
//读取可执行文件的解析器
for (i = 0; i < loc->elf_ex.e_phnum; i++) {
if (elf_ppnt->p_type == PT_INTERP) { //通过PT_INTERP标识来获取解析器信息所在的段
/* This is the program interpreter used for
* shared libraries - for now assume that this
* is an a.out format binary
*/
retval = -ENOEXEC;
if (elf_ppnt->p_filesz > PATH_MAX ||
elf_ppnt->p_filesz < 2)
goto out_free_ph;
retval = -ENOMEM;
elf_interpreter = kmalloc(elf_ppnt->p_filesz,
GFP_KERNEL);
if (!elf_interpreter)
goto out_free_ph;
//获取解析器的路径+名称
retval = kernel_read(bprm->file, elf_ppnt->p_offset,
elf_interpreter,
elf_ppnt->p_filesz);
if (retval != elf_ppnt->p_filesz) {
if (retval >= 0)
retval = -EIO;
goto out_free_interp;
}
/* make sure path is NULL terminated */
retval = -ENOEXEC;
if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
goto out_free_interp;
//打开解析器的句柄
interpreter = open_exec(elf_interpreter);
retval = PTR_ERR(interpreter);
if (IS_ERR(interpreter))
goto out_free_interp;
/*
* If the binary is not readable then enforce
* mm->dumpable = 0 regardless of the interpreter's
* permissions.
*/
if (file_permission(interpreter, MAY_READ) < 0)
bprm->interp_flags |= BINPRM_FLAGS_ENFORCE_NONDUMP;
//读取解析器头部，放到bprm->buf中
retval = kernel_read(interpreter, 0, bprm->buf,
BINPRM_BUF_SIZE);
if (retval != BINPRM_BUF_SIZE) {
if (retval >= 0)
retval = -EIO;
goto out_free_dentry;
}
/* Get the exec headers */
//最终获取解析器的头部，解析器的头部也是一个elf文件头
loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
break;
}
elf_ppnt++;
}
ELF格式的二进制映像在装入和启动的过程中需要得到一个工具软件的协助，其主要的目的在于为目标映像建立起跟共享库的动态连接。这个工具称为“解释器”。一个ELF映像在装入时需要用什么解释器是在编译/连接是就决定好了的，这信息就保存在映像的“解释器”部中。“解释器”部的类型为PT_INTERP，找到后就根据其位置p_offset和大小p_filesz把整个“解释器”部读入缓冲区。整个“解释器”部实际上只是一个字符串，即解释器的文件名，例如“/lib/ld-linux.so.2”。有了解释器的文件名以后，就通过open_exec()打开这个文件，再通过kernel_read()读入其开头128个字节，这就是映像的头部。早期的解释器映像是a.out格式的，现在已经都是ELF格式的了，/lib/ld-linux.so.2就是个ELF映像。 还是从目标映像的程序头表中搜索，这一次是寻找类型为PT_LOAD的段(Segment)。在二进制映像中，只有类型为PT_LOAD的部才是需要装入的。
/* Now we do a little grungy work by mmapping the ELF image into
the correct location in memory. */
for(i = 0, elf_ppnt = elf_phdata;
i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
int elf_prot = 0, elf_flags;
unsigned long k, vaddr;
//加载类型为PT_LOAD的段
if (elf_ppnt->p_type != PT_LOAD)
continue;
if (unlikely (elf_brk > elf_bss)) {
unsigned long nbyte;
/* There was a PT_LOAD segment with p_memsz > p_filesz
before this one. Map anonymous pages, if needed,
and clear the area. */
retval = set_brk(elf_bss + load_bias,
elf_brk + load_bias);
if (retval) {
send_sig(SIGKILL, current, 0);
goto out_free_dentry;
}
nbyte = ELF_PAGEOFFSET(elf_bss);
if (nbyte) {
nbyte = ELF_MIN_ALIGN - nbyte;
if (nbyte > elf_brk - elf_bss)
nbyte = elf_brk - elf_bss;
if (clear_user((void __user *)elf_bss +
load_bias, nbyte)) {
/*
* This bss-zeroing can fail if the ELF
* file specifies odd protections. So
* we don't check the return value
*/
}
}
}
if (elf_ppnt->p_flags & PF_R)
elf_prot |= PROT_READ;
if (elf_ppnt->p_flags & PF_W)
elf_prot |= PROT_WRITE;
if (elf_ppnt->p_flags & PF_X)
elf_prot |= PROT_EXEC;
elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
vaddr = elf_ppnt->p_vaddr;
if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
elf_flags |= MAP_FIXED;
} else if (loc->elf_ex.e_type == ET_DYN) {
/* Try and get dynamic programs out of the way of the
* default mmap base, as well as whatever program they
* might try to exec. This is because the brk will
* follow the loader, and is not movable. */
#if defined(CONFIG_X86) || defined(CONFIG_ARM)
load_bias = 0;
#else
load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
#endif
}
error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
elf_prot, elf_flags, 0);
if (BAD_ADDR(error)) {
send_sig(SIGKILL, current, 0);
retval = IS_ERR((void *)error) ?
PTR_ERR((void*)error) : -EINVAL;
goto out_free_dentry;
}
if (!load_addr_set) {
load_addr_set = 1;
load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
if (loc->elf_ex.e_type == ET_DYN) {
load_bias += error -
ELF_PAGESTART(load_bias + vaddr);
load_addr += load_bias;
reloc_func_desc = load_bias;
}
}
k = elf_ppnt->p_vaddr;
if (k < start_code)
start_code = k;
if (start_data < k)
start_data = k;
/*
* Check to see if the section's size will overflow the
* allowed task size. Note that p_filesz must always be
* <= p_memsz so it is only necessary to check p_memsz.
*/
if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
elf_ppnt->p_memsz > TASK_SIZE ||
TASK_SIZE - elf_ppnt->p_memsz < k) {
/* set_brk can never work. Avoid overflows. */
send_sig(SIGKILL, current, 0);
retval = -EINVAL;
goto out_free_dentry;
}
k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
if (k > elf_bss)
elf_bss = k;
if ((elf_ppnt->p_flags & PF_X) && end_code < k)
end_code = k;
if (end_data < k)
end_data = k;
k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
if (k > elf_brk)
elf_brk = k;
}
确定了装入地址以后，就通过elf_map()、实际上是elf32_map()、建立用户空间虚存区间与目标映像文件中某个连续区间之间的映射。这个函数基本上就是do_mmap()，其返回值就是实际映射的(起始)地址。对于类型为ET_EXEC的可执行程序映像而言，代码中的load_bias是0，所以装入的起点就是映像自己提供的地址vaddr。另一方面，对于ET_EXEC，由于参数中的elf_flags中的MAP_FIXED标志位为1，所以给定的映射地址是刚性的而不容许变通，如果与已经映射的区间有冲突就以失败告终。不过，目标映像的映射是从一片空白开始的，所以实际上不可能失败。顺便提一下，现在又多了一种ELF格式的目标映像，称为FDPIC，其装入地址就是可浮动的。即使总的装入地址是浮动的，一旦装入了第一个Segment以后，下一个Segment的装入地址就应该是固定的了，所以这里一方面把load_addr_set设置成1。
if (elf_interpreter) {
if (interpreter_type == INTERPRETER_AOUT)
elf_entry = load_aout_interp(&loc->interp_ex, interpreter);
else
elf_entry = load_elf_interp(&loc->interp_elf_ex, interpreter, &interp_load_addr);
. . . . . .
reloc_func_desc = interp_load_addr;
allow_write_access(interpreter);
fput(interpreter);
kfree(elf_interpreter);
} else {
elf_entry = loc->elf_ex.e_entry;
} 这段程序的逻辑很简单：如果需要装入解释器，并且解释器的映像是ELF格式的，就通过load_elf_interp()装入其映像，并把将来进入用户空间时的入口地址设置成load_elf_interp()的返回值，那显然是解释器的程序入口。而若不装入解释器，那么这个地址就是目标映像本身的程序入口。
显然，关键的操作是由load_elf_interp()完成的。
do_brk()从用户空间分配一段空间。这段代码总体上与前面映射目标映像的那一段相似。注意解释器映像的类型一般都是ET_DYN，所以load_addr可能不等于0。进程可使用exec系统调用执行新的命令。exec系统调用将一次性释放全部虚拟内存空间，之后生成新的空间并将新的命令影射入内。
do_execve（文件路径，参数。环境）
打开文件（open_namei函数）
计算exec后的UID/GID，读入文件头（prepare_binprm函数）
读入命令名，环境变量，起动参数（copy_strings函数）
呼叫各种不同二进制文件的操作函数（search_binary_handler函数）
ELF格式的话，经由search_binary_handler函数呼叫load_elf_binary函数。如果是动态联结，同时影射动态联结器（ld*.so）
load_elf_binary(linux_binprm* bprm,pt_regs* regs)
分析ELF文件头
读入程序的头部分（kernel_read函数）
if（存在解释器头部）{
读入解释器名（ld*.so）(kernel_read函数) |（zalem note：可用
打开解释器文件（open_exec函数） | objdump -s -j .interp xxx
读入解释器文件的头部（kernel_read函数） |命令查看，
） |linux下是/lib/ld-linux.so.x）
释放空间，清楚信号，关闭指定了close-on-exec标识的文件（flush_old_exec函数）
生成堆栈空间，塞入环境变量/参数部分（setup_arg_pages函数）
for（可引导的所有的程序头）{
将文件影射入内存空间（elf_map,do_mmap 函数）
}
if（为动态联结）{
影射动态联结器（load_elf_interp函数）
}
释放文件（sys_close函数）
确定执行中的UID，GID（compute_creds函数）
生成bss领域（set_brk函数）
bss领域清零（padzero函数）
设定从exec返回时的IP，SP（start_thread函数）（动态联结时的IP指向解释器的入口）
1658
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
