Linux内核之进程调度

等待队列

Sleep相关函数将进程的状态设置为非运行态，在下一次调度来时，将在schedule函数中将本进程从运行队列中移除。sleep函数将进程加入等待队列，然后调用schedule函数选择并重新开始另一个程序的执行。当调用wake_up类函数将进程唤醒时，wake_up类函数将进程加入运行队列中，调度程序重新从sleep函数中下一条没有执行的指令开始执行。

sleep类函数都调用sleep_on_common函数实现，只是传入的参数有别。

1. static long __sched  


2. sleep_on_common(wait_queue_head_t *q, int state, long timeout)  


3. {  


4.     unsigned long flags;  


5.     wait_queue_t wait;  


6.     /*初始化等待队列*/  


7.     init_waitqueue_entry(&wait, current);  


8.     /*设置当前进程状态*/  


9.     __set_current_state(state);  


10.       


11.     spin_lock_irqsave(&q->lock, flags);  


12.     __add_wait_queue(q, &wait);/*加入等待队列中*/  


13.     spin_unlock(&q->lock);  


14.     /*sleep until timeout,在本进程睡眠的过程中会调用别的进程运行*/  


15.     timeout = schedule_timeout(timeout);  


16.     spin_lock_irq(&q->lock);  


17.     /*当本进程被唤醒时，从这里继续开始运行 


18.     也就是将该进程从等待队列中移除*/  


19.     __remove_wait_queue(q, &wait);  


20.     spin_unlock_irqrestore(&q->lock, flags);  


21.   


22.     return timeout;  


23. }  

1. static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)  


2. {  


3.     q->flags = 0;  


4.     q->private = p;/*将进程保存为队列私有属性*/  


5.     q->func = default_wake_function;/*设定为缺省的唤醒函数*/  


6. }  

我们看唤醒函数，default_wake_function最终调用函数try_to_wake_up

1. /*** 


2.  * try_to_wake_up – wake up a thread 


3.  * @p: the to-be-woken-up thread 


4.  * @state: the mask of task states that can be woken 


5.  * @sync: do a synchronous wakeup? 


6.  * 


7.  * Put it on the run-queue if it’s not already there. The “current” 


8.  * thread is always on the run-queue (except when the actual 


9.  * re-schedule is in progress), and as such you’re allowed to do 


10.  * the simpler “current->state = TASK_RUNNING” to mark yourself 


11.  * runnable without the overhead of this. 


12.  * 


13.  * returns failure only if the task is already active. 


14.  */  


15. static int try_to_wake_up(struct task_struct *p, unsigned int state,  


16.               int wake_flags)  


