qemu中ELF文件的加载-embeddedlwp-ChinaUnix博客

前段时间分析了qemu中ELF文件的加载过程，个人感觉通过这个分析不但可以加深对ELF文件格式的理解，而且能够从侧面了解操作系统加载器的工作过程。

一、ELF相关的背景知识
1. ELF格式文件相关概念
ELF格式文件主要包括以下三种类型的文件：

可重定位的目标文件(.o文件) --> 用于链接生成可执行文件或动态链接库文件(.so)

可执行文件 --> 进程映像文件

共享库(.so文件) --> 用于链接

    从链接和执行的角度来讲，ELF文件存在两种视图：链接视图和执行视图。为了区分两种视图，只需记住链接视图由多个section组成，而执行视图由多个segment组成即可。另外，section是程序员可见的，是给链接器使用的概念，汇编文件中通常会显示的定义.text，.data等section，相反，segment是程序员不可见的，是给加载器使用的概念。下图形象的描述了ELF文件两种不同的视图的结构以及二者之间的联系。

    二者之间的联系在于：一个segment包含一个或多个section。
    注意：Section Header Table和Program Header Table并不是一定要位于文件的开头和结尾,其位置由ELF Header指出,上图这么画只是为了清晰。-- ELF文件每个部分的详细介绍参见《ELF 文件格式分析》。

TN05.ELF.Format.Summary.pdf

2. ELF文件主要数据结构
上面讲了ELF的相关概念，但是要想用计算机语言（C语言）来实现，必须对应相应的数据结构。linux下通过三个数据结构描述了ELF文件的相关概念。
(1) ELF Header
ELF Header描述了体系结构和操作系统等基本信息,并指出Section Header Table和Program Header Table在文件中的什么位置，每个成员的解释参见注释及附件。

#define EI_NIDENT 16
typedef struct{
/*ELF的一些标识信息，固定值*/
unsigned char e_ident[EI_NIDENT];
/*目标文件类型：1-可重定位文件，2-可执行文件，3-共享目标文件等*/
Elf32_Half e_type;
/*文件的目标体系结构类型：3-intel 80386*/
Elf32_Half e_machine;
/*目标文件版本：1-当前版本*/
Elf32_Word e_version;
/*程序入口的虚拟地址，如果没有入口，可为0*/
Elf32_Addr e_entry;
/*程序头表(segment header table)的偏移量，如果没有，可为0*/
Elf32_Off e_phoff;
/*节区头表(section header table)的偏移量，没有可为0*/
Elf32_Off e_shoff;
/*与文件相关的，特定于处理器的标志*/
Elf32_Word e_flags;
/*ELF头部的大小，单位字节*/
Elf32_Half e_ehsize;
/*程序头表每个表项的大小，单位字节*/
Elf32_Half e_phentsize;
/*程序头表表项的个数*/
Elf32_Half e_phnum;
/*节区头表每个表项的大小，单位字节*/
Elf32_Half e_shentsize;
/*节区头表表项的数目*/
Elf32_Half e_shnum;
/**/
Elf32_Half e_shstrndx;
}Elf32_Ehdr;

下面通过一个具体实例来说明ELF header中每个数据成员对应的值，下面是hello world的ELF文件头，在linux下可以通过"readelf -h ELF文件名"来获得。

ELF Header用数据结构Elf32_Ehdr来表示，描述了操作系统是UNIX,体系结构是80386。Section Header Table中有30个Section Header,从文件地址4412开始,每个Section Header占40字节,Segment Header Table中有9个segment，每个segment header占32个字节，此ELF文件的类型是可执行文件(EXEC)，入口地址是0x8048320。

(2) Section Header Table Entry
从ELF Header中可知，每个ELF文件有个Section Header Table，其中每一个表项对应一个section，由数据结构Elf32_Shdr来描述，每个成员的含义参见注释及附件。在linux下可以通过"readelf -S ELF文件名"来查看。

typedef struct{
/*节区名称*/
Elf32_Word sh_name;
/*节区类型：PROGBITS-程序定义的信息，NOBITS-不占用文件空间(bss),REL-重定位表项*/
Elf32_Word sh_type;
/*每一bit位代表一种信息，表示节区内的内容是否可以修改，是否可执行等信息*/
Elf32_Word sh_flags;
/*如果节区将出现在进程的内存影响中，此成员给出节区的第一个字节应处的位置*/
Elf32_Addr sh_addr;
/*节区的第一个字节与文件头之间的偏移*/
Elf32_Off sh_offset;
/*节区的长度，单位字节，NOBITS虽然这个值非0但不占文件中的空间*/
Elf32_Word sh_size;
/*节区头部表索引链接*/
Elf32_Word sh_link;
/*节区附加信息*/
Elf32_Word sh_info;
/*节区带有地址对齐的约束*/
Elf32_Word sh_addralign;
/*某些节区中包含固定大小的项目，如符号表，那么这个成员给出其固定大小*/
Elf32_Word sh_entsize;
}Elf32_Shdr;

