程序博客网 > c 编程主要应用

select系统调用

来源：互联网 发布：c 编程主要应用 编辑：程序博客网 时间：2024/05/17 23:03
您查询的关键词是：core_sys_select 。如果打开速度慢，可以尝试快速版；如果想保存快照，可以添加到搜藏；如果想更新或删除快照，可以投诉快照。
(百度和网页http://blog.163.com/yuanbor/blog/static/566746202011438630998/的作者无关，不对其内容负责。百度快照谨为网络故障时之索引，不代表被搜索网站的即时页面。)
博客 
发现
小组
风格
 
 
群博客召集令
创建博客登录 
 关注

SmallOfficeHomeOffic

Operating System and Architecture

  • 首页
  • 日志
  • 相册
  • 音乐
  • 收藏
  • 博友
  • 关于我
 
 

日志

 
 

Linux-2.6.25 select系统调用源码分析  

2011-05-03 20:06:30|  分类： Linux内核精华|字号 订阅

Linux 2.6.25中的select系统调用主要有4个函数: 
sys_select：处理时间参数，调用core_sys_select。 
core_sys_select：处理三个fd_set参数，调用do_select。 
do_select：做select/poll的工作。在合适的时机把自己挂起等待，调用sock_poll。 
sock_poll：用函数指针分派到具体的协议层函数tcp_poll、udp_poll、datagram_poll。 
层层分工明确，我也要多学习这种方式啊。 
C代码

  1. /* 
  2. sys_select(fs/select.c) 
  3. 处理了超时值（如果有）,将struct timeval转换成了时钟周期数,调用core_sys_select,然后检查剩余时间,处理时间 
  4. */ 
  5. asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,  
  6.                            fd_set __user *exp, struct timeval __user *tvp)  
  7. {  
  8.     s64 timeout = -1;  
  9.     struct timeval tv;  
  10.     int ret;  
  12.     if (tvp) {/*如果有超时值*/ 
  13.         if (copy_from_user(&tv, tvp, sizeof(tv)))  
  14.             return -EFAULT;  
  16.         if (tv.tv_sec < 0 || tv.tv_usec < 0)/*时间无效*/ 
  17.             return -EINVAL;  
  19.         /* Cast to u64 to make GCC stop complaining */ 
  20.         if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)  
  21.             timeout = -1;   /* 无限等待*/ 
  22.         else {  
  23.             timeout = DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC/HZ);  
  24.             timeout += tv.tv_sec * HZ;/*计算出超时的相对时间,单位为时钟周期数*/ 
  25.         }  
  26.     }  
  28.     /*主要工作都在core_sys_select中做了*/ 
  29.     ret = core_sys_select(n, inp, outp, exp, &timeout);  
  31.     if (tvp) {/*如果有超时值*/ 
  32.         struct timeval rtv;  
  34.         if (current->personality & STICKY_TIMEOUTS)/*模拟bug的一个机制,不详细描述*/ 
  35.             goto sticky;  
  36.         /*rtv中是剩余的时间*/ 
  37.         rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));  
  38.         rtv.tv_sec = timeout;  
  39.         if (timeval_compare(&rtv, &tv) >= 0)/*如果core_sys_select超时返回,更新时间*/ 
  40.             rtv = tv;  
  41.         /*拷贝更新后的时间到用户空间*/ 
  42.         if (copy_to_user(tvp, &rtv, sizeof(rtv))) {  
  43. sticky:  
  44.             /* 
  45.             * If an application puts its timeval in read-only 
  46.             * memory, we don't want the Linux-specific update to 
  47.             * the timeval to cause a fault after the select has 
  48.             * completed successfully. However, because we're not 
  49.             * updating the timeval, we can't restart the system 
  50.             * call. 
  51.             */ 
  52.             if (ret == -ERESTARTNOHAND)/*ERESTARTNOHAND表明,被中断的系统调用*/ 
  53.                 ret = -EINTR;  
  54.         }  
  55.     }  
  57.     return ret;  
  58. }  
  65. /*core_sys_select 
  66. 为do_select准备好了位图,然后调用do_select,将返回的结果集,返回到用户空间 
  67. */ 
  68. static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,  
  69.                            fd_set __user *exp, s64 *timeout)  
  70. {  
  71.     fd_set_bits fds;  
  72.     void *bits;  
  73.     int ret, max_fds;  
  74.     unsigned int size;  
  75.     struct fdtable *fdt;  
  76.     /* Allocate small arguments on the stack to save memory and be faster */ 
  78.     /*SELECT_STACK_ALLOC 定义为256*/ 
  79.     long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];  
  81.     ret = -EINVAL;  
  82.     if (n < 0)  
  83.         goto out_nofds;  
  85.     /* max_fds can increase, so grab it once to avoid race */ 
  86.     rcu_read_lock();  
  87.     fdt = files_fdtable(current->files);/*获取当前进程的文件描述符表*/ 
  88.     max_fds = fdt->max_fds;  
  89.     rcu_read_unlock();  
  90.     if (n > max_fds)/*修正用户传入的第一个参数：fd_set中文件描述符的最大值*/ 
  91.         n = max_fds;  
  93.     /* 
  94.     * We need 6 bitmaps (in/out/ex for both incoming and outgoing), 
  95.     * since we used fdset we need to allocate memory in units of 
  96.     * long-words.  
  97.     */ 
  99.     /* 
  100.     如果stack_fds数组的大小不能容纳下所有的fd_set,就用kmalloc重新分配一个大数组。 
  101.     然后将位图平均分成份,并初始化fds结构 
  102.     */ 
  103.     size = FDS_BYTES(n);  
  104.     bits = stack_fds;  
  105.     if (size > sizeof(stack_fds) / 6) {  
  106.         /* Not enough space in on-stack array; must use kmalloc */ 
  107.         ret = -ENOMEM;  
  108.         bits = kmalloc(6 * size, GFP_KERNEL);  
  109.         if (!bits)  
  110.             goto out_nofds;  
  111.     }  
  112.     fds.in      = bits;  
  113.     fds.out     = bits +   size;  
  114.     fds.ex      = bits + 2*size;  
  115.     fds.res_in  = bits + 3*size;  
  116.     fds.res_out = bits + 4*size;  
  117.     fds.res_ex  = bits + 5*size;  
  119.     /*get_fd_set仅仅调用copy_from_user从用户空间拷贝了fd_set*/ 
  120.     if ((ret = get_fd_set(n, inp, fds.in)) ||  
  121.         (ret = get_fd_set(n, outp, fds.out)) ||  
  122.         (ret = get_fd_set(n, exp, fds.ex)))  
  123.         goto out;  
  125.     zero_fd_set(n, fds.res_in);  
  126.     zero_fd_set(n, fds.res_out);  
  127.     zero_fd_set(n, fds.res_ex);  
  130.     /* 
  131.     接力棒传给了do_select 
  132.     */ 
  133.     ret = do_select(n, &fds, timeout);  
  135.     if (ret < 0)  
  136.         goto out;  
  138.     /*do_select返回,是一种异常状态*/ 
  139.     if (!ret) {  
  140.         /*记得上面的sys_select不？将ERESTARTNOHAND转换成了EINTR并返回。EINTR表明系统调用被中断*/ 
  141.         ret = -ERESTARTNOHAND;  
  142.         if (signal_pending(current))/*当当前进程有信号要处理时,signal_pending返回真,这符合了EINTR的语义*/ 
  143.             goto out;  
  144.         ret = 0;  
  145.     }  
  147.     /*把结果集,拷贝回用户空间*/ 
  148.     if (set_fd_set(n, inp, fds.res_in) ||  
  149.         set_fd_set(n, outp, fds.res_out) ||  
  150.         set_fd_set(n, exp, fds.res_ex))  
  151.         ret = -EFAULT;  
  153. out:  
  154.     if (bits != stack_fds)  
  155.         kfree(bits);/*对应上面的kmalloc*/ 
  156. out_nofds:  
  157.     return ret;  
  158. }  
  167. /*do_select 
  168. 真正的select在此,遍历了所有的fd,调用对应的xxx_poll函数 
  169. */ 
  170. int do_select(int n, fd_set_bits *fds, s64 *timeout)  
  171. {  
  172.     struct poll_wqueues table;  
  173.     poll_table *wait;  
  174.     int retval, i;  
  176.     rcu_read_lock();  
  177.     /*根据已经打开fd的位图检查用户打开的fd, 要求对应fd必须打开, 并且返回最大的fd*/ 
  178.     retval = max_select_fd(n, fds);  
  179.     rcu_read_unlock();  
  181.     if (retval < 0)  
  182.         return retval;  
  183.     n = retval;  
  186.     /*将当前进程放入自已的等待队列table, 并将该等待队列加入到该测试表wait*/ 
  187.     poll_initwait(&table);  
  188.     wait = &table.pt;  
  190.     if (!*timeout)  
  191.         wait = NULL;  
  192.     retval = 0;  
  194.     for (;;) {/*死循环*/ 
  195.         unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;  
  196.         long __timeout;  
  198.         /*注意:可中断的睡眠状态*/ 
  199.         set_current_state(TASK_INTERRUPTIBLE);  
  201.         inp = fds->in; outp = fds->out; exp = fds->ex;  
  202.         rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;  
  205.         for (i = 0; i < n; ++rinp, ++routp, ++rexp) {/*遍历所有fd*/ 
  206.             unsigned long in, out, ex, all_bits, bit = 1, mask, j;  
  207.             unsigned long res_in = 0, res_out = 0, res_ex = 0;  
  208.             const struct file_operations *f_op = NULL;  
  209.             struct file *file = NULL;  
  211.             in = *inp++; out = *outp++; ex = *exp++;  
  212.             all_bits = in | out | ex;  
  213.             if (all_bits == 0) {  
  214.                 /* 
  215.                 __NFDBITS定义为(8 * sizeof(unsigned long)),即long的位数。 
  216.                 因为一个long代表了__NFDBITS位，所以跳到下一个位图i要增加__NFDBITS 
  217.                 */ 
  218.                 i += __NFDBITS;  
  219.                 continue;  
  220.             }  
  222.             for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {  
  223.                 int fput_needed;  
  224.                 if (i >= n)  
  225.                     break;  
  227.                 /*测试每一位*/ 
  228.                 if (!(bit & all_bits))  
  229.                     continue;  
  231.                 /*得到file结构指针，并增加引用计数字段f_count*/ 
  232.                 file = fget_light(i, &fput_needed);  
  233.                 if (file) {  
  234.                     f_op = file->f_op;  
  235.                     mask = DEFAULT_POLLMASK;  
  237.                     /*对于socket描述符,f_op->poll对应的函数是sock_poll 
  238.                     注意第三个参数是等待队列，在poll成功后会将本进程唤醒执行*/ 
  239.                     if (f_op && f_op->poll)  
  240.                         mask = (*f_op->poll)(file, retval ? NULL : wait);  
  242.                     /*释放file结构指针，实际就是减小他的一个引用计数字段f_count*/ 
  243.                     fput_light(file, fput_needed);  
  245.                     /*根据poll的结果设置状态,要返回select出来的fd数目，所以retval++。 
  246.                     注意：retval是in out ex三个集合的总和*/ 
  247.                     if ((mask & POLLIN_SET) && (in & bit)) {  
  248.                         res_in |= bit;  
  249.                         retval++;  
  250.                     }  
  251.                     if ((mask & POLLOUT_SET) && (out & bit)) {  
  252.                         res_out |= bit;  
  253.                         retval++;  
  254.                     }  
  255.                     if ((mask & POLLEX_SET) && (ex & bit)) {  
  256.                         res_ex |= bit;  
  257.                         retval++;  
  258.                     }  
  259.                 }  
  261.                 /* 
  262.                 注意前面的set_current_state(TASK_INTERRUPTIBLE); 
  263.                 因为已经进入TASK_INTERRUPTIBLE状态,所以cond_resched回调度其他进程来运行， 
  264.                 这里的目的纯粹是为了增加一个抢占点。被抢占后，由等待队列机制唤醒。 
  266.                 在支持抢占式调度的内核中（定义了CONFIG_PREEMPT），cond_resched是空操作 
  267.                 */   
  268.                 cond_resched();  
  269.             }  
  270.             /*根据poll的结果写回到输出位图里*/ 
  271.             if (res_in)  
  272.                 *rinp = res_in;  
  273.             if (res_out)  
  274.                 *routp = res_out;  
  275.             if (res_ex)  
  276.                 *rexp = res_ex;  
  277.         }  
  278.         wait = NULL;  
  279.         if (retval || !*timeout || signal_pending(current))/*signal_pending前面说过了*/ 
  280.             break;  
  281.         if(table.error) {  
  282.             retval = table.error;  
  283.             break;  
  284.         }  
  286.         if (*timeout < 0) {  
  287.             /*无限等待*/ 
  288.             __timeout = MAX_SCHEDULE_TIMEOUT;  
  289.         } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT - 1)) {  
  290.             /* 时间超过MAX_SCHEDULE_TIMEOUT,即schedule_timeout允许的最大值，用一个循环来不断减少超时值*/ 
  291.             __timeout = MAX_SCHEDULE_TIMEOUT - 1;  
  292.             *timeout -= __timeout;  
  293.         } else {  
  294.             /*等待一段时间*/ 
  295.             __timeout = *timeout;  
  296.             *timeout = 0;  
  297.         }  
  299.         /*TASK_INTERRUPTIBLE状态下，调用schedule_timeout的进程会在收到信号后重新得到调度的机会， 
  300.         即schedule_timeout返回,并返回剩余的时钟周期数 
  301.         */ 
  302.         __timeout = schedule_timeout(__timeout);  
  303.         if (*timeout >= 0)  
  304.             *timeout += __timeout;  
  305.     }  
  307.     /*设置为运行状态*/ 
  308.     __set_current_state(TASK_RUNNING);  
  309.     /*清理等待队列*/ 
  310.     poll_freewait(&table);  
  312.     return retval;  
  313. }  
  316. static unsigned int sock_poll(struct file *file, poll_table *wait)  
  317. {  
  318.     struct socket *sock;  
  320.     /*约定socket的file->private_data字段放着对应的socket结构指针*/ 
  321.     sock = file->private_data;  
  323.     /*对应了三个协议的函数tcp_poll,udp_poll,datagram_poll，其中udp_poll几乎直接调用了datagram_poll 
  324.     累了，先休息一下，这三个函数以后分析*/ 
  325.     return sock->ops->poll(file, sock, wait);  
  326. } 
  329. /*
  330. sys_select(fs/select.c)
  331. 处理了超时值（如果有）,将struct timeval转换成了时钟周期数,调用core_sys_select,然后检查剩余时间,处理时间
  332. */
  333. asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
  334.                                                    fd_set __user *exp, struct timeval __user *tvp)
  335. {
  336.         s64 timeout = -1;
  337.         struct timeval tv;
  338.         int ret;
  340.         if (tvp) {/*如果有超时值*/
  341.                 if (copy_from_user(&tv, tvp, sizeof(tv)))
  342.                         return -EFAULT;
  344.                 if (tv.tv_sec < 0 || tv.tv_usec < 0)/*时间无效*/
  345.                         return -EINVAL;
  347.                 /* Cast to u64 to make GCC stop complaining */
  348.                 if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)
  349.                         timeout = -1;        /* 无限等待*/
  350.                 else {
  351.                         timeout = DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC/HZ);
  352.                         timeout += tv.tv_sec * HZ;/*计算出超时的相对时间,单位为时钟周期数*/
  353.                 }
  354.         }
  356.         /*主要工作都在core_sys_select中做了*/
  357.         ret = core_sys_select(n, inp, outp, exp, &timeout);
  359.         if (tvp) {/*如果有超时值*/
  360.                 struct timeval rtv;
  362.                 if (current->personality & STICKY_TIMEOUTS)/*模拟bug的一个机制,不详细描述*/
  363.                         goto sticky;
  364.                 /*rtv中是剩余的时间*/
  365.                 rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
  366.                 rtv.tv_sec = timeout;
  367.                 if (timeval_compare(&rtv, &tv) >= 0)/*如果core_sys_select超时返回,更新时间*/
  368.                         rtv = tv;
  369.                 /*拷贝更新后的时间到用户空间*/
  370.                 if (copy_to_user(tvp, &rtv, sizeof(rtv))) {
  371. sticky:
  372.                         /*
  373.                         * If an application puts its timeval in read-only
  374.                         * memory, we don't want the Linux-specific update to
  375.                         * the timeval to cause a fault after the select has
  376.                         * completed successfully. However, because we're not
  377.                         * updating the timeval, we can't restart the system
  378.                         * call.
  379.                         */
  380.                         if (ret == -ERESTARTNOHAND)/*ERESTARTNOHAND表明,被中断的系统调用*/
  381.                                 ret = -EINTR;
  382.                 }
  383.         }
  385.         return ret;
  386. }
  393. /*core_sys_select
  394. 为do_select准备好了位图,然后调用do_select,将返回的结果集,返回到用户空间
  395. */
  396. static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
  397.                                                    fd_set __user *exp, s64 *timeout)
  398. {
  399.         fd_set_bits fds;
  400.         void *bits;
  401.         int ret, max_fds;
  402.         unsigned int size;
  403.         struct fdtable *fdt;
  404.         /* Allocate small arguments on the stack to save memory and be faster */
  406.         /*SELECT_STACK_ALLOC 定义为256*/
  407.         long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
  409.         ret = -EINVAL;
  410.         if (n < 0)
  411.                 goto out_nofds;
  413.         /* max_fds can increase, so grab it once to avoid race */
  414.         rcu_read_lock();
  415.         fdt = files_fdtable(current->files);/*获取当前进程的文件描述符表*/
  416.         max_fds = fdt->max_fds;
  417.         rcu_read_unlock();
  418.         if (n > max_fds)/*修正用户传入的第一个参数：fd_set中文件描述符的最大值*/
  419.                 n = max_fds;
  421.         /*
  422.         * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
  423.         * since we used fdset we need to allocate memory in units of
  424.         * long-words.
  425.         */
  427.         /*
  428.         如果stack_fds数组的大小不能容纳下所有的fd_set,就用kmalloc重新分配一个大数组。
  429.         然后将位图平均分成份,并初始化fds结构
  430.         */
  431.         size = FDS_BYTES(n);
  432.         bits = stack_fds;
  433.         if (size > sizeof(stack_fds) / 6) {
  434.                 /* Not enough space in on-stack array; must use kmalloc */
  435.                 ret = -ENOMEM;
  436.                 bits = kmalloc(6 * size, GFP_KERNEL);
  437.                 if (!bits)
  438.                         goto out_nofds;
  439.         }
  440.         fds.in      = bits;
  441.         fds.out     = bits +   size;
  442.         fds.ex      = bits + 2*size;
  443.         fds.res_in  = bits + 3*size;
  444.         fds.res_out = bits + 4*size;
  445.         fds.res_ex  = bits + 5*size;
  447.         /*get_fd_set仅仅调用copy_from_user从用户空间拷贝了fd_set*/
  448.         if ((ret = get_fd_set(n, inp, fds.in)) ||
  449.                 (ret = get_fd_set(n, outp, fds.out)) ||
  450.                 (ret = get_fd_set(n, exp, fds.ex)))
  451.                 goto out;
  453.         zero_fd_set(n, fds.res_in);
  454.         zero_fd_set(n, fds.res_out);
  455.         zero_fd_set(n, fds.res_ex);
  458.         /*
  459.         接力棒传给了do_select
  460.         */
  461.         ret = do_select(n, &fds, timeout);
  463.         if (ret < 0)
  464.                 goto out;
  466.         /*do_select返回,是一种异常状态*/
  467.         if (!ret) {
  468.                 /*记得上面的sys_select不？将ERESTARTNOHAND转换成了EINTR并返回。EINTR表明系统调用被中断*/
  469.                 ret = -ERESTARTNOHAND;
  470.                 if (signal_pending(current))/*当当前进程有信号要处理时,signal_pending返回真,这符合了EINTR的语义*/
  471.                         goto out;
  472.                 ret = 0;
  473.         }
  475.         /*把结果集,拷贝回用户空间*/
  476.         if (set_fd_set(n, inp, fds.res_in) ||
  477.                 set_fd_set(n, outp, fds.res_out) ||
  478.                 set_fd_set(n, exp, fds.res_ex))
  479.                 ret = -EFAULT;
  481. out:
  482.         if (bits != stack_fds)
  483.                 kfree(bits);/*对应上面的kmalloc*/
  484. out_nofds:
  485.         return ret;
  486. }
  495. /*do_select
  496. 真正的select在此,遍历了所有的fd,调用对应的xxx_poll函数
  497. */
  498. int do_select(int n, fd_set_bits *fds, s64 *timeout)
  499. {
  500.         struct poll_wqueues table;
  501.         poll_table *wait;
  502.         int retval, i;
  504.         rcu_read_lock();
  505.         /*根据已经打开fd的位图检查用户打开的fd, 要求对应fd必须打开, 并且返回最大的fd*/
  506.         retval = max_select_fd(n, fds);
  507.         rcu_read_unlock();
  509.         if (retval < 0)
  510.                 return retval;
  511.         n = retval;
  514.         /*将当前进程放入自已的等待队列table, 并将该等待队列加入到该测试表wait*/
  515.         poll_initwait(&table);
  516.         wait = &table.pt;
  518.         if (!*timeout)
  519.                 wait = NULL;
  520.         retval = 0;
  522.         for (;;) {/*死循环*/
  523.                 unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
  524.                 long __timeout;
  526.                 /*注意:可中断的睡眠状态*/
  527.                 set_current_state(TASK_INTERRUPTIBLE);
  529.                 inp = fds->in; outp = fds->out; exp = fds->ex;
  530.                 rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
  533.                 for (i = 0; i < n; ++rinp, ++routp, ++rexp) {/*遍历所有fd*/
  534.                         unsigned long in, out, ex, all_bits, bit = 1, mask, j;
  535.                         unsigned long res_in = 0, res_out = 0, res_ex = 0;
  536.                         const struct file_operations *f_op = NULL;
  537.                         struct file *file = NULL;
  539.                         in = *inp++; out = *outp++; ex = *exp++;
  540.                         all_bits = in | out | ex;
  541.                         if (all_bits == 0) {
  542.                                 /*
  543.                                 __NFDBITS定义为(8 * sizeof(unsigned long)),即long的位数。
  544.                                 因为一个long代表了__NFDBITS位，所以跳到下一个位图i要增加__NFDBITS
  545.                                 */
  546.                                 i += __NFDBITS;
  547.                                 continue;
  548.                         }
  550.                         for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
  551.                                 int fput_needed;
  552.                                 if (i >= n)
  553.                                         break;
  555.                                 /*测试每一位*/
  556.                                 if (!(bit & all_bits))
  557.                                         continue;
  559.                                 /*得到file结构指针，并增加引用计数字段f_count*/
  560.                                 file = fget_light(i, &fput_needed);
  561.                                 if (file) {
  562.                                         f_op = file->f_op;
  563.                                         mask = DEFAULT_POLLMASK;
  565.                                         /*对于socket描述符,f_op->poll对应的函数是sock_poll
  566.                                         注意第三个参数是等待队列，在poll成功后会将本进程唤醒执行*/
  567.                                         if (f_op && f_op->poll)
  568.                                                 mask = (*f_op->poll)(file, retval ? NULL : wait);
  570.                                         /*释放file结构指针，实际就是减小他的一个引用计数字段f_count*/
  571.                                         fput_light(file, fput_needed);
  573.                                         /*根据poll的结果设置状态,要返回select出来的fd数目，所以retval++。
  574.                                         注意：retval是in out ex三个集合的总和*/
  575.                                         if ((mask & POLLIN_SET) && (in & bit)) {
  576.                                                 res_in |= bit;
  577.                                                 retval++;
  578.                                         }
  579.                                         if ((mask & POLLOUT_SET) && (out & bit)) {
  580.                                                 res_out |= bit;
  581.                                                 retval++;
  582.                                         }
  583.                                         if ((mask & POLLEX_SET) && (ex & bit)) {
  584.                                                 res_ex |= bit;
  585.                                                 retval++;
  586.                                         }
  587.                                 }
  589.                                 /*
  590.                                 注意前面的set_current_state(TASK_INTERRUPTIBLE);
  591.                                 因为已经进入TASK_INTERRUPTIBLE状态,所以cond_resched回调度其他进程来运行，
  592.                                 这里的目的纯粹是为了增加一个抢占点。被抢占后，由等待队列机制唤醒。
  594.                                 在支持抢占式调度的内核中（定义了CONFIG_PREEMPT），cond_resched是空操作
  595.                                 */
  596.                                 cond_resched();
  597.                         }
  598.                         /*根据poll的结果写回到输出位图里*/
  599.                         if (res_in)
  600.                                 *rinp = res_in;
  601.                         if (res_out)
  602.                                 *routp = res_out;
  603.                         if (res_ex)
  604.                                 *rexp = res_ex;
  605.                 }
  606.                 wait = NULL;
  607.                 if (retval || !*timeout || signal_pending(current))/*signal_pending前面说过了*/
  608.                         break;
  609.                 if(table.error) {
  610.                         retval = table.error;
  611.                         break;
  612.                 }
  614.                 if (*timeout < 0) {
  615.                         /*无限等待*/
  616.                         __timeout = MAX_SCHEDULE_TIMEOUT;
  617.                 } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT - 1)) {
  618.                         /* 时间超过MAX_SCHEDULE_TIMEOUT,即schedule_timeout允许的最大值，用一个循环来不断减少超时值*/
  619.                         __timeout = MAX_SCHEDULE_TIMEOUT - 1;
  620.                         *timeout -= __timeout;
  621.                 } else {
  622.                         /*等待一段时间*/
  623.                         __timeout = *timeout;
  624.                         *timeout = 0;
  625.                 }
  627.                 /*TASK_INTERRUPTIBLE状态下，调用schedule_timeout的进程会在收到信号后重新得到调度的机会，
  628.                 即schedule_timeout返回,并返回剩余的时钟周期数
  629.                 */
  630.                 __timeout = schedule_timeout(__timeout);
  631.                 if (*timeout >= 0)
  632.                         *timeout += __timeout;
  633.         }
  635.         /*设置为运行状态*/
  636.         __set_current_state(TASK_RUNNING);
  637.         /*清理等待队列*/
  638.         poll_freewait(&table);
  640.         return retval;
  641. }
  644. static unsigned int sock_poll(struct file *file, poll_table *wait)
  645. {
  646.         struct socket *sock;
  648.         /*约定socket的file->private_data字段放着对应的socket结构指针*/
  649.         sock = file->private_data;
  651.         /*对应了三个协议的函数tcp_poll,udp_poll,datagram_poll，其中udp_poll几乎直接调用了datagram_poll
  652.         累了，先休息一下，这三个函数以后分析*/
  653.         return sock->ops->poll(file, sock, wait);
  654. }