17. {  


18.     int cpu, orig_cpu, this_cpu, success = 0;  


19.     unsigned long flags;  


20.     struct rq *rq, *orig_rq;  


21.   


22.     if (!sched_feat(SYNC_WAKEUPS))  


23.         wake_flags &= ~WF_SYNC;/* waker not goes to sleep after wakup */  


24.   


25.     this_cpu = get_cpu();/*cpu id*/  


26.   


27.     smp_wmb();  


28.     rq = orig_rq = task_rq_lock(p, &flags);/*获得进程的rq*/  


29.     update_rq_clock(rq);/*更新rq的时钟*/  


30.     if (!(p->state & state))  


31.         goto out;  


32.   


33.     if (p->se.on_rq)/*如果进程已经在运行队列中*/  


34.         goto out_running;  


35.   


36.     cpu = task_cpu(p);/*返回进程对应的cpu*/  


37.     orig_cpu = cpu;  


38.   


39. #ifdef CONFIG_SMP   


40.     if (unlikely(task_running(rq, p)))/*如果当前进程时p，也就是waker*/  


41.         goto out_activate;  


42.   


43.     /* 


44.      * In order to handle concurrent wakeups and release the rq->lock 


45.      * we put the task in TASK_WAKING state. 


46.      * 


47.      * First fix up the nr_uninterruptible count: 


48.      */  


49.     if (task_contributes_to_load(p))  


50.         rq->nr_uninterruptible–;  


51.     p->state = TASK_WAKING;  


52.     task_rq_unlock(rq, &flags);  


53.     /*通常用在執行一個新的程序,或是WakeUp 


54.     一個Task時,會根據目前SMP下每個處理器的 


55.     負荷,決定Task是否要切換到另一個處理器 


56.     的RunQueue去執行,執行時會返回最後目標 


57.     處理器的值.*/  


58.     cpu = p->sched_class->select_task_rq(p, SD_BALANCE_WAKE, wake_flags);  


59.     if (cpu != orig_cpu)  


60.         set_task_cpu(p, cpu);/*设置task在制定的cpu上运行*/  


61.   


62.     rq = task_rq_lock(p, &flags);/*task对应的rq*/  


63.   


64.     if (rq != orig_rq)  


65.         update_rq_clock(rq);/*更新clock*/  


66.   


67.     WARN_ON(p->state != TASK_WAKING);  


68.     cpu = task_cpu(p);  


69.   


70. #ifdef CONFIG_SCHEDSTATS/*yes*/   


71.     schedstat_inc(rq, ttwu_count);/*Wake Up Task的次數加一.*/  


72.     if (cpu == this_cpu)  


73.         /*Wake Up 同一個處理器Task的次數加一.*/  


74.         schedstat_inc(rq, ttwu_local);  


75.     else {  


76.         struct sched_domain *sd;  


77.         for_each_domain(this_cpu, sd) {  


78.             if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {  


79.                 schedstat_inc(sd, ttwu_wake_remote);  


80.                 break;  


81.             }  


82.         }  


83.     }  


84. #endif /* CONFIG_SCHEDSTATS */   


85.   


86. out_activate:  


87. #endif /* CONFIG_SMP */   


88.     /*下面为设置相关计数变量*/  


89.     schedstat_inc(rq, field)(p, se.nr_wakeups);  


90.     if (wake_flags & WF_SYNC)  


91.         schedstat_inc(p, se.nr_wakeups_sync);  


92.     if (orig_cpu != cpu)  


93.         schedstat_inc(p, se.nr_wakeups_migrate);  


94.     if (cpu == this_cpu)  


95.         schedstat_inc(p, se.nr_wakeups_local);  


96.     else  


97.         schedstat_inc(p, se.nr_wakeups_remote);  


98.     /*将进程移动到对应调度类的运行队列*/  


99.     activate_task(rq, p, 1);  


100.     success = 1;  


101.   


102.     /* 


103.      * Only attribute actual wakeups done by this task. 


104.      */  


105.     if (!in_interrupt()) {/*下面为对se中变量last_wakeup和 


106.                         avg_wakeup的更新*/  


107.         struct sched_entity *se = ¤t->se;  


108.         u64 sample = se->sum_exec_runtime;  


109.   


110.         if (se->last_wakeup)  


111.             sample -= se->last_wakeup;  


112.         else  


113.             sample -= se->start_runtime;  


114.         update_avg(&se->avg_wakeup, sample);  


115.   


116.         se->last_wakeup = se->sum_exec_runtime;  


117.     }  


118.   


119. out_running:  


120.     trace_sched_wakeup(rq, p, success);  


121.       


122.     /*用以決定一個Task是否可以中斷目前正在 


123.     運作的Task,取得執行權.*/  


124.     check_preempt_curr(rq, p, wake_flags);  


125.   


126.     p->state = TASK_RUNNING;  


127. #ifdef CONFIG_SMP   


128.     if (p->sched_class->task_wake_up)  


129.         p->sched_class->task_wake_up(rq, p);  


130.   


131.     if (unlikely(rq->idle_stamp)) {/*该值可用以表示這個 


132.                             處理器是何時進入到Idle的 


133.                             狀態，在这里得到更新*/  


134.         u64 delta = rq->clock – rq->idle_stamp;  


135.         u64 max = 2*sysctl_sched_migration_cost;  


136.   


137.         if (delta > max)  


138.             rq->avg_idle = max;  


139.         else/*avg_idle可反應目前處理器進入Idle狀態的時間長短*/  


140.             update_avg(&rq->avg_idle, delta);  


141.         rq->idle_stamp = 0;  


142.     }  


143. #endif   


144. out:  


145.     task_rq_unlock(rq, &flags);  


146.     put_cpu();  


147.   


148.     return success;  


149. }  

