Linux fd 系列 — 定时器 timerfd 是什么？

timerfd 长什么样子？

什么是 timerfd ？这是跟时间有关系的 fd 类型，通常叫做定时器 fd ，先去看一下 timerfd 的样子吧。奇伢在 Linux 的机器上找了一个 open 了 timerfd 的进程，如下：

root@ubuntu:~# ll /proc/6997/fd/
...
lrwx--- 1 root root 64 Aug 10 14:13 3 -> anon_inode:[timerfd]

root@ubuntu:~# cat /proc/6997/fdinfo/3 
pos: 0
flags: 02
mnt_id: 11
clockid: 0
ticks: 0
settime flags: 01
it_value: (0, 969820149)
it_interval: (1, 0)

通过 proc fs 通过 /proc/${pid}/fd/ 可以看到进程打开的句柄。这里看到挺关键的信息：anon_inode:[timerfd]，说明 timerfd 绑定的是匿名 inode。

通过 /proc/${pid}/fdinfo/ 可以看到句柄的展示信息。

• clockid：时钟类型；
• ticks：超时次数；
• settime flags：这个是 timerfd_settime 的参数；
• it_value：定时器到期还剩多少时间；
• it_interval：超时间隔；

timerfd 是什么？

timerfd 这个名字拆开来看，就是 timer fd，所谓定时器 fd 类型，那么它的可读可写事件一定是跟时间有关系。timerfd 被 new 出来之后 （ timerfd_create ），可以设置超时时间（ timerfd_setting ），超时之后，该句柄可读，读出来的是超时的次数。

文件句柄，网络句柄都是可以 read/write/close 的，timerfd 可以做什么？

timerfd 可以 read，poll，close ，这个从内核实现的接口可知：

// fs/timerfd.c
static const struct file_operations timerfd_fops = { 
    .release    = timerfd_release,
    .poll       = timerfd_poll,
    .read       = timerfd_read,
    .show_fdinfo    = timerfd_show,
    // ...
};

定时器句柄 timerfd 的实现就内聚在 fs/timerfd.c 一个文件。还记得上面 cat /proc/${pid}/fdinfo/ 里面展示的信息吗？就是 timerfd_show 负责展示的。

timerfd 的使用姿势？

涉及到 timerfd 的系统调用有 3 个，函数原型如下：

// 创建一个 timerfd 句柄
int timerfd_create(int clockid, int flags);
// 启动或关闭 timerfd 对应的定时器
int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);
// 获取指定 timerfd 距离下一次超时还剩的时间
int timerfd_gettime(int fd, struct itimerspec *curr_value);

timerfd 常用来做定时器的使用，设置超时时间之后，每隔一段时间 timerfd 就是可读的。使用 man timerfd_create 就能查看到完整的文档，有一个 c 语言的示例，简要看下这个例子：

int main(int argc, char *argv[]) {
    // 第一次超时时间
    new_value.it_value.tv_sec = now.tv_sec + atoi(argv[1]);
    new_value.it_value.tv_nsec = now.tv_nsec;
    // 设置超时间隔
    new_value.it_interval.tv_sec = atoi(argv[2]);
    new_value.it_interval.tv_nsec = 0;
    // 创建 timerfd
    fd = timerfd_create(CLOCK_REALTIME, 0);
    // 设置第一次超时时间和超时间隔
    if (timerfd_settime(fd, TFD_TIMER_ABSTIME, &new_value, NULL) == -1)
    // 定时器循环
    for (tot_exp = 0; tot_exp < max_exp;) {
        // read timerfd，获取到超时次数
        s = read(fd, &exp, sizeof(uint64_t));
        // 累计总超时次数
        tot_exp += exp;
        // 打印超时次数的信息
        printf("read: %llu; total=%llu\n", (unsigned long long) exp, (unsigned long long) tot_exp);
    }
}

这个例子做的事情：

