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

//do_execve_common
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);

    // 调用里面的 search_binary_handler 
    retval = exec_binprm(bprm);

    // exec执行成功

}

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

/*
* This structure is used to hold the arguments that are used when loading binaries.
*/
// 内核中注释表明了这个结构体是用于保存载入二进制文件的参数.
struct linux_binprm {
    char buf[BINPRM_BUF_SIZE];
#ifdef CONFIG_MMU
    struct vm_area_struct *vma;
    unsigned long vma_pages;
#else
    //...
    unsigned interp_flags;
    unsigned interp_data;
    unsigned long loader, exec;
};

int search_binary_handler(struct linux_binprm *bprm)
{
    // 遍历formats链表
    list_for_each_entry(fmt, &formats, lh) {
        if (!try_module_get(fmt->module))
            continue;
        read_unlock(&binfmt_lock);
        bprm->recursion_depth++;

        // 应用每种格式的load_binary方法
        retval = fmt->load_binary(bprm);
        read_lock(&binfmt_lock);
        put_binfmt(fmt);
        bprm->recursion_depth--;
        // ...
    }
    return retval;
}

/*
* This structure defines the functions that are used to load the binary formats that
* linux accepts.
*/
struct linux_binfmt {
    struct list_head lh; //单链表表头
    struct module *module;
    int (*load_binary)(struct linux_binprm *);
    int (*load_shlib)(struct file *);
    int (*core_dump)(struct coredump_params *cprm);
    unsigned long min_coredump; /* minimal dump size */
};

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);

    // 如果是动态链接
    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;
    // 
}

void
start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
{
    set_user_gs(regs, 0); // 将用户态的寄存器清空
    regs->fs        = 0;
    regs->ds        = __USER_DS;
    regs->es        = __USER_DS;
    regs->ss        = __USER_DS;
    regs->cs        = __USER_CS;
    regs->ip        = new_ip; // 新进程的运行位置- 动态链接程序的入口处
    regs->sp        = new_sp; // 用户态的栈顶
    regs->flags     = X86_EFLAGS_IF;

    set_thread_flag(TIF_NOTIFY_RESUME);
}