Select函数实现原理分析

select 需要驱动程序的支持，驱动程序实现fops内的 poll 函数 。 select 通过每个设备文件对应的 poll 函数提供的信息判断当前是否有资源可用 ( 如可读或写 ) ，如果有的话则返回可用资源的文件描述符个数，没有的话则睡眠，等待有资源变为可用时再被唤醒继续执行。

 

下面我们分两个过程来分析 select ：

 

1. select 的睡眠过程

 

支持阻塞操作的设备驱动通常会实现一组自身的等待队列如读 / 写等待队列用于支持上层 ( 用户层 ) 所需的 BLOCK 或 NONBLOCK 操作。当应用程序通过设备驱动访问该设备时 ( 默认为 BLOCK 操作 ) ，若该设备当前没有数据可读或写，则将该用户进程插入到该设备驱动对应的读 / 写等待队列让其睡眠一段时间，等到有数据可读 / 写时再将该进程唤醒。

 

select 就是巧妙的利用等待队列机制让用户进程适当在没有资源可读 / 写时睡眠，有资源可读 / 写时唤醒。下面我们看看 select 睡眠的详细过程。

 

select 会循环遍历它所监测的 fd_set 内的所有文件描述符对应的驱动程序的 poll 函数。驱动程序提供的 poll 函数首先会将调用 select 的用户进程插入到该设备驱动对应资源的等待队列 ( 如读 / 写等待队列 ) ，然后返回一个 bitmask 告诉 select 当前资源哪些可用。当 select 循环遍历完所有 fd_set 内指定的文件描述符对应的 poll 函数后，如果没有一个资源可用 ( 即没有一个文件可供操作 ) ，则 select 让该进程睡眠，一直等到有资源可用为止，进程被唤醒 ( 或者 timeout) 继续往下执行。

 

下面分析一下代码是如何实现的。

select 的调用 path 如下： sys_select -> core_sys_select -> do_select

其中最重要的函数是 do_select, 最主要的工作是在这里 , 前面两个函数主要做一些准备工作。 do_select 定义如下：

1. int  do_select( int  n, fd_set_bits *fds, s64 *timeout)
2. 
   
