转自:http://blog.csdn.net/droidphone/article/details/8104433

我们已经在前面几章介绍了低分辨率定时器和高精度定时器的实现原理,内核为了方便其它子系统,在时间子系统中提供了一些用于延时或调度的API,例如msleep,hrtimer_nanosleep等等,这些API基于低分辨率定时器或高精度定时器来实现,本章的内容就是讨论这些方便、好用的API是如何利用定时器系统来完成所需的功能的。

/*****************************************************************************************************/
声明:本博内容均由http://blog.csdn.net/droidphone原创,转载请注明出处,谢谢!
/*****************************************************************************************************/

1.  msleep

msleep相信大家都用过,它可能是内核用使用最广泛的延时函数之一,它会使当前进程被调度并让出cpu一段时间,因为这一特性,它不能用于中断上下文,只能用于进程上下文中。要想在中断上下文中使用延时函数,请使用会阻塞cpu的无调度版本mdelay。msleep的函数原型如下:

  1. void msleep(unsigned int msecs)

延时的时间由参数msecs指定,单位是毫秒,事实上,msleep的实现基于低分辨率定时器,所以msleep的实际精度只能也是1/HZ级别。内核还提供了另一个比较类似的延时函数msleep_interruptible:

  1. unsigned long msleep_interruptible(unsigned int msecs)

延时的单位同样毫秒数,它们的区别如下:

函数 延时单位 返回值 是否可被信号中断
msleep 毫秒
msleep_interruptible 毫秒 未完成的毫秒数

最主要的区别就是msleep会保证所需的延时一定会被执行完,而msleep_interruptible则可以在延时进行到一半时被信号打断而退出延时,剩余的延时数则通过返回值返回。两个函数最终的代码都会到达schedule_timeout函数,它们的调用序列如下图所示:
                                             

图1.1  两个延时函数的调用序列

下面我们看看schedule_timeout函数的实现,函数首先处理两种特殊情况,一种是传入的延时jiffies数是个负数,则打印一句警告信息,然后马上返回,另一种是延时jiffies数是MAX_SCHEDULE_TIMEOUT,表明需要一直延时,直接执行调度即可:

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

然后计算到期的jiffies数,并在堆栈上建立一个低分辨率定时器,把到期时间设置到该定时器中,启动定时器后,通过schedule把当前进程调度出cpu的运行队列:

  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();

到这个时候,进程已经被调度走,那它如何返回继续执行?我们看到定时器的到期回调函数是process_timeout,参数是当前进程的task_struct指针,看看它的实现:

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

schedule返回后,说明要不就是定时器到期,要不就是因为其它时间导致进程被唤醒,函数要做的就是删除在堆栈上建立的定时器,返回剩余未完成的jiffies数。

说完了关键的schedule_timeout函数,我们看看msleep如何实现:

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

msleep先是把毫秒转换为jiffies数,通过一个while循环保证所有的延时被执行完毕,延时操作通过schedule_timeout_uninterruptible函数完成,它仅仅是在把进程的状态修改为TASK_UNINTERRUPTIBLE后,调用上述的schedule_timeout来完成具体的延时操作,TASK_UNINTERRUPTIBLE状态保证了msleep不会被信号唤醒,也就意味着在msleep期间,进程不能被kill掉。

看看msleep_interruptible的实现:

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

msleep_interruptible通过schedule_timeout_interruptible中转,schedule_timeout_interruptible的唯一区别就是把进程的状态设置为了TASK_INTERRUPTIBLE,说明在延时期间有信号通知,while循环会马上终止,剩余的jiffies数被转换成毫秒返回。实际上,你也可以利用schedule_timeout_interruptible或schedule_timeout_uninterruptible构造自己的延时函数,同时,内核还提供了另外一个类似的函数,不用我解释,看代码就知道它的用意了:

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

2.  hrtimer_nanosleep