• 通过 timerfd_create 获取到一个句柄之后，使用 timerfd_settime 设置超时时间并启动内核定时器；
• 后续使用 read 来读数据，timerfd 没超时之前 read 会阻塞到，直到内核定时器超时之后 read 才会返回，这样就达到了一个定时的效果；

上面例子相当于每隔一段时间 sleep 一下，然后打印一行信息，周期运行，这就是 timerfd 官方最简单的例子。

timerfd 可以和 epoll 配合起来，让 epoll 监听 timerfd 的可读事件，这样 timerfd 超时触发可读事件，epoll_wait 被唤醒，业务进行周期处理，从而也能达到定时器的目的。

timerfd 原理剖析

我们简要的看下内核的实现，原理其实很简单。

1 timerfd_create

从用户角度来看，该函数创建一个 timerfd，返回的 fd 可以进行 read、poll ( poll 、select，epoll )、close 等操作。

我们从源码实现角度来看，timerfd_create 对应了一个系统调用：

SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags)
{   
    int ufd;
    struct timerfd_ctx *ctx;

    // timerfd 对应的核心数据结构体
    ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);

    // 重要：初始化 ctx->wqh 队列，这是个表头，用来挂接 wait 对象的
    init_waitqueue_head(&ctx->wqh);

    // 初始化定时器
    if (isalarm(ctx))
        alarm_init(&ctx->t.alarm, ctx->clockid == CLOCK_REALTIME_ALARM ? ALARM_REALTIME : ALARM_BOOTTIME, timerfd_alarmproc);
    else
        hrtimer_init(&ctx->t.tmr, clockid, HRTIMER_MODE_ABS);

    // 获取一个匿名 fd，对应 file->f_op 初始化成 timerfd_fops
    ufd = anon_inode_getfd("[timerfd]", &timerfd_fops, ctx, O_RDWR | (flags & TFD_SHARED_FCNTL_FLAGS));
    // 返回正数句柄
    return ufd;
}

函数最关键做了以下几件事：

• 创建并初始化了一个 timerfd_ctx 的结构体（在这个 ctx 结构体内有个表头 ctx->wqh 很重要，是和 epoll 产生联系的关键点）；
• 初始化了定时器，根据类型可以创建 alarm 类型或者高精度的 hrtimer 类型的定时器（ 注意：timerfd 本身并没有实现定时器的功能，定时器直接使用的是内核封装好的定时器，timerfd 只针对“文件”的封装）；
• 创建一个匿名 fd，绑定 timerfd_fops 操作表；

核心结构体 timerfd_ctx ：

struct timerfd_ctx {
    // 真正的内核定时器
    union {
        struct hrtimer tmr;
        struct alarm alarm;
    } t;
    // wait 对象挂接的表头
    wait_queue_head_t wqh;
    // 记录超时的次数
    u64 ticks;
    // 定时器类型
    int clockid;
    // ...
};

这个 ctx 对象会赋值给 file->private_data 字段。后面针对 fd 的操作，就可以先通过 fd 找到 file ，取得 file->private_data ，强转成 timerfd_ctx 类型，然后进行定时器 fd 的一系列操作。

注意到关键操作：获取一个 file 结构体用的是 anon_inode_getfd 函数，这个函数是获取一个匿名句柄的。

重点提一下匿名 fd 的事情，为什么会有匿名 fd ? 什么是匿名？

在 Linux 里一切皆文件，你理解的常见“文件”有什么特性？是路径，也就是 path ，匿名的意思说的就是没有路径（ 在内核里面说的就是没有有效的 dentry ）。

在 Linux 的文件体系中，一个文件句柄，对应一个 file 结构体，关联一个 inode 。file/dentry/inode 这三驾马车是一定要配齐的，就算是匿名的（无 path，无效 dentry），对于 file 结构体来说，一定要绑定 inode 和 dentry ，哪怕是伪造的、不完整的 inode。

anon_inodefs 就应运而生了，内核就帮你搞出来一个公共的 inode ，这就节省了所有有这样需求的内核模块，避免了内存的浪费，省了冗余重复的 inode 初始化代码。

