ELF在Linux下的加载过程

原创 2012年06月24日 09:07:21

主要函数调用:

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;

              }
ELF可行档的载入:


内核中实际执行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;     }
找到一个PT_LOAD片以后,先要确定其装入地址。正如代码前面的注释所述,这里先假定装入地址是固定的,然后再根据映像是否允许浮动而作出调整。具体片头数据结构中的p_vaddr提供了映像在连接时确定的装入地址vaddr。如果映像的类型为ET_EXEC,(或者load_addr_set已经被设置成1,见下)那么装入地址就是固定的。而若类型为ET_DYN、即共享库,那么即使装入地址固定也要加上一个偏移量,代码中给出了计算方法,其中ELF_ET_DYN_BASE对于x86定义为(TASK_SIZE / 3 * 2),所以这是2GB边界,而ELF_PAGESTART表示按页面边界对齐。
确定了装入地址以后,就通过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指向解释器的入口)



相关文章推荐

ELF文件的加载过程(load_elf_binary函数详解)--Linux进程的管理与调度(十三)

日期 内核版本 架构 作者 GitHub CSDN 2016-06-04 Linux-4.6 X86 & arm gatieme LinuxDeviceDrive...
  • gatieme
  • gatieme
  • 2016年06月10日 19:00
  • 6725

ELF文件加载过程代码分析

fs/binfmt_elf.c代码如下: static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs) {...
  • bdc995
  • bdc995
  • 2011年10月13日 17:32
  • 1606

load_elf_binary中使用的内存映射机制

load binary 中使用到的内存映射机制   研究了半天的exec函数后发现,所谓的load binary不是load(read 函数)而是重新安排的过程,在这个过程中涉及了很多的vm操作,...

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

linux中ELF加载过程分析

运行环境:* Ubuntu 14.04 LTS x64gcc 4.9.2gdb 7.8vim 7.4 with vundle 过程分析 分析说明 在进行详细的分析之前,首先...

linux中ELF加载过程分析

sys_execve   | - do_execve|| - search_binary_handler                     |- linux_binfmt= elf_format...
  • ruixj
  • ruixj
  • 2009年11月07日 21:28
  • 3590

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

linux中ELF加载过程分析

sys_execve   | - do_execve|| - search_binary_handler                     |- linux_binfmt= elf_format...

ELF文件的加载和动态链接过程

本文的目的:大家对于Hello World程序应该非常熟悉,随便使用哪一种语言,即使还不熟悉的语言,写出一个Hello World程序应该毫不费力,但是如果让大家详细的说明这个程序加载和链接的过程,以...

开源项目之防火墙 tdifw

tdifw是windows防火墙软件(TDI层驱动过滤),负责监控网络监听与连接、以及过滤信息。 源码在src目录, 程序在Bin目录,执行根目录下的批处理文件也可以, 具体步骤如下:  1. ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:ELF在Linux下的加载过程
举报原因:
原因补充:

(最多只允许输入30个字)