Linux 内核定时器

目录

• 内核定时器
  • 定时器数据结构与函数
  • 定时器时间单位
  • 定时器使用模板
• 内核延时
  • 短延迟
  • 长延迟
  • 睡着延迟
• 参考

内核定时器

软件意义的定时器依赖于硬件定时器来实现，内核在时钟中断发生后检测各定时器是否到期，到期后定时器处理函数将作为软中断在底半部执行。实质上，时钟中断处理程序会唤起TIMER_SOFTIRQ软中断，运行当前处理器上到期的所有定时器。

定时器数据结构与函数

Linux设备驱动编程中，可利用Linux内核提供 一组函数和数据结构来实现定时触发工作，或者完成周期性的任务。

Linux内核提供的用于操作定时器的数据结构和函数位于<linux/timer.h>，定义/声明如下：

1）timer_list结构体

timer_list定义：

struct timer_list {
    /*
     * All fields that change during normal runtime grouped to the
     * same cacheline
     */
    struct hlist_node    entry;
    unsigned long        expires; // 定时器到期时间(jiffies)
    void                 (*function)(unsigned long); // 超时处理函数
    unsigned long        data;   // 传递给function()的参数
    u32                  flags;

#ifdef CONFIG_TIMER_STATS
    int             start_pid;
    void            *start_site;
    char            start_comm[16];
#endif
#ifdef CONFIG_LOCKDEP
    struct lockdep_map   lockdep_map;
#endif
};

一个timer_list结构体对象对应一个定时器。当定时器到期后，超时处理函数function()将会被执行。
驱动程序中，定义一个名为my_timer的定时器：

struct timer_list my_timer;

2）初始化定时器

init_timer 是一个宏，用于初始化定时器，其原型等价于：

void init_timer(struct timer_list *timer);

setup_timer 也是一个宏，用于初始化定时器并赋值其成员，原型等价于：

void setup_timer(struct timer_list *timer, void (*function)(unsigned long), unsigned long data, u32 flags);
// 源代码
#define setup_timer(timer, fn, data)                    \
    __setup_timer((timer), (fn), (data), 0)

#define __setup_timer(_timer, _fn, _data, _flags)            \
    do {                                \
        __init_timer((_timer), (_flags));            \
        (_timer)->function = (_fn);                \
        (_timer)->data = (_data);                \
    } while (0)

setup_timer与init_timer的区别在于，前者需要在调用时，指明超时处理函数、参数、标志位。

TIMER_INITIALIZER(_function, _expires, _data) 宏用于赋值定时器结构体的function、expires、data、flags等成员，该宏等价于：

#define TIMER_INITIALIZER(_function, _expires, _data) { \
        .entry = { .next = TIMER_ENTRY_STATIC },    \
        .function = (_function),            \
        .expires = (_expires),                \
        .data = (_data),                \
        .flags = (_flags),                \
        __TIMER_LOCKDEP_MAP_INITIALIZER(        \
            __FILE__ ":" __stringify(__LINE__))    \
    }

3）增加定时器

add_timer用于注册内核定时器，将定时器加入到内核动态定时器链表中。

void add_timer(struct timer_list *timer);

4）删除定时器

用于从内核定时链表删除定时器。

int del_timer(struct timer_list * timer);

del_timer_sync()是del_timer()的同步版，在删除一个定时器时需要等待其被处理完，因此该函数的调用不能位于中断上下文。因为中断上下文要求执行迅速，不能做无谓的等待。

5）修改定时器的expire

函数用于修改定时器的到期时间，在新的被传入的expires到来后，才会执行定时器函数。

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

定时器时间单位

内核源码根目录下，“ls -a”命令可以看到一个隐藏文件，这就是内核配置文件。打开后，可以看到这一项：

CONFIG_HZ=100

该项表示内核每秒会发生100次系统嘀嗒中断（tick），类似于人的心跳，这是Linux系统的心跳。每发生一次tick中断，全局遍历jiffies就会累加1。
CONFIG_HZ的单位是HZ，值100表示每个嘀嗒是10ms。

内核定时器timer_list 的时间就是基于jiffies的。如果我们要修改超时时间，通常用这2种方法：
（1）在add_timer之前，直接修改：

timer.expires = jiffies + xxx;    // xxx 表示多少各嘀嗒后超时，也就是xxx*10ms
timer.expires = jiffies + 2 * HZ; // HZ等于CONFIG_HZ，2*HZ相当于2秒

（2）在add_timer之后，使用mod_timer修改：

mod_timer(&timer, jiffies + xxx);    // xxx 表示多少各嘀嗒后超时，也就是xxx*10ms
mod_timer(&timer, jiffies + 2 * HZ); // HZ等于CONFIG_HZ，2*HZ相当于2秒

定时器使用模板

几个要素：1）定义定时器结构体；2）初始化定时器，并设置超时处理函数、参数、超时时间等；3）添加定时器；4）删除定时器；5）定义超时处理函数。

/* xxx 字符设备结构体 */
struct xxx_dev {
    struct cdev cdev;
    ...
    timer_list xxx_timer; /* 设备要用的定时器 */
};

/* xxx 驱动中的函数 */
xxx_func(...)
{
    struct xxx_dev *dev = filp->private_data;
    ...
    /* 初始化定时器 */
    init_timer(&dev->xxx_timer);
    dev->xxx_timer.function = &xxx_do_timer;  // 超时处理函数
    dev->xxx_timer.data = (unsigned long)dev; // 超时处理函数的参数
    dev->xxx_timer.expires = jiffies + delay; // 超时时间
    /* 添加（注册）定时器 */
    add_timer(&dev->xxx_timer);
    ...
}