复制代码

其他重要函数一览 
static int max_select_fd(unsigned long n, fd_set_bits *fds) 
返回在fd_set中已经打开的，并且小于用户指定最大值，的fd 
static inline int get_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset) 
从用户空间拷贝fd_set到内核 
static inline void zero_fd_set(unsigned long nr, unsigned long *fdset) 
把fd_set清零 
static inline unsigned long __must_check set_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset) 
把fd_set拷贝回用户空间 
static inline int signal_pending(struct task_struct *p) 
目前进程有信号需要处理 
struct file *fget_light(unsigned int fd, int *fput_needed) 
由fd得到其对应的file结构指针，并增加其引用计数 
static inline void fput_light(struct file *file, int fput_needed) 
释放由fget_light得到的file结构指针，减少其引用计数 
set_current_state 
设置当前进程的状态 
static inline int cond_resched(void) 
判断是否有进程需要抢占当前进程，如果是将立即发生调度。就是额外增加一个抢占点。 
signed long __sched schedule_timeout(signed long timeout) 
当前进程睡眠timeout个jiffies 
rcu_read_lock 
rcu_read_unlock 
Linux 2.6新加入的rcu锁。读锁的加锁、解锁函数 
参考http://www.ibm.com/developerworks/cn/linux/l-rcu 
poll_freewait 
poll_initwait 
poll_wait 
... 
和文件IO，poll机制有关的几个函数，参考《Linux设备驱动(第三版)》6.3 
tcp_poll 
udp_poll 
datagram_poll 
协议层的poll函数

