Linux内核分析第七周作业

编译链接的过程

• 预处理：负责把include的文件包含进来及宏替换等工作。

gcc -E -o hello.cpp hello.c -m32

• 将cpp文件转换成汇编文件(编译)

gcc -x cpp-output -S -o hello.s hello.cpp -m32

• 将汇编文件转换成目标文件（汇编）

gcc -x assembler -c hello.s -o hello.o -m32

• 将目标文件转换成可执行文件（链接）(使用共享库)

gcc -o hello hello.o -m32

• 将目标文件转化成可执行文件（链接）（使用静态库）

gcc -o hello.static hello.o -m32 -static

ELF文件格式

一个ELF头在文件的开始，保存了路线图，描述了该文件的组织情况程序头表包含了描述文件sections的信息。每个section在这个表中有一个入口；每个入口给出该section的名字，大小等等信息。

ELF文件默认从内存0x8048000位置开始加载。

上图中程序的实际入口为内存0x8048320,在这之间是文件头的一些信息。

刚加载过可执行文件的进程开始执行的第一行代码的位置就是：0x8048320。

使用exec*库函数加载一个可执行文件

main.c代码分析

#include 

#include "shlibexample.h"  //共享库头文件

#include   //动态加载头文件

/*
 * Main program
 * input    : none
 * output   : none
 * return   : SUCCESS(0)/FAILURE(-1)
 *
 */
int main()
{
    printf("This is a Main program!\n");
    /* Use Shared Lib */
    printf("Calling SharedLibApi() function of libshlibexample.so!\n");
    SharedLibApi(); //加载装载时链接的共享库
    /* Use Dynamical Loading Lib */
    void * handle = dlopen("libdllibexample.so",RTLD_NOW); //打开运行时动态装载共享库
    if(handle == NULL)
    {
        printf("Open Lib libdllibexample.so Error:%s\n",dlerror());
        return   FAILURE;
    }
    int (*func)(void); //声明一个函数指针
    char * error;
    func = dlsym(handle,"DynamicalLoadingLibApi");//定义指针指向加载运行时动态装载的共享库的函数
    if((error = dlerror()) != NULL)
    {
        printf("DynamicalLoadingLibApi not found:%s\n",error);
        return   FAILURE;
    }    
    printf("Calling DynamicalLoadingLibApi() function of libdllibexample.so!\n");
    func(); //加载运行时动态装载的共享库 
    dlclose(handle);//关闭运行时动态装载的共享库    
    return SUCCESS;
}

使用gdb跟踪分析一个execve系统调用内核处理函数sys_execve

跟踪的C语言代码

int Exec(int argc, char *argv[])
{
    int pid;
    /* fork another process */
    pid = fork();
    if (pid < 0) 
    { 
        /* error occurred */
        fprintf(stderr,"Fork Failed!");
        exit(-1);
    } 
    else if (pid == 0) 
    {
        /*   child process  */
        printf("This is Child Process!\n");
        execlp("/hello","hello",NULL); //跟踪的sys_execve
    } 
    else 
    {   
        /*  parent process   */
        printf("This is Parent Process!\n");
        /* parent will wait for the child to complete*/
        wait(NULL);
        printf("Child Complete!\n");
    }
}

跟踪结果及分析
设置断点

新的程序的执行起点

由以上的gdb分析得出新的程序的执行起点是new_ip即

这个语句，它将eip指针指向了新程序hello的执行起点，该程序开始执行。

同样有以上的gdb分析得出，新程序执行前系统创建了新的内核堆栈，并将原有的环境参数复制给了各个寄存器等，这保证了返回的新的可执行程序在合适的环境中顺利执行。如堆栈分析下图所示。

对于静态链接的可执行程序和动态链接的可执行程序execve系统调用返回时的不同。

静态链接和动态链接的可执行程序的处理代码如下所示（代码来自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;//如果是静态链接库则把loc->elf_ex.e_entry的地址作为程序入口
        if (BAD_ADDR(elf_entry)) {
            retval = -EINVAL;
            goto out_free_dentry;
        }
    }

对于动态链接和静态链接的可执行程序处理流程图如下图所示。

所以动态链接和静态链接返回时的不同是：

静态链接的可执行程序会直接进入可执行程序的入口执行可执行程序，而动态链接器会加载连接器ld连接可执行文件进行加载符号表等动态链接工作完成后，才进入可执行程序的入口，执行可执行程序。

总结

Linux内核先从ELF文件头中找到可执行程序的入口，然后判断它是静态加载的可执行程序还是动态加载的可执行程序，若是静态加载的可执行文件，直接进入可执行程序入口执行可执行程序，如果是动态加载的可执行程序则先加载连接器ld连接可执行文件进行加载符号表等动态链接工作完成后，才进入可执行程序的入口，执行可执行程序。

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