Linux内核如何装载和启动一个可执行程序

do_exec

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


                        static int do_execve_common(struct filename *filename,
                                        struct user_arg_ptr argv,
                                        struct user_arg_ptr envp)
                        {
                            // 检查进程的数量限制

                            // 选择最小负载的CPU，以执行新程序
                            sched_exec();

                            // 填充 linux_binprm结构体
                            retval = prepare_binprm(bprm);

                            // 拷贝文件名、命令行参数、环境变量
                            retval = copy_strings_kernel(1, &bprm->filename, bprm);
                            retval = copy_strings(bprm->envc, envp, bprm);
                            retval = copy_strings(bprm->argc, argv, bprm);

                            // 调用exec_binprm,保存当前的pid
                            retval = exec_binprm(bprm);

                            // exec执行成功

                        }

                        static int exec_binprm(struct linux_binprm *bprm)
                        {
                            // 扫描formats链表，根据不同的文本格式，选择不同的load函数
                            ret = search_binary_handler(bprm);
                            // ...
                            return ret;
                        }
                    

struct linux_binprm来保存要执行的文件相关信息

                        struct linux_binprm{
                            char buf[BINPRM_BUF_SIZE]; // 保存可执行文件的头128字节
                            struct page *page[MAX_ARG_PAGES];
                            struct mm_struct *mm;
                            unsigned long p; // 当前内存页最高地址
                            int sh_bang;
                            struct file * file; // 要执行的文件
                            int e_uid, e_gid; // 要执行的进程的有效用户ID和有效组ID
                            kernel_cap_t cap_inheritable, cap_permitted, cap_effective;
                            void *security;
                            int argc, envc; // 命令行参数和环境变量数目
                            char * filename; // 要执行的文件的名称
                            char * interp;        // 要执行的文件的真实名称，通常和filename相同
                            unsigned interp_flags;
                            unsigned interp_data;
                            unsigned long loader, exec;
                        };
                    

search_binary_handler

                        int search_binary_handler(struct linux_binprm *bprm)
                        {
                            // 遍历formats链表，记录着内核目前支持的文件格式
                            list_for_each_entry(fmt, &formats, lh) {
                                // 应用每种格式的load_binary方法
                                retval = fmt->load_binary(bprm);
                                // ...
                            }
                            return retval;
                        }
                    

linux_binfmt的结构体定义load the binary formats

                        struct linux_binfmt {
                            struct list_head lh;
                            struct module *module;
                            int (*load_binary)(struct linux_binprm *);
                            //load_binary本质上是一个函数指针
                            //retval = fmt->load_binary(bprm)，对应了不同的函数调用。
                            int (*load_shlib)(struct file *);//加载共享库
                            int (*core_dump)(struct coredump_params *cprm);
                            unsigned long min_coredump; /* minimal dump size */
                        };
                    

