可执行程序的装载

杨金龙 + 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

实验环境：https://www.shiyanlou.com/courses/195

基础知识

先以 helloworld.c 程序为例，搞清楚可执行文件是如何生成的：

#include <stdio.h>
int main(void)
{
    printf("hello, world!\n");
    return 0;
}

1.预处理，处理代码中的宏定义和 include 文件，并做语法检查

gcc -E helloworld.c -o helloworld.cpp

2.编译，生成汇编代码

gcc -S helloworld.cpp -o helloworld.s

3.汇编，生成汇编代码

gcc -c helloworld.s -o helloworld.o

4.链接，生成可执行文件

gcc helloworld.o -o helloworld

具体过程可以用下面的图片表示，各种文件格式之间的关系如下：

参考资料：https://wenku.baidu.com/view/a04ab40b581b6bd97f19eaa6.html

ELF 文件格式

ELF 格式：可执行和可链接格式 (Executable and Linkable Format) 是一种用于二进制文件、可执行文件、目标代码、共享库和核心转储的标准文件格式。它又包括三种文件格式：

1. 可重定位文件，如：.o 文件，包含代码和数据，可以被链接成可执行文件或共享目标文件，静态链接库属于这类。
2. 可执行文件，如：/bin/bash 文件，包含可直接执行的程序，没有扩展名。
3. 共享目标文件，如：.so 文件，包含代码和数据，可以跟其他可重定位文件和共享目标文件链接产生新的目标文件，也可以跟可执行文件结合作为进程映像的一部分。

ELF 文件由 ELF header 和文件数据组成，文件数据包括:

• Program header table, 程序头：描述段信息

• .text, 代码段：保存编译后得到的指令数据

• .data, 数据段：保存已经初始化的全局静态变量和局部静态变量

• Section header table, 节头表：链接与重定位需要的数据

链接

　　链接，是收集和组织程序所需的不同代码和数据的过程，以便程序能被装入内存并被执行。一般分为两步：1.空间与地址分配，2.符号解析与重定位。一般有两种类型，一是静态链接，二是动态链接。

• 空间与地址分配
  　　扫描所有的输入目标文件，获得它们的各个段的长度、属性和位置，并且将输入目标文件中的符号定义和符号引用收集起来，统一放到一个全局符号表。这一步中，连接器将能获得所有输入如目标文件的段长度，并且将它们合并，计算出输出文件中各个段合并后的长度和位置，并建立映射关系。

• 符号解析与重定位
  　　使用上面一步中收集的所有信息，读取输入文件中的段的数据、重定位信息，并且进行符号解析与重定位、调整代码中的地址等。事实上，这一步是链接过程的核心，特别是重定位过程。

  　　使用静态链接的好处是，依赖的动态链接库较少（这句话有点绕），对动态链接库的版本更新不会很敏感，具有较好的兼容性；不好地方主要是生成的程序比较大，占用资源多。使用动态链接的好处是生成的程序小，占用资源少。动态链接分为可执行程序装载时动态链接和运行时动态链接。

  　　当用户启动一个应用程序时，它们就会调用一个可执行和链接格式映像。Linux 中 ELF 支持两种类型的库：静态库包含在编译时静态绑定到一个程序的函数。动态库则是在加载应用程序时被加载的，而且它与应用程序是在运行时绑定的。

代码分析

sys_execve内部会解析可执行文件格式。代码在内核中/linux-3.18.6/fs/exec.c中。sys＿execve调用顺序：
do＿execve -> do＿execve＿common -> exec＿binprm

int do_execve(struct filename *filename,
const char __user *const __user *__argv,
const char __user *const __user *__envp)
{
struct user_arg_ptr argv = { .ptr.native = __argv };
struct user_arg_ptr envp = { .ptr.native = __envp };
return do_execve_common(filename, argv, envp);
}

---