/* xxx 驱动中的另一个函数 */
xxx_func2(...)
{
    ...
    /* 删除定时器 */
    del_timer(&dev->xxx_timer);
    ...
}

/* 定时器处理函数 */
static void xxx_do_timer(unsigned long arg)
{
    struct xxx_device *dev = (struct xxx_device*)arg;
    ...
    /* 调度定时器再执行 */
    dev->xxx_timer.expires = jiffies + delay;
    add_timer(&dev->xxx_timer);
    ...
}

---

内核延时

短延迟

Linux内核提供3个函数，分别以纳秒、微秒、毫秒为单位进行延迟：

void ndelay(unsigned long nsecs);
void udelay(unsigned long usecs);
void mdelay(unsigned long msecs);

延迟的实现原理是忙等等，根据CPU频率进行一定次数的循环。等价自定义实现于：

void delay(unsigned long time)
{
    while(time--);
}

内核启动时，会运行一个延迟循环校准（Delay Loop Calibration），计算出lpj（Loops Per Jiffy），内核启动时会打印如下类似信息：

Calibrating delay loop... 530.84 BogoMIPS (lpj=1327104)

如果我们直接在bootloader（uboot）传递给内核的bootargs中设置lpj=1327104，则可以省掉这个校准的过程，节约百毫秒开机时间。

在内核中，最好不要直接使用mdelay()，因为毫秒级延时很大了，无谓的等待将耗费CPU资源。对于毫秒级以上的延时，内核提供下列函数：

void msleep(unsigned int millisecs);
unsigned long msleep_interruptible(unsigned int millisecs);
void ssleep(unsigned int seconds);

上述函数，将使得调用它的进程睡眠参数指定的时间为millisecs。区别在于msleep()、ssleep()不能被打断，msleep_interruptible()能被打断。
注意：受系统Hz及进程调度的影响，msleep()及类似函数的精度有限。

长延迟

内核中进行延迟的一个很直观方法：比较当前jiffies（系统嘀嗒）和目标jiffies（设置为当前jiffies加上时间间隔的jiffies），直到未来jiffies达到目标jiffies。

例，先用忙等待延迟100个jiffies，再延迟2s。

/* 延迟100个jiffies */
unsigned long delay = jiffies + 100; // jiffies默认10ms单位, +100 意指1s以后
while (time_before(jiffies, delay));

/* 再延迟2s */
unsigned long delay = jiffies + 2*Hz; // Hz 单位1s
while (time_before(jiffies,  delay));

上述代码本质上都是忙等待。

time_before() 对应还有个time_after()，实际上是将传入的未来时间jiffies和被调用时的jiffies进行一个简单的比较：

#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)

timebefore(a,b) 含义：如果a在b前面，即a < b，那么表达式为true；否则，表达式为假。

睡着延迟

睡着延迟是在等待的时间到来之前，进程处于睡眠状态，CPU资源被其他进程使用。

schedule_timeout() ：使得当前任务休眠至指定的jiffies之后，再重新被调度执行。
msleep()，msleep_interrupt() 本质上都是依靠包含了schedule_timeout() 的schedule_timeout_uninterruptible()和schedule_timeout_interruptible()来实现睡眠的。

schedule_timeout原型：

#include <linux/sched.h>

signed long schedule_timeout(signed long timeout);

msleep和msleep_interrupt的实现：

void msleep(unsigned int msecs)
{
    unsigned long timeout = msecs_to_jiffies(msecs) + 1; // 将msec(毫秒单位)转换为jiffies并加1, 作为timeout

    while (timeout)
        timeout = schedule_timeout_uninterruptible(timeout);
}

unsigned long msleep_interruptible(unsigned int msecs)
{
    unsigned long timeout = msecs_to_jiffies(msecs) + 1;

    while (timeout && !signal_pending(current))
        timeout = schedule_timeout_interruptible(timeout);
    return jiffies_to_msecs(timeout);
}

schedule_timeout的实现原理是向系统添加一个定时器，在定时器处理函数中唤醒与参数对应的进程。

schedule_timeout_interruptible() 与 schedule_timeout_uninterruptible() 区别在于：前者在调用schedule_timeout() 之前置进程状态为TASK_INTERRUPTIBLE，后者置进程状态为TASK_UNINTERRUPTIBLE。也就是说，前者对应进程可以被中断唤醒，后者对应进程无法被中断唤醒。

schedule_timeout_interruptible与schedule_timeout_uninterruptible的实现：

signed long __sched schedule_timeout_interruptible(signed long timeout)
{
    __set_current_state(TASK_INTERRUPTIBLE);
    return schedule_timeout(timeout);
}

signed long __sched schedule_timeout_uninterruptible(signed long timeout)
{
    __set_current_state(TASK_UNINTERRUPTIBLE);
    return schedule_timeout(timeout);
}

#define __sched        __attribute__((__section__(".sched.text"))) // 将代码放到指定段".sched.text"

还有两个函数：sleep_on_timeout，可以将当前进程添加到等待队列中，从而在等待队列上睡眠。当超时发生时，进程将被唤醒（后者可以在超时前被打断）：

sleep_on_timeout(wait_queue_head_t *q, unsigned long timeout);

interruptible_sleep_on_timeout(wait_queue_head_t *q, unsigned long timeout);

---

参考

[1]宋宝华. Linux设备驱动开发详解[M]. 人民邮电出版社, 2010.