Linux内核定时器

1.概述    1

2.使用定时器    1

3.补充    2

4.定时器竞争条件    4

5.实现定时器    4

1.概述

定时器，有时也称为动态定时器或内核定时器，是管理内核时间的基础。内核经常要推后执行某些代码，比如下半部机制就是为了将工作推后执行。我们需要一种工具，使工作能够在指定时间点上执行，正好在希望的时间点上，内核定时器正是这样一种工具。

定时器使用简单，只须执行一些初始化工作，设置一个超时时间，指定超时发生后执行的函数，然后激活定时器就可以了。

注意，定时器并不周期运行，它在超时后就自行销毁，这就是这种定时器被称为动态定时器的原因。动态定时器不断地创建和销毁，而且它的运行次数也不受。

2.使用定时器

定时器由结构timer_list表示：

1.在中 

2.struct timer_list { 

3.     struct list_head entry;     //定时器链表的入口 

4.     unsigned long expires;     //定时器超时时的节拍数 

5.

6.     void (*function)(unsigned long ); //定时器处理函数 

7.     unsigned long data;             //传给定时器处理函数的长整型参数 

8.

9.     struct tvec_t_base_s *base; //定时器内部值，用户不要使用 

10.#ifdef CONFIG_TIMER_STATS 

11.     void *start_site; 

12.     char start_comm[16]; 

13.     int start_pid; 

14.#endif 

15.}; 

16.在中 

17.struct tvec_t_base_s { 

18.     spinlock_t lock; 

19.     struct timer_list *running_timer; 

20.     unsigned long timer_jiffies; 

21.     tvec_root_t tv1; 

22.     tvec_t tv2; 

23.     tvec_t tv3; 

24.     tvec_t tv4; 

25.     tvec_t tv5; 

26.} ____cacheline_aligned_in_smp; 

内核提供了一组与定时器相关的接口用来简化管理定时器的操作。所有这些接口都声明在中，大多数接口在中的到实现。

创建定时器首先要先定义它，然后通过一个辅助函数初始化定时器数据结构的内部值，初始化必须在使用其他定时器管理函数之前完成：

1.struct timer_list my_timer; 

2.init_timer(&my_timer);                  // 初始化定时器 

3.my_timer.expires = jiffies + delay;// delay这个值一般为seconds * HZ

关于时间和jiffies之间的转换请参考另一篇《linux HZ Tick Jiffies》，这里未考虑溢出的问题

4.my_timer.data = 0;                  // 传递给function的参数

5.my_timer.function = my_function; 

6.add_timer(&my_timer);                 //最后，激活定时器 

3.补充

也可以这样调用： 

1、setup_timer(struct timer_list, function,data)； //初始化timer并赋值func和data

2、mod_timer()；修改并启动之。另外，定时值可以这样设定：msecs_to_jiffies(50); 

调用方式： 

mod_timer(&mytimer, jiffies + msecs_to_jiffies(50) ); //未考虑jiffies溢出的问题

处理函数的原型：

void my_timer_function(unsigned long data);

data参数可以使你利用同一个处理函数注册多个定时器，只须通过该参数就能区别对待他们。如果你不需要这个参数，可以简单传递0或任何其他值给处理函数。

当前节拍计数等于或大于指定的超时时，内核就开始执行定时器处理函数。因为内核有可能延误定时器的执行，所以不能用定时器来实现任何硬实时任务。

有时可能需要更改已经激活的定时器超时时间，内核通过mod_timer()来实现该功能。当定时器已经初始化，但未激活，mod_timer()就激活它。一旦从该函数返回，定时器都被激活而且设置了新的定时值。

1.int mod_timer( struct timer_list *timer, unsigned long expires) 

2.{ 

3. BUG_ON(!timer->function);

4.

5.     timer_stats_timer_set_start_info(timer); 

6.     /* 

7.      * This is a common optimization triggered by the 

8.      * networking code - if the timer is re-modified 

9.      * to be the same thing then just return: 

10.      */ 

11. if (timer->expires == expires && timer_pending(timer))

12.         return 1; 

13.

14.     return __mod_timer(timer, expires); 

15.} 

如果要在定时器超时之前停止定时器，使用del_timer()函数：

1.int del_timer( struct timer_list *timer) 

2.{ 

3.     tvec_base_t *base; 

4.     unsigned long flags; 

5.     int ret = 0; 

6.

7.     timer_stats_timer_clear_start_info(timer); 

8.     if (timer_pending(timer)) { 

9.         base = lock_timer_base(timer, &flags); 

10.         if (timer_pending(timer)) { 

11.             detach_timer(timer, 1); 

12.             ret = 1; 

13.         } 

14. spin_unlock_irqrestore(&base->lock, flags);

15.     } 

16.

17.     return ret; 

18.} 

被激活或未被激活的定时器都可以使用该函数。注意，不要为已经超时的定时器调用该函数，因为它们会自动被删除。

删除定时器时要小心，可能存在潜在的竞争条件。多处理器机器上定时器中断可能已经在其他处理器上运行了，所以删除定时器时需要等待可能在其他处理器上运行的定时器处理程序都退出，这是要使用del_timer_sync()函数执行删除工作：

1.int del_timer_sync( struct timer_list *timer) 

2.{ 

3.     for (;;) { 

4.         int ret = try_to_del_timer_sync(timer); 

5. if (ret >= 0)

6.             return ret; 

7.         cpu_relax(); 

8.     } 

9.} 

和del_timer()函数不同，del_timer_sync()函数不能在中断上下文中使用。

4.定时器竞争条件

定时器与当前执行代码是异步的，因此有可能存在潜在的竞争条件。

首先，绝不能用下列代码来代替mod_timer()函数：

1.del_timer(my_timer); 

2.my_timer->expires = jiffies + new_delay;

3.add_timer(my_timer); 

其次，使用del_timer_sync()函数取代del_timer()函数。

最后，因为内核异步执行中断处理程序，所以应该重点保护定时器中断处理程序中的共享数据。

5.实现定时器

内核在时钟中断发生后执行定时器，定时器作为软中断在下半部上下文中执行。

具体来说，时钟中断处理程序会执行update_process_timers()函数，该函数随即调用run_local_timers()函数：

run_timer_softirq()函数处理软中断TIMER_SOFTIRQ，从而在当前处理器上运行所有的超时定时器：

所有定时器都以链表形式存放在一起，为了提高搜索效率，内核将定时器按它们的超时时间划分为五组。当定时器超时时间接近时，定时器将随组一起下移。采用分组定时器的方法可以在执行软中断的多数情况下，确保内核尽可能减少搜索超时定时器所带来的负担。

•定时器实例

在嵌入式开发中在upgrade firmware后可能会出现部分命令无法执行的情况，比如reboot，这里可以在upgrade firmware之前向内核注册一个reboot函数，并设定足够的升级时间。

struct timer_list reboot_timer;

init_timer(&led_reboot_timer);

reboot_timer.function=reboot_timer_fun;

static void reboot_timer_fun (unsigned long data)

{

    machine_restart(NULL); // 如果是在SMP上应该使用kernel_restar函数（kernel/sys.c 2.6中开始支持）

}

当内核收到信号后（可以通过proc，syscall，ioctl等方式从用户空间出发内核动作）

reboot_timer.expires = jiffies + REBOOT_INTERVAL;

add_timer(&reboot_timer);