(3) Program Header Table Entry
从ELF Header中可知，每个ELF文件有个Program Header Table，其中每一个表项对应一个segment，由数据结构Elf32_phdr来描述，每个成员的含义参见注释及附件。在linux下可以通过"readelf -l ELF文件名"来查看。

typedef struct
{
/*segment的类型：PT_LOAD = 1 可加载的段*/
Elf32_Word p_type;
/*从文件头到该段第一个字节的偏移*/
Elf32_Off p_offset;
/*该段第一个字节被放到内存中的虚拟地址*/
Elf32_Addr p_vaddr;
/*在linux中这个成员没有任何意义，值与p_vaddr相同*/
Elf32_Addr p_paddr;
/*该段在文件映像中所占的字节数*/
Elf32_Word p_filesz;
/*该段在内存映像中占用的字节数*/
Elf32_Word p_memsz;
/*段标志*/
Elf32_Word p_flags;
/*p_vaddr是否对齐*/
Elf32_Word p_align;
} Elf32_phdr;

二、qemu中ELF文件的加载过程
    在了解了ELF文件的基本结构之后，大体可以想到ELF文件的加载过程就是一个查表的过程，即通过ELF Header得到ELF文件的基本信息-Section Header Table和program Header Table,然后再根据Section Header Table和program Header Table的信息加载ELF文件中的相应部分。上面也提到过，section是从链接器的角度来讲的概念，所以，ELF文件的加载过程中，只有segment是有效的，加载器根据program Header Table中的信息来负责ELF文件的加载。
    首先，从感性上认识一下segment，还是以上面的hello world为例，其对应的program header table如下。

    第一列type即每个segment的类型，每个类型的具体含义参见附件。通常我们之关心程序的代码段(.text section)和数据段(.date section)，这两个section组成LOAD类型的segment。
    Offset：当前segment加载到的地址的偏移
    VirAddr：当前segment加载到的虚拟地址
    PhysAddr：当前segment加载到的物理地址（x86平台上，此值没有意义，并不指物理地址）
    FileSiz：当前segment在ELF文件中的偏移
    MemSiz:当前segment在内存页中的偏移
    Flg：segment的权限，R-可读，W-可写， E-可执行
    Align：x86平台内存页面的大小

    在了解了segment的相关信息后，分析下qemu代码中ELF文件的加载过程，印证下上面提到的ELF文件的加载的思想。

ret = loader_exec(filename, target_argv, target_environ, regs,info, &bprm);

    filename：要加载的ELF文件的名称
    target_argv：qemu运行的参数，在这里即hello（hello是生成的可执行文件名， $qemu hello）
    target_environ：执行qemu的shell的环境变量
    regs,info,bprm是ELF文件加载过程中涉及的三个重要数据结构，下面会详细分析。

loader_exec函数的功能及含义参见代码注释。

int loader_exec(const char * filename, char ** argv, char ** envp,
struct target_pt_regs * regs, struct image_info *infop,
struct linux_binprm *bprm)
{
int retval;
int i;
bprm->p = TARGET_PAGE_SIZE*MAX_ARG_PAGES-sizeof(unsigned int); /*MAX_ARG_PAGES = 33*/
memset(bprm->page, 0, sizeof(bprm->page));
retval = open(filename, O_RDONLY); /*返回打开文件的fd*/
if (retval < 0)
return retval;
bprm->fd = retval;
bprm->filename = (char *)filename;
bprm->argc = count(argv);
bprm->argv = argv;
bprm->envc = count(envp);
bprm->envp = envp;
/*1. 要加载文件的属性判断：是否常规文件，是否可执行文件，是否ELF文件； 2. 读取ELF文件的前1024个字节*/
retval = prepare_binprm(bprm);
if(retval>=0) { /*prepare_binrpm函数已经读出了目标文件的前1024个字节，先判断下这个文件是否是ELF文件，即前4个字节*/
if (bprm->buf[0] == 0x7f
&& bprm->buf[1] == 'E'
&& bprm->buf[2] == 'L'
&& bprm->buf[3] == 'F') {
retval = load_elf_binary(bprm, regs, infop);
#if defined(TARGET_HAS_BFLT)
} else if (bprm->buf[0] == 'b'
&& bprm->buf[1] == 'F'
&& bprm->buf[2] == 'L'
&& bprm->buf[3] == 'T') {
retval = load_flt_binary(bprm,regs,infop);
#endif
} else {
fprintf(stderr, "Unknown binary format\n");
return -1;
}
}
if(retval>=0) {
/* success. Initialize important registers */
do_init_thread(regs, infop);
return retval;
}
/* Something went wrong, return the inode and free the argument pages*/
for (i=0 ; i<MAX_ARG_PAGES ; i++) {
g_free(bprm->page[i]);
}
return(retval);
}

