下面是进程调度函数及其相关函数的代码。

void schedule(void)
{
    int i,next,c;
    struct task_struct ** p;

/* check alarm, wake up any interruptible tasks that have got a signal */
    // 处理进程的信号和状态
    for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
        if (*p) {
            /*
                alarm的值是调用alarm函数设置的，见alarm函数，进程可以调用alarm函数，设置一个时间，
                然后到期后会触发alram信号，alarm < jiffies说明过期了。设置alarm信号
            */
            if ((*p)->alarm && (*p)->alarm < jiffies) {
                    (*p)->signal |= (1<<(SIGALRM-1));
                    (*p)->alarm = 0;
                }
            /*
                _BLOCKABLE为可以阻塞的信号集合，blocked为当前进程设置的阻塞集合，相与
                得到进程当前阻塞的集合，即排除进程阻塞了不能阻塞的信号，然后取反得到可以接收的
                信号集合，再和signal相与，得到当前进程当前收到的信号。如果进程处于挂起状态，则改成可执行 
            */
            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;
        }
        // 还有进程需要执行，c大于等于0
        if (c) break;
        // 没有break说明c等于0，即所有的进程时间片已经执行完，需要重新设置
        for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
            if (*p)
                // 优先级越高，执行的时间越长，被选中执行的机会越大
                (*p)->counter = ((*p)->counter >> 1) +
                        (*p)->priority;
    }
    // 切换进程
    switch_to(next);
}

#define switch_to(n) {\
struct {long a,b;} __tmp; \
// ecx是第n个进程对应的pcb首地址，判断切换的下一个进程是不是就是当前执行的进程，是就不需要切换了
__asm__("cmpl %%ecx,_current\n\t" \
    "je 1f\n\t" \
    // 把第n个进程的tss选择子复制到__tmp.b
    "movw %%dx,%1\n\t" \
    // 更新current变量，使current变量执行ecx，ecx指向task[n]
    "xchgl %%ecx,_current\n\t" \
    // ljmp 跟一个tss选择子实现进程切换
    "ljmp %0\n\t" \
    // 忽略
    "cmpl %%ecx,_last_task_used_math\n\t" \
    "jne 1f\n\t" \
    "clts\n" \
    "1:" \
    ::"m" (*&__tmp.a),"m" (*&__tmp.b), \
    "d" (_TSS(n)),"c" ((long) task[n])); \
}

int sys_alarm(long seconds)
{
    int old = current->alarm;

    if (old)
        old = (old - jiffies) / HZ;
    // 1秒等于100个jiffies
    current->alarm = (seconds>0)?(jiffies+HZ*seconds):0;
    return (old);
}

// 修改进程执行的优先级,满足条件的情况下increment越大优先权越低
int sys_nice(long increment)
{
    if (current->priority-increment>0)
        current->priority -= increment;
    return 0;
}

每个进程有一个执行的时间，每次时钟中断会减少一个单位的时间。如果时间用完则直接重新调度，否则进程可以继续执行。进程调度的时候，系统会选择时间最长的进程，防止有的进程得不到执行，当所有进程的时间片都消耗完毕，则重新计算时间。

do_timer函数
    if ((--current->counter)>0) return;
        current->counter=0;