20135103王海甯
《Linux核心分析》MOOC課程http://mooc.study.163.com/course/USTC-1000029000
一 關于程序的補充
程序排程的時機
中斷處理過程（包括時鐘中斷、I/O中斷、系統調用和異常）中，直接調用schedule()，或者傳回使用者态時根據need_resched标記調用schedule()；
核心線程可以直接調用schedule()進行程序切換，也可以在中斷處理過程中進行排程，也就是說核心線程作為一類的特殊的程序可以主動排程，也可以被動排程；
使用者态程序無法實作主動排程，僅能通過陷入核心态後的某個時機點進行排程，即在中斷處理過程中進行排程。
程序的切換
為了控制程序的執行，核心必須有能力挂起正在CPU上執行的程序，并恢複以前挂起的某個程序的執行，這叫做程序切換、任務切換、上下文切換；
挂起正在CPU上執行的程序，與中斷時儲存現場是不同的，中斷前後是在同一個程序上下文中，隻是由使用者态轉向核心态執行；
程序上下文包含了程序執行需要的所有資訊
使用者位址空間：包括程式代碼，資料，使用者堆棧等
控制資訊：程序描述符，核心堆棧等
硬體上下文（注意中斷也要儲存硬體上下文隻是儲存的方法不同）
二 代碼分析
（不同于上幾次的模式，即先用gdb跟蹤分析，再分析代碼）linux中通過schedule()函數來實作程序的排程，涉及到知識很多，如，排程的政策，時間片的配置設定，程序上下文的切換等，這裡隻是粗淺的分析schedule等相關函數
先給出代碼：schedule()
| 1 2 3 4 5 6 7 | |
其中 sched_submit_work（）是為了避免程序睡眠時發生死鎖。
static inline void sched_submit_work(struct task_struct *tsk)
{
if (!tsk->state || tsk_is_pi_blocked(tsk))
return;
/*
* If we are going to sleep and we have plugged IO queued,
* make sure to submit it to avoid deadlocks.
*/
if (blk_needs_flush_plug(tsk))
blk_schedule_flush_plug(tsk);
} __schedule() 是程序排程的函數（裡面還有嵌套~）
1 static void __sched __schedule(void)
2 {
3 struct task_struct *prev, *next;
4 unsigned long *switch_count;
5 struct rq *rq;
6 int cpu;
7
8 need_resched:
9 preempt_disable();
10 cpu = smp_processor_id();
11 rq = cpu_rq(cpu);
12 rcu_note_context_switch(cpu);
13 prev = rq->curr;
14
15 schedule_debug(prev);
16
17 if (sched_feat(HRTICK))
18 hrtick_clear(rq);
19
20 /*
21 * Make sure that signal_pending_state()->signal_pending() below
22 * can't be reordered with __set_current_state(TASK_INTERRUPTIBLE)
23 * done by the caller to avoid the race with signal_wake_up().
24 */
25 smp_mb__before_spinlock();
26 raw_spin_lock_irq(&rq->lock);
27
28 switch_count = &prev->nivcsw;
29 if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
30 if (unlikely(signal_pending_state(prev->state, prev))) {
31 prev->state = TASK_RUNNING;
32 } else {
33 deactivate_task(rq, prev, DEQUEUE_SLEEP);
34 prev->on_rq = 0;
35
36 /*
37 * If a worker went to sleep, notify and ask workqueue
38 * whether it wants to wake up a task to maintain
39 * concurrency.
40 */
41 if (prev->flags & PF_WQ_WORKER) {
42 struct task_struct *to_wakeup;
43
44 to_wakeup = wq_worker_sleeping(prev, cpu);
45 if (to_wakeup)
46 try_to_wake_up_local(to_wakeup);
47 }
48 }
49 switch_count = &prev->nvcsw;
50 }
51
52 if (task_on_rq_queued(prev) || rq->skip_clock_update < 0)
53 update_rq_clock(rq);
54
55 next = pick_next_task(rq, prev);
56 clear_tsk_need_resched(prev);
57 clear_preempt_need_resched();
58 rq->skip_clock_update = 0;
59
60 if (likely(prev != next)) {
61 rq->nr_switches++;
62 rq->curr = next;
63 ++*switch_count;
64
65 context_switch(rq, prev, next); /* unlocks the rq */
66 /*
67 * The context switch have flipped the stack from under us
68 * and restored the local variables which were saved when
69 * this task called schedule() in the past. prev == current
70 * is still correct, but it can be moved to another cpu/rq.
71 */
72 cpu = smp_processor_id();
73 rq = cpu_rq(cpu);
74 } else
75 raw_spin_unlock_irq(&rq->lock);
76
77 post_schedule(rq);
78
79 sched_preempt_enable_no_resched();
80 if (need_resched())
81 goto need_resched;
82 } 上面的紅色給出了重點标記，context_switch()，進行了程序上下文切換。
context_switch
前文中提到的程序上下文關于硬體上下文，将目前程序的寄存器中的内容儲存，并裝入下一程序的以前儲存的堆棧，寄存器的内容，即下面的switch_to()實作：
1 #define switch_to(prev, next, last) \
2 32do { \
3 33 /* \
4 34 * Context-switching clobbers all registers, so we clobber \
5 35 * them explicitly, via unused output variables. \
6 36 * (EAX and EBP is not listed because EBP is saved/restored \
7 37 * explicitly for wchan access and EAX is the return value of \
8 38 * __switch_to()) \
9 39 */ \
10 40 unsigned long ebx, ecx, edx, esi, edi; \
11 41 \
12 42 asm volatile("pushfl\n\t" /* save flags */ \
13 43 "pushl %%ebp\n\t" /* save EBP */ \
14 44 "movl %%esp,%[prev_sp]\n\t" /* save ESP */ \
15 45 "movl %[next_sp],%%esp\n\t" /* restore ESP */ \
16 46 "movl $1f,%[prev_ip]\n\t" /* save EIP */ \
17 47 "pushl %[next_ip]\n\t" /* restore EIP */ \
18 48 __switch_canary \
19 49 "jmp __switch_to\n" /* regparm call */ \
20 50 "1:\t" \
21 51 "popl %%ebp\n\t" /* restore EBP */ \
22 52 "popfl\n" /* restore flags */ \
23 53 \
24 54 /* output parameters */ \
25 55 : [prev_sp] "=m" (prev->thread.sp), \
26 56 [prev_ip] "=m" (prev->thread.ip), \
27 57 "=a" (last), \
28 58 \
29 59 /* clobbered output registers: */ \
30 60 "=b" (ebx), "=c" (ecx), "=d" (edx), \
31 61 "=S" (esi), "=D" (edi) \
32 62 \
33 63 __switch_canary_oparam \
34 64 \
35 65 /* input parameters: */ \
36 66 : [next_sp] "m" (next->thread.sp), \
37 67 [next_ip] "m" (next->thread.ip), \
38 68 \
39 69 /* regparm parameters for __switch_to(): */ \
40 70 [prev] "a" (prev), \
41 71 [next] "d" (next) \
42 72 \
43 73 __switch_canary_iparam \
44 74 \
45 75 : /* reloaded segment registers */ \
46 76 "memory"); \
47 77} while (0)
48 78 可以從上面的嵌入彙編看出主要就是儲存目前程序的flags，ebp,esp,eip，并裝入下一程序的flags，ebp,esp,eip，當執行到 "pushl %[next_ip]\n\t" ，即進入到下一個程序的範疇了。
三 利用gdb工具跟蹤
配置qemu環境：
設定斷點：
發現gdb工具探測不到context_switch(),switch_to() ,隻有斷點1有效，下面的結果也驗證了
停在第一個斷點處。接着運作“c”，但是斷點一直在schedule（）處
主要是context_switch(),switch_to() 兩處設定不了斷點，有待解決，希望大家指出是什麼問題。。。。
三 總結分析
linux與任何分時系統一樣，通過一個程序到另一個程序的快速切換，達到表面上看起來多個任務并行執行的效果。
schedule（）可以由幾個核心控制路徑調用，可以采取直接調用的方式或延遲調用的方式。
直接調用：如果current程序不能獲得必須的資源而要立刻被阻塞，直接調用排程程式。
延遲調用：把current程序的TIF_NEED_RESCHED标志設定為1，而以延遲的方式排程排程程式。由于總是在恢複使用者态程序的執行之前檢查這個标志的值，是以schedule（）将在不久後的某個時刻被明确的執行。