码迷，mamicode.com
首页 > 其他好文 > 详细

Select函数实现

时间：2016-08-10 06:29:14      阅读：277      评论：0      收藏：0      [点我收藏+]

标签：

  1. int select(int nfds, 
  2.         fd_set *restrict readfds, 
  3.         fd_set *restrict writefds, 
  4.         fd_set *restrict errorfds, 
  5.         struct timeval *restrict timeout);
  1. SYSCALL_DEFINE5(select, int, n, 
  2.         fd_set __user *, inp, 
  3.         fd_set __user *, outp, 
  4.         fd_set __user *, exp, 
  5.         struct timeval __user *, tvp)
  6. {
  7.     ret = core_sys_select(n, inp, outp, exp, to);
  8.     ret = poll_select_copy_remaining(&end_time, tvp, 1, ret);
  9.     return ret;
  10. }

core_sys_select 主要工作:

  1. 初始化读写还有异常的bitmap
  2. 调用 do_select 实现核心的轮询工作。
  3. 把结果拷贝会用户空间
  1. int core_sys_select(int n, 
  2.         fd_set __user *inp, 
  3.         fd_set __user *outp, 
  4.         fd_set __user *exp, 
  5.         struct timespec *end_time)
  6. {
  7.     fd_set_bits fds;
  8.     // …
  9.     if ((ret = get_fd_set(n, inp, fds.in)) ||
  10.         (ret = get_fd_set(n, outp, fds.out)) ||
  11.         (ret = get_fd_set(n, exp, fds.ex)))   //*get_fd_set仅仅调用copy_from_user从用户空间拷贝了fd_set*/ 
  12.         goto out;
  13.     zero_fd_set(n, fds.res_in);
  14.     zero_fd_set(n, fds.res_out);
  15.     zero_fd_set(n, fds.res_ex);
  17.     //发现do_select函数
  18.     ret = do_select(n, &fds, end_time);
  19.     /*把结果集,拷贝回用户空间*/  
  20.     if (set_fd_set(n, inp, fds.res_in) ||  
  21.         set_fd_set(n, outp, fds.res_out) ||  
  22.         set_fd_set(n, exp, fds.res_ex))  
  23.         ret = -EFAULT;  
  24. }

  1. int do_select(int n, fd_set_bits *fds, struct timespec *end_time)
  2. {
  3.      
  4.  struct poll_wqueues table;
  5.     poll_table *wait;
  6.     poll_initwait(&table);//这个函数实现很关键，其内部的 init_poll_funcptr 初始化回调函数为 __pollwait, 后面轮询会回调这个函数，然后通过这个函数把进程添加到对应的监听文件等待队列，当有事件到来时，就会唤醒这个进程。
  7.     for (;;) {
  8.         //一次大循环
  9.         for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
  10.             // …
  11.             struct fd f;
  12.             f = fdget(i);
  13.             if (f.file) {
  14.                 const struct file_operations *f_op;  //每个设备拥有一个struct file_operations结构体
  15.                 f_op = f.file->f_op; 
  16.                 mask = DEFAULT_POLLMASK;
  17.                 if (f_op->poll) { //轮询函数不为空，每当设备模块加载就自动会加载设备轮询函数，等于将轮回函数统一付给poll这个指针，以便调用
  18.                     wait_key_set(wait, in, out,bit, busy_flag);//检查集合
  19.                     // 对每个fd进行I/O事件检测 （*f_op->poll)返回当前设备fd的状态（可读可写)
  20.                     mask = (*f_op->poll)(f.file, wait);//将会调用poll_wait函数，检测文件设备的状态，并且将当前进程加入到设备等待队列中。并且返回掩码
  21.                 }
  22.                 fdput(f);
  23.             }
  24.         }
  25.         // 退出循环体 
  26.         if (retval || timed_out || signal_pending(current))
  27.             break;
  28.         // 轮询一遍没有发现就绪。那就休眠
  29.         if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE,
  30.                 to, slack))
  31.             timed_out = 1;
  32.     }
  33. }
  


  1. 这个函数实现很关键，这里 init_poll_funcptr 初始化回调函数为 __pollwait, 后面轮询会回调这个函数，然后通过这个函数把进程添加到对应的监听文件等待队列，当有事件到来时，就会唤醒这个进程。
  2. poll_initwait(&table);
  3. void poll_initwait(struct poll_wqueues *pwq){//这里p->_qproc实际就是__pollwait函数，因为p->qproc在init_poll_funcptr中被赋值为__pollwait函数指针 
  4.   init_poll_funcptr(&pwq->pt, __pollwait); //初始化函数指针，设置为__pollwait
  5.     pwq->error = 0;
  6.     pwq->table = NULL;
  7.     pwq->inline_index = 0;}
  8. static inline void  init_poll_funcptr(poll_table *pt, poll_queue_proc qproc){
  9.     pt->qproc = qproc;    
  10. }

