Linux内核分析笔记七可执行程序的装载 ——by王玥

一、预处理、编译、链接和目标文件的格式

（一）可执行程序是怎么得来的？

2.可执行文件的创建——预处理、编译和链接

shiyanlou:~/ $ cd Code                                                [9:27:05]
shiyanlou:Code/ $ vi hello.c                                          [9:27:14]
shiyanlou:Code/ $ gcc -E -o hello.cpp hello.c -m32                    [9:34:55]    //预处理，负责把include的文件包含进来及宏替换等工作
shiyanlou:Code/ $ vi hello.cpp                                        [9:35:04]
shiyanlou:Code/ $ gcc -x cpp-output -S -o hello.s hello.cpp -m32      [9:35:21] //把预处理之后的程序编译成汇编代码
shiyanlou:Code/ $ vi hello.s                                          [9:35:28]
shiyanlou:Code/ $ gcc -x assembler -c hello.s -o hello.o -m32         [9:35:58]  //把汇编代码编译成目标代码
shiyanlou:Code/ $ vi hello.o                                          [9:38:44]  //得到一个二进制的文件，不是一个可执行文件
shiyanlou:Code/ $ gcc -o hello hello.o -m32                           [9:39:37]  //把hello.o链接成一个可执行文件
shiyanlou:Code/ $ vi hello                                            [9:39:44]  //可执行文件，与hello.o一样是ELF格式的文件，使用共享库
shiyanlou:Code/ $ gcc -o hello.static hello.o -m32 -static            [9:40:21]  //静态编译
shiyanlou:Code/ $ ls -l                                               [9:41:13]
-rwxrwxr-x 1 shiyanlou shiyanlou   7292  3\u6708 23 09:39 hello
-rw-rw-r-- 1 shiyanlou shiyanlou     64  3\u6708 23 09:30 hello.c
-rw-rw-r-- 1 shiyanlou shiyanlou  17302  3\u6708 23 09:35 hello.cpp
-rw-rw-r-- 1 shiyanlou shiyanlou   1020  3\u6708 23 09:38 hello.o
-rw-rw-r-- 1 shiyanlou shiyanlou    470  3\u6708 23 09:35 hello.s
-rwxrwxr-x 1 shiyanlou shiyanlou 733254  3\u6708 23 09:41 hello.static

（二）目标文件的格式ELF

A.out
COFF: PE（windows）、ELF（LINUX系统中常用）

1.ELF格式主要有三种文件

一个可重定位（reloacatable）文件保存着代码和适当的数据，用来和其他的object文件一起来创建一个可执行文件或者是一个共享文件。主要是.o文件
一个可执行(executable)文件保存着一个用来执行的程序；该文件指出了exec（BA_OS）如何来创建程序进程印象。
一个共享object文件保存着代码和合适的数据，用来被下面两个链接器链接：一个是连接编辑器,另一个是动态链接器。主要是.so文件

2.可执行文件的格式和进程的地址空间有一个影射关系。

（三）静态链接的ELF可执行文件与进程的地址空间

左半边是ELF格式，右半边是执行时候的格式；
其中，ELF头描述了该文件的组织情况，程序投标告诉系统如何创建一个进程的内存映像，section头表包含了描述文件sections的信息

当系统要执行一个文件的时候，理论上讲，他会把程序段拷贝到虚拟内存中某个段

entry代表（刚加载过新的可执行文件之后的）程序的入口地址（头部之后是代码和数据，进程的地址空间是4G，上面的1G是内核用，下面的3G是程序使用）默认的ELF头加载地址是0x8048000,头部大概要到0x48100处或者0x483000处，也就是可执行文件加载到内存之后执行的第一条代码地址

一般静态链接会把所有代码放到一个代码段
动态链接的进程会有多个代码段

二、可执行程序、共享库和动态链接

（一）装载可执行程序之前的工作

1.可执行程序的执行环境

命令行参数和shell环境，一般我们执行一个程序的Shell环境，我们的实验直接使用execve系统调用。

$ ls -l /usr/bin 列出/usr/bin下的目录信息
Shell本身不限制命令行参数的个数，命令行参数的个数受限于命令自身

例如，int main(int argc, char *argv[])
又如， int main(int argc, char *argv[], char *envp[])

Shell会调用execve将命令行参数和环境参数传递给可执行程序的main函数

int execve(const char * filename,char * const argv[ ],char * const envp[ ]);
库函数exec*都是execve的封装例程