所有的wake_up类函数都最终调用__wake_up_common函数实现

1. static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,  


2.             int nr_exclusive, int wake_flags, void *key)  


3. {  


4.     wait_queue_t *curr, *next;  


5.   


6.     list_for_each_entry_safe(curr, next, &q->task_list, task_list) {  


7.         unsigned flags = curr->flags;  


8.   


9.         if (curr->func(curr, mode, wake_flags, key) &&/*在这里会调用上面注册的try_to_wake_up函数*/  


10.                 (flags & WQ_FLAG_EXCLUSIVE) && !–nr_exclusive)  


11.             break;  


12.     }  


13. }  

wait_event方式

考虑到sleep_on类函数在以下条件中不能使用，那就是必须测试条件并且当条件还没哟得到验证时又紧接着让进城去睡眠；为实现这样的功能，内核采用wait_event的方式实现。

1. #define __wait_event(wq, condition)                     \   


2. do {                                    \  


3.     DEFINE_WAIT(__wait);                        \  


4.                                     \  


5.     for (;;) {  /*加入等待队列，设置进程状态*/       \  


6.         prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);    \  


7.         if (condition)                      \  


8.             break;                      \  


9.         schedule();/*调用其他进程运行*/             \  


10.     }/*当进程被唤醒时继续如下执行*/              \  


11.     finish_wait(&wq, &__wait);                  \  


12. } while (0)  

当下一次调度到来时，调度程序把设置为非运行的当前进程从运行队列里面删除，而进程被wake_up类函数唤醒时，wake_up类函数将其加入运行队列，继续执行上面没有执行完成的wait_event函数（执行finish_wait函数），finish_wait函数将其从等待队列中删除。

 sched_info_switch(prev, next);主要是更新切换出去和进来进程以及对应rq的相关变量。该函数主要调用__sched_info_switch函数来实现。

1. /* 


2.  * Called when tasks are switched involuntarily due, typically, to expiring 


3.  * their time slice.  (This may also be called when switching to or from 


4.  * the idle task.)  We are only called when prev != next. 


5.  */  


6. static inline void  


7. __sched_info_switch(struct task_struct *prev, struct task_struct *next)  


8. {  


9.     struct rq *rq = task_rq(prev);  


10.   


11.     /* 


12.      * prev now departs the cpu.  It’s not interesting to record 


13.      * stats about how efficient we were at scheduling the idle 


14.      * process, however. 


15.      */  


16.     if (prev != rq->idle)/*如果被切换出去的进程不是idle进程*/  


17.         sched_info_depart(prev);/*更新prev进程和他对应rq的相关变量*/  


18.   


19.     if (next != rq->idle)/*如果切换进来的进程不是idle进程*/  


20.         sched_info_arrive(next);/*更新next进程和对应队列的相关变量*/  


21. }  

1. /* 


2.  * Called when a process ceases being the active-running process, either 


3.  * voluntarily or involuntarily.  Now we can calculate how long we ran. 


4.  * Also, if the process is still in the TASK_RUNNING state, call 


5.  * sched_info_queued() to mark that it has now again started waiting on 


6.  * the runqueue. 


7.  */  


8. static inline void sched_info_depart(struct task_struct *t)  


