select 和poll的剖析

好久没剖析过网络知识了。所以这次好好的整理一下这个东西。
具体如何下整理

这是文件结构体，每个打开的文件的fd都会对应一个这样的结构体，主要是看f_op 这个主要是对文件进行操作方法的结构体

1. struct file {  
2.     const struct file_operations    *f_op;  
3.     spinlock_t          f_lock;  
4.     // 文件内部实现细节  
5.     void               *private_data;  
6. #ifdef CONFIG_EPOLL  
7.     /* Used by fs/eventpoll.c to link all the hooks to this file */  
8.     struct list_head    f_ep_links;  
9.     struct list_head    f_tfile_llink;  
10. #endif /* #ifdef CONFIG_EPOLL */  
11.     // 其他细节....  
12. };  

f _op 结构体定义如下

1. struct file_operations {  
2.     // 文件提供给poll/select/epoll  
3.     // 获取文件当前状态, 以及就绪通知接口函数  
4.     unsigned int (*poll) (struct file *, struct poll_table_struct *);  
5.     // 其他方法read/write 等... ...  
6. };  

所以我们调用系统read时候实际上是调用file->f_op_read 函数。但是这个里面全是定义的函数指针，但是我们主要关注的还是这个指针poll这个主要是为了当有需要的事件到来的时候进行通知所调用的回调函数。

这个函数的定义 如下

1. 
   // 通常的file.f_ops.poll 方法的实现  
2. unsigned int file_f_op_poll (struct file *filp, struct poll_table_struct *wait)  
3. {  
4.     unsigned int mask = 0;  
5.     wait_queue_head_t * wait_queue;  
6.   
7.     //1. 根据事件掩码wait->key_和文件实现filep->private_data 取得事件掩码对应的一个或多个wait queue head  
8.     some_code();  
9.   
10.     // 2. 调用poll_wait 向获得的wait queue head 添加节点  
11.     poll_wait(filp, wait_queue, wait);  
12.   
13.     // 3. 取得当前就绪状态保存到mask  
14.     some_code();  
15.   
16.     return mask;  
17. }  

其实这个函数很简单。传进来的参数第一个是当前fd对应文件的指针，第二个参数就是下面 的结构体，这个结构体中两个参数

第一个是一个函数指正第二个是key 保存当前文件的状态。

1. typedef struct poll_table_struct {  
2.     // 向wait_queue_head 添加回调节点(wait_queue_t)的接口函数  
3.     poll_queue_proc _qproc;  
4.     // 关注的事件掩码, 文件的实现利用此掩码将等待队列传递给_qproc  
5.     unsigned long   _key;  
6. } poll_table; 
7. //
   1. // 通用的poll_wait 函数, 文件的f_ops->poll 通常会调用此函数 函数如下通过这个函数可将有事件就绪调用回调函数将他放到自己的waitqueue上。

1. static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)  
2. {  
3.     if (p && p->_qproc && wait_address) {  
4.         // 调用_qproc 在wait_address 上添加节点和回调函数  
5.         // 调用 poll_table_struct 上的函数指针向wait_address添加节点, 并设置节点的func  
6.         // (如果是select或poll 则是 __pollwait, 如果是 epoll 则是 ep_ptable_queue_proc),  
7.         p->_qproc(filp, wait_address, p);  
8.     }  
9. }  
10.   

  select和poll下的poll_wait 函数插入到等待队列上

1.   
2. // wait_queue设置函数  
3. // poll/select 向文件wait_queue中添加节点的方法   先调用__pollwait 函数将他放到等待队列上并设置为休眠然后设置唤醒函数为回调函数当有事件发生时会唤醒然后便利整个等待队列。
4. static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,  
5.                        poll_table *p)  
6. {  
7.     struct poll_wqueues *pwq = container_of(p, struct poll_wqueues, pt);  
8.     struct poll_table_entry *entry = poll_get_entry(pwq);  
9.     if (!entry) {  
10.         return;  
11.     }  
12.     get_file(filp); //put_file() in free_poll_entry()  
13.     entry->filp = filp;  
14.     entry->wait_address = wait_address; // 等待队列头  
15.     entry->key = p->key;  
16.     // 设置回调为 pollwake  
17.     init_waitqueue_func_entry(&entry->wait, pollwake);  //设置回调函数。
18.     entry->wait.private = pwq;  
19.     // 添加到等待队列  
20.     add_wait_queue(wait_address, &entry->wait);  

回调函数就是当监听的文件描述符上有状态的改变就告知它里面的key保存 的就是当前掩码的值。

1.  当文件的状态发生改变时, 文件会调用此函数，此函数通过调用wait_queue_t.func通知poll的调用者  
2. // 其中key是文件当前的事件掩码  
3. void __wake_up(wait_queue_head_t *q, unsigned int mode,  
4.                int nr_exclusive, void *key)  
5. {  
6.     unsigned long flags;  
7.   
8.     spin_lock_irqsave(&q->lock, flags);  
9.     __wake_up_common(q, mode, nr_exclusive, 0, key);  
10.     spin_unlock_irqrestore(&q->lock, flags);  
11. }  

waitqueue的结构体如下

1. // wait_queue 头节点  
2. typedef struct __wait_queue_head wait_queue_head_t;  
3. struct __wait_queue_head {  
4.     spinlock_t lock;  
5.     struct list_head task_list;  
6. };  
7.   
8. // wait_queue 节点  
9. typedef struct __wait_queue wait_queue_t;  
10. struct __wait_queue {  
11.     unsigned int flags;  
12. #define WQ_FLAG_EXCLUSIVE   0x01  
13.     void *private;  
14.     wait_queue_func_t func;  
15.     struct list_head task_list;  
16. };  
17. typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key);  
18.   