分享到：         
阅读(224)| 评论(0)| 引用 (0) |举报

最近读者

评论

 
 
公司简介 - 联系方法 - 招聘信息 - 客户服务 - 隐私政策 - 博客风格 - 手机博客 - 订阅此博客

网易公司版权所有 ©1997-2011

您查询的关键词是：core_sys_select 。如果打开速度慢，可以尝试快速版；如果想保存快照，可以添加到搜藏；如果想更新或删除快照，可以投诉快照。
(百度和网页http://blog.163.com/yuanbor/blog/static/566746202011438630998/的作者无关，不对其内容负责。百度快照谨为网络故障时之索引，不代表被搜索网站的即时页面。)
博客 
发现
小组
风格
 
 
群博客召集令
创建博客登录 
 关注

SmallOfficeHomeOffic

Operating System and Architecture

  • 首页
  • 日志
  • 相册
  • 音乐
  • 收藏
  • 博友
  • 关于我
 
 

日志

 
 

Linux-2.6.25 select系统调用源码分析  

2011-05-03 20:06:30|  分类： Linux内核精华|字号 订阅

Linux 2.6.25中的select系统调用主要有4个函数: 
sys_select：处理时间参数，调用core_sys_select。 
core_sys_select：处理三个fd_set参数，调用do_select。 
do_select：做select/poll的工作。在合适的时机把自己挂起等待，调用sock_poll。 
sock_poll：用函数指针分派到具体的协议层函数tcp_poll、udp_poll、datagram_poll。 
层层分工明确，我也要多学习这种方式啊。 
C代码

  1. /* 
  2. sys_select(fs/select.c) 
  3. 处理了超时值（如果有）,将struct timeval转换成了时钟周期数,调用core_sys_select,然后检查剩余时间,处理时间 
  4. */ 
  5. asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,  
  6.                            fd_set __user *exp, struct timeval __user *tvp)  
  7. {  
  8.     s64 timeout = -1;  
  9.     struct timeval tv;  
  10.     int ret;  
  12.     if (tvp) {/*如果有超时值*/ 
  13.         if (copy_from_user(&tv, tvp, sizeof(tv)))  
  14.             return -EFAULT;  
  16.         if (tv.tv_sec < 0 || tv.tv_usec < 0)/*时间无效*/ 
  17.             return -EINVAL;  
  19.         /* Cast to u64 to make GCC stop complaining */ 
  20.         if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)  
  21.             timeout = -1;   /* 无限等待*/ 
  22.         else {  
  23.             timeout = DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC/HZ);  
  24.             timeout += tv.tv_sec * HZ;/*计算出超时的相对时间,单位为时钟周期数*/ 
  25.         }  
  26.     }  
  28.     /*主要工作都在core_sys_select中做了*/ 
  29.     ret = core_sys_select(n, inp, outp, exp, &timeout);  
  31.     if (tvp) {/*如果有超时值*/ 
  32.         struct timeval rtv;  
  34.         if (current->personality & STICKY_TIMEOUTS)/*模拟bug的一个机制,不详细描述*/ 
  35.             goto sticky;  
  36.         /*rtv中是剩余的时间*/ 
  37.         rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));  
  38.         rtv.tv_sec = timeout;  
  39.         if (timeval_compare(&rtv, &tv) >= 0)/*如果core_sys_select超时返回,更新时间*/ 
  40.             rtv = tv;  
  41.         /*拷贝更新后的时间到用户空间*/ 
  42.         if (copy_to_user(tvp, &rtv, sizeof(rtv))) {  
  43. sticky:  
  44.             /* 
  45.             * If an application puts its timeval in read-only 
  46.             * memory, we don't want the Linux-specific update to 
  47.             * the timeval to cause a fault after the select has 
  48.             * completed successfully. However, because we're not 
  49.             * updating the timeval, we can't restart the system 
  50.             * call. 
  51.             */ 
  52.             if (ret == -ERESTARTNOHAND)/*ERESTARTNOHAND表明,被中断的系统调用*/ 
  53.                 ret = -EINTR;  
  54.         }  
  55.     }  
  57.     return ret;  
  58. }  
  65. /*core_sys_select 
  66. 为do_select准备好了位图,然后调用do_select,将返回的结果集,返回到用户空间 
  67. */ 
  68. static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,  
  69.                            fd_set __user *exp, s64 *timeout)  
  70. {  
  71.     fd_set_bits fds;  
  72.     void *bits;  
  73.     int ret, max_fds;  
  74.     unsigned int size;  
  75.     struct fdtable *fdt;  
  76.     /* Allocate small arguments on the stack to save memory and be faster */ 
  78.     /*SELECT_STACK_ALLOC 定义为256*/ 
  79.     long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];  
  81.     ret = -EINVAL;  
  82.     if (n < 0)  
  83.         goto out_nofds;  
  85.     /* max_fds can increase, so grab it once to avoid race */ 
  86.     rcu_read_lock();  
  87.     fdt = files_fdtable(current->files);/*获取当前进程的文件描述符表*/ 
  88.     max_fds = fdt->max_fds;  
  89.     rcu_read_unlock();  
  90.     if (n > max_fds)/*修正用户传入的第一个参数：fd_set中文件描述符的最大值*/ 
  91.         n = max_fds;  
  93.     /* 
  94.     * We need 6 bitmaps (in/out/ex for both incoming and outgoing), 
  95.     * since we used fdset we need to allocate memory in units of 
  96.     * long-words.  
  97.     */ 
  99.     /* 
  100.     如果stack_fds数组的大小不能容纳下所有的fd_set,就用kmalloc重新分配一个大数组。 
  101.     然后将位图平均分成份,并初始化fds结构 
  102.     */ 
  103.     size = FDS_BYTES(n);  
  104.     bits = stack_fds;  
  105.     if (size > sizeof(stack_fds) / 6) {  
  106.         /* Not enough space in on-stack array; must use kmalloc */ 
  107.         ret = -ENOMEM;  
  108.         bits = kmalloc(6 * size, GFP_KERNEL);  
  109.         if (!bits)  
  110.             goto out_nofds;  
  111.     }  
  112.     fds.in      = bits;  
  113.     fds.out     = bits +   size;  
  114.     fds.ex      = bits + 2*size;  
  115.     fds.res_in  = bits + 3*size;  
  116.     fds.res_out = bits + 4*size;  
  117.     fds.res_ex  = bits + 5*size;  
  119.     /*get_fd_set仅仅调用copy_from_user从用户空间拷贝了fd_set*/ 
  120.     if ((ret = get_fd_set(n, inp, fds.in)) ||  
  121.         (ret = get_fd_set(n, outp, fds.out)) ||  
  122.         (ret = get_fd_set(n, exp, fds.ex)))  
  123.         goto out;  
  125.     zero_fd_set(n, fds.res_in);  
  126.     zero_fd_set(n, fds.res_out);  
  127.     zero_fd_set(n, fds.res_ex);  
  130.     /* 
  131.     接力棒传给了do_select 
  132.     */ 
  133.     ret = do_select(n, &fds, timeout);  
  135.     if (ret < 0)  
  136.         goto out;  
  138.     /*do_select返回,是一种异常状态*/ 
  139.     if (!ret) {  
  140.         /*记得上面的sys_select不？将ERESTARTNOHAND转换成了EINTR并返回。EINTR表明系统调用被中断*/ 
  141.         ret = -ERESTARTNOHAND;  
  142.         if (signal_pending(current))/*当当前进程有信号要处理时,signal_pending返回真,这符合了EINTR的语义*/ 
  143.             goto out;  
  144.         ret = 0;  
  145.     }  
  147.     /*把结果集,拷贝回用户空间*/ 
  148.     if (set_fd_set(n, inp, fds.res_in) ||  
  149.         set_fd_set(n, outp, fds.res_out) ||  
  150.         set_fd_set(n, exp, fds.res_ex))  
  151.         ret = -EFAULT;  
  153. out:  
  154.     if (bits != stack_fds)  
  155.         kfree(bits);/*对应上面的kmalloc*/ 
  156. out_nofds:  
  157.     return ret;  
  158. }  
  167. /*do_select 
  168. 真正的select在此,遍历了所有的fd,调用对应的xxx_poll函数 
  169. */ 
  170. int do_select(int n, fd_set_bits *fds, s64 *timeout)  
  171. {  
  172.     struct poll_wqueues table;  
  173.     poll_table *wait;  
  174.     int retval, i;  
  176.     rcu_read_lock();  
  177.     /*根据已经打开fd的位图检查用户打开的fd, 要求对应fd必须打开, 并且返回最大的fd*/ 
  178.     retval = max_select_fd(n, fds);  
  179.     rcu_read_unlock();  
  181.     if (retval < 0)  
  182.         return retval;  
  183.     n = retval;  
  186.     /*将当前进程放入自已的等待队列table, 并将该等待队列加入到该测试表wait*/ 
  187.     poll_initwait(&table);  
  188.     wait = &table.pt;  
  190.     if (!*timeout)  
  191.         wait = NULL;  
  192.     retval = 0;  
  194.     for (;;) {/*死循环*/ 
  195.         unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;  
  196.         long __timeout;  
  198.         /*注意:可中断的睡眠状态*/ 
  199.         set_current_state(TASK_INTERRUPTIBLE);  
  201.         inp = fds->in; outp = fds->out; exp = fds->ex;  
  202.         rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;  
  205.         for (i = 0; i < n; ++rinp, ++routp, ++rexp) {/*遍历所有fd*/ 
  206.             unsigned long in, out, ex, all_bits, bit = 1, mask, j;  
  207.             unsigned long res_in = 0, res_out = 0, res_ex = 0;  
  208.             const struct file_operations *f_op = NULL;  
  209.             struct file *file = NULL;  
  211.             in = *inp++; out = *outp++; ex = *exp++;  
  212.             all_bits = in | out | ex;  
  213.             if (all_bits == 0) {  
  214.                 /* 
  215.                 __NFDBITS定义为(8 * sizeof(unsigned long)),即long的位数。 
  216.                 因为一个long代表了__NFDBITS位，所以跳到下一个位图i要增加__NFDBITS 
  217.                 */ 
  218.                 i += __NFDBITS;  
  219.                 continue;  
  220.             }  
  222.             for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {  
  223.                 int fput_needed;  
  224.                 if (i >= n)  
  225.                     break;  
  227.                 /*测试每一位*/ 
  228.                 if (!(bit & all_bits))  
  229.                     continue;  
  231.                 /*得到file结构指针，并增加引用计数字段f_count*/ 
  232.                 file = fget_light(i, &fput_needed);  
  233.                 if (file) {  
  234.                     f_op = file->f_op;  
  235.                     mask = DEFAULT_POLLMASK;  
  237.                     /*对于socket描述符,f_op->poll对应的函数是sock_poll 
  238.                     注意第三个参数是等待队列，在poll成功后会将本进程唤醒执行*/ 
  239.                     if (f_op && f_op->poll)  
  240.                         mask = (*f_op->poll)(file, retval ? NULL : wait);  
  242.                     /*释放file结构指针，实际就是减小他的一个引用计数字段f_count*/ 
  243.                     fput_light(file, fput_needed);  
  245.                     /*根据poll的结果设置状态,要返回select出来的fd数目，所以retval++。 
  246.                     注意：retval是in out ex三个集合的总和*/ 
  247.                     if ((mask & POLLIN_SET) && (in & bit)) {  
  248.                         res_in |= bit;  
  249.                         retval++;  
  250.                     }  
  251.                     if ((mask & POLLOUT_SET) && (out & bit)) {  
  252.                         res_out |= bit;  
  253.                         retval++;  
  254.                     }  
  255.                     if ((mask & POLLEX_SET) && (ex & bit)) {  
  256.                         res_ex |= bit;  
  257.                         retval++;  
  258.                     }  
  259.                 }  
  261.                 /* 
  262.                 注意前面的set_current_state(TASK_INTERRUPTIBLE); 
  263.                 因为已经进入TASK_INTERRUPTIBLE状态,所以cond_resched回调度其他进程来运行， 
  264.                 这里的目的纯粹是为了增加一个抢占点。被抢占后，由等待队列机制唤醒。 
  266.                 在支持抢占式调度的内核中（定义了CONFIG_PREEMPT），cond_resched是空操作 
  267.                 */   
  268.                 cond_resched();  
  269.             }  
  270.             /*根据poll的结果写回到输出位图里*/ 
  271.             if (res_in)  
  272.                 *rinp = res_in;  
  273.             if (res_out)  
  274.                 *routp = res_out;  
  275.             if (res_ex)  
  276.                 *rexp = res_ex;  
  277.         }  
  278.         wait = NULL;  
  279.         if (retval || !*timeout || signal_pending(current))/*signal_pending前面说过了*/ 
  280.             break;  
  281.         if(table.error) {  
  282.             retval = table.error;  
  283.             break;  
  284.         }  
  286.         if (*timeout < 0) {  
  287.             /*无限等待*/ 
  288.             __timeout = MAX_SCHEDULE_TIMEOUT;  
  289.         } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT - 1)) {  
  290.             /* 时间超过MAX_SCHEDULE_TIMEOUT,即schedule_timeout允许的最大值，用一个循环来不断减少超时值*/ 
  291.             __timeout = MAX_SCHEDULE_TIMEOUT - 1;  
  292.             *timeout -= __timeout;  
  293.         } else {  
  294.             /*等待一段时间*/ 
  295.             __timeout = *timeout;  
  296.             *timeout = 0;  
  297.         }  
  299.         /*TASK_INTERRUPTIBLE状态下，调用schedule_timeout的进程会在收到信号后重新得到调度的机会， 
  300.         即schedule_timeout返回,并返回剩余的时钟周期数 
  301.         */ 
  302.         __timeout = schedule_timeout(__timeout);  
  303.         if (*timeout >= 0)  
  304.             *timeout += __timeout;  
  305.     }  
  307.     /*设置为运行状态*/ 
  308.     __set_current_state(TASK_RUNNING);  
  309.     /*清理等待队列*/ 
  310.     poll_freewait(&table);  
  312.     return retval;  
  313. }  
  316. static unsigned int sock_poll(struct file *file, poll_table *wait)  
  317. {  
  318.     struct socket *sock;  
  320.     /*约定socket的file->private_data字段放着对应的socket结构指针*/ 
  321.     sock = file->private_data;  
  323.     /*对应了三个协议的函数tcp_poll,udp_poll,datagram_poll，其中udp_poll几乎直接调用了datagram_poll 
  324.     累了，先休息一下，这三个函数以后分析*/ 
  325.     return sock->ops->poll(file, sock, wait);  
  326. } 
  329. /*
  330. sys_select(fs/select.c)
  331. 处理了超时值（如果有）,将struct timeval转换成了时钟周期数,调用core_sys_select,然后检查剩余时间,处理时间
  332. */
  333. asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
  334.                                                    fd_set __user *exp, struct timeval __user *tvp)
  335. {
  336.         s64 timeout = -1;
  337.         struct timeval tv;
  338.         int ret;
  340.         if (tvp) {/*如果有超时值*/
  341.                 if (copy_from_user(&tv, tvp, sizeof(tv)))
  342.                         return -EFAULT;
  344.                 if (tv.tv_sec < 0 || tv.tv_usec < 0)/*时间无效*/
  345.                         return -EINVAL;
  347.                 /* Cast to u64 to make GCC stop complaining */
  348.                 if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)
  349.                         timeout = -1;        /* 无限等待*/
  350.                 else {
  351.                         timeout = DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC/HZ);
  352.                         timeout += tv.tv_sec * HZ;/*计算出超时的相对时间,单位为时钟周期数*/
  353.                 }
  354.         }
  356.         /*主要工作都在core_sys_select中做了*/
  357.         ret = core_sys_select(n, inp, outp, exp, &timeout);
  359.         if (tvp) {/*如果有超时值*/
  360.                 struct timeval rtv;
  362.                 if (current->personality & STICKY_TIMEOUTS)/*模拟bug的一个机制,不详细描述*/
  363.                         goto sticky;
  364.                 /*rtv中是剩余的时间*/
  365.                 rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
  366.                 rtv.tv_sec = timeout;
  367.                 if (timeval_compare(&rtv, &tv) >= 0)/*如果core_sys_select超时返回,更新时间*/
  368.                         rtv = tv;
  369.                 /*拷贝更新后的时间到用户空间*/
  370.                 if (copy_to_user(tvp, &rtv, sizeof(rtv))) {
  371. sticky:
  372.                         /*
  373.                         * If an application puts its timeval in read-only
  374.                         * memory, we don't want the Linux-specific update to
  375.                         * the timeval to cause a fault after the select has
  376.                         * completed successfully. However, because we're not
  377.                         * updating the timeval, we can't restart the system
  378.                         * call.
  379.                         */
  380.                         if (ret == -ERESTARTNOHAND)/*ERESTARTNOHAND表明,被中断的系统调用*/
  381.                                 ret = -EINTR;
  382.                 }
  383.         }
  385.         return ret;
  386. }
  393. /*core_sys_select
  394. 为do_select准备好了位图,然后调用do_select,将返回的结果集,返回到用户空间
  395. */
  396. static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
  397.                                                    fd_set __user *exp, s64 *timeout)
  398. {
  399.         fd_set_bits fds;
  400.         void *bits;
  401.         int ret, max_fds;
  402.         unsigned int size;
  403.         struct fdtable *fdt;
  404.         /* Allocate small arguments on the stack to save memory and be faster */
  406.         /*SELECT_STACK_ALLOC 定义为256*/
  407.         long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
  409.         ret = -EINVAL;
  410.         if (n < 0)
  411.                 goto out_nofds;
  413.         /* max_fds can increase, so grab it once to avoid race */
  414.         rcu_read_lock();
  415.         fdt = files_fdtable(current->files);/*获取当前进程的文件描述符表*/
  416.         max_fds = fdt->max_fds;
  417.         rcu_read_unlock();
  418.         if (n > max_fds)/*修正用户传入的第一个参数：fd_set中文件描述符的最大值*/
  419.                 n = max_fds;
  421.         /*
  422.         * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
  423.         * since we used fdset we need to allocate memory in units of
  424.         * long-words.
  425.         */
  427.         /*
  428.         如果stack_fds数组的大小不能容纳下所有的fd_set,就用kmalloc重新分配一个大数组。
  429.         然后将位图平均分成份,并初始化fds结构
  430.         */
  431.         size = FDS_BYTES(n);
  432.         bits = stack_fds;
  433.         if (size > sizeof(stack_fds) / 6) {
  434.                 /* Not enough space in on-stack array; must use kmalloc */
  435.                 ret = -ENOMEM;
  436.                 bits = kmalloc(6 * size, GFP_KERNEL);
  437.                 if (!bits)
  438.                         goto out_nofds;
  439.         }
  440.         fds.in      = bits;
  441.         fds.out     = bits +   size;
  442.         fds.ex      = bits + 2*size;
  443.         fds.res_in  = bits + 3*size;
  444.         fds.res_out = bits + 4*size;
  445.         fds.res_ex  = bits + 5*size;
  447.         /*get_fd_set仅仅调用copy_from_user从用户空间拷贝了fd_set*/
  448.         if ((ret = get_fd_set(n, inp, fds.in)) ||
  449.                 (ret = get_fd_set(n, outp, fds.out)) ||
  450.                 (ret = get_fd_set(n, exp, fds.ex)))
  451.                 goto out;
  453.         zero_fd_set(n, fds.res_in);
  454.         zero_fd_set(n, fds.res_out);
  455.         zero_fd_set(n, fds.res_ex);
  458.         /*
  459.         接力棒传给了do_select
  460.         */
  461.         ret = do_select(n, &fds, timeout);
  463.         if (ret < 0)
  464.                 goto out;
  466.         /*do_select返回,是一种异常状态*/
  467.         if (!ret) {
  468.                 /*记得上面的sys_select不？将ERESTARTNOHAND转换成了EINTR并返回。EINTR表明系统调用被中断*/
  469.                 ret = -ERESTARTNOHAND;
  470.                 if (signal_pending(current))/*当当前进程有信号要处理时,signal_pending返回真,这符合了EINTR的语义*/
  471.                         goto out;
  472.                 ret = 0;
  473.         }
  475.         /*把结果集,拷贝回用户空间*/
  476.         if (set_fd_set(n, inp, fds.res_in) ||
  477.                 set_fd_set(n, outp, fds.res_out) ||
  478.                 set_fd_set(n, exp, fds.res_ex))
  479.                 ret = -EFAULT;
  481. out:
  482.         if (bits != stack_fds)
  483.                 kfree(bits);/*对应上面的kmalloc*/
  484. out_nofds:
  485.         return ret;
  486. }
  495. /*do_select
  496. 真正的select在此,遍历了所有的fd,调用对应的xxx_poll函数
  497. */
  498. int do_select(int n, fd_set_bits *fds, s64 *timeout)
  499. {
  500.         struct poll_wqueues table;
  501.         poll_table *wait;
  502.         int retval, i;
  504.         rcu_read_lock();
  505.         /*根据已经打开fd的位图检查用户打开的fd, 要求对应fd必须打开, 并且返回最大的fd*/
  506.         retval = max_select_fd(n, fds);
  507.         rcu_read_unlock();
  509.         if (retval < 0)
  510.                 return retval;
  511.         n = retval;
  514.         /*将当前进程放入自已的等待队列table, 并将该等待队列加入到该测试表wait*/
  515.         poll_initwait(&table);
  516.         wait = &table.pt;
  518.         if (!*timeout)
  519.                 wait = NULL;
  520.         retval = 0;
  522.         for (;;) {/*死循环*/
  523.                 unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
  524.                 long __timeout;
  526.                 /*注意:可中断的睡眠状态*/
  527.                 set_current_state(TASK_INTERRUPTIBLE);
  529.                 inp = fds->in; outp = fds->out; exp = fds->ex;
  530.                 rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
  533.                 for (i = 0; i < n; ++rinp, ++routp, ++rexp) {/*遍历所有fd*/
  534.                         unsigned long in, out, ex, all_bits, bit = 1, mask, j;
  535.                         unsigned long res_in = 0, res_out = 0, res_ex = 0;
  536.                         const struct file_operations *f_op = NULL;
  537.                         struct file *file = NULL;
  539.                         in = *inp++; out = *outp++; ex = *exp++;
  540.                         all_bits = in | out | ex;
  541.                         if (all_bits == 0) {
  542.                                 /*
  543.                                 __NFDBITS定义为(8 * sizeof(unsigned long)),即long的位数。
  544.                                 因为一个long代表了__NFDBITS位，所以跳到下一个位图i要增加__NFDBITS
  545.                                 */
  546.                                 i += __NFDBITS;
  547.                                 continue;
  548.                         }
  550.                         for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
  551.                                 int fput_needed;
  552.                                 if (i >= n)
  553.                                         break;
  555.                                 /*测试每一位*/
  556.                                 if (!(bit & all_bits))
  557.                                         continue;
  559.                                 /*得到file结构指针，并增加引用计数字段f_count*/
  560.                                 file = fget_light(i, &fput_needed);
  561.                                 if (file) {
  562.                                         f_op = file->f_op;
  563.                                         mask = DEFAULT_POLLMASK;
  565.                                         /*对于socket描述符,f_op->poll对应的函数是sock_poll
  566.                                         注意第三个参数是等待队列，在poll成功后会将本进程唤醒执行*/
  567.                                         if (f_op && f_op->poll)
  568.                                                 mask = (*f_op->poll)(file, retval ? NULL : wait);
  570.                                         /*释放file结构指针，实际就是减小他的一个引用计数字段f_count*/
  571.                                         fput_light(file, fput_needed);
  573.                                         /*根据poll的结果设置状态,要返回select出来的fd数目，所以retval++。
  574.                                         注意：retval是in out ex三个集合的总和*/
  575.                                         if ((mask & POLLIN_SET) && (in & bit)) {
  576.                                                 res_in |= bit;
  577.                                                 retval++;
  578.                                         }
  579.                                         if ((mask & POLLOUT_SET) && (out & bit)) {
  580.                                                 res_out |= bit;
  581.                                                 retval++;
  582.                                         }
  583.                                         if ((mask & POLLEX_SET) && (ex & bit)) {
  584.                                                 res_ex |= bit;
  585.                                                 retval++;
  586.                                         }
  587.                                 }
  589.                                 /*
  590.                                 注意前面的set_current_state(TASK_INTERRUPTIBLE);
  591.                                 因为已经进入TASK_INTERRUPTIBLE状态,所以cond_resched回调度其他进程来运行，
  592.                                 这里的目的纯粹是为了增加一个抢占点。被抢占后，由等待队列机制唤醒。
  594.                                 在支持抢占式调度的内核中（定义了CONFIG_PREEMPT），cond_resched是空操作
  595.                                 */
  596.                                 cond_resched();
  597.                         }
  598.                         /*根据poll的结果写回到输出位图里*/
  599.                         if (res_in)
  600.                                 *rinp = res_in;
  601.                         if (res_out)
  602.                                 *routp = res_out;
  603.                         if (res_ex)
  604.                                 *rexp = res_ex;
  605.                 }
  606.                 wait = NULL;
  607.                 if (retval || !*timeout || signal_pending(current))/*signal_pending前面说过了*/
  608.                         break;
  609.                 if(table.error) {
  610.                         retval = table.error;
  611.                         break;
  612.                 }
  614.                 if (*timeout < 0) {
  615.                         /*无限等待*/
  616.                         __timeout = MAX_SCHEDULE_TIMEOUT;
  617.                 } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT - 1)) {
  618.                         /* 时间超过MAX_SCHEDULE_TIMEOUT,即schedule_timeout允许的最大值，用一个循环来不断减少超时值*/
  619.                         __timeout = MAX_SCHEDULE_TIMEOUT - 1;
  620.                         *timeout -= __timeout;
  621.                 } else {
  622.                         /*等待一段时间*/
  623.                         __timeout = *timeout;
  624.                         *timeout = 0;
  625.                 }
  627.                 /*TASK_INTERRUPTIBLE状态下，调用schedule_timeout的进程会在收到信号后重新得到调度的机会，
  628.                 即schedule_timeout返回,并返回剩余的时钟周期数
  629.                 */
  630.                 __timeout = schedule_timeout(__timeout);
  631.                 if (*timeout >= 0)
  632.                         *timeout += __timeout;
  633.         }
  635.         /*设置为运行状态*/
  636.         __set_current_state(TASK_RUNNING);
  637.         /*清理等待队列*/
  638.         poll_freewait(&table);
  640.         return retval;
  641. }
  644. static unsigned int sock_poll(struct file *file, poll_table *wait)
  645. {
  646.         struct socket *sock;
  648.         /*约定socket的file->private_data字段放着对应的socket结构指针*/
  649.         sock = file->private_data;
  651.         /*对应了三个协议的函数tcp_poll,udp_poll,datagram_poll，其中udp_poll几乎直接调用了datagram_poll
  652.         累了，先休息一下，这三个函数以后分析*/
  653.         return sock->ops->poll(file, sock, wait);
  654. }

