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

[toc]

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 原理剖析

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

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 关联即可。

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 操作。

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 是个非常好的机会，因为它足够简单，没有任何复杂性。下面跟着奇伢一起梳理下吧，抓住这个机会哦。

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 操作表；

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 池了。

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

后记

这次讲到匿名 inode 系统 ，这个还挺有意思的，timerfd，eventfd，eventpoll fd 等都用的是匿名 inode ，有时间分享一波。

---

坚持思考，方向比努力更重要。关注公众号：奇伢云存储，获取更多干货。