select唤醒过程的时候先判断改变key值和我自己当前的key是不是相等的如果一样的话就唤醒操作

1. {  
2.     struct poll_table_entry *entry;  
3.     // 取得文件对应的poll_table_entry  
4.     entry = container_of(wait, struct poll_table_entry, wait);  
5.     // 过滤不关注的事件  
6.     if (key && !((unsigned long)key & entry->key)) {  
7.         return 0;  
8.     }  
9.     // 唤醒  
10.     return __pollwake(wait, mode, sync, key);  
11. }

唤醒程序在前面调用poll_wait 将本进程挂载到等待队列上。然后检查设备上有事件来了就唤醒该等待队列上的进程。

1. static int __pollwake(wait_queue_t *wait, unsigned mode, int sync, void *key)  
2. {  
3.     struct poll_wqueues *pwq = wait->private;  
4.     // 将调用进程 pwq->polling_task 关联到 dummy_wait  
5.     DECLARE_WAITQUEUE(dummy_wait, pwq->polling_task);  
6.     smp_wmb();  
7.     pwq->triggered = 1;// 标记为已触发  
8.     // 唤醒调用进程  
9.     return default_wake_function(&dummy_wait, mode, sync, key);  
10. }  

1. 1. // 默认的唤醒函数,poll/select 设置的回调函数会调用此函数唤醒  
   2. // 直接唤醒等待队列上的线程,即将线程移到运行队列(rq)  
   3. int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,  
   4.                           void *key)  
   5. {  
   6.     // 这个函数比较复杂, 这里就不具体分析了  
   7.     return try_to_wake_up(curr->private, mode, wake_flags);  
   8. }  
   
   

select代码实际的话select->sys_select 

asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, struct timeval __user *tvp)
{
    fd_set_bits fds;
    char *bits;
    long timeout;
    int ret, size, max_fdset;

    //将用户的等待事件拷贝到内核态
    timeout = MAX_SCHEDULE_TIMEOUT;
    if (tvp) {
        time_t sec, usec;

        if ((ret = verify_area(VERIFY_READ, tvp, sizeof(*tvp)))
            || (ret = __get_user(sec, &tvp->tv_sec))
            || (ret = __get_user(usec, &tvp->tv_usec)))
            goto out_nofds;

        ret = -EINVAL;
        if (sec < 0 || usec < 0)
            goto out_nofds;

        //进行单位换算
        if ((unsigned long) sec < MAX_SELECT_SECONDS) {
            timeout = ROUND_UP(usec, 1000000/HZ);
            timeout += sec * (unsigned long) HZ;
        }
    }

    ret = -EINVAL;
    if (n < 0)
        goto out_nofds;

    /* 下面代码是为了检查fd是不是大于规定的maxfd如果大于就不在对后面的放到进行呢间提供 */
    max_fdset = current->files->max_fdset;
    if (n > max_fdset)
        n = max_fdset;

    /*
     * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
     * since we used fdset we need to allocate memory in units of
     * long-words. 
     */
    ret = -ENOMEM;
    size = FDS_BYTES(n);//然后在内核中分配一个fdset的变量通过传进来的大小进行位的开辟
    //为内核的fd_set_bits申请空间并初始化
    bits = select_bits_alloc(size);
  

  if (!bits)
        goto out_nofds;
    fds.in      = (unsigned long *)  bits;然后获取到fds中存储不同事件位的地址
    fds.out     = (unsigned long *) (bits +   size);
    fds.ex      = (unsigned long *) (bits + 2*size);
    fds.res_in  = (unsigned long *) (bits + 3*size);
    fds.res_out = (unsigned long *) (bits + 4*size);
    fds.res_ex  = (unsigned long *) (bits + 5*size);
    //拷贝用户空间感兴趣的事件
    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;
    //清空存放事件的位数组（最后有时间发生发到这个里面）
    zero_fd_set(n, fds.res_in);
    zero_fd_set(n, fds.res_out);
    zero_fd_set(n, fds.res_ex);

    //监听用户感兴趣的事件
    ret = do_select(n, &fds, &timeout);

    if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
        time_t sec = 0, usec = 0;
        if (timeout) {
            sec = timeout / HZ;
            usec = timeout % HZ;
            usec *= (1000000/HZ);
        }
        put_user(sec, &tvp->tv_sec);
        put_user(usec, &tvp->tv_usec);//返回剩余的事件
    }

    if (ret < 0)
        goto out;
    if (!ret) {
        ret = -ERESTARTNOHAND;
        if (signal_pending(current))//在这里等待可读如果time结构体为nuLL那么无限等待。或者到达所设定时间进行跳出
            goto out;
        ret = 0;
    }
    //将存放事件结果的位数组拷贝给用户参数位数组，通过修改用户传进来的位数组将事件返回给用户
    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:
    select_bits_free(bits, size);