第一节讨论的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的代码:
  1. long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,
  2. const enum hrtimer_mode mode, const clockid_t clockid)
  3. {
  4. struct restart_block *restart;
  5. struct hrtimer_sleeper t;
  6. int ret = 0;
  7. unsigned long slack;
  8. slack = current->timer_slack_ns;
  9. if (rt_task(current))
  10. slack = 0;
  11. hrtimer_init_on_stack(&t.timer, clockid, mode);
  12. hrtimer_set_expires_range_ns(&t.timer, timespec_to_ktime(*rqtp), slack);
  13. if (do_nanosleep(&t, mode))
  14. goto out;
  15. /* Absolute timers do not update the rmtp value and restart: */
  16. if (mode == HRTIMER_MODE_ABS) {
  17. ret = -ERESTARTNOHAND;
  18. goto out;
  19. }
  20. if (rmtp) {
  21. ret = update_rmtp(&t.timer, rmtp);
  22. if (ret <= 0)
  23. goto out;
  24. }
  25. restart = ¤t_thread_info()->restart_block;
  26. restart->fn = hrtimer_nanosleep_restart;
  27. restart->nanosleep.clockid = t.timer.base->clockid;
  28. restart->nanosleep.rmtp = rmtp;
  29. restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);
  30. ret = -ERESTART_RESTARTBLOCK;
  31. out:
  32. destroy_hrtimer_on_stack(&t.timer);
  33. return ret;
  34. }

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

  1. void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, struct task_struct *task)
  2. {
  3. sl->timer.function = hrtimer_wakeup;
  4. sl->task = task;
  5. }
  6. EXPORT_SYMBOL_GPL(hrtimer_init_sleeper);
  7. static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode)
  8. {
  9. hrtimer_init_sleeper(t, current);

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

  1. do {
  2. set_current_state(TASK_INTERRUPTIBLE);
  3. hrtimer_start_expires(&t->timer, mode);
  4. if (!hrtimer_active(&t->timer))
  5. t->task = NULL;
  6. if (likely(t->task))
  7. schedule();
  8. hrtimer_cancel(&t->timer);
  9. mode = HRTIMER_MODE_ABS;
  10. } while (t->task && !signal_pending(current));
  11. __set_current_state(TASK_RUNNING);
  12. return t->task == NULL;
  13. }

除了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。

Linux时间子系统之七:定时器的应用--msleep(),hrtimer_nanosleep()【转】的更多相关文章

  1. Linux时间子系统之七:定时器的应用--msleep(),hrtimer_nanosleep()

    我们已经在前面几章介绍了低分辨率定时器和高精度定时器的实现原理,内核为了方便其它子系统,在时间子系统中提供了一些用于延时或调度的API,例如msleep,hrtimer_nanosleep等等,这些A ...

  2. Linux时间子系统专题汇总

    关于Linux时间子系统有两个系列文章讲的非常好,分别是WowoTech和DroidPhone. 还有两本书分别是介绍: Linux用户空间时间子系统<Linux/UNIX系统编程手册>的 ...

  3. Linux时间子系统之六:高精度定时器(HRTIMER)的原理和实现

    转自:http://blog.csdn.net/droidphone/article/details/8074892 上一篇文章,我介绍了传统的低分辨率定时器的实现原理.而随着内核的不断演进,大牛们已 ...

  4. Linux时间子系统之五:低分辨率定时器的原理和实现

    专题文档汇总目录 Notes:低精度timer在内核中的数据结构以及API接口:低精度timer精巧高效的分组,使用cascade进行定时器移位,组内Timer FIFO:低精度Timer的初始化流程 ...

  5. Linux时间子系统之(三):用户空间接口函数

    专题文档汇总目录 Notes:用户空间时间相关接口函数: 类型 API 精度 说明 时间 time stime time_t 精度为秒级 逐渐要被淘汰.需要定义__ARCH_WANT_SYS_TIME ...

  6. Linux时间子系统之(五):POSIX Clock

    专题文档汇总目录 Notes: 本章主要介绍了若干种类的静态时钟,这些时钟都可以通过k_clock表示,注册到posix_clocks中.这些都是静态时钟,可以分为三大类:各种REALTIME时钟.带 ...

  7. Linux时间子系统之(六):POSIX timer

    专题文档汇总目录 Notes:首先讲解了POSIX timer的标识(唯一识别).POSIX Timer的组织(管理POSIX Timer).内核中如何抽象POSIX Timer:然后分析了POSIX ...

  8. Linux时间子系统之(十七):ARM generic timer驱动代码分析

    专题文档汇总目录 Notes:ARM平台Clock/Timer架构:System counter.Timer以及两者之间关系:Per cpu timer通过CP15访问,System counter通 ...

  9. Linux时间子系统之八:动态时钟框架(CONFIG_NO_HZ、tickless)

    在前面章节的讨论中,我们一直基于一个假设:Linux中的时钟事件都是由一个周期时钟提供,不管系统中的clock_event_device是工作于周期触发模式,还是工作于单触发模式,也不管定时器系统是工 ...