9. {  


10.     /*计算在进程在rq中运行的时间长度*/  


11.     unsigned long long delta = task_rq(t)->clock –  


12.                     t->sched_info.last_arrival;  


13.     /*更新RunQueue中的Task所得到CPU執行 


14.     時間的累加值.*/  


15.     rq_sched_info_depart(task_rq(t), delta);  


16.       


17.     /*如果被切换出去进程的状态是运行状态 


18.     那么将进程sched_info.last_queued设置为rq的clock 


19.     last_queued为最后一次排队等待运行的时间*/  


20.     if (t->state == TASK_RUNNING)  


21.         sched_info_queued(t);  


22. }  

1. /* 


2.  * Called when a task finally hits the cpu.  We can now calculate how 


3.  * long it was waiting to run.  We also note when it began so that we 


4.  * can keep stats on how long its timeslice is. 


5.  */  


6. static void sched_info_arrive(struct task_struct *t)  


7. {  


8.     unsigned long long now = task_rq(t)->clock, delta = 0;  


9.   


10.     if (t->sched_info.last_queued)/*如果被切换进来前在运行进程中排队*/  


11.         delta = now – t->sched_info.last_queued;/*计算排队等待的时间长度*/  


12.     sched_info_reset_dequeued(t);/*因为进程将被切换进来运行，设定last_queued为0*/  


13.     t->sched_info.run_delay += delta;/*更新进程在运行队列里面等待的时间*/  


14.     t->sched_info.last_arrival = now;/*更新最后一次运行的时间*/  


15.     t->sched_info.pcount++;/*cpu上运行的次数加一*/  


16.     /*更新rq中rq_sched_info中的对应的变量*/  


17.     rq_sched_info_arrive(task_rq(t), delta);  


18. }  

context_switch函数完成主要的硬件、寄存器等实际的切换工作。

1. /* 


2.  * context_switch – switch to the new MM and the new 


3.  * thread’s register state. 


4.  */  


5. static inline void  


6. context_switch(struct rq *rq, struct task_struct *prev,  


7.            struct task_struct *next)  


8. {  


9.     struct mm_struct *mm, *oldmm;  


10.   


11.     prepare_task_switch(rq, prev, next);  


12.     trace_sched_switch(rq, prev, next);  


13.     mm = next->mm;  


14.     oldmm = prev->active_mm;  


15.     /* 


16.      * For paravirt, this is coupled with an exit in switch_to to 


17.      * combine the page table reload and the switch backend into 


18.      * one hypercall. 


19.      */  


20.     arch_start_context_switch(prev);  


21.   


22.     if (unlikely(!mm)) {/*如果被切换进来的进程的mm为空*/  


23.         next->active_mm = oldmm;/*将共享切换出去进程的active_mm*/  


24.         atomic_inc(&oldmm->mm_count);/*有一个进程共享，所有引用计数加一*/  


25.         /*将per cpu变量cpu_tlbstate状态设为LAZY*/  


26.         enter_lazy_tlb(oldmm, next);  


27.     } else/*如果mm不会空，那么进行mm切换*/  


28.         switch_mm(oldmm, mm, next);  


29.   


30.     if (unlikely(!prev->mm)) {/*如果切换出去的mm为空，从上面 


31.     可以看出本进程的active_mm为共享先前切换出去的进程 


32.     的active_mm,所有需要在这里置空*/  


33.         prev->active_mm = NULL;  


34.         rq->prev_mm = oldmm; /*更新rq的前一个mm结构*/  


35.     }  


36.     /* 


37.      * Since the runqueue lock will be released by the next 


38.      * task (which is an invalid locking op but in the case 


39.      * of the scheduler it’s an obvious special-case), so we 


40.      * do an early lockdep release here: 


41.      */  


42. #ifndef __ARCH_WANT_UNLOCKED_CTXSW   


43.     spin_release(&rq->lock.dep_map, 1, _THIS_IP_);  


44. #endif   


45.   


46.     /* Here we just switch the register state and the stack. */  


47.     switch_to(prev, next, prev);  


48.   


49.     barrier();  


50.     /* 


51.      * this_rq must be evaluated again because prev may have moved 


52.      * CPUs since it called schedule(), thus the ‘rq’ on its stack 


53.      * frame will be invalid. 


54.      */  


55.     finish_task_switch(this_rq(), prev);  


56. }  