int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
struct image_info * info)
{
struct image_info interp_info;
struct elfhdr elf_ex;
char *elf_interpreter = NULL;
info->start_mmap = (abi_ulong)ELF_START_MMAP; /*ELF_START_MMAP = 0x80000000*/
info->mmap = 0;
info->rss = 0;
/*主要工作就是初始化info，申请进程虚拟地址空间，将ELF文件映射到这段虚拟地址空间上*/
load_elf_image(bprm->filename, bprm->fd, info,
&elf_interpreter, bprm->buf);

... ... ... ...

return 0;
}

static void load_elf_image(const char *image_name, int image_fd,
struct image_info *info, char **pinterp_name,
char bprm_buf[BPRM_BUF_SIZE])
{
struct elfhdr *ehdr = (struct elfhdr *)bprm_buf;
struct elf_phdr *phdr;
abi_ulong load_addr, load_bias, loaddr, hiaddr, error;
int i, retval;
const char *errmsg;
/* First of all, some simple consistency checks */
errmsg = "Invalid ELF image for this architecture";
if (!elf_check_ident(ehdr)) {/*ELF头检查*/
goto exit_errmsg;
}
bswap_ehdr(ehdr); /*当前为空，是不是主机和目标机大小尾端不一致时才会swap*/
if (!elf_check_ehdr(ehdr)) {
goto exit_errmsg;
}
/*下面的代码即读出ELF文件的程序头表，首先判断下是否已经被完全读出*/
i = ehdr->e_phnum * sizeof(struct elf_phdr); /*program header 表的大小*/
if (ehdr->e_phoff + i <= BPRM_BUF_SIZE) {
phdr = (struct elf_phdr *)(bprm_buf + ehdr->e_phoff);
} else {
phdr = (struct elf_phdr *) alloca(i); /*申请i个程序头部*/
retval = pread(image_fd, phdr, i, ehdr->e_phoff); /*从文件image_id的偏移为ehdr->e_phoff处读取i个字节到phdr中，即phdr存放program header*/
if (retval != i) {
goto exit_read;
}
}
bswap_phdr(phdr, ehdr->e_phnum);
#ifdef CONFIG_USE_FDPIC
info->nsegs = 0;
info->pt_dynamic_addr = 0;
#endif
/* Find the maximum size of the image and allocate an appropriate
amount of memory to handle that. */
loaddr = -1, hiaddr = 0;
for (i = 0; i < ehdr->e_phnum; ++i) {/*遍历每一个program header*/
if (phdr[i].p_type == PT_LOAD) {
abi_ulong a = phdr[i].p_vaddr;
if (a < loaddr) { /*loaddr = -1而且是unsigned 类型的，所以loaddr是个很大的数*/
loaddr = a; /*loaddr记录segment的起始地址*/
}
a += phdr[i].p_memsz; /*这个segment在内存中的偏移地址*/
if (a > hiaddr) { /*hiaddr记录segment的结束地址*/
hiaddr = a;
}
#ifdef CONFIG_USE_FDPIC
++info->nsegs;
#endif
}
}
load_addr = loaddr; /*计算出来的需要加载的起始地址*/
if (ehdr->e_type == ET_DYN) { /*共享目标文件(.so)*/
/* The image indicates that it can be loaded anywhere. Find a
location that can hold the memory space required. If the
image is pre-linked, LOADDR will be non-zero. Since we do
not supply MAP_FIXED here we'll use that address if and
only if it remains available. */
load_addr = target_mmap(loaddr, hiaddr - loaddr, PROT_NONE,
MAP_PRIVATE | MAP_ANON | MAP_NORESERVE,
-1, 0);
if (load_addr == -1) {
goto exit_perror;
}
} else if (pinterp_name != NULL) {
/* This is the main executable. Make sure that the low
address does not conflict with MMAP_MIN_ADDR or the
QEMU application itself. */
probe_guest_base(image_name, loaddr, hiaddr);
}
load_bias = load_addr - loaddr;
#ifdef CONFIG_USE_FDPIC
{
struct elf32_fdpic_loadseg *loadsegs = info->loadsegs =
g_malloc(sizeof(*loadsegs) * info->nsegs);
for (i = 0; i < ehdr->e_phnum; ++i) {
switch (phdr[i].p_type) {
case PT_DYNAMIC:
info->pt_dynamic_addr = phdr[i].p_vaddr + load_bias;
break;
case PT_LOAD:
loadsegs->addr = phdr[i].p_vaddr + load_bias;
loadsegs->p_vaddr = phdr[i].p_vaddr;
loadsegs->p_memsz = phdr[i].p_memsz;
++loadsegs;
break;
}
}
}
#endif
info->load_bias = load_bias; /*真实的加载地址和计算出来(读ELF头信息)的加载地址之差*/
info->load_addr = load_addr; /*真实的加载地址*/
info->entry = ehdr->e_entry + load_bias; /*重新调整下程序的入口*/
info->start_code = -1;
info->end_code = 0;
info->start_data = -1;
info->end_data = 0;
info->brk = 0;
for (i = 0; i < ehdr->e_phnum; i++) {
struct elf_phdr *eppnt = phdr + i;
if (eppnt->p_type == PT_LOAD) {
abi_ulong vaddr, vaddr_po, vaddr_ps, vaddr_ef, vaddr_em;
int elf_prot = 0;
/*记录PT_LOAD类型segment的权限：读/写/可执行*/
if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;
if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
vaddr = load_bias + eppnt->p_vaddr;
vaddr_po = TARGET_ELF_PAGEOFFSET(vaddr); /*((vaddr) & ((1 << 12)-1))，目的是取页内偏移*/
vaddr_ps = TARGET_ELF_PAGESTART(vaddr); /*((vaddr) & ~(unsigned long)((1 << 12)-1))，向下页对齐，目的取页对齐的地址*/
/*将ELF文件映射到进程地址空间中*/
error = target_mmap(vaddr_ps, eppnt->p_filesz + vaddr_po, /*映射的时候从页内偏移vaddr_po开始映射，即保持原来的偏移量*/
elf_prot, MAP_PRIVATE | MAP_FIXED,
image_fd, eppnt->p_offset - vaddr_po);
if (error == -1) {
goto exit_perror;
}
vaddr_ef = vaddr + eppnt->p_filesz;
vaddr_em = vaddr + eppnt->p_memsz;
/* If the load segment requests extra zeros (e.g. bss), map it. */
if (vaddr_ef < vaddr_em) {
zero_bss(vaddr_ef, vaddr_em, elf_prot);
}
/* Find the full program boundaries. */
if (elf_prot & PROT_EXEC) {
if (vaddr < info->start_code) {
info->start_code = vaddr; /*代码段的起始虚拟地址（页对齐的地址）*/
}
if (vaddr_ef > info->end_code) {
info->end_code = vaddr_ef; /*代码段的结束虚拟地址（页对齐的地址）*/
}
}
if (elf_prot & PROT_WRITE) {
if (vaddr < info->start_data) {
info->start_data = vaddr; /*数据段的起始虚拟地址*/
}
if (vaddr_ef > info->end_data) {
info->end_data = vaddr_ef; /*数据段的起始虚拟地址（包括bss段的大小）*/
}
if (vaddr_em > info->brk) {
info->brk = vaddr_em; /*程序内存映像的顶端（代码段+数据段+bss段）*/
}
}
} else if (eppnt->p_type == PT_INTERP && pinterp_name) {/*内部解释程序名称：/lib/ld-linux.so.2*/
char *interp_name;
if (*pinterp_name) {
errmsg = "Multiple PT_INTERP entries";
goto exit_errmsg;
}
interp_name = malloc(eppnt->p_filesz);
if (!interp_name) {
goto exit_perror;
}
if (eppnt->p_offset + eppnt->p_filesz <= BPRM_BUF_SIZE) {
memcpy(interp_name, bprm_buf + eppnt->p_offset,
eppnt->p_filesz);
} else {
retval = pread(image_fd, interp_name, eppnt->p_filesz,
eppnt->p_offset);
if (retval != eppnt->p_filesz) {
goto exit_perror;
}
}
if (interp_name[eppnt->p_filesz - 1] != 0) {
errmsg = "Invalid PT_INTERP entry";
goto exit_errmsg;
}
*pinterp_name = interp_name;
}
}
if (info->end_data == 0) {
info->start_data = info->end_code;
info->end_data = info->end_code;
info->brk = info->end_code;
}
if (qemu_log_enabled()) {
load_symbols(ehdr, image_fd, load_bias);
}
close(image_fd);
return;
exit_read:
if (retval >= 0) {
errmsg = "Incomplete read of file header";
goto exit_errmsg;
}
exit_perror:
errmsg = strerror(errno);
exit_errmsg:
fprintf(stderr, "%s: %s\n", image_name, errmsg);
exit(-1);
}