复制代码

其他重要函数一览 
static int max_select_fd(unsigned long n, fd_set_bits *fds) 
返回在fd_set中已经打开的，并且小于用户指定最大值，的fd 
static inline int get_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset) 
从用户空间拷贝fd_set到内核 
static inline void zero_fd_set(unsigned long nr, unsigned long *fdset) 
把fd_set清零 
static inline unsigned long __must_check set_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset) 
把fd_set拷贝回用户空间 
static inline int signal_pending(struct task_struct *p) 
目前进程有信号需要处理 
struct file *fget_light(unsigned int fd, int *fput_needed) 
由fd得到其对应的file结构指针，并增加其引用计数 
static inline void fput_light(struct file *file, int fput_needed) 
释放由fget_light得到的file结构指针，减少其引用计数 
set_current_state 
设置当前进程的状态 
static inline int cond_resched(void) 
判断是否有进程需要抢占当前进程，如果是将立即发生调度。就是额外增加一个抢占点。 
signed long __sched schedule_timeout(signed long timeout) 
当前进程睡眠timeout个jiffies 
rcu_read_lock 
rcu_read_unlock 
Linux 2.6新加入的rcu锁。读锁的加锁、解锁函数 
参考http://www.ibm.com/developerworks/cn/linux/l-rcu 
poll_freewait 
poll_initwait 
poll_wait 
... 
和文件IO，poll机制有关的几个函数，参考《Linux设备驱动(第三版)》6.3 
tcp_poll 
udp_poll 
datagram_poll 
协议层的poll函数