例子：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(int argc, char * argv[])
{
    int pid;
    /* fork another process */
    pid = fork();//调用fork
    if (pid<0) 
    { 
        /* error occurred */
        fprintf(stderr,"Fork Failed!");
        exit(-1);
    } 
    else if (pid==0) 
    {
        /*   child process   */
        execlp("/bin/ls","ls",NULL);//加载可执行程序ls
    } 
    else 
    {  
        /*     parent process  */
        /* parent will wait for the child to complete*/
        wait(NULL);
        printf("Child Complete!");
        exit(0);
    }
}

fork子进程的时候完全复制了父进程；调用exec的时候，要加载的可执行程序把原来的进程环境覆盖掉，用户态堆栈也被清空
命令行参数和环境变量进入新程序的堆栈：把环境变量和命令行参数压栈（如上图），也就相当于main函数启动
shell程序-->execve-->sys_execve，然后在初始化新程序堆栈的时候拷贝进去
先函数调用参数传递，再系统调用参数传递

命令行参数和环境串都放在用户态堆栈中

（二）装载时动态链接和运行时动态链接应用举例

动态链接分为可执行程序装载时动态链接和运行时动态链接，如下代码演示了这两种动态链接。

准备.so文件

shlibexample.h (1.3 KB) - Interface of Shared Lib Example

shlibexample.c (1.2 KB) - Implement of Shared Lib Example

编译成libshlibexample.so文件

$ gcc -shared shlibexample.c -o libshlibexample.so -m32

dllibexample.h (1.3 KB) - Interface of Dynamical Loading Lib Example

dllibexample.c (1.3 KB) - Implement of Dynamical Loading Lib Example

编译成libdllibexample.so文件

$ gcc -shared dllibexample.c -o libdllibexample.so -m32

分别以共享库和动态加载共享库的方式使用libshlibexample.so文件和libdllibexample.so文件

main.c (1.9 KB) - Main program

编译main，注意这里只提供shlibexample的-L（库对应的接口头文件所在目录）和-l（库名，如libshlibexample.so去掉lib和.so的部分），并没有提供dllibexample的相关信息，只是指明了-ldl

编译

1.$ gcc main.c -o main -L/path/to/your/dir -lshlibexample -ldl -m32  #这里只提供shlibexample的-L（库对应的接口头文件所在目录，也就是path to your dir）和-l（库名，如libshlibexample.so去掉lib和.so的部分），并没有提供dllibexample的相关信息，只是指明了-ldl
2.$ export LD_LIBRARY_PATH=$PWD #将当前目录加入默认路径，否则main找不到依赖的库文件，当然也可以将库文件copy到默认路径下。
3.$ ./main
4.This is a Main program!
5.Calling SharedLibApi() function of libshlibexample.so!
6.This is a shared libary!
7.Calling DynamicalLoadingLibApi() function of libdllibexample.so!
8.This is a Dynamical Loading libary!

三、可执行程序的装载

（一）可执行程序的装载相关关键问题分析

1.execve与fork是比较特殊的系统调用

execve用它加载的可执行文件把当前的进程的可执行程序覆盖掉，返回之后就不是原来的程序而是新的可执行程序起点；
fork函数的返回点ret_from_fork是用户态起点

2.sys_execve内核处理过程

do_execve -> do_execve_common -> exec_binprm

最后，根据文件头部信息寻找对应的文件格式处理模块

1369    list_for_each_entry(fmt, &formats, lh) {//在链表中寻找可以处理这种格式（比如ELF）的模块
1370        if (!try_module_get(fmt->module))
1371            continue;
1372        read_unlock(&binfmt_lock);
1373        bprm->recursion_depth++;
1374        retval = fmt->load_binary(bprm);//对于ELF格式的可执行文件fmt->load_binary(bprm);执行的应该是load_elf_binary其内部是和ELF文件格式解析的部分需要和ELF文件格式标准结合起来阅读
1375        read_lock(&binfmt_lock);

3.Linux内核是如何支持多种不同的可执行文件格式的？

1.82static struct linux_binfmt elf_format = {//elf_format结构体
2.83  .module     = THIS_MODULE,
3.84  .load_binary    = load_elf_binary,
4.85  .load_shlib = load_elf_library,
5.86  .core_dump  = elf_core_dump,
6.87  .min_coredump   = ELF_EXEC_PAGESIZE,
7.88};



1.2198static int __init init_elf_binfmt(void)
2.2199{
3.2200    register_binfmt(&elf_format);//把elf_format变量注册到fmt链表中
4.2201    return 0;
5.2202}