以下根据scull设备分析轮询函数
每个驱动设备对应一个fd
每个fd包含struct file_operations
struct file_operations 每个设备都对应一个这样的结构体
  1. struct file {
  2.     struct path     f_path;//路径
  3.     struct inode        *f_inode;   //inode
  4.     const struct file_operations    *f_op; //包含各种用于操作设备的函数指针
  5. } __attribute__((aligned(4)));  /* lest something weird decides that 2 
  1. struct file_operations {
  2.     struct module *owner;
  3.     loff_t (*llseek) (struct file *, loff_t, int);
  4.     ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
  5.     // select()轮询设备fd的操作函数，对应一个file 跟poll_table_struct *
  6.     unsigned int (*poll) (struct file *, struct poll_table_struct *); //驱动加载。一般就挂到这个地方轮询函数
  7. };
具体分析scull设备
每个设备都有一个这样的结构体。而这样的结构体基本都有一个等待队列
  1. struct scull_pipe {
  2.         wait_queue_head_t inq, outq; //可读可写队列
  3. };
这个设备的轮询操作函数是scull_p_poll.驱动模块加载，这个函数就被挂到（*poll)函数指针sk;
返回当前设备的I/O状态，并且调用了poll_wait函数，将当前进程加入到等待队列，把wait_queue_head_t队列当做参数传入
  1. static unsigned int scull_p_poll(struct file *filp, poll_table *wait)
  2. {
  3.     struct scull_pipe *dev = filp->private_data;
  4.     unsigned int mask = 0；
  5.     mutex_lock(&dev->mutex);
  6.     poll_wait(filp, &dev->inq,  wait);//pollwait函数包含了__pollwait.这函数就是把当前进程添加到设备队列中
  7.     poll_wait(filp, &dev->outq, wait);//等待
  8.     if (dev->rp != dev->wp)
  9.         mask |= POLLIN | POLLRDNORM;    //可读
  10.     if (spacefree(dev))
  11.         mask |= POLLOUT | POLLWRNORM;   //可写
  12.     mutex_unlock(&dev->mutex);
  13.     return mask;//返回该设备的掩码，是否就绪可读可写
  14. }
注意poll_wait函数，把设备自己的等待队列给传进去了，还传了一个poll_table
看看poll_wait函数的最主要功能就是调用__pollwait将当前进程添加到设备等待队列
  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.         p->_qproc(filp, wait_address, p);//这里p->_qproc实际就是__pollwait函数，因为p->qproc在do_select中被赋值为__pollwait函数指针
  5. }
poll_table结构体包含 poll_queue_proc _qproc，unsigned long _key; 2个变量，
其中第一变量是一个函数指针
typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);

我们找下poll_table的初始化在哪
poll_table里的函数指针，是在do_select()初始化的。
  1. int do_select(int n, fd_set_bits *fds, struct timespec *end_time)
  2. {
  3.     struct poll_wqueues table;
  4.     poll_table *wait;
  5.     poll_initwait(&table);//初始化
  6. }
  8. void poll_initwait(struct poll_wqueues *pwq)
  9. {
  10.     // 初始化poll_table里的函数指针
  11.     init_poll_funcptr(&pwq->pt, __pollwait);
  12. }
  13. EXPORT_SYMBOL(poll_initwait);
  15. static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
  16. {
  17.     pt->_qproc = qproc;//将poll_table的函数指针设置为__pollwait完成初始化工作
  18.     pt->_key   = ~0UL; /* all events enabled */
  19. }
  1. static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
  2.                 poll_table *p)
  3. {
  4.     // 把当前进程装到设备的等待队列
  5.     add_wait_queue(wait_address, &entry->wait);
  6. }
如果当设备有数据可写的时候。将调用此函数那将此等待可写的队列中的进程唤醒
  1. static ssize_t scull_p_write(struct file *filp, const char __user *buf, size_t count,
  2.                 loff_t *f_pos)
  3. {
  4.     wake_up_interruptible(&dev->inq);  //唤醒当前进程
  5. }

  1. select慢的原因
  2. 从上面看，在第一次所有监听都没有事件时，调用 select 都需要把进程挂到所有监听的文件描述符一次。
  3. 有事件到来时，不知道是哪些文件描述符有数据可以读写，需要把所有的文件描述符都轮询一遍才能知道。
  4. 通知事件到来给用户进程，需要把整个 bitmap 拷到用户空间，让用户空间去查询。
  5. select返回时，会将该进程从全部监听的fd的等待队列里移除掉，这样就需要select每次都要重新传入全部监听的fd，然后重现将本进程挂载到全部的监测fd的等待队列













Select函数实现

标签：

原文地址：http://www.cnblogs.com/zengyiwen/p/5755205.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！