// /kernel/sched.c
void sched_init(void)
{
    ...
    outb_p(0x36,0x43);  /* binary, mode 3, LSB/MSB, ch 0 */
    outb_p(LATCH & 0xff , 0x40); /* LSB */
    outb(LATCH >> 8 , 0x40); /* MSB */
    set_intr_gate(0x20,&timer_interrupt); !
    ...
}


//    /kernel/sys_call.s

....

.align 2
_timer_interrupt: //時鐘中斷處理程序
    push %ds  # save ds,es and put kernel data space
    push %es  # into them. %fs is used by _system_call
    push %fs        #  # 保存ds、es并讓其指向內核數據段。fs將用于system_call
    pushl $-1  # 這里填-1，表明不是系統調用

    //下面我們保存寄存器eax、ecx和edx。這是因為gcc編譯器在調用函數時不會保存它們。 
    //這里也保存了ebx寄存器，會后面ret_from_sys_call中會用到它。
    pushl %edx  # we save %eax,%ecx,%edx as gcc doesn't
    pushl %ecx  # save those across function calls. %ebx
    pushl %ebx  # is saved as we use that in ret_sys_call
    pushl %eax
    movl $0x10,%eax  # ds,es置為指向內核數據段
    mov %ax,%ds
    mov %ax,%es
    movl $0x17,%eax   # fs置為指向局部數據段（程序的數據段）
    mov %ax,%fs
    incl _jiffies     #系統啟動后的時鐘滴答值+1

    // 由于初始化中斷控制芯片時沒有采用自動EOI，所以這里需要發指令結束該硬件中斷
    movb $0x20,%al  # EOI to interrupt controller #1
    outb %al,$0x20

    // 下面從堆棧中取出執行系統調用代碼的選擇符（CS段寄存器值）中的當前特權級別(0或3)并壓入 
    // 堆棧，作為do_timer的參數
    movl CS(%esp),%eax
    andl $3,%eax  # %eax is CPL (0 or 3, 0=supervisor) 獲取當前特權級別
    pushl %eax

    //do_timer()函數執行任務切換、計時等
    call _do_timer  # 'do_timer(long CPL)' does everything from
    addl $4,%esp  # task switching to accounting ...
    jmp ret_from_sys_call

// /kernel/sched.c

//參數cpl是當前特權級0或3，它是時鐘中斷發生時正被執行的代碼選擇符中的特權級。 
// cpl=0時表示中斷發生時正在執行內核代碼；cpl=3時表示中斷發生時正在執行用戶代碼。 
void do_timer(long cpl)
{
    static int blanked = 0;

    //首先判斷是否需要執行黑屏（blankout）操作
    if (blankcount || !blankinterval) {
        if (blanked)
            unblank_screen();// 屏幕恢復
        if (blankcount)
            blankcount--;
        blanked = 0;
    } else if (!blanked) {
        blank_screen();// 屏幕黑屏
        blanked = 1;
    }
    // 接著處理硬盤操作超時問題。如果硬盤超時計數遞減之后為0，則進行硬盤訪問超時處理
    if (hd_timeout)
        if (!--hd_timeout)
            hd_times_out();
    //如果發聲計數次數到，則關閉發聲。(向0x61口發送命令，復位位0和1。位0控制8253計數器2的工作，位1控制揚聲器)
    if (beepcount)
        if (!--beepcount)
            sysbeepstop();
    // 如果當前特權級(cpl)為0（最高，表示是內核程序在工作），則將內核代碼運行時間stime遞增
    if (cpl)
        current->utime++;
    else
        current->stime++;

    //如果有定時器存在，則將鏈表第1個定時器的值減1。如果已等于0，則調用相應的處理程序， 
    // 并將該處理程序指針置為空。然后去掉該項定時器-和軟盤有關
    if (next_timer) { // 定時器鏈表的頭指針
        next_timer->jiffies--;
        while (next_timer && next_timer->jiffies <= 0){
            void (*fn)(void);//插入了一個函數指針定義,利用函數指針臨時保存當前定時器的處理函數
            
            fn = next_timer->fn;
            next_timer->fn = NULL;
            next_timer = next_timer->next;
            (fn)(); //調用定時處理函數
        }
    }
    //如果當前軟盤控制器FDC的數字輸出寄存器DOR中馬達啟動位有置位的，則執行軟盤定時程序
    if (current_DOR & 0xf0)
        do_floppy_timer();

    //如果當前進程時間片不為0，則退出繼續執行當前進程。否則置當前任務運行計數值為0。
    if ((--current->counter)>0) return;
    current->counter=0;
 
    // 如果當前特權級表示發生中斷時正在內核態運行，則返回(內核任務不可被搶占) 
    if (!cpl) return;
    schedule();//執行調度函數
}

