夜雨聆风学习资料网

ARTICLE · 1361143

poll 源码分析(六):do_sys_poll()

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 就绪、或者超时、或者被信号打断为止。

这句话拆开来,至少有四类问题:

  1. 内核怎么知道某个 fd 有没有就绪?fd 背后可能是管道、socket、设备文件等,内核不可能为每种文件写一套判断。
  2. 一个都没就绪时,当前线程要睡下去。那睡在哪儿?
  3. 总不能一直睡眠吧,那谁来叫醒?叫醒的那一方怎么知道有人在等着它去唤醒?
  4. 叫醒之后怎么办?被叫醒就一定有 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 = __pollwait  do_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()                   // 回写 revents  kfree()

其中,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 be       faster - use long to make sure the buffer is aligned properly       on 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 be       faster - use long to make sure the buffer is aligned properly       on 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 allocating   additional 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() 干的事情就是一个循环:

  1. 遍历所有 pollfd,逐个调 do_pollfd() 问文件:你就绪了吗?
  2. 收集结果。有 fd 就绪、出错、或者有信号挂起,退出循环;上一轮已经睡到超时的,遍历完这一轮也退出。
  3. 开了 busy poll 的话,睡之前先忙等一小段时间。所谓忙等,就是在一段时间内,不间断地执行第 1 步和第 2 步。
  4. 都没有,就调 poll_schedule_timeout() 睡下,直到被唤醒或者超时。
  5. 醒来后回到第 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 实现侧要做的事情,然后深入分析睡下去的线程是如何被唤醒的。这里面涉及大量的数据结构和实现细节,不可谓不精彩。同时,本文有好几处的代码分析,也都是在下一篇收敛才最合适。

敬请各位道友期待!

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料