1. static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,  


2.                  struct task_struct *tsk)  


3. {  


4.     unsigned cpu = smp_processor_id();  


5.   


6.     if (likely(prev != next)) {  


7.         /* stop flush ipis for the previous mm */  


8.         /*将被替换进程使用的内存描述结构的CPU 


9.         掩码中当前处理器号对应的位码清0*/  


10.         cpumask_clear_cpu(cpu, mm_cpumask(prev));  


11. #ifdef CONFIG_SMP   


12.         /*设置per cpu变量tlb*/  


13.         percpu_write(cpu_tlbstate.state, TLBSTATE_OK);  


14.         percpu_write(cpu_tlbstate.active_mm, next);  


15. #endif   


16.         /*将要被调度运行进程拥有的内存描述结构 


17.         的CPU掩码中当前处理器号对应的位码设置为1*/  


18.         cpumask_set_cpu(cpu, mm_cpumask(next));  


19.   


20.         /* Re-load page tables */  


21.         load_cr3(next->pgd);/*将切换进来进程的pgd load到cr3寄存器*/  


22.   


23.         /* 


24.          * load the LDT, if the LDT is different: 


25.          */  


26.         if (unlikely(prev->context.ldt != next->context.ldt))  


27.             load_LDT_nolock(&next->context);  


28.     }  


29. #ifdef CONFIG_SMP   


30.     else {/*如果切换的两个进程相同*/  


31.         percpu_write(cpu_tlbstate.state, TLBSTATE_OK);  


32.         BUG_ON(percpu_read(cpu_tlbstate.active_mm) != next);  


33.   


34.         if (!cpumask_test_and_set_cpu(cpu, mm_cpumask(next))) {  


35.             /* We were in lazy tlb mode and leave_mm disabled 


36.              * tlb flush IPI delivery. We must reload CR3 


37.              * to make sure to use no freed page tables. 


38.              */  


39.             load_cr3(next->pgd);  


40.             load_LDT_nolock(&next->context);  


41.         }  


42.     }  


43. #endif   


44. }  

具体寄存器相关的切换由函数switch_to完成，改函数用汇编代码保持各种寄存器的值，然后调用c函数__switch_to,

汇编中实现了具体的切换：

1. /* 


2.  * Saving eflags is important. It switches not only IOPL between tasks, 


3.  * it also protects other tasks from NT leaking through sysenter etc. 


4.  */  


5. #define switch_to(prev, next, last)                 \   