分享到：         
阅读(224)| 评论(0)| 引用 (0) |举报

最近读者

评论

 
 
公司简介 - 联系方法 - 招聘信息 - 客户服务 - 隐私政策 - 博客风格 - 手机博客 - 订阅此博客

网易公司版权所有 ©1997-2011

c 编程主要应用 c 编程主要应用
原创粉丝点击
热门IT博客
爱上已婚男同事 知乎爱上已婚男同事 知乎
国产有限元分析软件国产有限元分析软件
西安企业法人查询软件
dsp优化方案
智库网站 知乎
网络口语课程
php开发用什么框架
java截取中文
新浪微博域名从哪里看
telnet端口号不通
交通 问题 优化
沃尔玛swot矩阵分析图
html广告源码
信道加密和网络层加密
sn是什么意思网络用语
a卡玩魔兽世界7.0优化
js解码urlencode编码
手机淘宝闲鱼网在哪里
一洋seo管家下载
windows查看共享文件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 食道炎的症状 食道炎吃什么药 食道反流症状会自愈吗 反流性食道炎 反流性食道炎能活多久 胃食道反流会自愈吗 食道炎能自愈吗 咽东西食道有堵塞感 鱼刺卡食道能自愈吗 食道炎什么症状 食道在脖子哪个位置图 胃食道反流能自愈吗 食道炎一般多久能好 咽东西时食道有些堵 反流性食道炎症状 反流食道炎症状 食道炎症状吃什么药 吃完饭感觉食道堵得慌 反流性食道炎吃什么药 如何判断自己得了食道炎 食邑是什么意思 食醋的作用 食醋成分 食醋是什么 酿造食醋 食醋加蜂蜜 食醋除水垢 食醋黑豆 食醋 除水垢 食醋防腐剂 正常人一天食醋多少合适 食醋的主要成分 食醋中总酸量的测定 食醋是纯净物吗 食醋的化学式 食醋是酸性还是碱性 食醋减肥方法 食醋可以去甲醛吗 食醋泡脚的功效与作用 食醋和白醋的区别 用食醋洗脸的好处

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里