linux内核实验八理解进程调度时机

郑斌《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

理解进程调度时机

中断处理过程（包括时钟中断、I/O中断、系统调用和异常）中，直接调用schedule()，或者返回用户态时根据need_resched标记调用schedule()；
内核线程可以直接调用schedule()进行进程切换，也可以在中断处理过程中进行调度，也就是说内核线程作为一类的特殊的进程可以主动调度，也可以被动调度；
用户态进程无法实现主动调度，仅能通过陷入内核态后的某个时机点进行调度，即在中断处理过程中进行调度。

进程的切换

为了控制进程的执行，内核必须有能力挂起正在CPU上执行的进程，并恢复以前挂起的某个进程的执行，这叫做进程切换、任务切换、上下文切换；
挂起正在CPU上执行的进程，与中断时保存现场是不同的，中断前后是在同一个进程上下文中，只是由用户态转向内核态执行；
进程上下文包含了进程执行需要的所有信息

用户地址空间：包括程序代码，数据，用户堆栈等
控制信息：进程描述符，内核堆栈等
硬件上下文（注意中断也要保存硬件上下文只是保存的方法不同）

进程调度过程函数的分析

先是执行schedul（）函数

asmlinkage __visible void __sched schedule(void)
{
    struct task_struct *tsk = current;

    sched_submit_work(tsk);
    __schedule();
}

在schedul函数中，创建一个任务结构体，先通过sched_submit_work(tsk)函数查看调度该任务是否会发生死锁。

然后执行系统调用__schedule()函数。

下面来查看__schedule()函数

static void __sched __schedule(void)
2771{
2772    struct task_struct *prev, *next;
2773    unsigned long *switch_count;
2774    struct rq *rq;
2775    int cpu;
2776
2777need_resched:
2778    preempt_disable();
2779    cpu = smp_processor_id();
2780    rq = cpu_rq(cpu);
2781    rcu_note_context_switch(cpu);
2782    prev = rq->curr;
2783
2784    schedule_debug(prev);
2785
2786    if (sched_feat(HRTICK))
2787        hrtick_clear(rq);
2788
2789    /*
2790     * Make sure that signal_pending_state()->signal_pending() below
2791     * can't be reordered with __set_current_state(TASK_INTERRUPTIBLE)
2792     * done by the caller to avoid the race with signal_wake_up().
2793     */
2794    smp_mb__before_spinlock();
2795    raw_spin_lock_irq(&rq->lock);
2796
2797    switch_count = &prev->nivcsw;
2798    if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
2799        if (unlikely(signal_pending_state(prev->state, prev))) {
2800            prev->state = TASK_RUNNING;
2801        } else {
2802            deactivate_task(rq, prev, DEQUEUE_SLEEP);
2803            prev->on_rq = 0;
2804
2805            /*
2806             * If a worker went to sleep, notify and ask workqueue
2807             * whether it wants to wake up a task to maintain
2808             * concurrency.
2809             */
2810            if (prev->flags & PF_WQ_WORKER) {
2811                struct task_struct *to_wakeup;
2812
2813                to_wakeup = wq_worker_sleeping(prev, cpu);
2814                if (to_wakeup)
2815                    try_to_wake_up_local(to_wakeup);
2816            }
2817        }
2818        switch_count = &prev->nvcsw;
2819    }

调度函数选择一个新的进程来运行，并调用context_switch进行上下文的切换，这个宏调用switch_to来进行关键上下文切换。

next = pick_next_task(rq, prev);//进程调度算法都封装这个函数内部

context_switch(rq, prev, next);//进程上下文切换

switch_to利用了prev和next两个参数：prev指向当前进程，next指向被调度的进程，进行了两个进程间寄存器等相关信息的切换。

#define switch_to(prev, next, last)                    \
32do {                                    \
33    /*                                \
34     * Context-switching clobbers all registers, so we clobber    \
35     * them explicitly, via unused output variables.        \
36     * (EAX and EBP is not listed because EBP is saved/restored    \
37     * explicitly for wchan access and EAX is the return value of    \
38     * __switch_to())                        \
39     */                                \
40    unsigned long ebx, ecx, edx, esi, edi;                \
41                                    \
42    asm volatile("pushfl\n\t"        /* save    flags */    \
43             "pushl %%ebp\n\t"        /* save    EBP   */    \
44             "movl %%esp,%[prev_sp]\n\t"    /* save    ESP   */ \
45             "movl %[next_sp],%%esp\n\t"    /* restore ESP   */ \
46             "movl $1f,%[prev_ip]\n\t"    /* save    EIP   */    \
47             "pushl %[next_ip]\n\t"    /* restore EIP   */    \
48             __switch_canary                    \
49             "jmp __switch_to\n"    /* regparm call  */    \
50             "1:\t"                        \
51             "popl %%ebp\n\t"        /* restore EBP   */    \
52             "popfl\n"            /* restore flags */    \
53                                    \
54             /* output parameters */                \
55             : [prev_sp] "=m" (prev->thread.sp),        \
56               [prev_ip] "=m" (prev->thread.ip),        \
57               "=a" (last),                    \
58                                    \
59               /* clobbered output registers: */        \
60               "=b" (ebx), "=c" (ecx), "=d" (edx),        \
61               "=S" (esi), "=D" (edi)                \
62                                           \
63               __switch_canary_oparam                \
64                                    \
65               /* input parameters: */                \
66             : [next_sp]  "m" (next->thread.sp),        \
67               [next_ip]  "m" (next->thread.ip),        \
68                                           \
69               /* regparm parameters for __switch_to(): */    \
70               [prev]     "a" (prev),                \
71               [next]     "d" (next)                \
72                                    \
73               __switch_canary_iparam                \
74                                    \
75             : /* reloaded segment registers */            \
76            "memory");                    \
77} while (0)