io复用之poll源码分析（基于linux2.6.13.1）

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd {
    int   fd;        
    short events;     /* 用户感兴趣的事件 */
    short revents;    /* 系统触发的事件 */
};

struct poll_wqueues table;
table->pt->qproc = __pollwait;
table->error = 0;
table->table = NULL

    head = NULL;
    walk = NULL;
    i = nfds;
    err = -ENOMEM;
    while(i!=0) {
        struct poll_list *pp;
        // 申请一页大小的内存，保存一个poll_list结构体和多个pollfd结构体，大于一页的，再循环这个过程
        pp = kmalloc(sizeof(struct poll_list)+
                sizeof(struct pollfd)*
                (i>POLLFD_PER_PAGE?POLLFD_PER_PAGE:i),
                    GFP_KERNEL);
        pp->next=NULL;
        // 记录本次复制的pollfd结构体个数
        pp->len = (i>POLLFD_PER_PAGE?POLLFD_PER_PAGE:i);
        // 构造链表
        if (head == NULL)
            head = pp;
        else
            walk->next = pp;
        // 执行当前的poll_list，poll_list形成一个链表
        walk = pp;
        // 复制用户的数据到内核
        copy_from_user(pp->entries, ufds + nfds-i, sizeof(struct pollfd)*pp->len);
        // 剩下待复制的个数
        i -= pp->len;
    }

// nfds文件描述符个数，head保存了文件描述符和事件的链表头指针，table用于挂起进程，timeout最多poll多久
fdcount = do_poll(nfds, head, &table, timeout);

static int do_poll(unsigned int nfds,  struct poll_list *list,
            struct poll_wqueues *wait, long timeout)
{
    int count = 0;
    poll_table* pt = &wait->pt;
    // timeout为空，说明即使没有就绪事件也不需要阻塞
    if (!timeout)
        pt = NULL;

    for (;;) {
        struct poll_list *walk;
        walk = list;
        while(walk != NULL) {
            do_pollfd( walk->len, walk->entries, &pt, &count);
            walk = walk->next;
        }
        // count代表有没有就绪事件，timeout 说明没有设置超时或者已经超时，signal_pending代表有信号需要处理
        if (count || !timeout || signal_pending(current))
            break;
        // 挂起进程，timeout后被唤醒
        timeout = schedule_timeout(timeout);
    }
    return count;
}

static void do_pollfd(unsigned int num, struct pollfd * fdpage,
    poll_table ** pwait, int *count)
{
    int i;

    for (i = 0; i < num; i++) {
        int fd;
        unsigned int mask;
        struct pollfd *fdp;

        mask = 0;
        // 当前当处理的pollfd结构体
        fdp = fdpage+i;
        // 待处理文件描述符
        fd = fdp->fd;
        if (fd >= 0) {
            // 获取fd对应的file结构体 
            struct file * file = fget(fd);
            mask = POLLNVAL;
            if (file != NULL) {
                mask = DEFAULT_POLLMASK;
                if (file->f_op && file->f_op->poll)
                    // mask记录就绪的事件
                    mask = file->f_op->poll(file, *pwait);
                // 过滤掉不感兴趣的
                mask &= fdp->events | POLLERR | POLLHUP;
                fput(file);
            }
            // 有就绪事件，记录
            if (mask) {
                *pwait = NULL;
                (*count)++;
            }
        }
        // 记录就绪的事件
        fdp->revents = mask;
    }
}

    static unsigned int
pipe_poll(struct file *filp, poll_table *wait)
{
    ...
    /* Reading only -- no need for acquiring the semaphore.  */
    nrbufs = info->nrbufs;
    mask = 0;
    if (filp->f_mode & FMODE_READ) {
        mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
        if (!PIPE_WRITERS(*inode) && filp->f_version != PIPE_WCOUNTER(*inode))
            mask |= POLLHUP;
    }

    if (filp->f_mode & FMODE_WRITE) {
        mask |= (nrbufs < PIPE_BUFFERS) ? POLLOUT | POLLWRNORM : 0;
        if (!PIPE_READERS(*inode))
            mask |= POLLERR;
    }

    return mask;
}