匿名 fd 背后的是一个叫做 anon_inodefs 的内核文件系统（ 位于 fs/anon_inodes.c ），这个文件系统极其简单，整个文件系统只有一个 inode ，这个 inode 是文件系统初始化的时候创建好的。

之后，所有需要一个匿名 inode 的句柄都直接跟这个 inode 关联即可。使用匿名 inode 的句柄叫做匿名句柄。

2 timerfd_settime

该函数是启停 timerfd 超时的，用来设置超时的时间，间隔的。参数结构如下：

struct timespec {
    time_t tv_sec;                /* Seconds */
    long   tv_nsec;               /* Nanoseconds */
};

struct itimerspec {
    struct timespec it_interval;  /* Interval for periodic timer */
    struct timespec it_value;     /* Initial expiration */
};

在结构体 itimerspec 的 it_value 字段标识定时器第一次超时时间，it_interval 标识之后的超时间隔。

主要逻辑如下：

SYSCALL_DEFINE4(timerfd_settime, int, ufd, int, flags, const struct __kernel_itimerspec __user *, utmr, struct __kernel_itimerspec __user *, otmr)
{
    ret = do_timerfd_settime(ufd, flags, &new, &old);
}
static int do_timerfd_settime(int ufd, int flags, const struct itimerspec64 *new, struct itimerspec64 *old)
{
    // 通过 fd 查询到 file 结构体
    ret = timerfd_fget(ufd, &f);

    // 通过 file 获取到 timerfd_ctx
    ctx = f.file->private_data;

    // 如果有已经存在的 timer 定时器，需要先停止；
    for (;;) {
        // 定时器处理逻辑
    }
    // 保存旧的定时器设置的值
    old->it_value = ktime_to_timespec64(timerfd_get_remaining(ctx));
    old->it_interval = ktime_to_timespec64(ctx->tintv);

    // 重置定时器
    ret = timerfd_setup(ctx, flags, new);
}

static int timerfd_setup(struct timerfd_ctx *ctx, int flags, const struct itimerspec64 *ktmr)
{
    // 根据是 alarm 还是 hrtimer 类型，进行定时器初始化；
    // 用 alarm_init 或者 hrtimer_init ，主要设置时间和回调这两个重要参数；
    // 回调函数分别是 timerfd_alarmproc 或者 timerfd_tmrproc
    if (isalarm(ctx)) {
        alarm_init(&ctx->t.alarm, ctx->clockid == CLOCK_REALTIME_ALARM ? ALARM_REALTIME : ALARM_BOOTTIME, timerfd_alarmproc);
    } else {
        hrtimer_init(&ctx->t.tmr, clockid, htmode);
    }

    if (texp != 0) {
        // 定时器启动，用 alarm_start 或者 hrtimer_start
    }
}

操作很简单：

1. 通过 fd 获取到 file，再获取到核心结构体 timerfd_ctx；
2. 然后再操作定时器，启动定时器即可；

划重点：timerfd 本身并没有实现定时器的功能，定时功能直接使用的是内核封装好的定时器，timerfd 只针对“文件语义”的封装，让定时器能跟文件一样，进行 IO 操作。

3 timerfd_gettime

该函数用于获取指定 timerfd 距离下一次超时还剩的时间。

SYSCALL_DEFINE2(timerfd_gettime, int, ufd, struct __kernel_itimerspec __user *, otmr)
{
    int ret = do_timerfd_gettime(ufd, &kotmr);
}
static int do_timerfd_gettime(int ufd, struct itimerspec64 *t)
{
    // 通过 fd 获取到 file 结构体
    int ret = timerfd_fget(ufd, &f);
    // 通过 file 获取到 timerfd_ctx 结构体
    ctx = f.file->private_data;
    // 计算距离下一次到期的时间
    // ...
}

操作步骤：

1. 通过 fd 获取到 file，再获取到核心结构体 timerfd_ctx ；
2. 然后通过 timerfd_ctx 里面存储的信息，计算举例下一次超时的时间即可；

timerfd 和 epoll 的配合