/*
* sys_execve() executes a new program.
*/
static int do_execve_common(struct filename *filename,
   struct user_arg_ptr argv,
   struct user_arg_ptr envp)
{
   struct linux_binprm *bprm;
   struct file *file;
   struct files_struct *displaced;
   int retval;
if (IS_ERR(filename))
   return PTR_ERR(filename);
/*
* We move the actual failure in case of RLIMIT_NPROC excess from
* set*uid() to execve() because too many poorly written programs
* don't check setuid() return code.  Here we additionally recheck
* whether NPROC limit is still exceeded.
*/
   if ((current->flags & PF_NPROC_EXCEEDED) &&
   atomic_read(&current_user()->processes) > rlimit(RLIMIT_NPROC)) {
   retval = -EAGAIN;
   goto out_ret;
   }
/* We're below the limit (still or again), so we don't want to make
* further execve() calls fail. */
   current->flags &= ~PF_NPROC_EXCEEDED;
retval = unshare_files(&displaced);
   if (retval)
   goto out_ret;
retval = -ENOMEM;
   bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
   if (!bprm)
   goto out_files;
retval = prepare_bprm_creds(bprm);
   if (retval)
   goto out_free;
check_unsafe_exec(bprm);
   current->in_execve = 1;
file = do_open_exec(filename);
   retval = PTR_ERR(file);
   if (IS_ERR(file))
   goto out_unmark;
sched_exec();
bprm->file = file;
   bprm->filename = bprm->interp = filename->name;
retval = bprm_mm_init(bprm);
   if (retval)
   goto out_unmark;
bprm->argc = count(argv, MAX_ARG_STRINGS);
   if ((retval = bprm->argc) < 0)
   goto out;
bprm->envc = count(envp, MAX_ARG_STRINGS);
   if ((retval = bprm->envc) < 0)
   goto out;
retval = prepare_binprm(bprm);
   if (retval < 0)
   goto out;
retval = copy_strings_kernel(1, &bprm->filename, bprm);
   if (retval < 0)
   goto out;
bprm->exec = bprm->p;
   retval = copy_strings(bprm->envc, envp, bprm);
   if (retval < 0)
   goto out;
retval = copy_strings(bprm->argc, argv, bprm);
   if (retval < 0)
   goto out;
retval = exec_binprm(bprm);
   if (retval < 0)
   goto out;
/* execve succeeded */
   current->fs->in_exec = 0;
   current->in_execve = 0;
   acct_update_integrals(current);
   task_numa_free(current);
   free_bprm(bprm);
   putname(filename);
   if (displaced)
   put_files_struct(displaced);
   return retval;
out:
   if (bprm->mm) {
   acct_arg_size(bprm, 0);
   mmput(bprm->mm);
   }
out_unmark:
   current->fs->in_exec = 0;
   current->in_execve = 0;
out_free:
   free_bprm(bprm);
out_files:
   if (displaced)
   reset_files_struct(displaced);
out_ret:
   putname(filename);
   return retval;
}

---