3. {
4. 
   
5.           struct  poll_wqueues table;
6. 
   
7.          poll_table *wait;
8. 
   
9.           int  retval, i;
10. 
    
11.  
12. 
    
13.          rcu_read_lock();
14. 
    
15.          retval = max_select_fd(n, fds);
16. 
    
17.          rcu_read_unlock();
18. 
    
19.  
20. 
    
21.           if  (retval < 0)
22. 
    
23.                     return  retval;
24. 
    
25.          n = retval;
26. 
    
27.  
28. 
    
29.          poll_initwait(&table);
30. 
    
31.          wait = &table.pt;
32. 
    
33.           if  (!*timeout)
34. 
    
35.                    wait = NULL;
36. 
    
37.          retval = 0;         //retval用于保存已经准备好的描述符数，初始为0
38. 
    
39.           for  (;;) {
40. 
    
41.                    unsigned  long  *rinp, *routp, *rexp, *inp, *outp, *exp;
42. 
    
43.                     long  __timeout;
44. 
    
45.  
46. 
    
47.                    set_current_state(TASK_INTERRUPTIBLE);     //将当前进程状态改为TASK_INTERRUPTIBLE
48. 
    
49.  
50. 
    
51.                    inp = fds->in; outp = fds->out; exp = fds->ex;
52. 
    
53.                    rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
54. 
    
55.  
56. 
    
57.                     for  (i = 0; i < n; ++rinp, ++routp, ++rexp) {  //遍历每个描述符
58. 
    
59.                             unsigned  long  in, out, ex, all_bits, bit = 1, mask, j;
60. 
    
61.                             unsigned  long  res_in = 0, res_out = 0, res_ex = 0;
62. 
    
63.                              const   struct  file_operations *f_op = NULL;
64. 
    
65.                              struct  file *file = NULL;
66. 
    
67.  
68. 
    
69.                             in = *inp++; out = *outp++; ex = *exp++;
70. 
    
71.                             all_bits = in | out | ex;
72. 
    
73.                              if  (all_bits == 0) {
74. 
    
75.                                      i += __NFDBITS;        // //如果这个字没有待查找的描述符, 跳过这个长字(32位)
76. 
    
77.                                       continue ;
78. 
    
79.                             }
80. 
    
81.  
82. 
    
83.                              for  (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {      //遍历每个长字里的每个位
84. 
    
85.                                       int  fput_needed;
86. 
    
87.                                       if  (i >= n)
88. 
    
89.                                                 break ;
90. 
    
91.                                       if  (!(bit & all_bits))
92. 
    
93.                                                 continue ;
94. 
    
95.                                      file = fget_light(i, &fput_needed);
96. 
    
97.                                       if  (file) {
98. 
    
99.                                                f_op = file->f_op;
100. 
     
101.                                                MARK(fs_select,  "%d %lld" ,
102. 
     
103.                                                                  i, ( long   long )*timeout);
104. 
     
105.                                                mask = DEFAULT_POLLMASK;
106. 
     
107.                                                 if  (f_op && f_op->poll)
108. 
     
109. /* 在这里循环调用所监测的fd_set内的所有文件描述符对应的驱动程序的poll函数 */
110. 
     
111.                                                         mask = (*f_op->poll)(file, retval ? NULL : wait);
112. 
     
113.                                                fput_light(file, fput_needed);
114. 
     
115.                                                 if  ((mask & POLLIN_SET) && (in & bit)) {
116. 
     
117.                                                         res_in |= bit;  //如果是这个描述符可读, 将这个位置位
118. 
     
119.                                                         retval++;   //返回描述符个数加1
120. 
     
121.                                                }
122. 
     
123.                                                 if  ((mask & POLLOUT_SET) && (out & bit)) {
124. 
     
125.                                                         res_out |= bit;
126. 
     
127.                                                         retval++;
128. 
     
129.                                                }
130. 
     
131.                                                 if  ((mask & POLLEX_SET) && (ex & bit)) {
132. 
     
133.                                                         res_ex |= bit;
134. 
     
135.                                                         retval++;
136. 
     
137.                                                }
138. 
     
139.                                      }
140. 
     
141.                                      cond_resched();
142. 
     
143.                             }
144. 
     
145. //返回结果
146. 
     
147.                              if  (res_in)
148. 
     
149.                                      *rinp = res_in;
150. 
     
151.                              if  (res_out)
152. 
     
153.                                      *routp = res_out;
154. 
     
155.                              if  (res_ex)
156. 
     
157.                                      *rexp = res_ex;
158. 
     
159.                    }
160. 
     
161.                    wait = NULL;
162. 
     
163. /* 到 这里遍历结束。retval保存了检测到的可操作的文件描述符的个数。如果有文件可操作，则跳出for(;;)循环，直接返回。若没有文件可操作且 timeout时间未到同时没有收到signal,则执行schedule_timeout睡眠。睡眠时间长短由__timeout决定，一直等到该进程 被唤醒。
164. 
     
165. 那该进程是如何被唤醒的？被谁唤醒的呢？
166. 
     
167. 我们看下面的select唤醒过程*/
168. 
     
169.                    if  (retval || !*timeout || signal_pending(current))
170. 
     
171.                              break ;
172. 
     
173.                    if (table.error) {
174. 
     
175.                             retval = table.error;
176. 
     
177.                              break ;
178. 
     
179.                    }
180. 
     
181.  
182. 
     
183.                     if  (*timeout < 0) {
184. 
     
185.                              /* Wait indefinitely */
186. 
     
187.                             __timeout = MAX_SCHEDULE_TIMEOUT;
188. 
     
189.                    }  else   if  (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT - 1)) {
190. 
     
191.                              /* Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in a loop */
192. 
     
193.                             __timeout = MAX_SCHEDULE_TIMEOUT - 1;
194. 
     
195.                             *timeout -= __timeout;
196. 
     
197.                    }  else  {
198. 
     
199.                             __timeout = *timeout;
200. 
     
201.                             *timeout = 0;
202. 
     
203.                    }
204. 
     
205.                    __timeout = schedule_timeout(__timeout);
206. 
     
207.                     if  (*timeout >= 0)
208. 
     
209.                             *timeout += __timeout;
210. 
     
211.          }
212. 
     
213.          __set_current_state(TASK_RUNNING);
214. 
     
215.  
216. 
     
217.          poll_freewait(&table);
218. 
     
219.  
220. 
     
221.           return  retval;
222. 
     
223. }

 

2.  select 的唤醒过程

前面介绍了 select 会循环遍历它所监测的 fd_set 内的所有文件描述符对应的驱动程序的 poll 函数。驱动程序提供的 poll 函数首先会将调用 select 的用户进程插入到该设备驱动对应资源的等待队列 ( 如读 / 写等待队列 ) ，然后返回一个 bitmask 告诉 select 当前资源哪些可用。

一个典型的驱动程序 poll 函数实现如下：

( 摘自《 Linux Device Drivers – ThirdEdition 》 Page 165)

1. static  unsigned  int  scull_p_poll( struct  file *filp, poll_table *wait)
2. 
   