//kernel/sched.c

void schedule(void) //調度程序
{
    int i,next,c;
    struct task_struct ** p; // 任務結構指針的指針

/* check alarm, wake up any interruptible tasks that have got a signal */
//檢測alarm（進程的報警定時值），喚醒任何已得到信號的可中斷任務

    for(p = &LAST_TASK ; p > &FIRST_TASK ; --p) // 從任務數組中最后一個任務開始循環檢測alarm
        if (*p) { //在循環時跳過空指針項, 即如果任務數組中有任務

             //當前任務超時，則重置當前任務超時時間
            if ((*p)->timeout && (*p)->timeout < jiffies) {
                (*p)->timeout = 0;
                
                //如果任務處于可中斷睡眠狀態TASK_INTERRUPTIBLE下
                if ((*p)->state == TASK_INTERRUPTIBLE)
                    (*p)->state = TASK_RUNNING;//將其置為就緒狀態（TASK_RUNNING）
            }
            
            //如果任務的alarm值超時則向任務發送SIGALARM信號
            if ((*p)->alarm && (*p)->alarm < jiffies) {
                (*p)->signal |= (1<<(SIGALRM-1));
                (*p)->alarm = 0; //重置任務alarm
            }

             // 如果當前任務中除了阻塞信號還有其他信號，并且該任務處于可中斷狀態
            if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
            (*p)->state==TASK_INTERRUPTIBLE)
                (*p)->state=TASK_RUNNING; //則置任務為就緒狀態
        }

/* this is the scheduler proper: */
    //下面是是調度程序的核心部分，簡短高效
    while (1) {
        c = -1;
        next = 0;
        i = NR_TASKS;//當前任務數組長度
        p = &task[NR_TASKS];
        while (--i) {//從任務數組的最后一個任務開始循環處理，并跳過不含任務的數組槽
            if (!*--p)
                continue;
            
            // 如果任務為運行態，就循環找出剩余時間片最大的那個任務
            if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
                c = (*p)->counter, next = i;
        }
        // 如果比較得出的結果不為0，則結束循環，執行switch_to
        if (c) break;
        
        // 如果比較結果為0,則重新循環任務數組
        for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
            if (*p) // 判斷任務數組值不為空
                (*p)->counter = ((*p)->counter >> 1) +
                        (*p)->priority;//counter 值的計算方式為 counter = counter/2 + priority 
        
        //回到while(1)
    }

    //任務切換
    switch_to(next);
}

// /include/linux/sched.h

#define switch_to(n) {\
struct {long a,b;} __tmp; \
__asm__("cmpl %%ecx,_current\n\t" \                 // 比較n是否是當前任務
    "je 1f\n\t" \                                   // 如果是就什么都不作
    "movw %%dx,%1\n\t" \                            // 將新任務的16位選擇符存入__tmp.b中
    "xchgl %%ecx,_current\n\t" \                    //  current = task[n]；ecx = 被切換出的任務
    "ljmp %0\n\t" \   // 長跳轉到__tmp處，此時會自動發生任務切換！！！！
    "cmpl %%ecx,_last_task_used_math\n\t" \         // 判斷是否使用了協處理器
    "jne 1f\n\t" \                                  // 沒有就退出
    "clts\n" \                                      // 原任務使用過則清理cr0中的任務
    "1:" \
    ::"m" (*&__tmp.a),"m" (*&__tmp.b), \
    "d" (_TSS(n)),"c" ((long) task[n])); \          //_TSS(n)傳入給dx，任務號n對應的任務傳入給ecx
}