在/fs/binfmt_elf.c中elf_format

                        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

                        static int load_elf_binary(struct linux_binprm *bprm)
                        {
                            // ....
                            struct pt_regs *regs = current_pt_regs();  // 获取当前进程的寄存器存储位置

                            // 获取elf前128个字节
                            loc->elf_ex = *((struct elfhdr *)bprm->buf);

                            // 检查魔数是否匹配
                            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)
                                // 
                            // 读取所有的头部信息
                            // 读入程序的头部分
                            retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,
                                         (char *)elf_phdata, size);

                            // 遍历elf的程序头
                            for (i = 0; i < loc->elf_ex.e_phnum; i++) {

                                // 如果存在解释器头部
                                if (elf_ppnt->p_type == PT_INTERP) {
                                    // 
                                    // 读入解释器名
                                    retval = kernel_read(bprm->file, elf_ppnt->p_offset,
                                                 elf_interpreter,
                                                 elf_ppnt->p_filesz);

                                    // 打开解释器文件
                                    interpreter = open_exec(elf_interpreter);

                                    // 读入解释器文件的头部
                                    retval = kernel_read(interpreter, 0, bprm->buf,
                                                 BINPRM_BUF_SIZE);

                                    // 获取解释器的头部
                                    loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
                                    break;
                                }
                                elf_ppnt++;
                            }

                            // 释放空间、删除信号、关闭带有CLOSE_ON_EXEC标志的文件
                            retval = flush_old_exec(bprm);


                            setup_new_exec(bprm);

                            // 为进程分配用户态堆栈，并塞入参数和环境变量
                            retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
                                         executable_stack);
                            current->mm->start_stack = bprm->p;

                            // 将elf文件映射进内存
                            for(i = 0, elf_ppnt = elf_phdata;
                                i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {

                                if (unlikely (elf_brk > elf_bss)) {
                                    unsigned long nbyte;

                                    // 生成BSS
                                    retval = set_brk(elf_bss + load_bias,
                                             elf_brk + load_bias);
                                    // ...
                                }

                                // 可执行程序
                                if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
                                    elf_flags |= MAP_FIXED;
                                } else if (loc->elf_ex.e_type == ET_DYN) { // 动态链接库
                                    // ...
                                }

                                // 创建一个新线性区对可执行文件的数据段进行映射
                                error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
                                        elf_prot, elf_flags, 0);

                                }

                            }

                            // 加上偏移量
                            loc->elf_ex.e_entry += load_bias;
                            // ....


                            // 创建一个新的匿名线性区，来映射程序的bss段
                            retval = set_brk(elf_bss, elf_brk);

                            // 如果该程序需要动态链接,则elf_interpreter指针不为空,
                            //并指向对应的 ld文件.内核则加载此文件,由该文件进行动态链接,并最终跳入程序头文件中制定的入口点
                            if (elf_interpreter) {
                                unsigned long interp_map_addr = 0;

                                // 调用一个装入动态链接程序的函数 此时elf_entry指向一个动态链接程序的入口
                                elf_entry = load_elf_interp(&loc->interp_elf_ex,
                                                interpreter,
                                                &interp_map_addr,
                                                load_bias);
                                // ...
                            } else {
                                // elf_entry是可执行程序的入口
                                elf_entry = loc->elf_ex.e_entry;
                                // ....
                            }

                            // 修改保存在内核堆栈，但属于用户态的eip和esp
                            start_thread(regs, elf_entry, bprm->p);
                            retval = 0;
                            // 
                        }
                    

可以看到，当这个文件需要用elf_interpreter的话，也就是说它需要依赖动态链接器来解释这个ELF文件，那么它就需要加载load_elf_interp，实际上是加载动态连接器ld，那么这时候Entry point address，也就是说在返回到用户态的时候，它返回的就不是这个可执行程序文件规定的起点，它返回的是动态连接器的程序入口，动态连接器负责解释当前的可执行文件，看它里面依赖哪些动态链接库，然后把那些动态链接库一个一个加载进来，加载进来之后再解释加载进来的动态链接库，看它这个动态链接库还依赖哪些文件，这样就有一个叫广度遍历的方法（即动态链接库的装载过程是一个图的遍历），把所有的动态链接库都装载起来，装载起来之后ld再负责把CPU的控制权移交给可执行程序头部规定的起点位置。

还有些小问题。关于动态链接的。

共享库在程序的链接时候并不像静态库那样在拷贝使用函数的代码，而只是作些标记。然后在程序开始启动运行的时候，动态地加载所需模块。

动态加载共享库(dynamically loaded (DL) libraries)是指在程序运行过程中可以加载的函数库。而不是像共享库一样在程序启动的时候加载。DL对于实现插件和模块非常有用，因为他们可以让程序在允许时等待插件的加载。在Linux中，动态库的文件格式跟共享库没有区别。

有专门的一组API用于完成操作动态库

函数原型：void *dlopen(const char *libname,int flag);功能描述：表示将库装载到内存并返回一个句柄给调用进程。如果要装载的库依赖于其它库，必须首先装载依赖库。

函数原型：char *dlerror(void);功能描述：dlerror可以获得最近一次dlopen,dlsym或dlclose操作的错误信息，返回NULL表示无错误。dlerror在返回错误信息的同时，也会清除错误信息。

函数原型：void *dlsym(void *handle,const char *symbol);功能描述：handle是由dlopen打开动态链接库后返回的指针，symbol就是要求获取的函数的名称，函数返回值是void*,指向函数的地址，供调用使用

函数原型：int dlclose(void *);功能描述：将已经装载的库句柄减一，如果句柄减至零，则该库会被卸载。如果存在析构函数，则在dlclose之后，析构函数会被调用。

有了这些知识，分析一下运行结果。

在编译的时候，就对可执行文件中做了共享库libshlibexample.so的标记。装载后，运行可以直接调用里面的SharedLibApi函数。

但是动态加载共享库libdllibexample.so不同，没有任何标记。只能先打来这个库，此时才把库装载到内存中，返回给进程一个句柄。再根据这个句柄找到库中的DynamicalLoadingLibApi函数，赋予函数指针func，最后调用func()。关闭库。

总结

这次内容是真多呀。做了好几天。也算是把一些疑惑有了大致的思路。

求5分好评。