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