随机推荐

  1. C 输入 & 输出——Day03

    当我们提到输入时,这意味着要向程序填充一些数据.输入可以是以文件的形式或从命令行中进行.C 语言提供了一系列内置的函数来读取给定的输入,并根据需要填充到程序中. 当我们提到输出时,这意味着要在屏幕上. ...

  2. git 复位出现If no other git process is currently running, this probably means a git process crashed in this repo

    复位到A节点的时候点了取消(终止),又去复位另外个节点,结果每次不管复位哪个都会报这个错误 fatal: Unable to create 'XXXXXXXXX' : File exists. If ...

  3. BZOJ 1283: 序列

    1283: 序列 Time Limit: 10 Sec  Memory Limit: 162 MBSubmit: 272  Solved: 151[Submit][Status][Discuss] D ...

  4. Weblogic CVE-2018-3191远程代码命令执行漏洞复现

      0x00 简介 北京时间10月17日,Oracle官方发布的10月关键补充更新CPU(重要补丁更新)中修复了一个高危的WebLogic远程代码执行漏洞(CVE-2018-3191).该漏洞允许未经 ...

  5. CH暑假欢乐赛 SRM 07 天才麻将少女KPM(DP+treap)

    首先LIS有个$O(n^2)$的DP方法 $f(i,j)$表示前i个数,最后一个数<=j的LIS 如果$a_i!=0$则有 如果$a_i=0$则有 注意因为$f(i-1,j)\leq f(i-1 ...

  6. 解题:CEOI 2017 Mousetrap

    题外话: 这是制杖yd的交流题目 题面 首先把捕鼠夹所在的点提出来当根,然后这变成了一棵有根树,我们先来看耗子移动的影响 可以发现耗子往下走就回不来了,而且最后还会被困在一个叶子上,那么这个时候我们把 ...

  7. Laravel 项目集合

    1.  CMS LaraCMS  https://github.com/wanglelecc/laracms 2. 电商 3.  点播 MeEdu      https://github.com/Qs ...

  8. K8S钩子操作

    简介 我们知道,K8S可以在应用容器启动之前先执行一些预定义的操作,比如事先生成一些数据,以便于应用容器在启动的时候使用.这种方式可以通过init container技术实现,具体可以参考<Ku ...

  9. NATS_01:NATS基础介绍

    1.介绍 NATS(Message bus): 从CloudFoundry的总架构图看,位于各模块中心位置的是一个叫nats的组件.NATS是由CloudFoundry的架构师Derek开发的一个开源 ...

  10. python中的文件操作

    文件操作时,有'r','w','a'不同的操作类型,其中'r'只能读文件,seek(),tell()函数定位读的起始地方.'w'会清空文件内容然后写文件,seek(),tell()函数定位写的起始地方 ...