select 系统调用分析

2472阅读　2评论2012-04-22　datao0907
分类：LINUX

select 系统调用简单分析:

点击(此处)折叠或打开

  1. 函数的入口定义如下:
  2. SYSCALL_DEFINES(select, int n,fd_set __user *,inp,fd_set __user *,outp,fd_set __user *,exp,struct timeval __user *,tvp)
  3. {
  4.     struct timespec end_time,*to = NULL;
  5.     struct timeval tv;
  6.     int ret;
  7.     
  8.     if(tvp) {
  9.         if(copy_from_user(&tv,tvp,sizeof(tv)))
  10.             return -FAULT;
  11.         to = &end_time;
  12.         //获取绝对超时时间
  13.         if(poll_select_set_timeout(to,
  14.             tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
  15.             (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))
  16.         return -EINVAL;
  17.     }

  19.     ret = core_sys_select(n,inp,outp,exp,to);
  20.     ret = poll_select_copy_remaining(&end_time,tvp,1,ret);
  21.     
  22.     return ret;
  23. }

  25. int poll_select_set_timeout(struct timespec *to,long sec,long nsec)
  26. {
  27.     struct timespec ts = {.tv_sec = sec,.tv_nsec = nsec};
  28.     
  29.     if(!timespec_valid(&ts))
  30.         return – EINVAL;
  31.     if(!sec && !nsec) {
  32.         to->tv_sec = to->tv_nsec = 0;
  33.     } else {
  34.         ktime_get_ts(to);
  35.         *to = timespec_add_safe(*to,ts);
  36.     }

  38.     return 0;
  39. }
  40. //fd_set其实就是一个大小为32(32位系统)的长整性数组，这也就说明select最多只能注册32*32(1024)个fd
  41. int core_sys_select(int n,fd_set __user *inp,fd_set __user *outp,fd_set __user *exp,
  42.         struct timespec *end_time)
  43. {
  44.     /* typedef struct {
  45.                  unsigned long *in,*out,*ex;
  46.                  unsigned long *res_in,*res_out,*res_ex;
  47.                  }fd_set_bits;
  48.      */            
  49.     fd_set_bits fds;
  50.     void *bits;
  51.     int ret,max_fds;
  52.     unsigned int size;
  53.     /*
  54.      struct fdtable {
  55.             unsigned int max_fds;
  56.      struct file_rcu **fd; //current fd array
  57.              fd_set *close_on_exec;
  58.             fd_set *open_fdt;
  59.              struct rcu_head rcu;
  60.      struct fdtable *next;
  61.              };
  62.     
  63.      **/
  64.     struct fdtable *fdt;
  65.     long stack_fds[SELECT_STACK_ALLOC / sizeof(long)];
  66.     
  67.     ret = -EINVAL;
  68.     if(n < 0)
  69.         goto out_nofds;
  70.     
  71.     rcu_read_lock();
  72.     //获取对应进程的文件打开表
  73.     fdt = file_fdtable(current->files);
  74.     max_fds = fdt->max_fds;
  75.     rcu_read_unlock();
  76.     if(n > max_fds)
  77.         n = max_fds;
  78.     //通过最大的文件fd，找到总共需要的数组大小，并为指针开辟内存
  79.     size = FDS_BYTES(n);
  80.     bits = stack_fds;
  81.     if(size > sizeof(stack_fds) / 6) {
  82.         ret = -ENOMEM;
  83.         bits = kmalloc(6 * size,GFP_KERNEL);
  84.         if(!bits)
  85.             goto out_nofds;
  86.     }
  87.     fds.in = bits;
  88.     fds.out = bits + size;
  89.     fds.ex = bits + 2 * size;
  90.     fds.res_in = bits + 3 * size;
  91.     fds.res_out = bits + 4 * size;
  92.     fds.res_ex = bits + 5 * size;
  93.     //拷贝至内核态
  94.     if((ret = get_fd_set(n,inp,fds.in)) ||
  95.      (ret = get_fd_set(n,outp,fds.out)) ||
  96.      (ret = get_fd_set(n,exp,fds.ex)))
  97.             goto out;
  98.     
  99.     zero_fd_set(n,fds.res_in);
  100.     zero_fd_set(n,fds.res_out);
  101.     zero_fd_set(n,fds.res_ex);
  102.     //将用户态的fd拷贝至内核态后开始进行处理
  103.     ret = do_select(n,&fds,end_time);
  104.     
  105.     if(ret < 0)
  106.         goto out;
  107.     if(!ret) {
  108.         ret = -ERESTARTNOHAND;
  109.         if(signal_pending(current))
  110.             goto out;
  111.         ret = 0;
  112.     }
  113.     //将结果拷贝至用户态，只要出现错误就立即返回
  114.     if(set_fd_set(n,inp,fds.res_in) ||
  115.     set_fd_set(n,outp,fds.res_out) ||
  116.     set_fd_set(n,exp,fds.res_ex))
  117.         ret = -EFAULT;

  119. out:
  120.     if(bits != stack_fds) //通过kmalloc分配所得，就进行释放
  121.         kfree(bits);
  122. out_nofds:
  123.     retun ret;
  124. }
核心代码如下:

点击(此处)折叠或打开

  1. int do_select(int n,fd_set_bits *fds,struct timespec *end_time)
  2. {
  3.     ktime_t expire,*to = NULL;
  4.     /*
  5.     typedef struct poll_table_struct {
  6.         poll_queue_proc qproc;
  7.         unsigned long key;
  8.     } poll_table;
  9.     struct page_table_entry {
  10.         struct file *filp;
  11.         unsigned long key;
  12.         wait_queue_t wait;
  13.         wait_queue_head_t *wait_address;
  14.     }
  15.     struct poll_table_page {
  16.         struct poll_table_page *next;
  17.         struct poll_table_entry *entry;
  18.         struct poll_table_entry entries[0];
  19.     }
  20.      struct poll_wqueue {
  21.         poll_table pt;
  22.         struct poll_table_page *table;
  23.         struct task_struct *polling_task;
  24.         int triggered;
  25.         int error;
  26.         int inline_index;
  27.         //N_INLINE_POLL_ENTRIES 18(32位系统)
  28.         struct poll_table_entry inline_entries[N_INLINE_POLL_ENTRIES];
  29.     }    
  30.      **/
  31.     struct poll_wqueue table;
  32.     poll_table *wait;
  33.     int retval,i,timed_out = 0;
  34.     unsigned long slack = 0;
  35.     
  36.     rcu_read_lock();
  37.     retval = max_select_fd(n,fds);
  38.     rcu_read_unlock();

  40.     if(retval < 0)
  41.         return retval;
  42.     n = retval;
  43.     
  44.     poll_initwait(&table);
  45.     wait = & table.pt;
  46.     if(end_time && !end_time->tv_sec && !end_time->tv_nsec) {
  47.             wait = NULL;
  48.             timed_out = 1;
  49.     }

  51.     if(end_time && !time_out)
  52.         slack = select_estimate_accuracy(end_time);
  53.     retval = 0;
  54.     for(;;) {
  55.         unsigned long *rinp,*routp,*rexp,*inp,*oup,*exp;
  56.         
  57.         inp = fds->in;outp = fds->out;exp = fds->ex;
  58.         rinp = fds->res_in;routp = fds->res_out;rexp = fds->res_ex;
  59.         
  60.         for(i = 0;i < n;++rinp,++routp,++rexp) {
  61.             unsigned long in,out,ex,all_bits,bit = 1,mask,j;
  62.             unsigned long res_in = 0,res_out = 0,res_ex = 0;
  63.             const struct file_operations *f_op = NULL;
  64.             struct file *file = NULL;
  65.             //获取一个fd
  66.             in = *inp ++; out = *oup++;ex = *exp ++;
  67.             all_bits = in | out | ex;
  68.             if(all_bits == 0) {    //三个都没有注册，则直接进行下一个long
  69.                 i += __NFDBITS;
  70.                 continue;
  71.             }
  72.             for(j = 0;j < __NFDBITS;++j,++i,bit << =1) {
  73.                 int fput_needed;
  74.                 if(i >= n)
  75.                         break;
  76.                 if(!(bit & all_bits))
  77.                     continue;
  78.                 //增加对fd的引用计数，获取文件对象
  79.                 file = fget_light(i,&fput_needed);
  80.                 if(file) {
  81.                     f_op = file->f_op;
  82.                     mask = DEFAULT_POLLMASK;
  83.                     if(f_op && f_op->poll) {
  84.                     //获取用户态注册的事件
  85.                     wait_key_set(wait,in,out,bit);
  86.                     //调用对应文件系统的poll驱动，如果没有事件产生就会进行睡眠等待，
  87.                     //所有的文件poll驱动都会睡眠在同一对象wait上面
  88.                     mask = (*f_op->poll)(file,wait);
  89.                 }
  90.                 fput_light(file,fput_needed);
  91.                 if((mask & POLLIN_SET) && (in & bit)) {
  92.                     res_in |= bit;
  93.                     retval ++;
  94.                     wait = NULL;
  95.                 }
  96.                 if((mask & POLLOUT_SET) && (out & bit)) {
  97.                     res_out |= bit;
  98.                     retval ++;
  99.                     wait = NULL;
  100.                 }
  101.                 if((mask & POLLEX_SET) && (ex & bit)) {
  102.                     res_ex |= bit;
  103.                     retval ++;
  104.                     wait = NULL;
  105.                 }
  106.                 }
  107.             }
  108.         //将结果返回至数组中
  109.         if(res_in)
  110.             *rinp = res_in;
  111.         if(res_out)
  112.             *routp = res_out;
  113.         if(res_ex)
  114.             *rexp = res_ex;
  115.         //如果有抢占进程，则让其运行
  116.         cond_resched();    
  117.         }
  118.     wait = NULL;
  119.     //一有返回事件或超时或被信号中断就立即返回
  120.     if(ret_val || timed_out || signal_pending(current))
  121.         break;
  122.     if(table.error) {
  123.         retal = table.error;
  124.         break;
  125.     }
  126.     if(end_time && !to) { //更新剩余过期时间
  127.         expire = timespec_to_ktime(*end_time);
  128.         to = &expire;
  129.     }
  130.     //睡眠(to,to+slack)之间直到超时
  131.     if(!poll_schedule_timeout(&table,TASK_INTERRUPTIBLE,
  132.         to,slack))
  133.         timed_out = 1;
  134.     }
  135.     poll_freewait(&table);//释放资源
  136.     return retval;
  137. }
参考资料:
1.linux-3.3.2 
2.linux 设备驱动程序


上一篇：Fibonacci 堆
下一篇：C++ Slab分配器的实现

文章评论