每个 fd 类型奇伢都会带上 epoll ，让大家一遍遍去理解 epoll 机制，这次的 timerfd 是个非常好的机会，因为它足够简单，没有任何复杂性。下面跟着奇伢一起梳理下吧，抓住这个机会哦。

1 timerfd 创建的时候暗藏玄机？

前面提到了，timerfd 的核心结构是 timerfd_ctx ，挂到 file->private_data 字段上，在 ctx 里面有一个链表的表头，还记得吗？

就是这个 timerfd_ctx->wqh ，这是一个链表表头，timerfd 创建的时候初始化，这就是玄机。

这个表头都是用来挂接 wait 对象的，在事件就绪的时候，就会遍历这个表，依次调用 wait 对象的回调函数。

类比分享过的 Linux fd 系列的特殊 fd：

• timerfd：在 timerfd_ctx 结构体中有个表头 timerfd_ctx->wqh；
• eventfd：在 eventfd_ctx 结构体中有个表头 eventfd_ctx->wqh；
• socketfd：在 sock 结构体中有个表头 sk->sk_wq ；

划重点：这个 wait 链表是核心基础之一呀，给 poll 操作的时候，挂 wait entry 用的。

初始化过程的另一个核心是把 timerfd 的 file->f_op 设置为 timerfd_fops 函数操作表；

重点小结下：

1. 创建了 timerfd_ctx 结构体，里面有个 wait entry 的队列（ ctx->wqh ）；
2. file->f_op 赋值为 timerfd_fops 操作表；

2 epoll_ctl 的配合？

问题来了，那什么时候会往 ctx->wqh 添加元素呢？

以 timerfd 来说，timerfd_poll 函数中会使用 poll_wait 函数往这个链表中添加元素。调用如下：

// fs/timerfd.c
static __poll_t timerfd_poll(struct file *file, poll_table *wait) {
    // 添加元素
    poll_wait(file, &ctx->wqh, wait);
}

// include/linux/poll.h
static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p) {
    if (p && p->_qproc && wait_address)
        p->_qproc(filp, wait_address, p); 
}

wait 对象就是在 poll_wait 函数中，通过 p->_qproc 添加到链表的。童鞋可能会问了，这个函数回调是啥呢？这个问题先留着，先往后看。

先来思考一个问题，谁会调用到 timerfd_poll 呢？

epoll_ctl 注册句柄的时候会！具体调用路径如下：

epoll_ctl
    -> ep_insert
        // poll_table->_qporc 初始化成 ep_ptable_queue_proc
        -> init_poll_funcptr 
        // 挂接等待链表
        -> ep_item_poll
            -> vfs_poll
                -> timerfd_poll

我们知道 vfs_poll 就是调用 file->f_op->poll 操作函数，而 timerfd 的 f_op 操作表是 timerfd_fops ，.poll 接口就是 timerfd_poll ，这就串起来了呀。

同时这里也回答了上面另一个问题，p->_qproc 是啥？

是在 ep_insert 中 init_poll_funcptr 里初始化成 ep_ptable_queue_proc 函数了。

那我们想再看一下 ep_ptable_queue_proc 里面究竟是怎么添加的？

static void ep_ptable_queue_proc(struct file *file, wait_queue_head_t *whead, poll_table *pt) {
    // 获取到对应的 epitem
    struct epitem *epi = ep_item_from_epqueue(pt);

    // 初始化 wait entry
    init_waitqueue_func_entry(&pwq->wait, ep_poll_callback);
    pwq->whead = whead;
    pwq->base = epi; 

    // 添加 wait entry 到链表中（这个链表，就是 timerfd_ctx->wqh 的链表）
    if (epi->event.events & EPOLLEXCLUSIVE)
        add_wait_queue_exclusive(whead, &pwq->wait);
    else 
        add_wait_queue(whead, &pwq->wait);

}

通过这里我们得到两个关键信息：

1. wait entry 的回调（ wq_entry->func ）设置为：ep_poll_callback；
2. pwq->base 设置为 epi（句柄对应的 epoll item 结构体）；

