结合中断上下文切换和进程上下文切换分析Linux内核的一般执行过程

1. 实验目的

• 以fork和execve系统调用为例分析中断上下文的切换
• 分析execve系统调用中断上下文的特殊之处
• 分析fork子进程启动执行时进程上下文的特殊之处
• 以系统调用作为特殊的中断，结合中断上下文切换和进程上下文切换分析Linux系统的一般执行过程

2. fork系统调用

查看do_fork的代码：

long _do_fork(struct kernel_clone_args *args)
{
    u64 clone_flags = args->flags;
    struct completion vfork;
    struct pid *pid;
    struct task_struct *p;
    int trace = 0;
    long nr;

    /*
     * Determine whether and which event to report to ptracer.  When
     * called from kernel_thread or CLONE_UNTRACED is explicitly
     * requested, no event is reported; otherwise, report if the event
     * for the type of forking is enabled.
     */
    if (!(clone_flags & CLONE_UNTRACED)) {
        if (clone_flags & CLONE_VFORK)
            trace = PTRACE_EVENT_VFORK;
        else if (args->exit_signal != SIGCHLD)
            trace = PTRACE_EVENT_CLONE;
        else
            trace = PTRACE_EVENT_FORK;

        if (likely(!ptrace_event_enabled(current, trace)))
            trace = 0;
    }
    p = copy_process(NULL, trace, NUMA_NO_NODE, args);
    add_latent_entropy();

    if (IS_ERR(p))
        return PTR_ERR(p);

    /*
     * Do this prior waking up the new thread - the thread pointer
     * might get invalid after that point, if the thread exits quickly.
     */
    trace_sched_process_fork(current, p);
    pid = get_task_pid(p, PIDTYPE_PID);
    nr = pid_vnr(pid);

    if (clone_flags & CLONE_PARENT_SETTID)
        put_user(nr, args->parent_tid);
    if (clone_flags & CLONE_VFORK) {
        p->vfork_done = &vfork;
        init_completion(&vfork);
        get_task_struct(p);
    }
    wake_up_new_task(p);

    /* forking complete and child started to run, tell ptracer */
    if (unlikely(trace))
        ptrace_event_pid(trace, pid);
    if (clone_flags & CLONE_VFORK) {
        if (!wait_for_vfork_done(p, &vfork))
            ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
    }

    put_pid(pid);
    return nr;
}

fork系统调用定义是依赖于体系结构的, 因为在用户空间和内核空间之间传递参数的方法因体系结构而异，但他们都调用体系结构无关的_do_fork（或者早期的do_fork）函数, 负责进程的复制。_do_fork以调用copy_process开始, 后者执行生成新的进程的实际工作, 并根据指定的标志复制父进程的数据。在子进程生成后, 内核必须执行一些收尾操作,如复制进程信息，子进程加入调度器等。调用fork之后，数据、堆、栈有两份，代码仍然为一份但是这个代码段成为两个进程的共享代码段都从fork函数中返回。fork给父进程返回子进程pid，给其拷贝出来的子进程返回0，这也是他的特点之一，一次调用，两次返回，所以与一般的系统调用处理流程也必定不同。

3. execve系统调用

系统调用execve的内核入口为sys_execve：

asmlinkage int sys_execve(struct pt_regs regs)
    {
        int error;
        char * filename;
    
        filename = getname((char *) regs.ebx);
        error = PTR_ERR(filename);
        if (IS_ERR(filename))
            goto out;
        error = do_execve(filename, (char **) regs.ecx, (char **) regs.edx, &regs);
        if (error == 0)
            current->ptrace &= ~PT_DTRACE;
        putname(filename);
    out:
        return error;
    }

execve() 系统调用的作用是运行另外一个指定的程序。它会把新程序加载到当前进程的内存空间内，当前的进程会被丢弃，它的堆、栈和所有的段数据都会被新进程相应的部分代替，然后会从新程序的初始化代码和 main 函数开始运行。同时，进程的 ID 将保持不变。

execve() 系统调用通常与 fork() 系统调用配合使用。从一个进程中启动另一个程序时，通常是先 fork() 一个子进程，然后在子进程中使用 execve() 变身为运行指定程序的进程。 例如，当用户在 Shell 下输入一条命令启动指定程序时，Shell 就是先 fork() 了自身进程，然后在子进程中使用 execve() 来运行指定的程序。

execve的主要作用为：
1.分配进程新的地址空间，将环境变量、main参数等拷贝到新地址空间的推栈中；
2.解析可执行文件，将代码、数据装入/映射到内存
3.进程新环境的设置，如关闭设置FD_CLOEXEC的文件等
4.设置execve函数返回到用户态时的执行地址；解析器入口地址或程序的入口地址

execve系统调用是通过do_execve实现的，其处理流程如下：
1.进程分配并使用自己的文件描述符表，不再使用共享的文件描述符表
2.分配进程新的地址空间mm_struct，并复制老mm_struct的context，并分配一页大小的堆栈内存区。
3.打开可执行文件；检查可执行文件权限，并预读可执行文件的前BINPRM_BUF_SIZE=128字节数据到buf中
4.计算环境变量、main参数个数；并将这些参数复制到新地址空间的堆栈中
5.根据可执行文件的格式，查找对应的handler作后续处理；

4. 总结

Linux系统的一般执行过程，例如正在运行的用户态进程X切换到运行用户态进程Y的过程：

（1）正在运行的用户态进程X

（2）发生中断——save cs:eip/esp/eflags(current) to kernel stack,then load cs:eip(entry of a specific ISR) and ss:esp(point to kernel stack).

（3）SAVE_ALL //保存现场

（4）中断处理过程中或中断返回前调用了schedule()，其中的switch_to做了关键的进程上下文切换

（5）标号1之后开始运行用户态进程Y(这里Y曾经通过以上步骤被切换出去过因此可以从标号1继续执行)

（6）restore_all //恢复现场

（7）iret - pop cs:eip/ss:esp/eflags from kernel stack

（8）继续运行用户态进程Y

系统调用可以视为一种特殊的中断，老的32位linux就是采用int 0x80中断指令进入内核，因此自然涉及中断上下文，也就是切换到用户内核栈，同时保存相关的寄存器使得中断结束后能够正常返回。

而fork系统调用特殊之处在于他创建了一个新的进程，且有两次返回。对于fork的父进程来说，fork系统调用和普通的系统调用并无两样。但是对fork子进程来说，需要设置子进程的进程上下文环境，这样子进程才能从fork系统调用后返回。

而对于execve而言，由于execve使得新加载可执⾏程序已经覆盖了原来⽗进程的上下⽂环境，而原来的中断上下文就是保存的是原来的、被覆盖的进程的上下文，因此需要修改原来的中断上下文，使得系统调用返回后能够指向现在加载的这个可执行程序的入口，比如main函数的地址（静态链接下）。