当前位置:   article > 正文

Linux内核开发基础-低精度timer_list和高精度hrtimer定时器_mod_timer

mod_timer

Linux内核定时器开发-低精度和高精度定时器

上篇文章讲解了如何正确的使用内核延时函数,在进行驱动开发时,可能会经常用到精确地延时操作。除此之外,如果要实现一个定时任务,那就需要用到定时器。作为一项基础功能需求,Linux内核提供了定时器相关的实现。下面就具体看一下,Linux内核所提供的定时器实现。

定时器种类

为了适应不同的应用场景,Linux内核提供了两种定时器:低精度和高精度定时器。低精度定时器基于硬件的周期性中断实现,其定时周期的粒度为1/HZms,例如,内核HZ为1000,那么低精度的定时器最小定时时间为1ms;高精度定时器可以实现ns级的定时,不过,实际的定时周期粒度与CPU的主频有关,比如,桌面级的CPU一般都是GHZ级别,那么,其定时粒度可以达到ns级别,而对于嵌入式CPU,其主频一般在百兆级别,那么定时粒度就只能达到us级别了。在进行开发时,需要根据实际场景,选择合适的定时器来实现功能。那么,实际开发时,如何使用这两类定时器呢?下面两节,就来具体看一下。

低精度定时器

上文说了,低精度定时器依赖于内核时钟中断实现,内核中所有的此类定时器会组成一个链表,处理时钟中断时,内核会检查定时器列表是否有到时的定时器,如果有,就会调用定时器处理函数,进行相关的处理。

这里需要强调的是,执行此类定时器的处理函数时处于“软中断”上下文,软中断是中断下半部处理的一种机制,“软中断”上下文是原子性的,不可以执行可能会引起系统调度或可能睡眠的操作,比如,kmalloc、copy_from_user、msleep、mutex_lock等等。如果在定时器处理函数中调用了上述函数,比如,msleep函数,会引其内核模块崩溃,严重的会导致系统崩溃,所以,使用时切记小心!

基本数据结构

struct timer_list {
	/*
	 * All fields that change during normal runtime grouped to the
	 * same cacheline
	 */
	struct hlist_node	entry;
	unsigned long		expires;
	void			(*function)(unsigned long);
	unsigned long		data;
	u32			flags;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

上面是低精度定时器timer_list的数据结构,从名字就可以判断出其基于链表实现,其通过entry挂载到内核的定时器哈希列表中。expires表示定时时间,注意:expires的单位为时钟滴答间隔,比如,你想设置一个定时周期为10ms的定时器,那么expires应该表示为jiffies+msec_to_jiffies(10);function为定时器处理函数,data为function的入参,flags为定时器的一些选项,一般不需要配置。

可以看到,定时器的数据结构十分的简单,基本上没有什么难理解的地方。下面主要看一下,如何使用该定时器。

主要API

要想在内核中使用timer_list定时器,一般需要以下几个步骤:

  1. 声明一个定时器,例如,struct timer_list timer;

  2. 初始化定义定时器,初始化定时器有几种方式:

    • #define TIMER_INITIALIZER(_function, _expires, _data) ,例如,struct timer_list timer = TIMER_INITIALIZER(func, expires, data);
    • #define DEFINE_TIMER(_name, _function, _expires, _data),例如,DEFIME_TIMER(timer,func,expires,data);
    • #define setup_timer(timer, fn, data), 例如,setup_timer(&timer, func, data)
  3. 增加定时器, add_timer用于将定时器添加到内核定时器链表中,至此,定时器开始工作。timer_list,为单次触发的定时器,如果想连续执行定时任务,那么需要再定时处理函数的末尾再次执行add_timer,以便再次激活定时器。add_timer函数原型如下:

    extern void add_timer(struct timer_list *timer);

  4. 删除定时器,del_timer用于将定时器从内核定时器链表中立刻去除,不管是否正在处理该定时器。del_timer_sync(),是del_timer的同步版本,其会等待该定时器被处理完毕,注意,该函数可能会导致发生系统调度,所以其不能用在原子上下文中,比如,中断上下文。del_timer函数原型如下:

    extern int del_timer(struct timer_list * timer);

  5. 修改定时器,mod_timer可以修改定时器的超时时间,其函数原型如下:

    mod_timer(struct timer_list *timer, unsigned long expires)

    • timer,表示当前被修改的定时器
    • expires,基于jiffiesd新的超时时间

对于已经激活的定时器(未激活时,mod_timer会将其激活),修改超时时间,使用mod_timer十分高效的,其相当于下面的操作:

del_timer(timer); timer->expires = expires; add_timer(timer); 
  • 1

这里需要注意的是,如果系统中有多个用户同步的使用同一个已激活的定时器(未加锁进行串行化),那么使用mod_timer是唯一可以安全的修改定时器的方法,因为mod_timer对于定时器的超时时间的修改是原子性的

定时器使用模板

好了,实际开发时,知道上面的API使用方式,完全可以应付90%的低速定时器使用场景。下面说一下此类定时器的使用时的具体模式,请看代码。

lrtimer.c文件:

