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

一.进程上下文和中断上下文

　　进程上下文指的是一个进程在执行的时候，CPU的所有寄存器中的值、进程的状态以及堆栈上的内容，当内核需要切换到另一个进程时，它需要保存当前进程的所有状态，即保存当前进程的进程上下文，以便再次执行该进程时，能够恢复切换时的状态，继续执行。

　　中断上下文是硬件通过触发信号，向CPU发送中断信号，导致内核调用中断处理程序，进入内核空间。这个过程中，硬件的一些变量和参数也要传递给内核，内核通过这些参数进行中断处理。中断处理的过程中，并不会涉及到虚拟内存等进程用户态的资源，也不会切换进程。中断上下文切换并不涉及到进程的用户态。所以，即便中断过程打断了一个正处在用户态的进程，也不需要保存和恢复这个进程的虚拟内存、全局变量等用户态资源。中断上下文，其实只包括内核态中断服务程序执行所必需的状态，包括 CPU 寄存器、内核堆栈、硬件中断参数等。因为中断处理借用的是当前被中断进程的内核栈来执行。

二.fork系统调用的上下文切换

fork函数内部执行的是do_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;
}

28行 copy_process函数会copy父进程的一些资源

关键代码

p = dup_task_struct(current, node);
retval = sched_fork(clone_flags, p);

if (retval)
        goto bad_fork_cleanup_audit;
    retval = copy_semundo(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_security;
    retval = copy_files(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_semundo;
    retval = copy_fs(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_files;
    retval = copy_sighand(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_fs;
    retval = copy_signal(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_sighand;
    retval = copy_mm(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_signal;
    retval = copy_namespaces(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_mm;
    retval = copy_io(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_namespaces;
    retval = copy_thread_tls(clone_flags, args->stack, args->stack_size, p,
                 args->tls);

if (pid != &init_struct_pid) {
        pid = alloc_pid(p->nsproxy->pid_ns_for_children);
        if (IS_ERR(pid)) {
            retval = PTR_ERR(pid);
            goto bad_fork_cleanup_thread;
        }
    }

执行dup_task_struct()，拷贝当前进程task_struct
检查进程数是否超过系统所允许的上限(默认32678)
执行sched_fork()，设置调度器相关信息，设置task进程状态为TASK_RUNNING，并分配CPU资源
执行copy_xxx()，拷贝进程的files, fs, mm, io, sighand, signal等信息
1. 　　
  - copy_semundo: 当设置CLONE_SYSVSEM，则父子进程间共享SEM_UNDO状态
  - copy_files: 当设置CLONE_FILES，则只增加文件引用计数，不创建新的files_struct
  - copy_fs: 当设置CLONE_FS，且没有执行exec, 则设置用户数加1
  - copy_sighand: 当设置CLONE_SIGHAND, 则增加sighand->count计数
  - copy_signal: 拷贝进程信号
  - copy_mm：当设置CLONE_VM，则增加mm_users计数
  - copy_namespaces：一般情况，不需要创建新用户空间
  - copy_io：当设置CLONE_IO，则父子进程间共享io context，增加nr_tasks计数
  - copy_thread_tls：设置子进程的寄存器等信息，从父进程拷贝thread_struct的sp0，sp,io_bitmap_ptr等成员变量值
执行copy_thread_tls(), 拷贝子进程的内核栈信息
执行alloc_pid()，为新进程分配新pid

三.execve系统调用

execve() 系统调用的作用是运行另外一个指定的程序。它会把新程序加载到当前进程的内存空间内，当前的进程会被丢弃，它的堆、栈和所有的段数据都会被新进程相应的部分代替，然后会从新程序的初始化代码和 main 函数开始运行。同时，进程的 ID 将保持不变。execve() 系统调用通常与 fork() 系统调用配合使用。从一个进程中启动另一个程序时，通常是先 fork() 一个子进程，然后在子进程中使用 execve() 变身为运行指定程序的进程。例如，当用户在 Shell 下输入一条命令启动指定程序时，Shell 就是先 fork() 了自身进程，然后在子进程中使用 execve() 来运行指定的程序。

代码如下：

static int do_execve_common(struct filename *filename,struct user_arg_ptr argv,struct user_arg_ptr envp)
{
    struct linux_binprm *bprm;  
    struct file *file;
    struct files_struct *displaced;
    int retval;
    current->flags &= ~PF_NPROC_EXCEEDED;  
    retval = unshare_files(&displaced);  
    bprm = kzalloc(sizeof(*bprm), GFP_KERNEL);
    retval = prepare_bprm_creds(bprm);   
    check_unsafe_exec(bprm);             
    current->in_execve = 1;
    file = do_open_exec(filename);       
    sched_exec();
    bprm->file = file;
    bprm->filename = bprm->interp = filename->name;
    retval = bprm_mm_init(bprm);       
    bprm->argc = count(argv, MAX_ARG_STRINGS);
    bprm->envc = count(envp, MAX_ARG_STRINGS);
    retval = prepare_binprm(bprm);     
    retval = copy_strings_kernel(1, &bprm->filename, bprm);
    bprm->exec = bprm->p;
    retval = copy_strings(bprm->envc, envp, bprm);
    retval = copy_strings(bprm->argc, argv, bprm);
    
    <strong>retval = exec_binprm(bprm);</strong>
    
    current->fs->in_exec = 0;
    current->in_execve = 0;
    acct_update_integrals(current);
    task_numa_free(current);
    free_bprm(bprm);
    putname(filename);
    if (displaced)
        put_files_struct(displaced);
    return retval;
}

execve具体的调用过程为：

1.陷入内核

2.加载新的进程，并且将新的进程覆盖原进程的空间

3.将新的进程的入口地址设置为IP值

4.切换回用户态，继续执行原来的进程。

四.总结

中断上下文的一般处理过程

swapgs指令保存现场，可以理解CPU通过swapgs指令给当前CPU寄存器状态做了一个快照。

rsp point to kernel stack，加载当前进程内核堆栈栈顶地址到RSP寄存器。快速系统调用是由系统调用入口处的汇编代码实现用户堆栈和内核堆栈的切换。
save cs:rip/ss:rsp/rflags:将当前CPU关键上下文压入进程X的内核堆栈，快速系统调用是由系统调用入口处的汇编代码实现的。

此时完成了中断上下文切换，即从进程X的用户态到进程X的内核态。

进程上下文的一般处理过程

每个进程切换基本由两个步骤组成。
• 切换⻚全局目录(CR3)以安装一个新的地址空间，这样不同进程的虚拟地

　　址如0x8048400(32位x86)就会经过不同的⻚表转换为不同的物理地址。

进程切换

• 切换内核态堆栈和进程的CPU上下文，因为进程的CPU上下文提供了内核执

　　行新进程所需要的所有信息，包含所有CPU寄存器状态

posted @ 2020-06-14 23:06 sunanacc 阅读(226) 评论(0) 收藏举报

刷新页面返回顶部

sunanacc

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

一.进程上下文和中断上下文

二.fork系统调用的上下文切换

三.execve系统调用

四.总结

公告