static int exec_binprm(struct linux_binprm *bprm)
{
   pid_t old_pid, old_vpid;
   int ret;
/* Need to fetch pid before load_binary changes it */
   old_pid = current->pid;
   rcu_read_lock();
   old_vpid = task_pid_nr_ns(current, task_active_pid_ns(current->parent));
   rcu_read_unlock();
ret = search_binary_handler(bprm);
   if (ret >= 0) {
   audit_bprm(bprm);
   trace_sched_process_exec(current, old_pid, bprm);
   ptrace_event(PTRACE_EVENT_EXEC, old_vpid);
   proc_exec_connector(current);
   }

search＿binary＿handler寻找符合文件格式对应的解析模板，如下：（对于给定的文件名，根据文件头部信息寻找对应的文件格式处理模块）

/*
* cycle the list of binary formats handler, until one recognizes the image
*/
int search_binary_handler(struct linux_binprm *bprm)
{
   bool need_retry = IS_ENABLED(CONFIG_MODULES);
   struct linux_binfmt *fmt;
   int retval;
/* This allows 4 levels of binfmt rewrites before failing hard. */
   if (bprm->recursion_depth > 5)
   return -ELOOP;
retval = security_bprm_check(bprm);
   if (retval)
   return retval;
retval = -ENOENT;
retry:
   read_lock(&binfmt_lock);
   list_for_each_entry(fmt, &formats, lh) {
   if (!try_module_get(fmt->module))
   continue;
   read_unlock(&binfmt_lock);
   bprm->recursion_depth++;
   retval = fmt->load_binary(bprm);
   read_lock(&binfmt_lock);
   put_binfmt(fmt);
   bprm->recursion_depth--;
   if (retval < 0 && !bprm->mm) {
   /* we got to flush_old_exec() and failed after it */
   read_unlock(&binfmt_lock);
   force_sigsegv(SIGSEGV, current);
   return retval;
   }
   if (retval != -ENOEXEC || !bprm->file) {
   read_unlock(&binfmt_lock);
   return retval;
   }
   }
   read_unlock(&binfmt_lock);
if (need_retry) {
   if (printable(bprm->buf[0]) && printable(bprm->buf[1]) &&
   printable(bprm->buf[2]) && printable(bprm->buf[3]))
   return retval;
   if (request_module("binfmt-%04x", *(ushort *)(bprm->buf + 2)) < 0)
   return retval;
   need_retry = false;
   goto retry;
   }
return retval;
}
EXPORT_SYMBOL(search_binary_handler);

对于ELF格式的可执行文件fmt->load＿binary(bprm); 执行的应该是load＿elf＿binary其内部是和ELF文件格式解析的部分需要和ELF文件格式标准结合起来阅读。load＿elf＿binary在/linux-3.18.6/fs/binfmt_elf.c文件中，代码太长，在此不贴出，这个函数主要作用就是在函数的最后根据链接种类启动一个起点为新的可执行程序的入口的进程。其中的关键代码如下：

...
if (elf_interpreter) {   //动态链接
    unsigned long interp_map_addr = 0;

    elf_entry = load_elf_interp(&loc->interp_elf_ex,
                    interpreter,
                    &interp_map_addr,
                    load_bias);
    if (!IS_ERR((void *)elf_entry)) {
        /*
         * load_elf_interp() returns relocation
         * adjustment
         */
        interp_load_addr = elf_entry;
        elf_entry += loc->interp_elf_ex.e_entry;
    }
    if (BAD_ADDR(elf_entry)) {
        retval = IS_ERR((void *)elf_entry) ?
                (int)elf_entry : -EINVAL;
        goto out_free_dentry;
    }
    reloc_func_desc = interp_load_addr;

    allow_write_access(interpreter);
    fput(interpreter);
    kfree(elf_interpreter);
} else {   //静态链接
    elf_entry = loc->elf_ex.e_entry;
    if (BAD_ADDR(elf_entry)) {
        retval = -EINVAL;
        goto out_free_dentry;
    }
}
...
start_thread(regs, elf_entry, bprm->p);

ELF文件格式结构体：

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,
};

load＿elf＿binary 的最后调用 start＿thread 函数。修改 int 0x80 压入内核堆栈的 EIP，当 load＿elf＿binary 执行完毕，返回至 do＿execve 再返回至 sys＿execve 时，系统调用的返回地址，即 EIP 寄存器，已经被改写成了被装载的 ELF 程序的入口地址了。

追踪过程

配置实验环境https://www.shiyanlou.com/courses/running

rm menu -rf //删除menu

git clone https://github.com/mengning/menu.git //下载克隆新的menu

cd menu //切换到menu目录下

mv test_exce.c test.c //把test_exce.c 改成 test.c ，这里是应为Makefile里面用的是test.c

vi test.c //查看一下test.c的内容

vi makefile //查看一下Makefile的内容

make rootfs //启动系统

启动gdb

gdb -tui  //启动gdb
file linux-3.18.6/vmlinux //读取符号表
target remote:1234  //设置端口

设置断点

实验截图

总结

1、可执行程序的产生：

C语言代码–>编译器预处理–>编译成汇编代码–>汇编器编译成目标代码–>链接成可执行文件，再由操作系统加载到内存中执行。

2、ELF格式中主要有3种可执行文件：可重定位文件.o，可执行文件，共享目标文件。

3、ELF可执行文件会被默认映射到0x8048000这个地址。

4、命令行参数和环境变量是如何进入新程序的堆栈的？

Shell程序–>execve–>sys_execve，然后在初始化新程序堆栈时拷贝进去。

先函数调用参数传递，再系统调用参数传递。

5、当前程序执行到execve系统调用时陷入内核态，在内核中用execve加载可执行文件，把当前进程的可执行文件覆盖掉，execve系统调用返回到新的可执行程序的起点。

6、动态链接库的装载过程是一个图的遍历过程，

ELF格式中的.interp和.dynamic需要依赖动态链接器来解析，entry返回到用户态时不是返回到可执行程序规定的起点，返回到动态链接器的程序入口。