    #include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/time.h>
	 
	static struct timer_list timer;
	static unsigned long data = 10; 	 
	 
	/*
	 * @breif:定时器处理函数
	 *
	 * @func:
	 *
	 * @param: data为setup_timer时传入的data参数
	 *
	 * @return:
	 *
	 */
	static void timer_cb(unsigned long data)
	{
	    printk("data = %lu.\n", data);
	 
	    mod_timer(&timer, jiffies + msecs_to_jiffies(10)); /*step3:重新激活定时器*/
	}
	 
	 
	static int __init module_lrtimer_init( void )
	{
	    printk("low resolution timer init.\n");
	    
	    setup_timer(&timer, timer_cb, data);              /*step1:定义并初始化定时器*/
	 
	    mod_timer(&timer, jiffies + msecs_to_jiffies(10/*ms*/));/*step2:修改定时器超时时间,并激活定时器*/
	 
	    return 0;
	}
	 
	 
	static void __exit module_lrtimer_exit( void )
	{
	    printk("low resolution timer exit.\n");
	    del_timer(&timer);
	}
	 
	module_init(module_lrtimer_init);
	module_exit(module_lrtimer_exit);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

Makefile文件:

	KVERS = $(shell uname -r)
	        
	# Kernel modules
	obj-m += lrtimer.o
	        
	# Specify flags for the module compilation.
	EXTRA_CFLAGS=-g -O0 
	        
	build: kernel_modules
	        
	kernel_modules:
	    make -C $(KVERS)/build M=$(CURDIR) modules
	        
	clean:
	    make -C $(KVERS)/build M=$(CURDIR) clean         
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

高精度定时器

上文看到低精度定时器的分辨率严重依赖内核的时钟中断,如果HZ为1000,那么其分辨率也仅仅为1ms,如果想要使用更高分辨率的定时器,那只能求助于hrtimer了。Linux内核在2005年开始在内核中增加hrtimer的支持,其基本特性如下:

  • 高精度,定时的分辨率为1ns(ps:实际的分辨率依赖于CPU时钟的频率,嵌入式系统的分辨率在us级别),其时钟源来自于CPU的硬件clock。
  • 与timer_list不同,与jiffies没有任何关系,所有内核逻辑都工作在64-bit ns级分辨率之上。
  • 支持多种平台,i386, x86_64, ARM, PPC, PPC64, IA64。

hrtimer的应用也十分的广泛,依赖于posix-timers的用户空间程序,内核中需要高分辨率的驱动程序(多媒体驱动程序)等。

检查是否支持hrtimer

在使用hrtimer之前,需要确认当前内核是否支持,检测是否支持的方式有两种:

  1. 对于自行编译的内核,可以检测内核的配置文件是否打开了CONFIG_HIGH_RES_TIMERS选项。

     #
     # Timers subsystem
     #
     CONFIG_TICK_ONESHOT=y
     CONFIG_NO_HZ_COMMON=y
     # CONFIG_HZ_PERIODIC is not set
     CONFIG_NO_HZ_IDLE=y
     # CONFIG_NO_HZ_FULL is not set
     CONFIG_NO_HZ=y
     CONFIG_HIGH_RES_TIMERS=y
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
  2. 对于现存的内核,可以通过查看/proc/timer_list的信息,来确定是否支持hrtimer。

     root@zpd /proc$ cat timer_list 
     Timer List Version: v0.7
     HRTIMER_MAX_CLOCK_BASES: 4
     now at 1559369165518 nsecs
     
     cpu: 0
      clock 0:
       .base:       8bdc0308
       .index:      0
       .resolution: 1 nsecs
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

注意到,HRTIMER_MAX_CLOCK_BASES:4,.resolution: 1 nsecs表示当前内核是支持hrtimer的。

基本数据结构

  1. ktime:

     union ktime {   
         s64 tv64;
     	#if BITS_PER_LONG != 64 && !defined(CONFIG_KTIME_SCALAR)
     	struct {
     	# ifdef __BIG_ENDIAN
     	s32 sec, nsec;
     	# else
     	s32 nsec, sec;
     	# endif
     	} tv; 
     	#endif	
     };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

ktime用于保存hrtimer的定时时间,从定义中可以看出其完美高效的支持32bit/64bit系统。

  1. hrtimer

     struct hrtimer {
     	struct timerqueue_node		node;
     	ktime_t				_softexpires;
     	enum hrtimer_restart		(*function)(struct hrtimer *);
     	struct hrtimer_clock_base	*base;
     	u8				state;
     	u8				is_rel;
     };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

struct hrtimer为hrtimer的基本数据结构,其主要包括如下几部分:

