轉自：http://blog.csdn.net/huntinux/article/details/39289317
原文：http://blog.csdn.net/boboiask/article/details/4055655
Linux—select詳解
select系統調用時用來讓我們的程序監視多個文件句柄的狀態變化的。程序會停在select這里等待，直到被監視的文件句柄有一個或多個發生了狀態改變。
關於文件句柄，其實就是一個整數，通過socket函數的聲明就明白了：
int socket(int domain, int type, int protocol);
我們最熟悉的句柄是0、1、2三個，0是標准輸入，1是標准輸出，2是標准錯誤輸出。0、1、2是整數表示的，對應的FILE *結構的表示就是stdin、stdout、stderr。
繼續上面的select，就是用來監視某個或某些句柄的狀態變化的。select函數原型如下：
int select (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
函數的最后一個參數timeout是一個超時時間值。其類型是struct timeval *，即一個struct timeval結構的變量的指針，所以我們在程序里要聲明一個struct timeval tv;然后把變量tv的地址&tv傳遞給select函數。struct timeval結構如下：
struct timeval
{
long tv_sec; //seconds
long tv_usec; //microseconds
}；
第2、3、4三個參數是一樣的類型;fd_set *,即我們在程序里要申請幾個fd_set類型的變量，比如rdfds，wtfds，exfds，然后把這個變量的地址&rdfds,&wtfds,&exfds傳遞給select函數。這三個參數都是一個句柄的集合，第一個rdfds是用來保存這樣的句柄的:當句柄的狀態變成可讀時系統就告訴select函數返回，同理第二個函數是指向有句柄狀態變成可寫時系統就會告訴select函數返回，同理第三個參數exfds是特殊情況，即句柄上有特殊情況發生時系統會告訴select函數返回。特殊情況比如對方通過一個socket句柄發來了緊急數據。如果我們程序里只想檢測某個socket是否有數據可讀，我們可以這樣：
fd_set rdfds;
struct timeval tv;
int ret;
FD_ZERO(&rdfds);
FD_SET(socket, &rdfds);
tv.tv_sec = 1;
tv.tv_uses = 500;
ret = select (socket + 1, %rdfds, NULL, NULL, &tv);
if(ret < 0) perror (“select”);
else if (ret = = 0) printf(“time out”);
else {
printf(“ret = %d/n”,ret);
if(FD_ISSET(socket, &rdfds)){
/* 讀取socket句柄里的數據 */
recv( );
}
}
注意select函數的第一個參數，是所有加入集合的句柄值的最大那個那個值還要加1.比如我們創建了3個句柄;
int sa, sb, sc;
sa = socket(……);
connect (sa,….);
sb = socket(….);
connect (sb,…);
sc = socket(….);
connect(sc,…);
FD_SET(sa, &rdfds);
FD_SET(sb, &rdfds);
FD_SET(sc, &rdfds);
在使用select函數之前，一定要找到3個句柄中的最大值是哪個，我們一般定義一個變量來保存最大值，取得最大socket值如下：
int maxfd = 0;
if(sa > maxfd) maxfd = sa;
if(sb > maxfd) maxfd = sb;
if(sc > maxfd) maxfd = sc;
然后調用select函數：
ret = select (maxfd+1, &rdfds, NULL, NULL,&tv);
同樣的道理，如果我們是檢測用戶是否按了鍵盤進行輸入，我們就應該把標准輸入0這個句柄放到select里來檢測，如下：
FD_ZERO(&rdfds);
FD_SET(0, &rdfds);
tv.tv_sec = 1;
tv.tv_usec = 0;
ret = select (1, &rdfds,NULL,NULL,&tv);
if(ret < 0) perror(“select”);
else if (ret = = 0) printf (“time out/n”);
else{
scanf(“%s”,buf);
}
===================select 實現原理=======================
參考：http://linux.chinaunix.NET/techdoc/net/2009/05/03/1109887.shtml
Select函數實現原理分析（轉載）
select需要驅動程序的支持，驅動程序實現fops內的poll函數。select通過每個設備文件對應的poll函數提供的信息判斷當前是否有資源可用(如可讀或寫)，如果有的話則返回可用資源的文件描述符個數，沒有的話則睡眠，等待有資源變為可用時再被喚醒繼續執行。
下面我們分兩個過程來分析select：
1. select的睡眠過程
支持阻塞操作的設備驅動通常會實現一組自身的等待隊列如讀/寫等待隊列用於支持上層(用戶層)所需的BLOCK或NONBLOCK操作。當應用程序通過設備驅動訪問該設備時(默認為BLOCK操作)，若該設備當前沒有數據可讀或寫，則將該用戶進程插入到該設備驅動對應的讀/寫等待隊列讓其睡眠一段時間，等到有數據可讀/寫時再將該進程喚醒。
select就是巧妙的利用等待隊列機制讓用戶進程適當在沒有資源可讀/寫時睡眠，有資源可讀/寫時喚醒。下面我們看看select睡眠的詳細過程。
select會循環遍歷它所監測的fd_set（一組文件描述符(fd)的集合）內的所有文件描述符對應的驅動程序的poll函數。驅動程序提供的poll函數首先會將調用select的用戶進程插入到該設備驅動對應資源的等待隊列(如讀/寫等待隊列)，然后返回一個bitmask告訴select當前資源哪些可用。當select循環遍歷完所有fd_set內指定的文件描述符對應的poll函數后，如果沒有一個資源可用(即沒有一個文件可供操作)，則select讓該進程睡眠，一直等到有資源可用為止，進程被喚醒(或者timeout)繼續往下執行。
下面分析一下代碼是如何實現的。
select的調用path如下：sys_select -> core_sys_select -> do_select
其中最重要的函數是do_select, 最主要的工作是在這里, 前面兩個函數主要做一些准備工作。do_select定義如下：
int do_select(int n, fd_set_bits *fds, s64 *timeout)
{
struct poll_wqueues table;
poll_table *wait;
int retval, i;
rcu_read_lock();
retval = max_select_fd(n, fds);
rcu_read_unlock();
if (retval
return retval;
n = retval;
poll_initwait(&table);
wait = &table.pt;
if (!*timeout)
wait = NULL;
retval = 0; //retval用於保存已經准備好的描述符數，初始為0
for (;;) {
unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
long __timeout;
set_current_state(TASK_INTERRUPTIBLE); //將當前進程狀態改為TASK_INTERRUPTIBLE
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 遍歷每個描述符
unsigned long in, out, ex, all_bits, bit = 1, mask, j;
unsigned long res_in = 0, res_out = 0, res_ex = 0;
const 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; // //如果這個字沒有待查找的描述符, 跳過這個長字(32位)
continue;
}
for (j = 0; j 遍歷每個長字里的每個位
int fput_needed;
if (i >= n)
break;
if (!(bit & all_bits))
continue;
file = fget_light(i, &fput_needed);
if (file) {
f_op = file->f_op;
MARK(fs_select, "%d %lld",
i, (long long)*timeout);
mask = DEFAULT_POLLMASK;
if (f_op && f_op->poll)
/* 在這里循環調用所監測的fd_set內的所有文件描述符對應的驅動程序的poll函數 */
mask = (*f_op->poll)(file, retval ? NULL : wait);
fput_light(file, fput_needed);
if ((mask & POLLIN_SET) && (in & bit)) {
res_in |= bit; //如果是這個描述符可讀, 將這個位置位
retval++; //返回描述符個數加1
}
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;
/* 到這里遍歷結束。retval保存了檢測到的可操作的文件描述符的個數。如果有文件可操作，則跳出for(;;)循環，直接返回。若沒有文件可操作且timeout時間未到同時沒有收到signal,則執行schedule_timeout睡眠。睡眠時間長短由__timeout決定，一直等到該進程被喚醒。
那該進程是如何被喚醒的？被誰喚醒的呢？
我們看下面的select喚醒過程*/
if (retval || !*timeout || signal_pending(current))
break;
if(table.error) {
retval = table.error;
break;
}
if (*timeout
/* Wait indefinitely */
__timeout = MAX_SCHEDULE_TIMEOUT;
} else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT - 1)) {
/* Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in a loop */
__timeout = MAX_SCHEDULE_TIMEOUT - 1;
*timeout -= __timeout;
} else {
__timeout = *timeout;
*timeout = 0;
}
__timeout = schedule_timeout(__timeout);
if (*timeout >= 0)
*timeout += __timeout;
}
__set_current_state(TASK_RUNNING);
poll_freewait(&table);
return retval;
}
2. select的喚醒過程
前面介紹了select會循環遍歷它所監測的fd_set內的所有文件描述符對應的驅動程序的poll函數。驅動程序提供的poll函數首先會將調用select的用戶進程插入到該設備驅動對應資源的等待隊列(如讀/寫等待隊列)，然后返回一個bitmask告訴select當前資源哪些可用。
一個典型的驅動程序poll函數實現如下：
(摘自《Linux Device Drivers – ThirdEdition》Page 165)
static unsigned int scull_p_poll(struct file *filp, poll_table *wait)
{
struct scull_pipe *dev = filp->private_data;
unsigned int mask = 0;
/*
* The buffer is circular; it is considered full
* if "wp" is right behind "rp" and empty if the
* two are equal.
*/
down(&dev->sem);
poll_wait(filp, &dev->inq, wait);
poll_wait(filp, &dev->outq, wait);
if (dev->rp != dev->wp)
mask |= POLLIN | POLLRDNORM; /* readable */
if (spacefree(dev))
mask |= POLLOUT | POLLWRNORM; /* writable */
up(&dev->sem);
return mask;
}
將用戶進程插入驅動的等待隊列是通過poll_wait做的。
Poll_wait定義如下：
static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
{
if (p && wait_address)
p->qproc(filp, wait_address, p);
}
這里的p->qproc在do_select內poll_initwait(&table)被初始化為__pollwait，如下：
void poll_initwait(struct poll_wqueues *pwq)
{
init_poll_funcptr(&pwq->pt, __pollwait);
pwq->error = 0;
pwq->table = NULL;
pwq->inline_index = 0;
}
__pollwait定義如下：
/* Add a new entry */
static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
poll_table *p)
{
struct poll_table_entry *entry = poll_get_entry(p);
if (!entry)
return;
get_file(filp);
entry->filp = filp;
entry->wait_address = wait_address;
init_waitqueue_entry(&entry->wait, current);
add_wait_queue(wait_address,&entry->wait);
}
通過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
本文來自ChinaUnix博客，如果查看原文請點：http://blog.chinaunix.net/u3/94284/showart_1917293.html
==========另外參考LDD chp6 poll和select==============
用戶空間程序在驅動程序關聯的文件描述符上執行poll、select、epoll系統調用時，驅動程序中 fops里面的 poll方法被調用。