1. void msleep(unsigned int msecs)

1. unsigned long msleep_interruptible(unsigned int msecs)

1. signed long __sched schedule_timeout(signed long timeout)
2. {
3. struct timer_list timer;
4. unsigned long expire;
5. switch (timeout)
6. {
7. case MAX_SCHEDULE_TIMEOUT:
8. schedule();
9. goto out;
10. default:
11. if (timeout < 0) {
12. printk(KERN_ERR "schedule_timeout: wrong timeout "
13. "value %lx\n", timeout);
14. dump_stack();
15. current->state = TASK_RUNNING;
16. goto out;
17. }
18. }

1. expire = timeout + jiffies;
2. setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);
3. __mod_timer(&timer, expire, false, TIMER_NOT_PINNED);
4. schedule();

1. static void process_timeout(unsigned long __data)
2. {
3. wake_up_process((struct task_struct *)__data);
4. }

1. del_singleshot_timer_sync(&timer);
2. /* Remove the timer from the object tracker */
3. destroy_timer_on_stack(&timer);
4. timeout = expire - jiffies;
5. out:
6. return timeout < 0 ? 0 : timeout;
7. }

1. signed long __sched schedule_timeout_uninterruptible(signed long timeout)
2. {
3. __set_current_state(TASK_UNINTERRUPTIBLE);
4. return schedule_timeout(timeout);
5. }
6. void msleep(unsigned int msecs)
7. {
8. unsigned long timeout = msecs_to_jiffies(msecs) + 1;
9. while (timeout)
10. timeout = schedule_timeout_uninterruptible(timeout);
11. }

1. signed long __sched schedule_timeout_interruptible(signed long timeout)
2. {
3. __set_current_state(TASK_INTERRUPTIBLE);
4. return schedule_timeout(timeout);
5. }
6. unsigned long msleep_interruptible(unsigned int msecs)
7. {
8. unsigned long timeout = msecs_to_jiffies(msecs) + 1;
9. while (timeout && !signal_pending(current))
10. timeout = schedule_timeout_interruptible(timeout);
11. return jiffies_to_msecs(timeout);
12. }

1. signed long __sched schedule_timeout_killable(signed long timeout)
2. {
3. __set_current_state(TASK_KILLABLE);
4. return schedule_timeout(timeout);
5. }

第一节讨论的msleep函数基于时间轮定时系统，只能提供毫秒级的精度，实际上，它的精度取决于HZ的配置值，如果HZ小于1000，它甚至无法达到毫秒级的精度，要想得到更为精确的延时，我们自然想到的是要利用高精度定时器来实现。没错，linux为用户空间提供了一个api：nanosleep，它能提供纳秒级的延时精度，该用户空间函数对应的内核实现是sys_nanosleep，它的工作交由高精度定时器系统的hrtimer_nanosleep函数实现，最终的大部分工作则由do_nanosleep完成。调用过程如下图所示：

 

                 图  2.1  nanosleep的调用过程

与msleep的实现相类似，hrtimer_nanosleep函数首先在堆栈中创建一个高精度定时器，设置它的到期时间，然后通过do_nanosleep完成最终的延时工作，当前进程在挂起相应的延时时间后，退出do_nanosleep函数，销毁堆栈中的定时器并返回0值表示执行成功。不过do_nanosleep可能在没有达到所需延时数量时由于其它原因退出，如果出现这种情况，hrtimer_nanosleep的最后部分把剩余的延时时间记入进程的restart_block中，并返回ERESTART_RESTARTBLOCK错误代码，系统或者用户空间可以根据此返回值决定是否重新调用nanosleep以便把剩余的延时继续执行完成。下面是hrtimer_nanosleep的代码：

接着我们看看do_nanosleep的实现代码，它首先通过hrtimer_init_sleeper函数，把定时器的回调函数设置为hrtimer_wakeup，把当前进程的task_struct结构指针保存在hrtimer_sleeper结构的task字段中：

然后，通过一个do/while循环内：启动定时器，挂起当前进程，等待定时器或其它事件唤醒进程。这里的循环体实现比较怪异，它使用hrtimer_active函数间接地判断定时器是否到期，如果hrtimer_active返回false，说明定时器已经过期，然后把hrtimer_sleeper结构的task字段设置为NULL，从而导致循环体的结束，另一个结束条件是当前进程收到了信号事件，所以，当因为是定时器到期而退出时，do_nanosleep返回true，否则返回false，上述的hrtimer_nanosleep正是利用了这一特性来决定它的返回值。以下是do_nanosleep循环体的代码：

除了hrtimer_nanosleep，高精度定时器系统还提供了几种用于延时/挂起进程的api：

• schedule_hrtimeout    使得当前进程休眠指定的时间，使用CLOCK_MONOTONIC计时系统；
• schedule_hrtimeout_range    使得当前进程休眠指定的时间范围，使用CLOCK_MONOTONIC计时系统；
• schedule_hrtimeout_range_clock    使得当前进程休眠指定的时间范围，可以自行指定计时系统；
• usleep_range 使得当前进程休眠指定的微妙数，使用CLOCK_MONOTONIC计时系统；

它们之间的调用关系如下：

                                                          图 2.2  schedule_hrtimeout_xxxx系列函数

最终，所有的实现都会进入到schedule_hrtimeout_range_clock函数。需要注意的是schedule_hrtimeout_xxxx系列函数在调用前，最好利用set_current_state函数先设置进程的状态，在这些函数返回前，进城的状态会再次被设置为TASK_RUNNING。如果事先把状态设置为TASK_UNINTERRUPTIBLE，它们会保证函数返回前一定已经经过了所需的延时时间，如果事先把状态设置为TASK_INTERRUPTIBLE，则有可能在尚未到期时由其它信号唤醒进程从而导致函数返回。主要实现该功能的函数schedule_hrtimeout_range_clock和前面的do_nanosleep函数实现原理基本一致。大家可以自行参考内核的代码，它们位于：kernel/hrtimer.c。