6. do {                                    \  


7.     /*                              \ 


8.      * Context-switching clobbers all registers, so we clobber  \ 


9.      * them explicitly, via unused output variables.        \ 


10.      * (EAX and EBP is not listed because EBP is saved/restored \ 


11.      * explicitly for wchan access and EAX is the return value of   \ 


12.      * __switch_to())                       \ 


13.      */                             \  


14.     unsigned long ebx, ecx, edx, esi, edi;              \  


15.                                     \  


16.     asm volatile(“pushfl\n\t”       /* save    flags */ \  


17.              “pushl %%ebp\n\t”      /* save    EBP   */ \  


18.              “movl %%esp,%[prev_sp]\n\t”    /* save    ESP   */ \  


19.              “movl %[next_sp],%%esp\n\t”    /* restore ESP   */ \  


20.              “movl $1f,%[prev_ip]\n\t”  /* save    EIP   */ \  


21.         /*将next_ip入栈，下面用jmp跳转，这样 


22.         返回到标号1时就切换过来了*/  


23.              “pushl %[next_ip]\n\t” /* restore EIP   */ \  


24.              __switch_canary                    \  


25.              “jmp __switch_to\n”    /* regparm call  */ \  


26.              “1:\t”                     \  


27.              /*切换到新进程的第一条指令*/  


28.              “popl %%ebp\n\t”       /* restore EBP   */ \  


29.              “popfl\n”          /* restore flags */ \  


30.                                     \  


31.              /* output parameters */                \  


32.              : [prev_sp] “=m” (prev->thread.sp),     \  


33.                [prev_ip] “=m” (prev->thread.ip),     \  


34.                “=a” (last),                 \  


35.                                     \  


36.                /* clobbered output registers: */        \  


37.                “=b” (ebx), “=c” (ecx), “=d” (edx),      \  


38.                “=S” (esi), “=D” (edi)               \  


39.                                         \  


40.                __switch_canary_oparam               \  


41.                                     \  


42.                /* input parameters: */              \  


43.              : [next_sp]  “m” (next->thread.sp),     \  


44.                [next_ip]  “m” (next->thread.ip),     \  


45.                                         \  


46.                /* regparm parameters for __switch_to(): */  \  


47.                [prev]     “a” (prev),               \  


48.                [next]     “d” (next)                \  


49.                                     \  


50.                __switch_canary_iparam               \  


51.                                     \  


52.              : /* reloaded segment registers */         \  


53.             “memory”);                  \  


54. } while (0)  

1. /*  


2.  *  switch_to(x,yn) should switch tasks from x to y.  


3.  *  


4.  * We fsave/fwait so that an exception goes off at the right time  


5.  * (as a call from the fsave or fwait in effect) rather than to  


6.  * the wrong process. Lazy FP saving no longer makes any sense  


7.  * with modern CPU’s, and this simplifies a lot of things (SMP  


8.  * and UP become the same).  


9.  *  


10.  * NOTE! We used to use the x86 hardware context switching. The  


11.  * reason for not using it any more becomes apparent when you  


12.  * try to recover gracefully from saved state that is no longer  


13.  * valid (stale segment register values in particular). With the  


14.  * hardware task-switch, there is no way to fix up bad state in  


15.  * a reasonable manner.  


16.  *  


17.  * The fact that Intel documents the hardware task-switching to  


18.  * be slow is a fairly red herring – this code is not noticeably  


19.  * faster. However, there _is_ some room for improvement here,  


20.  * so the performance issues may eventually be a valid point.  


21.  * More important, however, is the fact that this allows us much  


22.  * more flexibility.  


23.  *  


24.  * The return value (in %ax) will be the “prev” task after  


25.  * the task-switch, and shows up in ret_from_fork in entry.S,  


26.  * for example.  


27.  */  


28. __notrace_funcgraph struct task_struct *  


29. __switch_to(struct task_struct *prev_p, struct task_struct *next_p)  


