schedule_timeout

schedule_timeout()进入延时唤醒状态. 如果在延迟过程中.

在通常的驱动程序中，可以以下列两种方式重新获得执行：在等待队列上调用一个 wake_up，或者 timout 超时。在这个特定实现中，没人会调用 wake_up（毕竟其它代码根本就不知道这件事），所以进程总是因 timeout 超时而被唤醒。这是一个完美有效的实现，不过，如果驱动程序无须等待其它事件，可以用一种更直接的方式获取延迟，即使用schedule_timeout：

schedule_timeout也是处理一个时间增量而不是一个 jiffies 的绝对值 
schedule_timeout (jit_delay*HZ);

sleep_on_timeout、interruptible_sleep_on_timeout和schedule_timeout这几个函数是在2.2版本内核才加入的。在使用2.0的时期，超时值是通过 task 结构中的一个变量（timeout）处理的。作一个比较，现在的代码是这样进行调用的：

extern inline void schedule_timeout(int timeout) 
{ 

    current->timeout = jiffies + timeout; 

    current->state = TASK_INTERRUPTIBLE; 
    schedule(); 
    current->timeout = 0; 
}

long interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout) 
 { 

    SLEEP_ON_VAR 
    current->state = TASK_INTERRUPTIBLE; 
    SLEEP_ON_HEAD 
    timeout = schedule_timeout(timeout); 
    SLEEP_ON_TAIL 
 
    return timeout; 
 } 
 EXPORT_SYMBOL(interruptible_sleep_on_timeout);

void sleep_on(wait_queue_head_t *q) 
 { 
     SLEEP_ON_VAR 
 
     current->state = TASK_UNINTERRUPTIBLE; 
 
     SLEEP_ON_HEAD 
     schedule(); 
     SLEEP_ON_TAIL 
 } 
EXPORT_SYMBOL(sleep_on); 

long sleep_on_timeout(wait_queue_head_t *q, long timeout) 

{ 

    SLEEP_ON_VAR  
    current->state = TASK_UNINTERRUPTIBLE; 
    SLEEP_ON_HEAD 
    timeout = schedule_timeout(timeout); 
    SLEEP_ON_TAIL 
    return timeout; 

}

schedule_timeout 用来让出CPU；在指定的时间用完以后或者其它事件到达并唤醒进程（比如接收了一个信号量）时，该进程才可以继续运行


signed long __sched schedule_timeout(signed long timeout)
{
        struct timer_list timer;
        unsigned long expire;

        switch (timeout)
        {
        case MAX_SCHEDULE_TIMEOUT:
                schedule();
                goto out;
        default:
                if (timeout < 0) {
                        printk(KERN_ERR "schedule_timeout: wrong timeout "
                                "value %lx\n", timeout);
                        dump_stack();
                        current->state = TASK_RUNNING;
                        goto out;
                }
        }

        expire = timeout + jiffies;

        setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
        __mod_timer(&timer, expire, false, TIMER_NOT_PINNED);
        schedule();
        del_singleshot_timer_sync(&timer);

        /* Remove the timer from the object tracker */
        destroy_timer_on_stack(&timer);

        timeout = expire - jiffies;

out:
        return timeout < 0 ? 0 : timeout;
}

schedule_timeout这个函数除了对当前进程调用schedule之外，还有一个功能，如同其名字中暗示的，在指定的时间到期后(timeout了)将进程唤醒。我们知道，进程一旦进入睡眠状态，就会从cpu的run queue中移走，直觉是系统将不会维护散落到系统各处（等待队列等）的这些睡眠进程的时间信息，那么如何在指定的时间到期时唤醒这些进程呢？Linux内核使用了timer机制来完成，timer不依赖于进程，依赖于处理器的中断，当然关于timer的内部实现的机制可以成为另一个帖子了，这里就不多说。看看schedule_timeout的源码：

我们关注的主要是default那块，因为前一个case指定的时间太漫长，不知道猴年马月才到期呢吧？！defalt case其实蛮简单，expire = timeout + jiffies;
用当前jiffies加上函数调用时的timeout值构成到期时间点，然后setup_timer_on_stack创建了一个timer，这个timer到期后将调用process_timeout，传入的参数是当前进程的指针current，然后调用schedule，函数将停留在schedule上(当前进程被调度出处理器，同时从cpu的run queue中移走，一个新的进程被调度运行起来)。但是不管进程怎么切换，游离于进程世界之外的timer在每次时钟中断都有相应，当这个timer的时间到期后，将调用timer上的回调函数。

schedule_timeout为timer安装的回调是process_timeout，核心代码就是wake_up(current)类似的样子，这样因为schedule_timeout而睡眠的进程将进入到cpu的run queue，当它被调度时，schedule函数返回，除了删除已经不再使用的timer之外，一个比较重要的步骤是timeout = expire - jiffies，这个主要是用来判断进程被唤醒的原因，因为有可能在timer没到期时，其他进程唤醒了该进程，这种情况下timeout = expire - jiffies算出的timeout是>0的，所以反映到函数的返回值上就是，0意味着进程因为时间timeout而被唤醒，一个正数意味着进程在时间尚没有timeout的情况下被唤醒。