  • node,hrtimer最终通过node挂接到timerqueue中。
  • _softexpires,表示hrtimer的定时时间,_soft表示此定时时间只是软件意义上的。
  • function,表示hrtimer的超时处理函数。

主要API

  1. ktime相关的API

    • ktime_t ktime_set(const long secs, const unsigned long nsecs),通过secs和nsecs生成ktime_t
    • static inline ktime_t ns_to_ktime(u64 ns),通过ns生成ktime_t
    • static inline ktime_t ms_to_ktime(u64 ms),通过ms生成ktime_t
  2. hrtimer_init 用于初始化一个hrtimer

     extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock, enum hrtimer_mode mode);
    
     - timer:表示hrtimer定时器
     - which_clock:表示选择系统的哪种时钟,主要包括两种:CLOCK_REALTIME、CLOCK_MONOTONIC,两种时钟的区别是,CLOCK_REALTIME表示绝对时间,而CLOCK_MONOTONIC表示相对时间。
     - mode:表示hrtimer的类型,主要包括两种:HRTIMER_MODE_ABS、HRTIMER_MODE_REL,前者是绝对模式,对应于CLOCK_REALTIME时钟,后者是相对模式,对应于CLOCK_MONOTONIC。
    
    • 1
    • 2
    • 3
    • 4
    • 5
  3. hrtimer_start用于启动一个定时器

     int hrtimer_start(struct hrtimer *timer, ktime_t tim, const enum hrtimer_mode mode)
     
    - timer:表示当前的定时器
    - tim:定时时间
    - mode:与hrtimer_init中的mode一样。
    
    • 1
    • 2
    • 3
    • 4
    • 5
  4. hrtimer_cancle应于取消一个定时器, 并等待其执行完毕

     int hrtimer_cancel(struct hrtimer *timer)
    
    • 1
  5. hrtimer_forward_now,重新设置hrtimer的超时时间,用于实现连续定时。

      u64 hrtimer_forward_now(struct hrtimer *timer, ktime_t interval)                                                                                                                                                  
    
    • 1

示例

下面是基于hrtimer的简单示例,定时器的超时时间为10ms,并且在定时器超时处理函数中,调用hrtimer_forward_now再次启动定时器。

hrtimer.c

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/hrtimer.h>
#include <linux/ktime.h>
 
MODULE_LICENSE("GPL");
                                                                                                                                                                                                                    
static struct hrtimer hr_timer;
static unsigned long interval= 10; /* unit: ms */
struct timespec uptimeLast;
 
unsigned long long diff_tv(struct timespec start, struct timespec end) 
{
    return (end.tv_sec - start.tv_sec)*1000000000 + (end.tv_nsec-start.tv_nsec);
}
 
enum hrtimer_restart my_hrtimer_callback( struct hrtimer *timer )
{
    struct timespec uptime;
 
    do_posix_clock_monotonic_gettime(&uptime);  
 
    printk(KERN_INFO"hrtimer:%9lu sec, %9lu ns, interval_delay=%lu us\n", 
            (unsigned long) uptime.tv_sec, 
            uptime.tv_nsec,
            (unsigned long)(diff_tv(uptimeLast, uptime))/1000); 
 
    uptimeLast=uptime;
 
    hrtimer_forward_now(timer, ns_to_ktime(interval));
 
    return HRTIMER_RESTART;
}
 
static int __init module_hrtimer_init( void )
{
    struct timespec uptime; 
    static ktime_t ktime;
 
    printk(KERN_INFO"HR Timer module installing\n");
 
    hrtimer_init( &hr_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL );
 
    ktime = ms_to_ktime(interval);
 
    hr_timer.function = my_hrtimer_callback;
    hrtimer_start(&hr_timer, ktime, HRTIMER_MODE_REL );
 
    do_posix_clock_monotonic_gettime(&uptime);
    uptimeLast = uptime;
 
    printk(KERN_INFO "hrtimer:%9lu sec, %9lu ns\n", 
            (unsigned long) uptime.tv_sec, uptime.tv_nsec ); 
 
    return 0;
}

static void __exit module_hrtimer_exit( void )
{
	int ret;
    ret = hrtimer_cancel( &hr_timer );
    if (ret) 
      printk("The timer was still in use...\n");
    printk("HR Timer module uninstalling.\n");
}

module_init(module_hrtimer_init);
module_exit(module_hrtimer_exit);   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68

Makefile文件:

#KVERS = $(shell uname -r)                                                                                                                                                                                          

# Kernel modules
obj-m += hrtimer.o

# Specify flags for the module compilation.	
EXTRA_CFLAGS=-g -O0 

build: kernel_modules

kernel_modules:
    make -C $(KVERS)/build M=$(CURDIR) modules

clean:
    make -C $(KVERS)/build M=$(CURDIR) clean
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家自动化/article/detail/183435
推荐阅读
相关标签
  

闽ICP备14008679号