out_nofds:
    return ret;
}

do_select

int do_select(int n, fd_set_bits *fds, long *timeout)
{
    struct poll_wqueues table; //上面的等待队列
    poll_table *wait;
    int retval, i;
    long __timeout = *timeout;

    spin_lock(&current->files->file_lock);
    retval = max_select_fd(n, fds);//获取到轮询的次数不可能每次都循环1024 次通过最大的fdfds进行确定
    spin_unlock(&current->files->file_lock);

    if (retval < 0)
        return retval;
    n = retval;

    //设置回调函数，该回调函数将当前进程挂到等待对队中，等待队列上有可以唤醒进程的回调函数。
    poll_initwait(&table);
    wait = &table.pt;
    if (!__timeout)时间到了但是wait=NULL；
        wait = NULL;
    retval = 0;
    for (;;) {
        unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;

        set_current_state(TASK_INTERRUPTIBLE);////select是可中断的应该是休眠可以被唤醒的。

        inp = fds->in; outp = fds->out; exp = fds->ex;
        rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;

        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;
            struct file_operations *f_op = NULL;
            struct file *file = NULL;

            in = *inp++; out = *outp++; ex = *exp++;
            all_bits = in | out | ex;
            if (all_bits == 0) {
                i += __NFDBITS;
                continue;
            }

            for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
                if (i >= n)
                    break;
                if (!(bit & all_bits))
                    continue;
                file = fget(i);
                if (file) {
                    f_op = file->f_op;
                    mask = DEFAULT_POLLMASK;
                    if (f_op && f_op->poll)
                        //调用回调函数，为每一个fd分配一个poll_table_page，用来保存当前fd监听的事件                        
                        mask = (*f_op->poll)(file, retval ? NULL : wait);
                    fput(file);
                    //判断当前fd是否有事件发生，然后设置事件返回位数组
                    if ((mask & POLLIN_SET) && (in & bit)) {
                        res_in |= bit;
                        retval++;
                    }
                    if ((mask & POLLOUT_SET) && (out & bit)) {
                        res_out |= bit;
                        retval++;
                    }
                    if ((mask & POLLEX_SET) && (ex & bit)) {
                        res_ex |= bit;
                        retval++;
                    }
                }
                cond_resched();
            }
            //将返回事件位数组的值拷贝给传进来的参数
            if (res_in)
                *rinp = res_in;
            if (res_out)
                *routp = res_out;
            if (res_ex)
                *rexp = res_ex;
        }
        wait = NULL;
        if (retval || !__timeout || signal_pending(current))
            break;
        if(table.error) {
            retval = table.error;
            break;
        }
        __timeout = schedule_timeout(__timeout);//进程进行休眠
    }
    __set_current_state(TASK_RUNNING);
    //删除fd的poll_table_page
    poll_freewait(&table);

    *timeout = __timeout;
    return retval;
}

内），驱动程序中的Poll函数的工作 有两个，

 一个就是调用poll_wait 函数，把进程挂到等待队列中去（这个是必须的，你要睡眠，必须要在一个等待队列上面，否则到哪里去唤醒你呢？？），

 另一个是确定相关的fd是否有内容可 读，如果可读，就返回1，否则返回0，如果返回1 ，do_poll函数中的count++，    

 然后  do_poll函数然后判断三个条件（if (count ||!timeout || signal_pending(current))）如果成立就直接跳出，如果不成立，

 就睡眠timeout个jiffes这么长的时间（调用schedule_timeout实现睡眠），如果在这段时间内没有其他进程去唤醒它，

 那么第二次执行判断的时候就会跳出死循环。如果在这段时间内有其他进程唤醒它，那么也可以跳出死循环返回

 （例如我们可以利用中断处理函数去唤醒它，这样的话一有数据可读，就可以让它立即返回）

1. poll > sys_poll > do_sys_poll >poll_initwait，poll_initwait函数注册一下回调函数__pollwait，它就是我们的驱动程序执行poll_wait时，真正被调用的函数。

 

2. 接下来执行file->f_op->poll，即我们驱动程序里自己实现的poll函数

   它会调用poll_wait把自己挂入某个队列，这个队列也是我们的驱动自己定义的；

   它还判断一下设备是否就绪。

 

3. 如果设备未就绪，do_sys_poll里会让进程休眠一定时间，这个时间是应用提供的“超时时间”

 

4. 进程被唤醒的条件有2：一是上面说的“一定时间”到了，二是被驱动程序唤醒。驱动程序发现条件就绪时，就把“某个队列”上挂着的进程唤醒，这个队列，就是前面通过poll_wait把本进程挂过去的队列。

 

5. 如果驱动程序没有去唤醒进程，那么chedule_timeout(__timeou)超时后，会重复2、3动作1次，直到应用程序的poll调用传入的时间到达， 然后返回。