3. {
4. 
   
5.      struct  scull_pipe *dev = filp->private_data;
6. 
   
7.     unsigned  int  mask = 0;
8. 
   
9.      /*
10. 
    
11.      * The buffer is circular; it is considered full
12. 
    
13.      * if "wp" is right behind "rp" and empty if the
14. 
    
15.      * two are equal.
16. 
    
17.      */
18. 
    
19.     down(&dev->sem);
20. 
    
21.     poll_wait(filp, &dev->inq,  wait);
22. 
    
23.     poll_wait(filp, &dev->outq, wait);
24. 
    
25.      if  (dev->rp != dev->wp)
26. 
    
27.         mask |= POLLIN | POLLRDNORM;     /* readable */
28. 
    
29.      if  (spacefree(dev))
30. 
    
31.         mask |= POLLOUT | POLLWRNORM;    /* writable */
32. 
    
33.     up(&dev->sem);
34. 
    
35.      return  mask;
36. 
    
37. }

将用户进程插入驱动的等待队列是通过 poll_wait 做的。

Poll_wait 定义如下：

1. static   inline   void  poll_wait( struct  file * filp, wait_queue_head_t * wait_address, poll_table *p)
2. 
   
3. {
4. 
   
5.           if  (p && wait_address)
6. 
   
7.                    p->qproc(filp, wait_address, p);
8. 
   
9. }

这里的 p->qproc 在 do_select 内 poll_initwait(&table) 被初始化为 __pollwait ，如下：

1. void  poll_initwait( struct  poll_wqueues *pwq)
2. 
   
3. {
4. 
   
5.          init_poll_funcptr(&pwq->pt, __pollwait);
6. 
   
7.          pwq->error = 0;
8. 
   
9.          pwq->table = NULL;
10. 
    
11.          pwq->inline_index = 0;
12. 
    
13. }

__pollwait 定义如下：

1. /* Add a new entry */
2. 
   
3. static   void  __pollwait( struct  file *filp, wait_queue_head_t *wait_address,
4. 
   
5.                                      poll_table *p)
6. 
   
7. {
8. 
   
9.           struct  poll_table_entry *entry = poll_get_entry(p);
10. 
    
11.           if  (!entry)
12. 
    
13.                     return ;
14. 
    
15.          get_file(filp);
16. 
    
17.          entry->filp = filp;
18. 
    
19.          entry->wait_address = wait_address;
20. 
    
21.          init_waitqueue_entry(&entry->wait, current);
22. 
    
23.          add_wait_queue(wait_address,&entry->wait);
24. 
    
25. }

通过 init_waitqueue_entry 初始化一个等待队列项，这个等待队列项关联的进程即当前调用 select 的进程。然后将这个等待队列项插入等待队列 wait_address 。 Wait_address 即在驱动 poll 函数内调用 poll_wait(filp, &dev->inq,  wait); 时传入的该驱动的 &dev->inq 或者 &dev->outq 等待队列。

 

注 : 关于等待队列的工作原理可以参考下面这篇文档 :

http://blog.chinaunix.net/u2/60011/showart_1334657.html

 

到这里我们明白了 select 如何当前进程插入所有所监测的 fd_set 关联的驱动内的等待队列，那进程究竟是何时让出 CPU 进入睡眠状态的呢？

进入睡眠状态是在 do_select 内调用 schedule_timeout(__timeout) 实现的。当 select 遍历完 fd_set 内的所有设备文件，发现没有文件可操作时 ( 即 retval=0), 则调用 schedule_timeout(__timeout) 进入睡眠状态。

 

唤醒该进程的过程通常是在所监测文件的设备驱动内实现的，驱动程序维护了针对自身资源读写的等待队列。当设备驱动发现自身资源变为可读写并且有进程睡眠在该资源的等待队列上时，就会唤醒这个资源等待队列上的进程。

举个例子，比如内核的 8250 uart driver:

Uart 是使用的 Tty 层维护的两个等待队列 , 分别对应于读和写 : (uart 是 tty 设备的一种 )

struct tty_struct {

         ……

         wait_queue_head_t write_wait;

         wait_queue_head_t read_wait;

         ……

}

当 uart 设备接收到数据，会调用 tty_flip_buffer_push(tty); 将收到的数据 push 到 tty 层的 buffer 。

然后查看是否有进程睡眠的读等待队列上，如果有则唤醒该等待会列。

过程如下：

serial8250_interrupt -> serial8250_handle_port -> receive_chars -> tty_flip_buffer_push ->

flush_to_ldisc -> disc->receive_buf

在 disc->receive_buf 函数内：

if (waitqueue_active(&tty->read_wait)) // 若有进程阻塞在 read_wait 上则唤醒

wake_up_interruptible(&tty->read_wait);

 

到这里明白了 select 进程被唤醒的过程。由于该进程是阻塞在所有监测的文件对应的设备等待队列上的，因此在 timeout 时间内，只要任意个设备变为可操作，都会立即唤醒该进程，从而继续往下执行。这就实现了 select 的当有一个文件描述符可操作时就立即唤醒执行的基本原理。

 

Referece:

1.       Linux Device Drivers – ThirdEdition

2.       内核等待队列机制原理分析

http://blog.chinaunix.net/u2/60011/showart_1334657.html

3.       Kernel code : Linux 2.6.18_pro500 - Montavista