select/poll源码分析——I/O复用函数总结（一）

转载请注明出处：http://blog.csdn.net/linxdcn/article/details/72983933

---

1 概述

Linux内核一旦发现进程指定的一个或多个IO条件就绪，它就通知进程。这个能力称为IO复用。

IO复用的函数主要由select、poll和epoll，本文主要介绍select和poll函数。

poll和select的实现基本上是一致的，只是传递参数有所不同，他们的基本流程如下：

1. 复制用户数据到内核空间
2. 估计超时时间
3. 遍历每个文件并调用f_op->poll 取得文件当前就绪状态， 如果前面遍历的文件都没有就绪，向文件插入wait_queue节点
4. 遍历完成后检查状态：
   a). 如果已经有就绪的文件转到5；
   b). 如果有信号产生，重启poll或select（转到 1或3）；
   c). 否则挂起进程等待超时或唤醒，超时或被唤醒后再次遍历所有文件取得每个文件的就绪状态
5. 将所有文件的就绪状态复制到用户空间
6. 清理申请的资源

---

2 select源码分析

select函数的主要调用流程如下：

• syscall的select：处理时间参数，调用core_sys_select核心函数
• core_sys_select：处理三个fd_set文件描述符，调用do_select
• do_select：select最主要的工作在此完成。在合适的时机把自己挂起等待，调用file_operations的poll

2.1 select

