ARTICLE · 1361143
poll 源码分析(六):do_sys_poll()
本文来分析 do_sys_poll(),它是真正实现 poll 语义的函数。
阅读本文前,建议各位道友先速览一遍 poll 源码分析(四)一文。这能够帮我们快速回忆起 do_sys_poll() 在整个路径上的位置。
摘取调用链如下:
sys_ppoll()poll_select_set_timeout()sigdelsetmask()sigprocmask()ret = do_sys_poll() <--- 本文的主角if (ret == -EINTR)set_restore_sigmask()else if (sigmask)sigprocmask()poll_select_copy_remaining()
本文基于 Linux 4.4.126 版本的源码。
1. 概述
从调用者的角度看,do_sys_poll() 要做的事情一句话就能说清楚:
告诉我这些目标 fd 里哪些已经就绪了;一个都没有的话,就等,等到有至少一个 fd 就绪、或者超时、或者被信号打断为止。
这句话拆开来,至少有四类问题:
内核怎么知道某个 fd 有没有就绪?fd 背后可能是管道、socket、设备文件等,内核不可能为每种文件写一套判断。 一个都没就绪时,当前线程要睡下去。那睡在哪儿? 总不能一直睡眠吧,那谁来叫醒?叫醒的那一方怎么知道有人在等着它去唤醒? 叫醒之后怎么办?被叫醒就一定有 fd 就绪了吗?
本文的分析就围绕上面这些问题展开。
2. 涉及到的结构体
本文涉及的结构体比较多,而且它们之间相互引用,不先认识一下的话,代码读起来会很吃力。这一节先把它们逐个过一遍,混个脸熟,等到具体代码分析时再来详细解释。
2.1 struct pollfd
这是用户态和内核态共用的结构体,定义在 include/uapi/asm-generic/poll.h:
struct pollfd {int fd;short events;short revents;};
三个字段:
fd 是要监听的文件描述符 events 是用户想等什么事件 revents 是内核回填的实际发生了什么事件
这个结构体大小是 8 字节。
2.2 struct poll_list
这是 fs/select.c 内部的一个结构体:
struct poll_list {struct poll_list *next;int len;struct pollfd entries[0];};#define POLLFD_PER_PAGE ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
也是三个字段:
next 指向下一个 poll_list len 记录本块装了几个 pollfd entries 是一个零长数组。零长数组在内核中是个很常见的小技巧,这里的意思是结构体后面紧跟着一片不定长的 pollfd 存储区,entries 就是这片存储区的起始地址。
很明显,poll_list 是用来存储 pollfd 的。
紧跟在结构体后面的 POLLFD_PER_PAGE 表示一个 PAGE 最多能存放的 pollfd 的个数。PAGE_SIZE 表示一个物理页面的大小,通常来说是 4096 字节。
ARM64 上 next 占 8 字节,len 占 4 字节,entries 不占空间,结构体本身因为要按 8 字节对齐,所以 sizeof 算出来是 16。
4096 减去 16 字节块头,再除以 8,POLLFD_PER_PAGE 就等于 510。
每个物理页最多存放 510 个 pollfd,当需要存放的 pollfd 多于 510 时,就需要申请第二个物理页,然后第一个物理页里的 poll_list.next 就指向第二个物理页。依此类推,物理页之间就用 next 串成了一个单向链表。
2.3 等待队列
接下来的几个结构体都和等待队列有关,所以有必要先介绍一下它。
等待队列是内核里"睡眠 - 唤醒"机制的基础设施。等待队列主要涉及两个结构体,一个是队列头,一个是队列节点,都定义在 include/linux/wait.h:
struct __wait_queue_head {spinlock_t lock;struct list_head task_list;};typedef struct __wait_queue_head wait_queue_head_t;typedefint(*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key);struct __wait_queue {unsigned int flags;void *private;wait_queue_func_t func;struct list_head task_list;};typedef struct __wait_queue wait_queue_t;
先看队列头 wait_queue_head_t,两个字段:
lock:一把自旋锁。对节点做增删改查之前都要先拿到它,因为这些操作完全有可能并发。 task_list:链表头。所有在这个队列头上等待的节点,都串在这条链表上。
再看队列节点 wait_queue_t,四个字段:
flags:标志位。4.4.126 上只定义了两个:
WQ_FLAG_EXCLUSIVE(0x01):独占节点。唤醒方遍历链表时,如果遇到了独占节点,唤醒它,然后就停止遍历,不再处理后面的节点。
WQ_FLAG_WOKEN(0x02):已唤醒标志。防止在检查条件和真正睡下之间丢唤醒。
private:节点的私有数据,等待队列本身不解释它。最常见的用法是存放等待的那个线程的 task_struct,这样唤醒时知道该叫醒谁。 func:唤醒函数。唤醒方遍历链表时,调用的每个节点的回调就是它。它的类型 wait_queue_func_t 定义在上面第 7 行。 task_list:链表节点。节点就是靠这个字段串到队列头的链表上的。
要理解这两个结构体之间的关系,得先从资源说起。
资源可以是一个文件、一块内存,或者一个硬件设备。以一块共享内存为例,线程 A 往里面写数据,线程 B 从里面读数据。内存里没有数据时,线程 B 读不到东西,只能在旁边等着,等线程 A 写入之后再通知它来读。
线程 B 等的这段时间里,让它霸着 CPU 属于占着茅坑不拉屎,是资源浪费。更好的做法是让它睡下去,把 CPU 让给别的线程,等数据就绪后再把它唤醒。
类似这样一方等待另一方通知的情况,内核里比比皆是。而把这套处理流程规范起来的机制,就是等待队列。
首先,我们为这块共享内存创建一个等待队列头,它和这块内存绑定,不属于任何线程。线程 B 去读内存,发现没有数据,就给自己准备一个等待队列节点,然后把节点挂到共享内存的等待队列头上,最后让出 CPU 睡下去。
等线程 A 写完数据,就去遍历这个等待队列头上的链表,逐个调用每个节点里的 func,由 func 唤醒节点背后的线程。
注意,读这块共享内存的可能还有线程 C、D、E 等。它们各自准备各自的节点,挂到同一个队列头上。所以一个等待队列头可以挂任意多个节点,而一个节点只属于一个等待者。
同样地,往这块共享内存写数据的也不一定只有线程 A。谁写完了数据,谁就来遍历这个队列头。唤醒方可以是任何线程,甚至可以是硬件设备的中断处理函数。
两个结构体之间的关系画成示意图就是:
资源对象(管道、socket、硬件设备……)└─ wait_queue_head_t├─ lock└─ task_list ──► 节点 B ──► 节点 C ──► 节点 D ──►...│ │ ││ │ └─ 线程 D 的 wait_queue_t:flags, private, func│ └─────────── 线程 C 的节点└────────────────────── 线程 B 的节点
2.4 poll_table
这个结构体定义在 include/linux/poll.h:
struct poll_table_struct;/** structures and helpers for f_op->poll implementations*/typedefvoid(*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);/** Do not touch the structure directly, use the access functions* poll_does_not_wait() and poll_requested_events() instead.*/typedef struct poll_table_struct {poll_queue_proc _qproc;unsigned long _key;} poll_table;
注释说,这是给 f_op->poll 实现用的结构体。
f_op 是文件的 file_operations 指针,每种文件都有自己的一套 fops 回调,.poll 是其中一个成员。也就是说,poll_table 是 poll 核心层和具体某种文件的 poll 实现之间的接口对象。
它只有两个字段:
_qproc 是一个函数指针。文件的 poll 实现通过它告诉核心层自己想被哪个等待队列唤醒。 _key 是核心层告诉文件调用者用户程序关心你的哪些事件。
结构体上方的注释要求不要直接修改这两个字段,而是用封装好的函数。
文件的 poll 实现调用 _qproc 的入口是 poll_wait():
staticinlinevoidpoll_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);}
这里看的比较懵没关系,有个大概即可。关于 poll_wait() 和它背后的 _qproc,下一篇文章会专门分析。
2.5 struct poll_table_entry
这个结构体也定义在 include/linux/poll.h:
struct poll_table_entry {struct file *filp;unsigned long key;wait_queue_t wait;wait_queue_head_t *wait_address;};
四个字段:
filp: 文件指针 key: 事件掩码 wait: 等待队列节点。注意这里是内嵌的,不是指针 wait_address: 等待队列头,wait 就是挂入到这个队列头里
这四个成员凑在一起,描述的是本次 poll 在某个文件的等待队列头上挂了一个节点这件事。
filp 占 8 字节,key 8 字节,wait_queue_t 40 字节,wait_address 8 字节,合计 64 字节。这个大小后文要用。
由于没有涉及具体代码,这个结构体虽然重要,但这里先了解到这个程度就可以了。
2.6 struct poll_table_page
这个结构体定义在 fs/select.c:
struct poll_table_page {struct poll_table_page *next;struct poll_table_entry *entry;struct poll_table_entry entries[0];};#define POLL_TABLE_FULL(table) \((unsigned long)((table)->entry+1) > PAGE_SIZE + (unsigned long)(table))
和 2.2 节的 poll_list 是一个套路。结构体是块头,后面跟着不定长的 poll_table_entry 存储区。next 指向下一个 page,entry 则指向本页内下一个可用的位置。
结构体下面的 POLL_TABLE_FULL 宏用来判断本页是否已满,借助的正是 entry 成员。
假设 PAGE_SIZE 还是 4096,减去 16 字节块头,再除以 64,一页能放 63 个 entry,还剩下 48 字节的空间。
示意图如下:
table entry table + PAGE_SIZE│ │ │▼ ▼ ▼┌───────┬───────┬───────┬── ──┬───────┬───────┬──────┐│ next │entries│entries│ │entries│entries│ ││ entry │ [0] │ [1] │ ... │ [61] │ [62] │ 48 B ││ 16 B │ 64 B │ 64 B │ │ 64 B │ 64 B │ │└───────┴───────┴───────┴── ──┴───────┴───────┴──────┘偏移 0 16 80 144 3920 3984 4048 4096
参考这个图,POLL_TABLE_FULL 宏就很好理解了。如果 (table)->entry + 1 > PAGE_SIZE + (table),那么就说明 entry 指向的偏移处必然大于 4096 - 64 = 4032,满足条件的就只有 4048 了,后面虽然还有空间,但已装不了一个新的 entry 了,说明本页已满。
2.7 struct poll_wqueues
这个结构体定义在 include/linux/poll.h:
struct poll_wqueues {poll_table pt;struct poll_table_page *table;struct task_struct *polling_task;int triggered;int error;int inline_index;struct poll_table_entry inline_entries[N_INLINE_POLL_ENTRIES];};
七个字段:
pt:内嵌的 poll_table。 table:poll_table_page 指针,页链表的表头。 polling_task:task_struct 指针,记录是谁在 poll。 triggered:是否已触发的标志位。至于触发什么,暂不得知。 error:错误码。 inline_index:索引值,表示 inline_entries 数组已用掉的元素个数。 inline_entries:poll_table_entry 数组。关于 N_INLINE_POLL_ENTRIES 宏,放到后面源码分析时再来解释。
inline_entries 和 table 都用来存储 poll_table_entry。前者内嵌在结构体里,在栈上;后者按页分配,在堆中,可以无限扩展。等到后面分析到相关代码时,再来解释为什么要这么来存储。
2.8 串起来
上面这 8 个结构体之间的包含和引用关系如下:
┌─ struct poll_wqueues ──────┐│ ┌─ poll_table pt ────────┐ ││ │ _qproc │ ││ │ _key │ ││ └────────────────────────┘ ││ polling_task ───────────┼──► ┌─ struct task_struct ─┐│ │ │ ... ││ │ └──────────────────────┘│ table ──────────────────┼──► ┌─ struct poll_table_page ───┐│ │ │ next ───────────────────┼──► 下一页,或 NULL│ ┌─ inline_entries[] ─────┐ │ │ entry ───────────┐ ││ │ ┌─ poll_table_entry ─┐ │ │ │ ▼ ││ │ │ ... │ │ │ │ ┌─ entries[63] ──────────┐ ││ │ └────────────────────┘ │ │ │ │ ┌─ poll_table_entry ─┐ │ ││ └────────────────────────┘ │ │ │ │ ... │ │ ││ │ │ │ └────────────────────┘ │ │└────────────────────────────┘ │ └────────────────────────┘ │└────────────────────────────┘┌─ struct poll_table_entry ──┐│ filp ───────────────────┼──► ┌─ struct file ─┐│ │ │ .poll ││ │ └───────────────┘│ wait_address ───────────┼──► ┌─ wait_queue_head_t ─┐│ ┌─ wait_queue_t wait ──┐ │ │ lock ││ │ task_list ◄───────┼───┼────┼► task_list ││ └──────────────────────┘ │ └─────────────────────┘└────────────────────────────┘┌─ struct poll_list ─────────┐│ next ───────────────────┼──► 下一块,或 NULL│ ┌─ entries[] ─────────┐ ││ │ ┌─ struct pollfd ─┐ │ ││ │ │ fd │ │ ││ │ │ events │ │ ││ │ │ revents │ │ ││ │ └─────────────────┘ │ ││ └─────────────────────┘ │└────────────────────────────┘
3. 完整调用链
老规矩,先把本文要分析的调用链列出来:
do_sys_poll()copy_from_user() // 分块拷入 pollfd 数组poll_initwait()init_poll_funcptr() // _qproc = __pollwaitdo_poll()select_estimate_accuracy()for (;;) {do_pollfd() // 逐个 fd 问:就绪了吗fdget()f_op->poll() // 文件自己的 poll 实现poll_wait() // 登记到文件的等待队列,下一篇分析__pollwait()fdput()signal_pending()poll_schedule_timeout() // 睡下set_current_state()schedule_hrtimeout_range()smp_store_mb()}poll_freewait() // 撤销登记__put_user() // 回写 reventskfree()
其中,do_poll() 将是分析重点,而里面的 for 循环是重点中的重点。
4. 代码逐行分析
do_sys_poll() 定义在 fs/select.c,完整实现如下:
intdo_sys_poll(struct pollfd __user *ufds, unsignedint nfds,struct timespec *end_time){struct poll_wqueues table;int err = -EFAULT, fdcount, len, size;/* Allocate small arguments on the stack to save memory and befaster - use long to make sure the buffer is aligned properlyon 64 bit archs to avoid unaligned access */long stack_pps[POLL_STACK_ALLOC/sizeof(long)];struct poll_list *const head = (struct poll_list *)stack_pps;struct poll_list *walk = head;unsigned long todo = nfds;if (nfds > rlimit(RLIMIT_NOFILE))return -EINVAL;len = min_t(unsigned int, nfds, N_STACK_PPS);for (;;) {walk->next = NULL;walk->len = len;if (!len)break;if (copy_from_user(walk->entries, ufds + nfds-todo,sizeof(struct pollfd) * walk->len))goto out_fds;todo -= walk->len;if (!todo)break;len = min(todo, POLLFD_PER_PAGE);size = sizeof(struct poll_list) + sizeof(struct pollfd) * len;walk = walk->next = kmalloc(size, GFP_KERNEL);if (!walk) {err = -ENOMEM;goto out_fds;}}poll_initwait(&table);fdcount = do_poll(nfds, head, &table, end_time);poll_freewait(&table);for (walk = head; walk; walk = walk->next) {struct pollfd *fds = walk->entries;int j;for (j = 0; j < walk->len; j++, ufds++)if (__put_user(fds[j].revents, &ufds->revents))goto out_fds;}err = fdcount;out_fds:walk = head->next;while (walk) {struct poll_list *pos = walk;walk = walk->next;kfree(pos);}return err;}
六十多行,可以分成四段:
拷入(第 14 - 39 行):检查 nfds,然后把用户态的 pollfd 数组拷贝进内核。
干活(第 41 - 43 行):三个函数调用,初始化、轮询加睡眠、清理。真正的 poll 语义在中间的 do_poll() 里。
回写(第 45 - 52 行):把每个 fd 的 revents 写回用户态。
释放(第 54 - 63 行):释放之前申请的内存块,最后返回。
下面逐段分析。
4.1 参数和局部变量
先来看看 do_sys_poll() 的三个参数:
ufds:用户态 pollfd 数组的首地址 nfds:数组元素个数 end_time:即 sys_ppoll() 里的 to,可能是 NULL、{0, 0}、或者一个绝对到期时刻
第 4 - 12 行定义了九个局部变量:
struct poll_wqueues table;int err = -EFAULT, fdcount, len, size;/* Allocate small arguments on the stack to save memory and befaster - use long to make sure the buffer is aligned properlyon 64 bit archs to avoid unaligned access */long stack_pps[POLL_STACK_ALLOC/sizeof(long)];struct poll_list *const head = (struct poll_list *)stack_pps;struct poll_list *walk = head;unsigned long todo = nfds;
第 4 行:table,类型是 2.7 节介绍的 poll_wqueues,直接放在栈上。
table 内部有个 inline_entries 数组,元素个数是 N_INLINE_POLL_ENTRIES,一会儿和下面的 POLL_STACK_ALLOC 一起分析。
第 5 行:err 初始化为 -EFAULT。
后面会看到,凡是 goto out_fds 而没有改 err 的路径,返回的都是这个默认值。
第 6 - 9 行:注释的两点说明值得细品:
小的参数直接放在栈上,省内存也更快。
前面介绍 poll_list 和 poll_table_page 时,说它们都是通过申请物理页面来存储 pollfd 和 poll_table_entry。但当需要存储的 pollfd 和 poll_table_entry 的个数很少时,申请一个页大小的内存并不划算。更好的方式是直接把他们存储在栈上,一来省掉一张物理页,二来不用走申请内存的流程,速度更快。
用 long 做数组元素类型,是为了保证缓冲区在 64 位平台上对齐。
这句话说的是 stack_pps 这个数组的起始地址问题。
stack_pps 本身只是一块 256 字节的 buffer,第 10 行会把它强转成 struct poll_list 来使用。
poll_list 的第一个字段 next 是一个 8 字节的指针,64 位平台的 ABI 要求 8 字节的指针放在 8 的整数倍地址上。所以这块缓冲区的起始地址必须是 8 的倍数,否则 next 就是未对齐的。
缓冲区的起始地址由编译器决定,而编译器是按数组元素类型的对齐要求来安排的:

两种写法占的空间一样,都是 256 字节,区别只在起始地址。用 long 做元素类型,等于告诉编译器这块内存按 8 字节对齐来存放,这样把它当 poll_list 用时,里面的指针和整数字段自然就都对齐了。
对于未对齐的访问,有的架构可能直接触发异常,有的架构能跑但要拆成多次访问,这样执行速度就慢下来了。注释里说的 avoid unaligned access 就是这层意思。
实际上 GCC 对栈上的 char 数组往往也会给较大的对齐,但那是编译器实现细节,不是 C 语言的保证。写成 long 数组是把这个保证落到语言层面,而不是依赖编译器的习惯。
指定数组元素个数时用到了 POLL_STACK_ALLOC 这个宏,它的定义如下(第四个 #define):
/* ~832 bytes of stack space used max in sys_select/sys_poll before allocatingadditional memory. */#define MAX_STACK_ALLOC 832#define FRONTEND_STACK_ALLOC 256#define SELECT_STACK_ALLOC FRONTEND_STACK_ALLOC#define POLL_STACK_ALLOC FRONTEND_STACK_ALLOC#define WQUEUES_STACK_ALLOC (MAX_STACK_ALLOC - FRONTEND_STACK_ALLOC)#define N_INLINE_POLL_ENTRIES (WQUEUES_STACK_ALLOC / sizeof(struct poll_table_entry))
sizeof(long) 等于 8,所以 stack_pps 是一个包含 256/8=32 个 long 的数组,256 字节。
看看宏上方的注释。select 和 poll 在分配额外内存之前,最多用 832 字节的栈空间。这 832 字节被拆成了两块:

832 没有什么特殊意义,只是一个工程上的折中。常见的少量 fd 的场景下,pollfd 副本和 poll_table_entry 都直接放在栈上,不用额外申请堆内存,同时单个栈帧又不至于太大。
第 10 行:把 stack_pps 强转成 poll_list 指针。从这一行起,这 256 字节就是 pollfd 链表的第一块,head 是链表头。
第 11 - 12 行:walk 是遍历用的游标,从 head 开始;todo 记录还有多少个 pollfd 没有拷贝,初始值是 nfds。
4.2 拷入
第 14 - 15 行:先检查 nfds 是否合法。
if (nfds > rlimit(RLIMIT_NOFILE))return -EINVAL;
RLIMIT_NOFILE 是当前进程最多能打开的文件个数的上限,ulimit -n 看到的就是它。一个进程打开的 fd 不可能比这个上限多,所以如果 nfds 超过它一定不正常,直接返回 -EINVAL。
接下来第 17 - 39 行的 for 循环是把用户空间的 pollfd 拷贝进内核空间:
len = min_t(unsigned int, nfds, N_STACK_PPS);for (;;) {walk->next = NULL;walk->len = len;if (!len)break;if (copy_from_user(walk->entries, ufds + nfds-todo,sizeof(struct pollfd) * walk->len))goto out_fds;todo -= walk->len;if (!todo)break;len = min(todo, POLLFD_PER_PAGE);size = sizeof(struct poll_list) + sizeof(struct pollfd) * len;walk = walk->next = kmalloc(size, GFP_KERNEL);if (!walk) {err = -ENOMEM;goto out_fds;}}
注意,我们前面反复提到,对于只有少量 pollfd 的场景,栈空间足以应对,当 pollfd 很多时,再来申请堆内存。这么设计的原因,在前面分析注释时已经阐述过了。
理解了这一点,这个 for 循环就搞懂了一大半。
第 17 行:选出 nfds 和 N_STACK_PPS 中的较小值。
N_STACK_PPS 就定义在 do_sys_poll() 的上方:
#define N_STACK_PPS ((sizeof(stack_pps) - sizeof(struct poll_list)) / \sizeof(struct pollfd))
这个宏算的是:把 stack_pps 当作一个 poll_list 来用,刨去 head 之后还能放几个 pollfd。示意图如下:
|<─────────────────── stack_pps ───────────────────>|┌────── poll_list ─────┬────── entries[] ───────────┐│ next │ len │ padding │ pollfd[0] │ pollfd[1] │ … │└──────────────────────┴────────────────────────────┘0 8 12 16 256↑ head ↑ copy_from_user 拷入用户 pollfd
stack_pps 刚刚说过,大小是 256 字节。256 减 16 再除以 8,所以 N_STACK_PPS 等于 30。
它和 2.2 节的 POLLFD_PER_PAGE 一起,构成了 pollfd 数组的存放策略:
第一块放在栈上,最多 30 个 放不下的部分,再按页分块,每页可以放 510 个
下面的循环正是这么做的。
第 19 - 20 行:初始化 poll_list 的 next 和 len。
第 21 - 22 行:len 为 0 就退出循环。
只有一种 len 为 0 的情况存在,那就是第一次循环进来时,且用户程序传进来的 nfds 也是 0。这种情况下,后面的 do_poll() 一个 fd 也不会检查,只会睡到超时。此时 poll(NULL, 0, timeout) 可以当作一个毫秒级的 sleep 来用。
之后的循环,len 不可能为 0。
第 24 - 26 行:从用户态拷贝 len 个 pollfd 到本块的 entries。
源起始地址是 ufds + nfds - todo。nfds 是总数,todo 是还没拷贝的个数,nfds - todo 就是已经拷贝的个数,也就是用户数组 ufds 里第一个还未被拷贝到内核空间的 pollfd 的下标。
如果 nfds ≤ N_STACK_PPS(30),那么这里一次就可以把所有的 pollfd 拷贝完。否则,就得继续拷贝。
第 28 - 30 行:todo 减去本次拷贝的个数。
减到 0,说明全拷完了,退出循环。注意,todo 的初始值是 nfds,如果 nfds ≤ N_STACK_PPS,在这里就退出了,整个 pollfd 数组都在栈上。
第 32 - 38 行:还有剩余的 pollfd 未拷贝完,就需要额外申请内存来存放了。
len 是 todo 和 POLLFD_PER_PAGE 中的较小值。todo 不可能为 0,POLLFD_PER_PAGE 是 510,所以 len 不可能为 0。
size 是 poll_list 的 head,加上 len 个 pollfd,最大是 16 + 8 * 510 = 4096,正好一个页面大小。
如果 todo ≤ POLLFD_PER_PAGE(510),那么这里申请的内存小于一个页面,下一轮循环就可以把剩下的 pollfd 全部拷贝完。否则,这里先最多准备 510 个 pollfd 的空间,下次循环拷贝后还得再跑到这里继续申请内存。
第 34 行,kmalloc 的结果先赋给 walk->next,把新申请的内存块挂到链表尾部,再赋给 walk,相当于把游标移到了新块上。下一轮循环就在新块上填 head、拷数据。
分配失败则返回 -ENOMEM,注意这里要显式修改 err。
假设本次 poll 监听了 1024 个文件,那么 nfds 就是 1024,整个链表就会长这样:
head:栈上,就是 stack_pps 那 256 字节|<───────────────────────────── 256 B ──────────────────────────────>|┌──────┬─────┬─────────┬───────────┬───────────┬───────┬─────────────┐│ next │ len │ padding │ pollfd[0] │ pollfd[1] │ ... │ pollfd[29] ││ 8 B │ 4 B │ 4 B │ 8 B │ 8 B │ │ 8 B │└──┬───┴─────┴─────────┴───────────┴───────────┴───────┴─────────────┘0 │ 8 12 16 24 32 248 256│ len = 30▼块 1:堆上,kmalloc(4096)|<──────────────────────────── 4096 B ──────────────────────────────>|┌──────┬─────┬─────────┬───────────┬───────────┬───────┬─────────────┐│ next │ len │ padding │ pollfd[0] │ pollfd[1] │ ... │ pollfd[509] │└──┬───┴─────┴─────────┴───────────┴───────────┴───────┴─────────────┘0 │ 8 12 16 24 32 4088 4096│ len = 510▼块 2:堆上,kmalloc(3888)|<──────────────────────────── 3888 B ──────────────────────────────>|┌──────┬─────┬─────────┬───────────┬───────────┬───────┬─────────────┐│ next │ len │ padding │ pollfd[0] │ pollfd[1] │ ... │ pollfd[483] │└──┬───┴─────┴─────────┴───────────┴───────────┴───────┴─────────────┘0 │ 8 12 16 24 32 3880 3888│ len = 484▼NULL
30 + 510 + 484 = 1024。第一块的 len 由 N_STACK_PPS 决定,第二块的 len 由 POLLFD_PER_PAGE 决定,最后一块装剩下的 484 个 pollfd。
4.3 干活
第 41 - 43 行:
poll_initwait(&table);fdcount = do_poll(nfds, head, &table, end_time);poll_freewait(&table);
三个函数,传的都是栈上的 table。第 41 行的 poll_initwait() 做初始化。第 42 行的 do_poll() 是整个 poll 的核心,返回值 fdcount 从名字看也可以猜到是就绪的 fd 个数。第 43 行的 poll_freewait() 和 poll_initwait() 成对。
下面按顺序分析这三个函数。
4.3.1 poll_initwait()
函数在 fs/select.c:
voidpoll_initwait(struct poll_wqueues *pwq){init_poll_funcptr(&pwq->pt, __pollwait);pwq->polling_task = current;pwq->triggered = 0;pwq->error = 0;pwq->table = NULL;pwq->inline_index = 0;}
第 3 行:init_poll_funcptr() 是个内联函数,定义在 include/linux/poll.h:
static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc){pt->_qproc = qproc;pt->_key = ~0UL; /* all events enabled */}
很明显这是在初始化一个 poll_table,而且是内嵌在 poll_wqueues 里的这个。
这里把 __pollwait 赋值给了 _qproc。对于文件的 poll 实现,比如某个字符设备文件,其 poll 回调里通常约定要调用 poll_wait()。2.4 节里有贴出 poll_wait() 的源码,它做的事情很简单,就是调用 _qproc 指向的函数,也就是 __pollwait。
所以,这里 poll 核心层先赋值初始化,然后文件的 poll 实现里调用 poll_wait(),最后又回到 poll 核心层的 __pollwait。
文件操作集里 poll 函数的定义如下:
struct file_operations {...unsigned int (*poll) (structfile *, struct poll_table_struct *);...};
第二个参数就是 poll_table,由 poll 核心层传给具体某个文件的 poll 实现。poll_table 就是 poll 核心层和文件的 poll 实现之间沟通的桥梁。
有的道友此刻可能有两个疑惑:
为什么文件的 poll 实现里一定要调用 poll_wait()? __pollwait 干了些什么事情?
不着急,后面有个更合适的地方来回答这两个问题。
把 _key 的 bit 位全置 1 表示默认关心所有事件。这里是初始化,后面的代码到时还会覆盖写入。
第 4 行:把 current 保存到 polling_task。调用 poll 的是当前线程,后面没有 fd 就绪时睡眠的也是它,最后被唤醒的还是它。这里用 polling_task 先保存下来,后面在合适的时候会派上用场。
第 5 - 8 行:triggered、error、inline_index 清零,table 置 NULL。这里暂时看不出这些成员变量有什么作用,知道是在这里初始化的即可。
4.3.2 do_poll()
函数也在 fs/select.c:
staticintdo_poll(unsignedint nfds, struct poll_list *list,struct poll_wqueues *wait, struct timespec *end_time){poll_table* pt = &wait->pt;ktime_t expire, *to = NULL;int timed_out = 0, count = 0;unsigned long slack = 0;unsigned int busy_flag = net_busy_loop_on() ? POLL_BUSY_LOOP : 0;unsigned long busy_end = 0;/* Optimise the no-wait case */if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {pt->_qproc = NULL;timed_out = 1;}if (end_time && !timed_out)slack = select_estimate_accuracy(end_time);for (;;) {struct poll_list *walk;bool can_busy_loop = false;for (walk = list; walk != NULL; walk = walk->next) {struct pollfd * pfd, * pfd_end;pfd = walk->entries;pfd_end = pfd + walk->len;for (; pfd != pfd_end; pfd++) {/** Fish for events. If we found one, record it* and kill poll_table->_qproc, so we don't* needlessly register any other waiters after* this. They'll get immediately deregistered* when we break out and return.*/if (do_pollfd(pfd, pt, &can_busy_loop,busy_flag)) {count++;pt->_qproc = NULL;/* found something, stop busy polling */busy_flag = 0;can_busy_loop = false;}}}/** All waiters have already been registered, so don't provide* a poll_table->_qproc to them on the next loop iteration.*/pt->_qproc = NULL;if (!count) {count = wait->error;if (signal_pending(current))count = -EINTR;}if (count || timed_out)break;/* only if found POLL_BUSY_LOOP sockets && not out of time */if (can_busy_loop && !need_resched()) {if (!busy_end) {busy_end = busy_loop_end_time();continue;}if (!busy_loop_timeout(busy_end))continue;}busy_flag = 0;/** If this is the first loop and we have a timeout* given, then we convert to ktime_t and set the to* pointer to the expiry value.*/if (end_time && !to) {expire = timespec_to_ktime(*end_time);to = &expire;}if (!poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack))timed_out = 1;}return count;}
八十多行,先看整体结构。第 20 行开始是一个 for 循环,基本就是整个函数体了。
循环体里:
第 24 - 46 行,遍历所有 pollfd,逐个调 do_pollfd()。 第 47 - 58 行,检查结果,决定要不要退出循环。 第 60 - 69 行,网络 busy poll 的优化,大多数场景都不走这段代码。 第 71 - 82 行,睡下,醒来后回到循环顶部。
下面逐行来分析。
4.3.2.1 局部变量
第 4 - 9 行:
poll_table* pt = &wait->pt;ktime_t expire, *to = NULL;int timed_out = 0, count = 0;unsigned long slack = 0;unsigned int busy_flag = net_busy_loop_on() ? POLL_BUSY_LOOP : 0;unsigned long busy_end = 0;
第 4 行:pt 指向 poll_wqueues 里内嵌的 poll_table。
第 5 行:expire 和 to。to 初始为 NULL,后面会看到它要么一直是 NULL,要么指向 expire。
ktime_t 是高精度定时器用的时间类型,64 位的纳秒数。
第 6 行:timed_out 是超时标志,count 是就绪的 fd 个数。
第 7 行:slack 是定时器允许的误差。
第 8 - 9 行:busy_flag 和 busy_end 属于网络子系统的 busy poll 优化。
简单介绍下 busy poll 的背景。
socket 没有数据时,poll 的常规做法是睡下,等网卡收到包、中断处理完、协议栈把数据放进接收队列,然后再把线程唤醒。这一串流程下来通常需要几微秒到几十微秒。对延迟敏感的场景,比如高频交易、存储网络,这几十微秒就算是长的难以忍受了。
busy poll 的思路是:既然数据可能马上就到,那就先别睡,让线程原地忙等一小段时间,直接去问网卡驱动是否有收到新包,有就立刻处理,绕过中断和唤醒。代价是忙等期间 CPU 不能释放,所以它是用 CPU 资源换取低延迟。
net_busy_loop_on() 读的是 sysctl 的 net.core.busy_poll,单位微秒,表示 poll 允许忙等多久,默认为 0。
非 0 时 busy_flag 置成 POLL_BUSY_LOOP,这是 poll.h 里一个只在内核内部使用的事件位,用户态看不到。busy_flag 在 do_poll() 里是总开关,表示允许本次 poll 忙等。
busy_end 是本次 poll 忙等的截止时刻,先置 0 表示还没开始。
4.3.2.2 零超时场景
第 11 - 15 行:看注释,优化无等待的情况。
/* Optimise the no-wait case */if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {pt->_qproc = NULL;timed_out = 1;}
if 判断针对的是 end_time 为 {0, 0} 的场景,对应用户程序传 timeout 为 0,语义是:不等待,轮询一遍就返回,不管有没有 fd 就绪。
如果条件命中,就需要为这个场景做两件事:
_qproc 置 NULL。这里还看不出为什么要这么做,后面我们再来收敛这行代码。
timed_out 置 1。这个控制了后面的 for 循环的执行次数。我们的语义是轮询一遍就退出,所以第一遍 for 循环走完后,就需要在第 57 行 break 退出,然后直接返回。
4.3.2.3 定时器误差
第 17 - 18 行:有超时、而且不是零超时,就算一个 slack。slack 的中文意思是余量。
if (end_time && !timed_out)slack = select_estimate_accuracy(end_time);
select_estimate_accuracy() 也定义在 fs/select.c,本文不打算逐行分析它,只介绍为什么需要这个 slack,以及这个 slack 是怎么计算出来的。
为什么需要 slack
高精度定时器的精度是纳秒级,但精度不是免费的。每个定时器到期都要产生一次中断,即使 CPU 正处在省电的 idle 状态,内核也要把它从里面拉出来,走一遍调度。
系统里同时睡着的任务很多,每个任务的到期时刻都略有不同,如果每一个都要求 CPU 严格按自己设定的时刻来响应,那 CPU 就会频繁地做状态切换。
slack 是定时器的主人向内核做的一个让步,表明我允许你比到期时刻最多晚 slack 的时间再叫我。
有了这个让步,内核可以把到期窗口有重叠的几个定时器合并成一次中断,一起处理,这样 CPU 的状态切换次数就少了。这是典型的牺牲实时性来换取功耗的做法。内核里还有很多类似的权衡折中处理。
对 poll 来说这个让步是合理的。内核对超时的承诺从来都是至少等这么久,而不是最多。到期之后多久能真正跑起来,取决于中断和调度延迟,内核从来给不出准确的上限时间。
既然晚一点是常态,不如明说允许晚多少,还能换来合并定时器的好处。晚的时间仍是几十微秒的量级,应用程序几乎感知不到。
怎么计算 slack
思路是:愿意等得越久,就越不在乎晚一点。所以 slack 和剩余等待时间成比例:
先用 end_time 减去当前时刻,得到还要等多久。end_time 是绝对到期时刻,所以要先减去当前时刻。 取剩余时间的千分之一作为 slack。比如,等 1 秒就允许晚 1 毫秒,等 10 毫秒就允许晚 10 微秒。 但有个上限 100 毫秒。等再久,也不能晚超过 100 毫秒,否则应用程序会明显感觉到。 最后和线程自己的 timer_slack_ns 取大者。这个值每个线程一份,默认 50 微秒,可以用 prctl 修改。
它是个下限。剩余时间很短时,按比例算出来的 slack 可能只有几微秒,可是定时器到期后把线程叫醒这个动作本身就要花几十微秒,比这更精确的要求内核做不到,也没有意义。所以不管算出来多小,至少允许晚 50 微秒。
关于上面千分之一的比例,针对不同的线程,这个比例会稍有调整:
对于 nice 值大于 0 的任务,取千分之五。
nice 是普通非实时进程的优先级数值,范围 -20 到 19,默认 0。nice 这个词很形象,表明了自己对别人的友好程度。数值越大,进程越谦让,调度器分给它的 CPU 时间份额越小,这样其它进程分到的就越多。数值越小则越霸道。
所以对于 nice 值大于 0 的任务,相当于它自己声明了不着急,那内核就多占它一点便宜,给它更长的 slack。
对于实时任务,slack 为 0。此类任务要的就是准时,不能做任何让步。
这个 slack 计算出来后只用在了一个地方,那就是传给了 for 循环最后的 poll_schedule_timeout() 函数。
4.3.2.4 遍历所有 pollfd
接下来是函数主体 for 循环。本小节先只看内层的 for 循环:
for (;;) {struct poll_list *walk;bool can_busy_loop = false;for (walk = list; walk != NULL; walk = walk->next) {struct pollfd * pfd, * pfd_end;pfd = walk->entries;pfd_end = pfd + walk->len;for (; pfd != pfd_end; pfd++) {/** Fish for events. If we found one, record it* and kill poll_table->_qproc, so we don't* needlessly register any other waiters after* this. They'll get immediately deregistered* when we break out and return.*/if (do_pollfd(pfd, pt, &can_busy_loop,busy_flag)) {count++;pt->_qproc = NULL;/* found something, stop busy polling */busy_flag = 0;can_busy_loop = false;}}}
第 22 行:can_busy_loop 是 busy poll 机制的另一个重要变量。
它和 busy_flag 有不同的分工:
busy_flag 是总开关,表示允许忙等 can_busy_loop 则表示这一轮监听的文件里真的碰到了能忙等的 socket
每轮扫描开始前清零。被监听的文件状态随时有可能变化,所以每一轮查询开始前都需要清掉上一轮的结果。
第 24 - 29 行:两层循环。看一眼 4.2 节最后的那个链表图,这里的循环就不难理解了:
外层沿 poll_list 链表走,一块一块地遍历 内层在块内走,pfd 从 entries 开始,到 entries + len 为止,逐个取出块里的 pollfd
第 30 - 44 行:调用 do_pollfd() 函数,如果返回非零,则处理一些变量。
为了尽快走完 do_poll() 函数的代码,行文上就不在这里展开分析 do_pollfd() 了,详细分析放到 4.3.2.9 小节。
这里暂时把它当成一个黑盒,这个黑盒做的事情概括来说就是:根据 pollfd 里的 fd 找到对应的文件,调用这个文件的 poll 实现,再把它返回的事件掩码过滤后写进 revents,并把这个掩码作为返回值返回到这里。
返回 0 表示这个 fd 还未就绪,继续遍历下一个 pollfd。返回非 0 则表示已就绪,那就需要处理这些变量:
count 加 1
count 用来统计就绪的 fd 个数,do_poll() 最后返回的也是它。这个值会一路返回到用户态作为 poll() 的返回值。
_qproc 置 NULL
第 30 - 36 行的注释主要就是在解释这行代码。如果有 fd 就绪了,这次 poll 肯定会返回,后面还没有遍历到的 fd 也没有必要再注册 waiters 了,因为挂上去了也马上要被摘下来。
要理解这句话,涉及到 poll_wait() 函数,等下一篇分析完 poll_wait() 我们再来收敛这行代码。这里先有个大概了解即可。
busy_flag 和 can_busy_loop 清零
这里清 busy_flag 和 can_busy_loop 不是为了阻止下面 4.3.2.6 小节的 busy poll 分支。count 非 0 时第 58 行一定会 break,代码不可能跑到下面的 busy poll 分支。
此处清零真正的目的是让本轮后面还未遍历到的 fd 的 .poll 不再收到 POLL_BUSY_LOOP。对 socket 来说,收到 POLL_BUSY_LOOP 可能会触发一次非阻塞 sk_busy_loop()。既然本次 poll 已确定会返回且不会走 busy poll 分支,再为后面的 socket 做这种低延迟探测就没有意义了。
注意循环并没有 break。虽然已经有 fd 就绪,本轮还是会把剩下的 fd 遍历完,把此刻已经就绪的 fd 都统计进来。用户态拿到的 revents 是所有 fd 的当前状态,而不是只有一个。
4.3.2.5 收集结果
继续往后看:
/** All waiters have already been registered, so don't provide* a poll_table->_qproc to them on the next loop iteration.*/pt->_qproc = NULL;if (!count) {count = wait->error;if (signal_pending(current))count = -EINTR;}if (count || timed_out)break;
第 47 - 51 行:注释说,所有等待者都已经注册过了,下一轮循环不要再给它们 _qproc 了。
这里已经是第三处把 _qproc 置为 NULL 了。要更好地理解这行代码,还是得等到分析 poll_wait() 时才能更彻底地解释清楚。
第 52 - 56 行:如果一个 fd 都没就绪,那就去检查是否有信号挂起待处理。
wait->error 记录的是 poll_wait() 执行过程中是否出现过错误。如果有错误,那么也需要在这里 break 返回。至于到底是什么错误,等下一篇分析 poll_wait() 时再来收敛。
紧接着检查有没有挂起的信号,有就把 count 改成 -EINTR。
poll 源码分析(四)的第 4.5 节分析过这个检查的意义:在每次真正睡下之前,都先查一遍 signal_pending(),一旦发现挂起的信号就立刻返回,绝不带着未处理的信号睡下去。
注意 error 和 signal_pending 只在 count 为 0 时才检查。有 fd 就绪就直接返回就绪个数,这一轮的错误和信号都不管了。
第 57 - 58 行:这里是退出循环的唯一出口。
退出循环的情况有且只有下面四种:
count 非零(有 fd 就绪、出错、或者有信号挂起) 已经超时
4.3.2.6 busy poll
接下来是 poll 忙等的处理:
/* only if found POLL_BUSY_LOOP sockets && not out of time */if (can_busy_loop && !need_resched()) {if (!busy_end) {busy_end = busy_loop_end_time();continue;}if (!busy_loop_timeout(busy_end))continue;}busy_flag = 0;
走到这里,说明本轮遍历没有 fd 就绪,也没超时,正常来说下一步线程就该睡了。busy poll 在睡之前插了一脚。注释说,只有发现了 POLL_BUSY_LOOP 的 socket、并且还没到时间,才走这里。
第 61 行:两个条件:
can_busy_loop 要为真,说明本轮扫描碰到了能忙等的 socket。 need_resched() 要为假,说明没有别的任务等着用这个 CPU。忙等并不会释放 CPU 资源,如果有更高优先级的线程等着,那就放弃忙等。后面线程睡下去后就能让出 CPU 了。
第 62 - 65 行:busy_end 还是 0,说明是第一次进来。busy_loop_end_time() 用当前时刻加上 net.core.busy_poll 那个微秒数,算出忙等的截止时刻,然后 continue。
第 66 - 67 行:还没到截止时刻,也 continue。
continue 后就回到了第 20 行循环顶部,立刻开始重新遍历所有 fd,这就是"忙等"。然后再一次执行 do_pollfd(),再一次调用文件的 poll 实现。
socket 的 poll 实现也再调一次网卡驱动的收包函数,拉一把新包。所以每遍历一次,都再问网卡一次。有包到了,count 就非 0,第 57 行 break 退出,然后返回。整个过程没有睡过,也没有中断参与。
第 69 行:跑到这里,说明:
没发现能忙等的 socket 或者有任务在等 CPU 或者忙等到期了
busy_flag 清零,相当于关掉了本次 poll 调用的 busy poll,然后走下面的正常睡眠路径。也就是说,忙等只在睡下之前做这一次,后面被叫醒再次遍历时,由于 busy_flag 已经是 0,socket 不会再被要求拉包,can_busy_loop 也不会再被置位,也就不会再忙等了。
为什么被叫醒后就不再忙等了呢?
因为醒来之后通常也用不着忙等了。线程被叫醒,多半是因为某个 fd 真的有事了,重新遍历一遍大概率 count 非 0,然后就返回了。即使是被信号或超时叫醒,重新遍历之后也是直接退出。
真正醒来重新遍历之后发现没就绪而又要睡下去的情况很少,为这种情况每次都忙等一段时间,不划算。
正常清零之后,一次 poll 调用最多忙等一个窗口,也就最多 net.core.busy_poll 这么多微秒的 CPU。反之,如果每次醒来都忙等,那么对于一个超时很长、中间被反复叫醒的 poll 调用,CPU 开销将会随唤醒次数累加,极端情况下会变得没有上限。
4.3.2.7 睡下
文件遍历了,信号也检查了,busy poll 也处理完了,接下来就只能老实地睡下去了,静静地等着有事情发生,然后被别人唤醒。
睡下去的代码如下,也是外层 for 循环的最后一段代码:
/** If this is the first loop and we have a timeout* given, then we convert to ktime_t and set the to* pointer to the expiry value.*/if (end_time && !to) {expire = timespec_to_ktime(*end_time);to = &expire;}if (!poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack))timed_out = 1;
第 71 - 79 行:注释说,如果这是第一轮、而且给了超时,就把它转成 ktime_t,让 to 指向它。
end_time 为 NULL 表示无限等待,to 也将一直是 NULL。否则,第一轮循环在这里转换一次,后续循环复用同一个绝对到期时刻。
前面的文章解释过为什么要用绝对时刻。使用绝对时刻可以保证超时判断的标准始终是同一个,不管中间睡眠唤醒过几次。
第 81 - 82 行:真正睡下的地方。
返回 0 表示睡到超时了,置 timed_out。返回非 0 表示被别人唤醒,说明 fd 状态有变。
不管哪种情况,接下来都回到循环顶部,重新扫描所有 fd。
如果是超时,遍历完这一轮后第 57 行的 timed_out 会让循环退出,返回最后这一轮的 count。如果是被唤醒,遍历完之后由 count 决定去留。
为什么醒来后还要重查?因为唤醒只代表某个 fd 的状态可能变了,并不保证一定就绪,也不知道是哪个。最终返回什么,仍由再次调用每个 fd 的 poll 实现来决定。
第 84 行:返回 count,就绪的 fd 个数。
到这里 do_poll() 的骨架就分析完了。
4.3.2.8 do_poll() 小结
回顾一下前面的分析,do_poll() 干的事情就是一个循环:
遍历所有 pollfd,逐个调 do_pollfd() 问文件:你就绪了吗? 收集结果。有 fd 就绪、出错、或者有信号挂起,退出循环;上一轮已经睡到超时的,遍历完这一轮也退出。 开了 busy poll 的话,睡之前先忙等一小段时间。所谓忙等,就是在一段时间内,不间断地执行第 1 步和第 2 步。 都没有,就调 poll_schedule_timeout() 睡下,直到被唤醒或者超时。 醒来后回到第 1 步,重新扫描。
返回值 count 是就绪的 fd 个数,或者一个负的错误码。
回到第 1 节提出的四类问题,其中第 2 类和第 4 类在这里就可以收敛了。
一个都没就绪时,当前线程要睡下去。那睡在哪儿?
睡在 poll_schedule_timeout() 里,也就是 do_poll() 的第 81 行。睡眠状态是 TASK_INTERRUPTIBLE,可以被信号打断;带不带定时器,取决于用户程序给没给 timeout 值。
叫醒之后怎么办?被叫醒就一定有 fd 就绪了吗?
唤醒只说明有 fd 的状态变了,既不保证一定就绪,也没说具体是哪个。所以醒来之后一律回到循环顶部,重新问一遍每个 fd,才能知道是否有就绪的文件,以及具体是哪个或哪几个文件。
前面分析的时候,我们刻意跳过了 do_pollfd() 和 poll_schedule_timeout() 源码层面的分析,现在就来会会它们。
4.3.2.9 do_pollfd()
函数完整实现如下:
static inline unsigned intdo_pollfd(struct pollfd *pollfd, poll_table *pwait,bool *can_busy_poll,unsigned int busy_flag){unsigned int mask;int fd;mask = 0;fd = pollfd->fd;if (fd >= 0) {struct fd f = fdget(fd);mask = POLLNVAL;if (f.file) {mask = DEFAULT_POLLMASK;if (f.file->f_op->poll) {pwait->_key = pollfd->events|POLLERR|POLLHUP;pwait->_key |= busy_flag;mask = f.file->f_op->poll(f.file, pwait);if (mask & busy_flag)*can_busy_poll = true;}/* Mask out unneeded events. */mask &= pollfd->events | POLLERR | POLLHUP;fdput(f);}}pollfd->revents = mask;return mask;}
四个参数:
pollfd 是当前要检查的那个 pollfd pwait 是 poll_table,要传给文件的 poll 实现 can_busy_poll 传进来的是地址,值会在这里被修改 busy_flag 是 busy poll 是否使能的总开关
第 8 - 9 行:mask 清零,取出 fd。
第 10 行:文件描述符 fd 必须是个有效值才允许后续的操作。
如果 fd 小于 0 ,那么整段跳过,mask 保持为 0,最后返回的也是 0。poll 的手册页规定:fd 为负数时忽略 events,revents 返回 0。这条规定的源头就是这里。
第 11 行:根据 fd 找到 struct file。
这个寻找过程值得展开聊聊。
我们知道,内核用 task_struct 这么一个结构体来描述一个线程。task_struct 里有这么一个指针:
struct task_struct {...struct files_struct *files;...};
这个 files 指针就指向线程的打开文件表。files_struct 定义在 include/linux/fdtable.h:
struct files_struct {atomic_t count;...struct fdtable __rcu *fdt;struct fdtable fdtab;...struct file __rcu * fd_array[NR_OPEN_DEFAULT];};
上面只列出了和本节主题相关的成员,各成员解释如下:

注意,fdtab 和 fd_array 是内嵌在 files_struct 里的,不是指针。打开的文件不超过 64 个时,整张表不需要额外分配一个字节。这和 do_sys_poll() 用 stack_pps 的思路是一样一样的:先用自带的小缓冲区,不够了再去堆上申请。
fdtable 本身不存 struct file 指针,它只是一个描述符,描述存储 struct file 指针的数组在哪儿,有多大。其定义在 include/linux/fdtable.h:
struct fdtable {unsigned int max_fds;struct file __rcu **fd; /* current fd array */...struct rcu_head rcu;};
也是只列出相关的成员:

数组元素是 struct file 指针,定义在 include/linux/fs.h,只看和本文相关的两个字段:
struct file {...const struct file_operations *f_op;...atomic_long_t f_count;...};
f_op: 操作函数表,第 18 行调的 f_op->poll 就在这里。
f_count: 引用计数,减到 0 文件才释放。
最后是 fdget() 的返回值,定义在 include/linux/file.h:
struct fd {struct file *file;unsigned int flags;};
file 是查到的文件,查不到为 NULL。flags 记录这次查找有没有给 f_count 加 1,后面第 24 行的 fdput() 据此决定要不要减回去。
加不加引用由 files_struct 的 count 决定。
如果打开文件表只有当前线程在用,而当前线程正在 poll,不可能同时去 close,所以数组在这次系统调用期间不会变,查完数组后就可以直接返回,引用计数不用加一。
如果表被多个线程共用,别的线程随时可能 close 这个 fd,那么就需要在 RCU 读临界区里查数组并给 f_count 加 1,保证 f_op->poll 调用期间文件不会被释放。
几个结构体之间的关系
┌──────────────────┐│ task_struct ││ files ─────────┼──────────┐└──────────────────┘ │▼┌───────────────────────────────────────────────┐│ files_struct ││ count ││ fdt ───────┐ ││ ▼ ││ ┌─────────────────┐ ││ │ fdtab (fdtable) │ ┌─────────────────┐ ││ │ max_fds = 64 │ │ fd_array[64] │ ││ │ fd ───────────┼──►│ [0] [1] [2] ... │ ││ └─────────────────┘ └──────┬──────────┘ │└────────────────────────────────┼──────────────┘▼┌──────────────┐│ struct file ││ f_op ││ .poll ││ f_count │└──────────────┘┌──────────────────┐ ▲│ struct fd │ ││ file ──────────┼─────────────┘│ flags │└──────────────────┘
图里画的是初始状态:fdt 指向内嵌的 fdtab,fdtab.fd 指向内嵌的 fd_array。
沿着箭头走,fdget() 的路径就是 current->files->fdt->fd[fd],最终就找到了目标文件指针。
fd_array 最多能保存 64 个文件,如果打开的文件超过 64 了怎么办呢?
当打开第 65 个文件时,内核会在堆上分配一个新的 fdtable 和一个更大的数组,把旧数组的内容拷过去,然后让 fdt 指向这个新的 fdtable:
files_struct 堆上┌────────────────────┐ ┌─────────────────┐│ fdt ───────────────┼───►│ fdtable ││ │ │ max_fds = 256 │| ┌────────────────┐ | | fd ──┐ |│ | fdtab │ │ └────────┼────────┘│ | max_fds = 64 │ │ |│ | fd ─┐ │ │ ▼│ └───────┼────────┘ │ ┌───┬───┬───┬─────┬─────┐│ ▼ │ │ 0 │ 1 │ 2 │ ... │ 255 ││ fd_array[64] │ └───┴───┴───┴─────┴─────┘└────────────────────┘
内嵌的 fdtab 和 fd_array 从此不再使用,但也不回收,仍然作为 files_struct 的一部分。
你可能已经隐约感觉到这里的怪异之处了。既然只是扩容,让 fdtab.fd 指向一个新的数组,然后更新 fdtab.max_fds 的值不就可以了?为什么把 fdtab 也给换掉了?
换句话,这个 fdt 指针多少有点多余了吧?
一点都不多余,而且是必需的。
原因是打开文件表的并发是用 RCU 管理的。RCU 的套路很简单:要改一样东西,不在原地改,而是先创建一份新的,改好之后把指针一拨,指向新的那份,等没人再用旧的了,再把旧的释放掉。其它人要么看到完整的旧版本,要么看到完整的新版本,永远不会看到改了一半的中间状态。
这个套路有一个前提:得有一个指针可以拨。所以凡是用 RCU 保护的东西,都要被一个指针指着。
在当前这个场景下,内嵌的 fdtab 是打开文件表的第一个版本,扩容时堆上分配的 fdtable 是新版本,fdt 就是那个可以拨的指针。
至于 RCU 是如何管理并发,以及具体的实现细节,感兴趣的道友可自行研究,本文不展开。
第 12 行:mask 先置成 POLLNVAL,表示 not valid。
如果下一行发现 file 是空的,可以直接用 POLLNVAL 填充 revents,并返回之。
第 13 行:找到了文件,可以继续往下走。
第 14 行:mask 改成 DEFAULT_POLLMASK,定义在 include/linux/poll.h:
#define DEFAULT_POLLMASK (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)如果下一行发现文件没有 poll 实现,可以直接用 DEFAULT_POLLMASK 填充 revents:永远可读可写。普通磁盘文件就是这种情况,poll 它们没有意义,因为总是返回可读可写。
注意 mask 和 if 判断的规律,每次 if 判断前都先把 mask 设置为一个默认值,随时提防 if 不成立,保证突然返回也不会出问题。
第 15 行:文件有 poll 实现,那就调用之。
第 16 - 17 行:调用之前需要先更新一下 _key 字段。
把本次关心的事件写进 pwait->_key。pollfd->events 是用户程序传进来的感兴趣的事件,再或上 POLLERR 和 POLLHUP。
也就是说,错误和挂断是隐式关心的,不管用户程序有没有传,都是本次 poll 关心的事件。
busy_flag 也或进来。socket 的 poll 实现看到 _key 里有 POLL_BUSY_LOOP,就先让网卡驱动主动收一次包,把已经到达的数据收进 socket 的接收队列,然后再检查自己的状态。没有它,socket 不会主动去联系网卡。
2.4 节说 _key 是调用者关心的事件掩码,这里就是它被写入的地方。注意它是按每个 fd 覆盖写入的,上一个 fd 的 _key 值不会带给下一个 fd。
第 18 行:调用文件的 poll 实现,传文件和 poll_table。返回值是这个文件当前就绪的事件。
这一行就是第 1 节第 1 个问题的答案:poll 核心层不负责判断一个 fd 有没有就绪,它把问题转交给每个文件自己。
每种文件在自己的 file_operations 里提供一个 poll 函数,然后 poll 核心层调用它来查询文件是否就绪。这种分工是合理的,因为文件有很多种,poll 核心层不可能为每一种文件单独实现是否就绪的判断,这个工作交由文件自己才最合理,只有它才最清楚自己的状态。
第 19 - 20 行:返回值里带了 POLL_BUSY_LOOP,说明这个 socket 具备 busy poll 的条件,那就通过 can_busy_poll 告诉 do_poll()。busy poll 的流程前面已经分析过了。
第 22 - 23 行:注释说把不需要的事件过滤掉。
f_op->poll 可能返回比用户关心的更多的事件,这里用 events 加 POLLERR | POLLHUP 过滤一下,只留下用户真正想要的。
比如,管道的 poll 会同时报告可读和可写,但用户可能只关心是否可读(POLLIN),那这里就可以把可写(POLLOUT)给过滤掉。
POLL_BUSY_LOOP 也在这里被过滤掉了。
第 24 行:引用计数减一。与 fdget() 成对。
第 27 行:过滤后的结果写进 revents。
注意,写的是 4.2 节的 poll_list 副本的 revents,不是用户态的,回写到用户态还在后面。
第 29 行:返回 mask。
mask 非零有三种情况:
真就绪。 f_op->poll 返回的事件,经第 23 行过滤后只留下用户想要的,或者是 POLLERR、POLLHUP。 POLLNVAL。 fd 非负但没有对应的打开文件。poll 返回这个值,告诉用户你传了个非法的 fd。 文件没有 poll 实现。 mask 是 DEFAULT_POLLMASK,只要用户 events 里设置了可读或可写中的任何一个,最终的 mask 就非零。
4.3.2.10 f_op->poll
每种文件的 poll 实现各不相同,因为都有各自的业务逻辑。但每个 poll 实现都需要按照约定做两件事:
调用 poll_wait() 返回就绪的事件掩码,如果没有事件就绪,就返回 0
好奇的道友可以去内核源码随便搜一搜,几乎每一个具体文件的 poll 实现都做了这两件事。这是 poll 核心层对 f_op->poll 的要求:
调用 poll_wait() 是为了给唤醒流程做准备,否则就没法唤醒睡下去的线程 返回值在 4.3.2.9 节分析 do_pollfd() 时就说明过了,代码上就是这么设计的
一个典型的 f_op->poll 实现示例如下:
#include<linux/module.h>#include<linux/fs.h>#include<linux/poll.h>#include<linux/wait.h>staticDECLARE_WAIT_QUEUE_HEAD(demo_wq);staticunsignedintdemo_poll(struct file *filp, poll_table *wait){unsigned int mask = 0;poll_wait(filp, &demo_wq, wait);if (readable())mask |= POLLIN | POLLRDNORM;if (writable())mask |= POLLOUT | POLLWRNORM;return mask;}static const struct file_operations demo_fops = {.owner = THIS_MODULE,.poll = demo_poll,...};
关于这段 demo 代码,有两点要说明:
poll_wait() 的第二个参数是一个等待队列头
要解释清楚这个等待队列头,得先解释一下 poll 的休眠唤醒机制。这里先只讲解原理,源码级别的分析放在下一篇。
为了方便描述,把调用 poll() 系统调用的用户线程记作线程 A,把负责唤醒 A 的线程记作 B。每当线程 A poll 一个目标文件时,poll 核心层都要求目标文件为 A 创建一个等待队列节点,然后把这个节点挂到目标文件的等待队列头上。之后线程 A 睡下。
假设线程 B 操作目标文件,导致目标文件变得可读或可写了。既然文件状态有变,那线程 A 就需要被唤醒,然后就可以去读或写目标文件了。此时唤醒 A 的任务需要由 B 来完成。
B 怎么完成?很简单,找到目标文件对应的那个等待队列头,然后取出一开始为线程 A 创建的那个等待队列节点,等待队列节点里有个回调就可以唤醒线程 A。
注意,站在目标文件的角度来看,有可能不止线程 A 在 poll 我。每一个线程 poll 我时,我的 f_op->poll 就要为这个线程创建一个等待队列节点,然后挂到我的等待队列头里。
这样,一旦我的状态有变,那么引起我状态变化的那个线程就可以循着这个等待队列头,唤醒每一个 poll 我的线程。
readable() 和 writable()
每一种文件是可读还是可写,需要满足的条件都不一样,所以对应的具体实现也会千差万别。
假设有个设备文件,FIFO 里有数据才可读,FIFO 未满才可写。那 readable() 和 writable() 的实现就需要读和 FIFO 相关的状态寄存器。
通常,文件的状态变化与 f_op->read 和 f_op->write 有很大的关系。比如,某个线程调用 read 读出了一些数据,那就说明 FIFO 变得可写了,或者 FIFO 为空不可读了。或者调用 write 写入了一些数据,那 FIFO 就变得可读了,或者 FIFO 满了不可写了。
所以,唤醒线程 A 的那个线程 B 是随机的,谁来读或者写,谁就是那个幸运儿。而且,f_op->read 和 f_op->write 通常也是唤醒线程 A 的地方。
4.3.2.11 poll_schedule_timeout()
第一轮扫描结束,count 是 0,没有信号,没超时,接下来就只能睡下去了,等文件状态有变时再让别人把自己唤醒。
睡下去走的是 poll_schedule_timeout(),函数也定义在 fs/select.c:
intpoll_schedule_timeout(struct poll_wqueues *pwq, int state,ktime_t *expires, unsigned long slack){int rc = -EINTR;set_current_state(state);if (!pwq->triggered)rc = schedule_hrtimeout_range(expires, slack, HRTIMER_MODE_ABS);__set_current_state(TASK_RUNNING);/** Prepare for the next iteration.** The following smp_store_mb() serves two purposes. First, it's* the counterpart rmb of the wmb in pollwake() such that data* written before wake up is always visible after wake up.* Second, the full barrier guarantees that triggered clearing* doesn't pass event check of the next iteration. Note that* this problem doesn't exist for the first iteration as* add_wait_queue() has full barrier semantics.*/smp_store_mb(pwq->triggered, 0);return rc;}
四个参数:poll_wqueues、要进入的睡眠状态、到期时刻、误差。do_poll() 传的 state 是 TASK_INTERRUPTIBLE,表示本次睡眠可以被信号打断。
第 4 行:rc 默认 -EINTR。如果第 7 行的 if 条件不成立,函数直接返回 -EINTR,do_poll() 看到非 0 就不会置 timed_out,直接回到循环顶部进行下一轮遍历。
第 6 行:把当前线程的 state 设置成 TASK_INTERRUPTIBLE。
第 7 - 8 行:triggered 没有被置位,才真的去睡。triggered 的理解是个难点,下篇来重点分析。
这里的写法是内核里睡眠的经典范式:
set_current_state(TASK_INTERRUPTIBLE); // 先把自己标记为”准备睡”if (!condition) // 再检查条件schedule(); // 没满足才真的睡
先改 state,再查条件,最后才 schedule。顺序不能反。
schedule_hrtimeout_range() 是带高精度定时器的睡眠,不打算逐行分析了,但有几点需要说明:
函数的作用是让当前线程睡到指定的到期时刻 除非调用前已经设置了 state,否则会立刻返回,这解释了第 6 行为什么必须在它之前 slack 给了内核自由度,实际唤醒可以在 expires 到 expires + slack 之间,但不会早于 expires state 是 TASK_INTERRUPTIBLE 时,信号可以让它提前返回 返回 0 表示定时器到期了,否则返回 -EINTR
第 9 行:把 state 该回 TASK_RUNNING。不管是从睡眠中被唤醒,还是压根儿就没睡,都需要把 state 改回去。
第 11 - 22 行:一段注释加一行代码。代码本身只是把 triggered 清零。
注释说这行代码有两个作用:
它是 pollwake() 里 wmb 的配对读屏障,保证唤醒前写入的数据在唤醒后一定可见。 全屏障保证清除 triggered 这个动作不会越过下一轮的事件检查。注释还说第一轮没有这个问题,因为 add_wait_queue() 有全屏障语义。
这行代码是我个人认为整个 poll 系统调用源码里最难理解的一行。主要原因是它涉及内存屏障,以及隐藏在雾里的唤醒侧流程。
下篇将斗胆说说我对这行代码的理解。
第 24 行:返回 rc。
到这里 poll 线程就睡下了。注意,它是在循环里睡下的,被唤醒后流程会进到下一轮循环。至于谁来唤醒它、怎么唤醒,是下篇文章的重点。
4.3.3 poll_freewait()
函数在 fs/select.c:
voidpoll_freewait(struct poll_wqueues *pwq){struct poll_table_page * p = pwq->table;int i;for (i = 0; i < pwq->inline_index; i++)free_poll_entry(pwq->inline_entries + i);while (p) {struct poll_table_entry * entry;struct poll_table_page *old;entry = p->entry;do {entry--;free_poll_entry(entry);} while (entry > p->entries);old = p;p = p->next;free_page((unsigned long) old);}}
根据函数名,以及又是调用 free_poll_entry(),又是 free_page() 的,很明显,这是在释放资源。而资源的最小单位就是 entry,即 poll_table_entry。
这个函数和 poll_wait() 以及唤醒侧的实现密切相关,留到下一篇再来详细分析。
4.4 回写
do_poll() 走完了,回到 do_sys_poll() 的最后两段。
第 45 - 52 行:
for (walk = head; walk; walk = walk->next) {struct pollfd *fds = walk->entries;int j;for (j = 0; j < walk->len; j++, ufds++)if (__put_user(fds[j].revents, &ufds->revents))goto out_fds;}
又是两层循环。这和 pollfd 在内核空间的存储方式有关,看一下 4.2 节末尾的那个图,就很好理解了。外层是一块一块的遍历,内层则是在一个块上逐个地遍历每一个 pollfd。
__put_user() 把每个内核副本里的 revents,写回用户态对应 pollfd 的 revents 字段。
有三点要说明:
只回写 revents,不碰用户的 fd 和 events,所以不能整块 copy_to_user(),只能逐个地修改 revents 字段。 ufds 这个参数被当作游标直接往后推。用户数组是连续的,内核副本虽然分了块,但块与块之间的 pollfd 是按原顺序排的,所以内层循环每写一个就 ufds++,就算是跨块也不需要任何额外的偏移计算。 revents 是用户程序最关注的返回结果,如果写不回去,就只能 goto 返回错误。
4.5 释放
第 54 - 63 行:
err = fdcount;out_fds:walk = head->next;while (walk) {struct poll_list *pos = walk;walk = walk->next;kfree(pos);}return err;
fdcount 是 do_poll() 的返回值,赋给 err,最后再返回给上一级的 sys_ppoll()。这个返回值控制着 sys_ppoll() 里的流程。可见,大到 for 循环,小到返回值,都需要精心设计。
三条 goto out_fds 的路径都会走到这里,分别是拷入失败、内存分配失败、回写失败。前两种情况链表可能只建了一半,但 for 循环里面第一条语句总是先把 walk->next 置为 NULL,所以任何时候链表的最后一个 next 肯定是 NULL,不会让 while 是个死循环。
接下来释放堆上的内存。循环是从 head->next 开始,head 本身在栈上,所以不用释放。
注意,必须要先临时保存 walk,并把 walk->next 的值取出来,然后才能释放内存块。否则一旦 free,walk->next 就可能是个非法值了,轻则原来的内存释放不了引起内存泄漏,重则释放了不该释放的内存导致系统崩溃。
最后返回 err。do_sys_poll() 所有可能的返回值总结如下:

5. 小结
本文重点分析了 do_sys_poll() 函数的实现,主要侧重在 poll 核心层这边,刻意回避了 poll 核心层和文件的 poll 实现(f_op->poll)之间的暧昧关系,以及唤醒侧的流程。
这么做主要是基于行文上的考量,避免单篇文章的篇幅过长。而且,拆开能让文章更有侧重点,这样理解起来会更快,不必将精力分散在各处,否则容易心生迷茫而抓不到重点。
下一篇我们就以 f_op->poll 为入口,详细剖析文件 poll 实现侧要做的事情,然后深入分析睡下去的线程是如何被唤醒的。这里面涉及大量的数据结构和实现细节,不可谓不精彩。同时,本文有好几处的代码分析,也都是在下一篇收敛才最合适。
敬请各位道友期待!















































































