Linux0.12任务调度、休眠与唤醒

// /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
 }
}