SYSCALL_DEFINE5(select, int, n, fd_set __user *, inp, fd_set __user *, outp,        fd_set __user *, exp, struct timeval __user *, tvp){    struct timespec64 end_time, *to = NULL;    struct timeval tv;    int ret;    // 1 判断是否有设置超时时间，如果超时发出信号    if (tvp) {        if (copy_from_user(&tv, tvp, sizeof(tv)))            return -EFAULT;        to = &end_time;        if (poll_select_set_timeout(to,                tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),                (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))            return -EINVAL;    }    // 2 调用core_sys_select完成主要工作    ret = core_sys_select(n, inp, outp, exp, to);    ret = poll_select_copy_remaining(&end_time, tvp, 1, ret);    return ret;}

主要步骤如下：

1. 判断是否有设置超时时间，如果超时发出信号
2. 调用core_sys_select完成主要工作

2.2 core_sys_select

int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,               fd_set __user *exp, struct timespec64 *end_time){    fd_set_bits fds;    void *bits;    int ret, max_fds;    size_t size, alloc_size;    struct fdtable *fdt;    // 在栈中先申请一小块stack_fds空间存储    // SELECT_STACK_ALLOC 定义为256    long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];    ret = -EINVAL;    if (n < 0)        goto out_nofds;    // 获取当前进程的文件描述符表    rcu_read_lock();    fdt = files_fdtable(current->files);    max_fds = fdt->max_fds;    rcu_read_unlock();    if (n > max_fds)        n = max_fds;    // 如果stack_fds数组的大小不能容纳下所有的fd_set,就用kmalloc重新分配一个大数组。    // 然后将位图平均分成份,并初始化fds结构    // 1 为传入的文件描述符和结果文件描述符bitmap申请分配空间    size = FDS_BYTES(n);    bits = stack_fds;    if (size > sizeof(stack_fds) / 6) {        /* Not enough space in on-stack array; must use kmalloc */        ret = -ENOMEM;        if (size > (SIZE_MAX / 6))            goto out_nofds;        alloc_size = 6 * size;        bits = kvmalloc(alloc_size, GFP_KERNEL);        if (!bits)            goto out_nofds;    }    fds.in      = bits;    fds.out     = bits +   size;    fds.ex      = bits + 2*size;    fds.res_in  = bits + 3*size;    fds.res_out = bits + 4*size;    fds.res_ex  = bits + 5*size;    // 2 调用get_fd_set从用户空间拷贝了fd_set，只是copy_from_user的包装    if ((ret = get_fd_set(n, inp, fds.in)) ||        (ret = get_fd_set(n, outp, fds.out)) ||        (ret = get_fd_set(n, exp, fds.ex)))        goto out;    // 把结果fd_set清零    zero_fd_set(n, fds.res_in);    zero_fd_set(n, fds.res_out);    zero_fd_set(n, fds.res_ex);    // 3 调用do_select真正完成select任务    ret = do_select(n, &fds, end_time);    if (ret < 0)        goto out;    if (!ret) {        ret = -ERESTARTNOHAND;        if (signal_pending(current))            goto out;        ret = 0;    }    // 4 把结果集,拷贝回用户空间    if (set_fd_set(n, inp, fds.res_in) ||        set_fd_set(n, outp, fds.res_out) ||        set_fd_set(n, exp, fds.res_ex))        ret = -EFAULT;out:    if (bits != stack_fds)        kvfree(bits);out_nofds:    return ret;}

主要步骤：

1. 为传入的文件描述符和结果文件描述符bitmap申请分配空间
2. 调用get_fd_set从用户空间拷贝了fd_set，这个函数只是copy_from_user的包装
3. 调用do_select真正完成select任务
4. 把结果集通过set_fd_set拷贝回用户空间

2.3 do_select

// 真正的select在此,遍历了所有的fd,调用对应的xxx_poll函数// n是最大描述符+1，描述符0，1，2...n-1均被检测static int do_select(int n, fd_set_bits *fds, struct timespec64 *end_time){    ktime_t expire, *to = NULL;    struct poll_wqueues table;    poll_table *wait;    int retval, i, timed_out = 0;    u64 slack = 0;    unsigned int busy_flag = net_busy_loop_on() ? POLL_BUSY_LOOP : 0;    unsigned long busy_start = 0;    // 1 根据位图检查用户打开的fd, 要求对应fd必须打开, 并且返回最大的fd    rcu_read_lock();    retval = max_select_fd(n, fds);    rcu_read_unlock();    if (retval < 0)        return retval;    n = retval;    // 2 将当前进程放入自已的等待队列table, 并将该等待队列加入到该测试表wait    poll_initwait(&table);    wait = &table.pt;    if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {        wait->_qproc = NULL;        timed_out = 1;    }    if (end_time && !timed_out)        slack = select_estimate_accuracy(end_time);    retval = 0;    // 自旋    for (;;) {        unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;        bool can_busy_loop = false;        inp = fds->in; outp = fds->out; exp = fds->ex;        rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;        // 3 遍历所有的fd        for (i = 0; i < n; ++rinp, ++routp, ++rexp) {            unsigned long in, out, ex, all_bits, bit = 1, mask, j;            unsigned long res_in = 0, res_out = 0, res_ex = 0;            // 检查当前的 slot 中的描述符            in = *inp++; out = *outp++; ex = *exp++;            all_bits = in | out | ex;            // 没有需要监听的描述符, 下一个slot            if (all_bits == 0) {                i += BITS_PER_LONG;                continue;            }            for (j = 0; j < BITS_PER_LONG; ++j, ++i, bit <<= 1) {                struct fd f;                if (i >= n)                    break;                // 不需要监听描述符 i                if (!(bit & all_bits))                    continue;                // 取得文件结构                f = fdget(i);                if (f.file) {                    const struct file_operations *f_op;                    // 没有 f_op 的话就认为一直处于就绪状态                    f_op = f.file->f_op;                    mask = DEFAULT_POLLMASK;                    // 4 获得到file结构指针，并调用file->f_op->poll                    // 注意第三个参数是等待队列，在poll成功后会将本进程唤醒执行                    if (f_op->poll) {                        // 设置等待事件的掩码                        wait_key_set(wait, in, out,                                 bit, busy_flag);                        // 获取当前的就绪状态, 并添加到文件的对应等待队列中                        mask = (*f_op->poll)(f.file, wait);                    }                    // 释放file结构指针                    fdput(f);                    // 5 根据poll的结果设置状态,要返回select出来的fd数目                    if ((mask & POLLIN_SET) && (in & bit)) {                        res_in |= bit;                        retval++;                        wait->_qproc = NULL;                    }                    if ((mask & POLLOUT_SET) && (out & bit)) {                        res_out |= bit;                        retval++;                        wait->_qproc = NULL;                    }                    if ((mask & POLLEX_SET) && (ex & bit)) {                        res_ex |= bit;                        retval++;                        wait->_qproc = NULL;                    }                    /* got something, stop busy polling */                    if (retval) {                        can_busy_loop = false;                        busy_flag = 0;                    /*                     * only remember a returned                     * POLL_BUSY_LOOP if we asked for it                     */                    } else if (busy_flag & mask)                        can_busy_loop = true;                }            }            // 6 根据poll的结果写回到输出位图里            if (res_in)                *rinp = res_in;            if (res_out)                *routp = res_out;            if (res_ex)                *rexp = res_ex;            cond_resched();        }        wait->_qproc = NULL;        if (retval || timed_out || signal_pending(current))            break;        if (table.error) {            retval = table.error;            break;        }        /* only if found POLL_BUSY_LOOP sockets && not out of time */        if (can_busy_loop && !need_resched()) {            if (!busy_start) {                busy_start = busy_loop_current_time();                continue;            }            if (!busy_loop_timeout(busy_start))                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 = timespec64_to_ktime(*end_time);            to = &expire;        }        if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE,                       to, slack))            timed_out = 1;    }    poll_freewait(&table);    return retval;}

主要步骤：

1. 根据位图检查用户打开的fd, 要求对应fd必须打开, 并且返回最大的fd，传入的n会被修正
2. 将当前进程放入自已的等待队列table, 并将该等待队列加入到该测试表wait
3. 遍历所有的fd
4. 获得到对应的file结构指针，并调用file->f_op->poll，在poll成功后会将本进程唤醒执行
5. 根据poll的结果设置状态,要返回select出来的fd数目
6. 把poll的结果写回到输出位图里

---

3 poll源码分析

poll函数的主要调用流程如下：

• syscall的poll：处理时间参数，调用do_sys_poll核心函数
• do_sys_poll：处理poll_list文件描述符链表，调用do_poll
• do_poll：poll最主要的工作在此完成。调用do_pollfd，在合适的时机把自己挂起等待。

3.1 poll

// poll 使用的结构体  struct pollfd {      int fd;        // 描述符      short events;  // 关注的事件掩码      short revents; // 返回的事件掩码  };// 用链表来管理pollfdstruct poll_list {    struct poll_list *next;    int len;    struct pollfd entries[0];};SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds,        int, timeout_msecs){    struct timespec64 end_time, *to = NULL;    int ret;    if (timeout_msecs >= 0) {        to = &end_time;        // 将相对超时时间msec 转化为绝对时间        poll_select_set_timeout(to, timeout_msecs / MSEC_PER_SEC,            NSEC_PER_MSEC * (timeout_msecs % MSEC_PER_SEC));    }    // 调用do_sys_poll处理    ret = do_sys_poll(ufds, nfds, to);    // do_sys_poll 被信号中断, 重新调用, 对使用者来说 poll 是不会被信号中断的    if (ret == -EINTR) {        struct restart_block *restart_block;        restart_block = &current->restart_block;        restart_block->fn = do_restart_poll;        restart_block->poll.ufds = ufds;        restart_block->poll.nfds = nfds;        if (timeout_msecs >= 0) {            restart_block->poll.tv_sec = end_time.tv_sec;            restart_block->poll.tv_nsec = end_time.tv_nsec;            restart_block->poll.has_timeout = 1;        } else            restart_block->poll.has_timeout = 0;        // ERESTART_RESTARTBLOCK 不会返回给用户进程,          // 而是会被系统捕获, 然后调用 do_restart_poll        ret = -ERESTART_RESTARTBLOCK;    }    return ret;}

3.2 do_sys_poll

static int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds,        struct timespec64 *end_time){    struct poll_wqueues table;    int err = -EFAULT, fdcount, len, size;    // 首先使用栈上的空间，节约内存，加速访问    long stack_pps[POLL_STACK_ALLOC/sizeof(long)];    struct poll_list *const head = (struct poll_list *)stack_pps;    // 由于采用链表保存pollfd，所以监听的文件描述符不受限制    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;        // 复制到当前的 entries        if (copy_from_user(walk->entries, ufds + nfds-todo,                    sizeof(struct pollfd) * walk->len))            goto out_fds;        todo -= walk->len;        if (!todo)            break;        // 1 当申请的栈上空间不足，在堆上申请剩余的poll_list空间        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;        }    }    // 2 初始化 poll_wqueues 结构, 设置函数指针_qproc  为__pollwait    poll_initwait(&table);    // 3 调用do_poll    fdcount = do_poll(head, &table, end_time);    // 4 从文件wait queue 中移除对应的节点, 释放entry    poll_freewait(&table);    // 5 复制结果到用户空间    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;}

主要步骤：

1. 当申请的栈上空间不足，在堆上申请剩余的poll_list空间
2. 初始化 poll_wqueues 结构, 设置函数指针_qproc为__pollwait
3. 调用do_poll
4. 从文件wait queue 中移除对应的节点, 释放entry
5. 复制结果到用户空间

3.3 do_poll

static int do_poll(struct poll_list *list, struct poll_wqueues *wait,           struct timespec64 *end_time){    poll_table* pt = &wait->pt;    ktime_t expire, *to = NULL;    int timed_out = 0, count = 0;    u64 slack = 0;    unsigned int busy_flag = net_busy_loop_on() ? POLL_BUSY_LOOP : 0;    unsigned long busy_start = 0;    // 已经超时,直接遍历所有文件描述符, 然后返回    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);    // 1 遍历文件，为每个文件的等待队列添加唤醒函数(pollwake)    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++) {                // do_pollfd 会向文件对应的wait queue 中添加节点                // 和回调函数(如果 pt 不为空)                // 并检查当前文件状态并设置返回的掩码                if (do_pollfd(pfd, pt, &can_busy_loop,                          busy_flag)) {                    // 该文件已经准备好了.                    // 不需要向后面文件的wait queue 中添加唤醒函数了.                    count++;                    pt->_qproc = NULL;                    /* found something, stop busy polling */                    busy_flag = 0;                    can_busy_loop = false;                }            }        }        // 下次循环的时候不需要向文件的wait queue 中添加节点,        // 因为前面的循环已经把该添加的都添加了        pt->_qproc = NULL;        // 第一次遍历没有发现ready的文件        if (!count) {            count = wait->error;            if (signal_pending(current))                count = -EINTR;        }        // 有ready的文件或已经超时        if (count || timed_out)            break;        if (can_busy_loop && !need_resched()) {            if (!busy_start) {                busy_start = busy_loop_current_time();                continue;            }            if (!busy_loop_timeout(busy_start))                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 = timespec64_to_ktime(*end_time);            to = &expire;        }        // 2 等待事件就绪, 如果有事件发生或超时，就再循 环一遍，取得事件状态掩码并计数,        // 注意此次循环中, 文件 wait queue 中的节点依然存在        if (!poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack))            timed_out = 1;    }    return count;}

主要步骤：

1. 遍历文件，为每个文件的等待队列添加唤醒函数(pollwake)
2. 等待事件就绪, 如果有事件发生或超时，就再循 环一遍，取得事件状态掩码并计数

---

4 总结

（1）select/poll执行效率低

select/poll函数的执行效率相对于epoll函数低很多，主要有两方面的原因：

• 每次调用select/poll都需要将所有数据（select是fd_set，poll是poll_fd）用用户空间传入到内核空间，然后结果又需要从内核空间传回用户空间。
• 每次调用select/poll都需要在内核中遍历所有传入的文件描述符，并处理（调用file的poll）

上述两个原因在fd较多时，带来严重的性能下降。

（2）select支持最大文件描述符数量为1024，而poll没有限制

fd_set结构定义

typedef struct{    #ifdef__USE_XOPEN    __fd_maskfds_bits[__FD_SETSIZE/__NFDBITS];    #define__FDS_BITS(set)((set)->fds_bits)    #else    __fd_mask__fds_bits[__FD_SETSIZE/__NFDBITS];    #define__FDS_BITS(set)((set)->__fds_bits)    #endif}fd_set;

实际上是一long类型的数组，每一个long元素是一个bitmap，每一位都能与一打开的文件句柄对应，由于数组大小有限，最大支持1024个文件描述符。

而poll采用了pollfd的链表poll_list来存储，所有没有大小限制。

（3）select传入的fd_set是值-结果参数，返回时，传入的参数fd_set是最终的结果；而poll则不是，要测试的成员由events成员指定，返回结果在revents成员

---

转载请注明出处：http://blog.csdn.net/linxdcn/article/details/72983933