//不可中斷等待狀態 // /kernel/sched.c

static inline void __sleep_on(struct task_struct **p, int state)
{
 struct task_struct *tmp;

 if (!p) // 若指針無效，則退出
  return;
 if (current == &(init_task.task))//如果當前任務是任務 0，則恐慌
  panic("task[0] trying to sleep");
    
    //讓 tmp 指向已經在等待隊列上的任務(如果有的話)，例如 inode->i_wait，并且將睡眠隊列頭
 // 的指針指向當前任務。這樣就把當前任務插入到 *p 的等待隊列中。然后將當前任務置為指定
 // 的等待狀態，并執行重新調度
 tmp = *p;
 *p = current;
 current->state = state;
repeat: schedule();

    //只有當這個等待任務被喚醒時，程序才又會從這里繼續執行。表示進程已被明確地喚醒并執行
    //如果隊列中還有等待的任務，并且隊列頭指針 *p 所指向的任務不是當前任務，則說明在本任務
    // 插入隊列后還有任務進入隊列，于是我們應該也要喚醒這些后續進入隊列的任務，因此這里將隊
    // 列頭所指任務先置為就緒狀態，而自己則置為不可中斷等待狀態，即要等待這些后續進入隊列的
    // 任務被喚醒后才用 wake_up()喚醒本任務。然后跳轉至 repeat 標號處重新執行調度函數
 if (*p && *p != current) {
  (**p).state = 0;//0是運行態
  current->state = TASK_UNINTERRUPTIBLE;//TASK_UNINTERRUPTIBLE,2,不可中斷等待狀態 
  goto repeat;
 }
    // 執行到這里，說明任務被真正被喚醒執行。此時等待隊列頭指針應該指向本任務。若它為空，
    // 則表明調度有問題，
 if (!*p)
  printk("Warning: *P = NULL\n\r");
    
 if (*p = tmp) //最后我們讓頭指針指向在我們的前面進入隊列的任務//（*p = tmp）
  tmp->state=0;
}

//把當前任務置為不可中斷的等待狀態（TASK_UNINTERRUPTIBLE）;需要利用wake_up()函數來明確喚醒，即使有信號也無法喚醒
void sleep_on(struct task_struct **p)
{
 __sleep_on(p,TASK_UNINTERRUPTIBLE);//同時傳入了當前任務指針p
}

// 將當前任務置為可中斷的等待狀態（TASK_INTERRUPTIBLE）;可以通過信號、任務超時等手段喚醒
void interruptible_sleep_on(struct task_struct **p)
{
 __sleep_on(p,TASK_INTERRUPTIBLE);
}

// sched.h
#define TASK_RUNNING      0 // 運行態
#define TASK_INTERRUPTIBLE     1 // 可中斷等待狀態
#define TASK_UNINTERRUPTIBLE 2 // 不可中斷等待狀態
#define TASK_ZOMBIE          3 // 僵死
#define TASK_STOPPED      4 // 停止狀態

void wake_up(struct task_struct **p)
{
 if (p && *p) {
  if ((**p).state == TASK_STOPPED)// 處于停止狀態
   printk("wake_up: TASK_STOPPED");
  if ((**p).state == TASK_ZOMBIE) // 處于僵死狀態
   printk("wake_up: TASK_ZOMBIE");
  (**p).state=0;//設置為就緒狀態 TASK_RUNNING
 }
}