NIO底层的实现

poll函数的定义如下：

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

 其中的参数类型pollfd的定义如下：

struct pollfd {
    int   fd;
    short events; 
    short revents;
};

poll系统调用对应的内核中的代码为sys_poll，整体的流程是先把用户想知道的事件从用户内存弄到内核空间中来。然后调用文件的poll函数来监听对应的事件。如果在指定的时间内发生了，那么就要通知用户态的进程了。为了更清楚地阅读代码，先来看涉及到的数据结构，poll_wqueues用来保存发生的事件：

poll_list用来保存从用户空间得到的用户感兴趣的事件：

asmlinkage long sys_poll(struct pollfd __user * ufds, unsigned int nfds, long timeout)
{
    struct poll_wqueues table;
    int fdcount, err;
    unsigned int i;
    struct poll_list *head;
    struct poll_list *walk;

    if (nfds > current->files->max_fdset && nfds > OPEN_MAX)
        return -EINVAL;
    if (timeout) {
        if ((unsigned long) timeout < MAX_SCHEDULE_TIMEOUT / HZ)
            timeout = (unsigned long)(timeout*HZ+999)/1000+1;
        else
            timeout = MAX_SCHEDULE_TIMEOUT;
    }
    // 初始化poll_wqueues，设置了回调函数为__pollwait
    poll_initwait(&table);
    
    head = NULL;
    walk = NULL;
    i = nfds;
    err = -ENOMEM;
    // 每次都分配一个页面来保存传入的pollfd数组，下面的循环用来分割
    while(i!=0) {
        struct poll_list *pp;
        pp = kmalloc(sizeof(struct poll_list)+ sizeof(struct pollfd)*(i>POLLFD_PER_PAGE?POLLFD_PER_PAGE:i), GFP_KERNEL);
        if(pp==NULL)
            goto out_fds;
        pp->next=NULL;
        pp->len = (i>POLLFD_PER_PAGE?POLLFD_PER_PAGE:i);
        if (head == NULL)
            head = pp;
        else
            walk->next = pp;
            
        walk = pp;
        if (copy_from_user(pp->entries, ufds + nfds-i, sizeof(struct pollfd)*pp->len)) {
            err = -EFAULT;
            goto out_fds;
        }
        i -= pp->len;
    }
    // 真正的执行
    fdcount = do_poll(nfds, head, &table, timeout);
    walk = head;
    err = -EFAULT;
    // 如果发现事件发生了，这些仍然在内核空间，需要通知用户进程
    while(walk != NULL) {
        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;
        }
        walk = walk->next;
    }
    err = fdcount;
    if (!fdcount && signal_pending(current))
        err = -EINTR;
out_fds:
    // 在离开之前释放掉分配的内存
    walk = head;
    while(walk!=NULL) {
        struct poll_list *pp = walk->next;
        kfree(walk);
        walk = pp;
    }
    poll_freewait(&table);
    return err;
}

在poll_wqueues中我们看到了一个回调函数poll_queue_proc，在初始化poll_wqueues的时候（也就是poll_initwait函数中）会被初始化为__pollwait。

void __pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *_p)
{
    // 根据_p的位置就能找到所在的poll_wqueues所在的位置
    struct poll_wqueues *p = container_of(_p, struct poll_wqueues, pt);
    struct poll_table_page *table = p->table;
    // 如果为空或者没有足够的空间
    if (!table || POLL_TABLE_FULL(table)) {
        struct poll_table_page *new_table;
        new_table = (struct poll_table_page *) __get_free_page(GFP_KERNEL);
        if (!new_table) {
            p->error = -ENOMEM;
            __set_current_state(TASK_RUNNING);
            return;
        }
        new_table->entry = new_table->entries;
        new_table->next = table;
        p->table = new_table;
        table = new_table;
    }
    {
        struct poll_table_entry * entry = table->entry;
        table->entry = entry+1;
        get_file(filp);
        entry->filp = filp;
        entry->wait_address = wait_address;
        // 初始化等待队列项，挂载当前线程
        init_waitqueue_entry(&entry->wait, current);
        add_wait_queue(wait_address,&entry->wait);
    }
}

接下来会调动do_poll函数，在这个函数里并没有做什么实际性的工作，循环处理poll_list下面的每个页面（每个页面上有用户进程感兴趣的事件），然后再do_pollfd函数中循环处理一个页面上所有的pollfd。这个函数中实际上还是循环调用file_operation结构中的poll函数。在返回的结果中判断我们感兴趣的事件有没有发生。具体的代码如下：

static void do_pollfd(unsigned int num, struct pollfd * fdpage, poll_table ** pwait, int *count)
{
    int i;
    // 循环遍历一个页面上保存的所有的pollfd
    for (i = 0; i < num; i++) {
        int fd;
        unsigned int mask;
        struct pollfd *fdp;
        mask = 0;
        fdp = fdpage+i;
        fd = fdp->fd;
        if (fd >= 0) {
            struct file * file = fget(fd);
            mask = POLLNVAL;
            if (file != NULL) {
                mask = DEFAULT_POLLMASK;
                if (file->f_op && file->f_op->poll)
                    mask = file->f_op->poll(file, *pwait);
                // 用来判断是不是自己感兴趣的事件发生了
                mask &= fdp->events | POLLERR | POLLHUP;
                fput(file);
            }
            // 如果发生了，就将pwait清空，后面就不用再把当前线程挂入等待队列
            if (mask) {
                *pwait = NULL;
                (*count)++;
            }
        }
        // 把发生的事件记录下来，用来返回
        fdp->revents = mask;
    }
}

到此为止，如果发现我们感兴趣的事件发生了，那就把回调函数设置为null，这样就算以后再发现有事件发生也不会做任何实质性的操作，而是记录一下数目而已。相应的在do_poll函数中发现对应的事件发生了就会中断循环返回。再底层的比如file_operation中的poll是怎么实现的话以后有事件再看。