ep_poll_callback 主要做两个事情：

1. 把对应的 epitem 挂到 epoll 的 ready list 链表（就绪链表）；
2. 唤醒 epoll_wait 阻塞的进程（ epoll_wait 切走之前，把 cur 进程对应的一个 wait entry 挂到了 epoll 的 wait 链表中）；

重点小结：

1. epoll_ctl 里面通过 timerfd_poll 函数，把一个跟 epitem 关联的 wait entry 挂到 timerfd 的 ctx->wqh 队列中；
2. 这个 wait entry 的回调参数设置为 ep_poll_callback ，参数为 epitem；

有了这两手准备工作，等 timerfd 事件准备好了之后，就能通过 wait entry 通知到 epoll 池了。

3 timerfd 怎么唤醒 epoll_wait？

准备工作基本上就做好了，回调唤醒的路已经准备好了，下面继续看下怎么触发的。

timerfd 实现定时器的功能是直接用的内核定时器，根据类型分为两种：

struct hrtimer tmr;
struct alarm alarm;

hrtimer 是高精度的定时器，为了方便，奇伢下面就只说 hrtimer 定时器。定时器可以设置回调函数，超时之后会异步调用。timerfd 设置的回调函数是 timerfd_tmrproc ，那么不难想象，这个函数中是回调的起点。

定时器到期之后，内核调用回调：

timerfd_tmrproc (在初始化的时候配置)
-> timerfd_trigger
    -> wake_up_locked_poll （唤醒 timerfd 上所有的等待对象）
        -> ep_poll_callback

还记得 socketfd 的回调路线吗？

-> 硬中断
    -> 软中断
        -> tcp_v4_rcv（具体协议栈处理函数）
            -> sk->sk_data_ready
                -> ep_poll_callback

相同的秘方，相同的套路，至此和 epoll 的路径全部打通了。

小结一下**完整路径描述**：

1. timerfd 句柄 timerfd_create 创建的时候准备好等待队列 ctx->wqh ；
2. timerfd_settime 设置定时回调 timerfd_tmrproc；
3. epoll_ctl 注册句柄的时候把 ep_poll_back 装进 wait 对象并挂到 ctx->wqh 链表之上；
4. 定时器超时的时候，由 timerfd_tmrproc 遍历 ctx->wqh ，调用 ep_poll_callback 从而完成事件触发；

说了这么多，用一张图来总结下，看你理解了不？

总结

1. procfs 是内核给用户探视进程信息的接口，非常重要，/proc/${pid}/fd/ 下有所有打开的句柄， /proc/${pid}/fdinfo/ 下能看到句柄的详细信息，挂钩的是 .show_fdinfo 回调实现；
2. timerfd 的核心结构是 timerfd_ctx ，通过 fd 先找到 file 结构体，它就藏在 file->private_data 这里；
3. timerfd 是直接复用的 hrtimer 或者 alarm 类型的定时器，timerfd 本身只是对定时器做的文件接口的封装；
4. 内核提供了一套名叫 anon_inodefs 的匿名文件系统，起到节省内存，代码复用的目的。对于想实现文件接口，但又不想实现完整的 inode 功能的句柄类型来说是福音，timerfd ，eventfd，eventpoll 等类型的 fd 都得益于此；
5. timerfd 把定时器像文件一样 IO 得益于“一切皆文件”的设计理念，timerfd 是理解内核这一设计的极佳例子，同时也是理解 epoll 管理 fd 事件的极佳例子，因为它足够简单！

后记

极简的 timerfd 配合之前的 epoll 的剖析，童鞋们应该彻底理解了 epoll 机制吧！讲到匿名 fd ，还挺有意思的，timerfd，eventfd，eventpoll fd 都是用的匿名 inode 的匿名 fd ，找机会分享一波。

本文由哈喽比特于3年以前收录，如有侵权请联系我们。
文章来源：https://mp.weixin.qq.com/s/cAu42eqHPzk6fXIIeirwhg