linux内核静态定时器,Linux内核中的定时器

jiffies操作函数

include/linux/jiffies.h:

#define time_after(a,b)

(typecheck(unsigned long, a) &&

typecheck(unsigned long, b) &&

((long)((b) - (a)) < 0))

#define time_before(a,b) time_after(b,a)

#define time_after_eq(a,b)

(typecheck(unsigned long, a) &&

typecheck(unsigned long, b) &&

((long)((a) - (b)) >= 0))

#define time_before_eq(a,b) time_after_eq(b,a)

系统使用一个　unsigned long 类型来表示系统从启动开始到当前的系统滴答计数jiffies。那么经过一定的时间后可能会产生数据溢出问题，而利用上述宏定义的函数已经把溢出问题考虑进去了，所以不管在何时使用jiffies操作，最好都使用上述宏操作。

低精度定时器

内核基于tick系统滴答实现了低精度定时器，使用时利用(jiffies+interval)来设定定时器的expires超期时间。

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;

#ifdef CONFIG_LOCKDEP

struct lockdep_map lockdep_map;

#endif

};

extern void init_timers(void);

extern void add_timer(struct timer_list *timer);

extern void add_timer_on(struct timer_list *timer, int cpu);

extern int del_timer(struct timer_list * timer);

extern int mod_timer(struct timer_list *timer, unsigned long expires);

extern int mod_timer_pending(struct timer_list *timer, unsigned long expires);

需要注意的是这种类型的定时器是在软中断中执行的。

ktime操作函数

前面介绍了系统滴答和基于它实现的低精度定时器，对于HZ=100的系统来说，这种定时器精度确实不高，如果要使用更高精度的定时器，为了防止溢出，就需要有一个新的更大的变量类型来表示它。

ktime_t是一个以nanosecond精度来表示的墙上时间的结构体：

typedef s64 ktime_t;

内核中的timekeeping模块实现了墙上时间：

struct timespec {

long ts_sec;

long ts_nsec;

};

struct timespec xtime;

可以方便的利用如下接口转换xtime和ktime_t类型：

/* convert a timespec to ktime_t format: */

static inline ktime_t timespec_to_ktime(struct timespec ts)

{

return ktime_set(ts.tv_sec, ts.tv_nsec);

}

struct timespec ns_to_timespec(const s64 nsec)

{

struct timespec ts;

s32 rem;

if (!nsec)

return (struct timespec) {0, 0};

ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);

if (unlikely(rem < 0)) {

ts.tv_sec--;

rem += NSEC_PER_SEC;

}

ts.tv_nsec = rem;

return ts;

}

#define ktime_to_timespec(kt) ns_to_timespec((kt))

高精度的定时器都会利用ktime作为时间计算单位，它的操作函数如下：

static inline ktime_t ktime_set(const s64 secs, const unsigned long nsecs)

{

if (unlikely(secs >= KTIME_SEC_MAX))

return KTIME_MAX;

return secs * NSEC_PER_SEC + (s64)nsecs;

}

static inline int ktime_compare(const ktime_t cmp1, const ktime_t cmp2)

{

if (cmp1 < cmp2)

return -1;

if (cmp1 > cmp2)

return 1;

return 0;

}

static inline bool ktime_after(const ktime_t cmp1, const ktime_t cmp2)

{

return ktime_compare(cmp1, cmp2) > 0;

}

static inline bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)

{

return ktime_compare(cmp1, cmp2) < 0;

}

hrtimer高精度定时器

高精度定时器最大可以使用nanosecond的精度来进行定时器设定，所以这类定时器都使用ktime_t类型来描述超期时间。

/* Initialize timers: */

void hrtimer_init(struct hrtimer *timer, clockid_t which_clock, enum hrtimer_mode mode);

void hrtimer_start(struct hrtimer *timer, ktime_t tim, const enum hrtimer_mode mode);

int hrtimer_cancel(struct hrtimer *timer);

int hrtimer_try_to_cancel(struct hrtimer *timer);

void hrtimer_restart(struct hrtimer *timer);

hrtimer它所支持的clock类型有如下一些(4.14内核版本)：

#define CLOCK_REALTIME 0 //实际时间，也就是常说的墙上时间

#define CLOCK_MONOTONIC 1 //单调增长时间，从系统启动时开始计算，不包含suspend时间

#define CLOCK_PROCESS_CPUTIME_ID 2 //进程CPU时间

#define CLOCK_THREAD_CPUTIME_ID 3 //线程CPU时间

#define CLOCK_MONOTONIC_RAW 4 //单调增长时间，从系统启动时开始计算，不包含时钟频率漂移的调整(NTP服务)

#define CLOCK_REALTIME_COARSE 5

#define CLOCK_MONOTONIC_COARSE 6

#define CLOCK_BOOTTIME 7 //从系统启动时开始计算，包含了suspend时间

#define CLOCK_REALTIME_ALARM 8 //alarm时钟

#define CLOCK_BOOTTIME_ALARM 9 //alarm时钟

参考：

kernel-4.14 source code

https://www.kernel.org/doc/html/v4.14/driver-api/index.html