30. {  


31.     struct thread_struct *prev = &prev_p->thread,  


32.                  *next = &next_p->thread;  


33.     int cpu = smp_processor_id();  


34.     struct tss_struct *tss = &per_cpu(init_tss, cpu);/*init_tss为一个per cpu变量*/  


35.     bool preload_fpu;  


36.   


37.     /* never put a printk in __switch_to… printk() calls wake_up*() indirectly */  


38.   


39.     /*  


40.      * If the task has used fpu the last 5 timeslices, just do a full  


41.      * restore of the math state immediately to avoid the trap; the  


42.      * chances of needing FPU soon are obviously high now  


43.      */  


44.     preload_fpu = tsk_used_math(next_p) && next_p->fpu_counter > 5;  


45.     /*保存FPU寄存器*/  


46.     __unlazy_fpu(prev_p);  


47.   


48.     /* we’re going to use this soon, after a few expensive things */  


49.     if (preload_fpu)  


50.         prefetch(next->xstate);  


51.   


52.     /*  


53.      * Reload esp0.  


54.      */  


55.      /*吧next_p->thread.esp0装入对应于本地cpu的tss的esp0  


56.     字段；任何由sysenter汇编指令产生的从用户态  


57.     到内核态的特权级转换将把这个地址拷贝到  


58.     esp寄存器中*/  


59.     load_sp0(tss, next);  


60.   


61.     /*  


62.      * Save away %gs. No need to save %fs, as it was saved on the  


63.      * stack on entry.  No need to save %es and %ds, as those are  


64.      * always kernel segments while inside the kernel.  Doing this  


65.      * before setting the new TLS descriptors avoids the situation  


66.      * where we temporarily have non-reloadable segments in %fs  


67.      * and %gs.  This could be an issue if the NMI handler ever  


68.      * used %fs or %gs (it does not today), or if the kernel is  


69.      * running inside of a hypervisor layer.  


70.      */  


71.     lazy_save_gs(prev->gs);  


72.   


73.     /*  


74.      * Load the per-thread Thread-Local Storage descriptor.  


75.      */  


76.      /*把next进程使用的县城局部存储(TLS)段装入本地CPU  


77.      的全局描述符表；三个段选择符保存在进程描述符  


78.      内的tls_array数组中*/  


79.     load_TLS(next, cpu);  


80.   


81.     /*  


82.      * Restore IOPL if needed.  In normal use, the flags restore  


83.      * in the switch assembly will handle this.  But if the kernel  


84.      * is running virtualized at a non-zero CPL, the popf will  


85.      * not restore flags, so it must be done in a separate step.  


86.      */  


87.     if (get_kernel_rpl() && unlikely(prev->iopl != next->iopl))  


88.         set_iopl_mask(next->iopl);  


89.   


90.     /*  


91.      * Now maybe handle debug registers and/or IO bitmaps  


92.      */  


93.     if (unlikely(task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV ||  


94.              task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT))  


95.         __switch_to_xtra(prev_p, next_p, tss);  


96.   


97.     /* If we’re going to preload the fpu context, make sure clts  


98.        is run while we’re batching the cpu state updates. */  


99.     if (preload_fpu)  


100.         clts();  


101.   


102.     /*  


103.      * Leave lazy mode, flushing any hypercalls made here.  


104.      * This must be done before restoring TLS segments so  


105.      * the GDT and LDT are properly updated, and must be  


106.      * done before math_state_restore, so the TS bit is up  


107.      * to date.  


108.      */  


109.     arch_end_context_switch(next_p);  


110.   


111.     if (preload_fpu)  


112.         __math_state_restore();/*装载FPU寄存器*/  


113.   


114.     /*  


115.      * Restore %gs if needed (which is common)  


116.      */  


117.     if (prev->gs | next->gs)  


118.         lazy_load_gs(next->gs);  


119.   


120.     percpu_write(current_task, next_p);  


121.   


122.     return prev_p;  


123. }  

1. static inline void __unlazy_fpu(struct task_struct *tsk)  


2. {   /*包含在thread_info描述符的status字段中的 


3.     TS_USEDFPU标志。他表示进程在当前执行的过程中 


4.     是否使用过FPU/MMU/XMM寄存器*/  


5.     if (task_thread_info(tsk)->status & TS_USEDFPU) {  


6.         /*由于tsk在这次执行中使用了FPU/MMX/SSE或 


7.         SSE2指令；因此内核必须保存相关的硬件 


8.         上下文*/  


9.         __save_init_fpu(tsk);  


10.         stts();  


11.     } else  


12.         tsk->fpu_counter = 0;  


13. }  

1. static inline void __save_init_fpu(struct task_struct *tsk)  


2. {   /*如果CPU使用SSE/SSE2扩展，则*/  


3.     if (task_thread_info(tsk)->status & TS_XSAVE)  


4.         xsave(tsk);  


5.     else  


6.         fxsave(tsk);  


7.   


8.     clear_fpu_state(tsk);  


9.     task_thread_info(tsk)->status &= ~TS_USEDFPU;/*重置TS_USEDFPU标志*/  


10. }