I/O复用技术是：把我们关注的描述符组成一个描述符表(通常不止一个描述符)，调用I/O复用函数（select/poll/epoll），当描述符表中有可进行非阻塞I/O操作的描述符时，复用函数返回；否则阻塞复用函数，直到描述符表中有可进行非阻塞I/O操作的描述符出现时，才唤醒进程继续执行复用函数；当复用函数正常返回时，就可以知道哪些描述符可进行非阻塞I/O操作。
I/O复用的描述符通常包括：终端/伪终端，pipes，socket等
I/O复用函数主要过程：
1.遍历描述符表，判断该描述符表中是否有描述符可进行非阻塞I/O操作（读、写、异常等）；
2.如果描述符表中有描述符可进行非阻塞I/O操作，I/O复用函数通知用户进程这些描述符；
3.如果描述符表中没有描述符可进行非阻塞I/O操作，那么I/O复用函数被阻塞，并将进程添加到描述符表中所有描述符的poll等待队列中
4.当有描述符可进行非阻塞I/O操作时，内核唤醒该描述符poll等待队列中的阻塞进程；进程唤醒后继续执行I/O复用函数，I/O复用函数将进程从描述符表中所有描述符的poll等待队列中移除；然后重新遍历描述符表
I.select
select是I/O复用函数之一，其原型为：
int select(int nfds, fd_set *restrict ,
fd_set *restrict writefds, fd_set *restrict errorfds,
struct timeval *restrict timeout);输入参数：
1、readfds、writefds、errorfds：我们所关心的可进行非阻塞读、写、异常操作的描述符表
2、nfds：文件描述符表大小
3、timeout：超时时间(一直、指定时间、不等待)，当超时后仍没有文件可进行非阻塞I/O操作时，复用函数返回。
输出参数：
1、readfds、writefds、errorfds：可进行非阻塞读、写、异常操作的描述符表
2、timeout：有超时设置时，超时剩余的时间；即输出timeout=输入timeout-select所花时间
返回值：
0：超时
-1：错误
>0：可进行非阻塞读、写、异常操作的描述符表大小，即readfds、writefds、errorfds中位置1的个数，如一个文件即可进行读也可进行写则会算成2
注：
在输入参数readfds、writefds中有，但是在输入参数errorfds中没有的描述符，当这些描述符表示的文件有错误时，会在输出参数errorfds中包含该描述符，并且I/O复用函数立即返回。
输出参数readfds是输入参数readfds的子集，输出参数writefds是输入参数writefds的子集，输出参数errorfds是输出参数readfds,writefds,errorfds的子集
II.数据结构
80 /*
81 * Scaleable version of the fd_set.
82 */
83
84 typedef struct {
85 unsigned long *in, *out, *ex;
86 unsigned long *res_in, *res_out, *res_ex;
87 } fd_set_bits;
88
89 /*
90 * How many longwords for "nr" bits?
91 */
92 #define FDS_BITPERLONG (8*sizeof(long))
93 #define FDS_LONGS(nr) (((nr)+FDS_BITPERLONG-1)/FDS_BITPERLONG)
94 #define FDS_BYTES(nr) (FDS_LONGS(nr)*sizeof(long))fd_set_bits：用于标识出可读、可写、异常描述符位图内核内存块起始位置(包括输入和输出)；内存块的大小是FDS_BYTES(nfds)，与select函数参数nfds的大小对应，FDS_BYTES会对nfds大小做long对齐（即32或64对齐）
fd_set_bits用法如下图：
ii.poll_wqueues
33 typedef struct poll_table_struct {
34 poll_queue_proc qproc;
35 unsigned long key;
36 } poll_table;
50 struct poll_table_entry {
51 struct file *filp;
52 unsigned long key;
53 wait_queue_t wait;
54 wait_queue_head_t *wait_address;
55 };
56
57 /*
58 * Structures and helpers for sys_poll/sys_poll
59 */
60 struct poll_wqueues {
61 poll_table pt;
62 struct poll_table_page *table;
63 struct task_struct *polling_task;
64 int triggered;
65 int error;
66 int inline_index;
67 struct poll_table_entry inline_entries[N_INLINE_POLL_ENTRIES];
68 };poll_table：对每个文件进行poll操作时，判断是否能够非阻塞的进行key值（poll事件组成）标识的I/O操作；如果不能，调用回调函数qproc将进程添加到文件的poll等待队列中
poll_table_entry：用于阻塞进程并将进程添加到文件的poll等待队列中，一个文件对应一个poll_table_entry
poll_wqueues：用于在select/poll时，如果需要阻塞进程，将进程添加到描述符表标识的所有文件的poll等待队列中，以便任意一个文件可进行非阻塞I/O操作时唤醒进程
iii.进程、打开文件、poll等待队列之间关系图
III.复用函数阻塞/唤醒
i.poll_wqueues的初始化
44 static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
45 {
46 pt->qproc = qproc;
47 pt->key = ~0UL; /* all events enabled */
48 }
116 void poll_initwait(struct poll_wqueues *pwq)
117 {
118 init_poll_funcptr(&pwq->pt, __pollwait);
119 pwq->polling_task = current;
120 pwq->triggered = 0;
121 pwq->error = 0;
122 pwq->table = NULL;
123 pwq->inline_index = 0;
124 }1.将阻塞回调函数设置成__pollwait
2.将阻塞进程设置成当前进程
ii.文件poll阻塞
1.poll阻塞
当对单个文件执行poll操作时，如果文件不能非阻塞的进行key标识的I/O操作，会将当前进程添加到该文件的poll等待队列中
tcp阻塞f_op->poll：socket_file_ops->sock_poll->inet_stream_ops->tcp_poll->sock_poll_wait->poll_wait
pipe阻塞f_op->poll：write_pipefifo_fops->pipe_poll->poll_wait
38 static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
39 {
40 if (p && wait_address)
41 p->qproc(filp, wait_address, p);
42 }
216 static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
217 poll_table *p)
218 {
219 struct poll_wqueues *pwq = container_of(p, struct poll_wqueues, pt);
220 struct poll_table_entry *entry = poll_get_entry(pwq);
221 if (!entry)
222 return;
223 get_file(filp);
224 entry->filp = filp;
225 entry->wait_address = wait_address;
226 entry->key = p->key;
227 init_waitqueue_func_entry(&entry->wait, pollwake);
228 entry->wait.private = pwq;
229 add_wait_queue(wait_address, &entry->wait);
230 }a.poll_wait中的qproc在poll_initwait时设置成__pollwait；如果poll_table与wait_address非NULL，则调用__poll_wait
b.将poll等待队列的waiter唤醒函数设置成pollwake
c.将poll_table_entry放入wait_address(socket为sock->sk_sleep，pipe为pipe_inode_info->wait)的等待队列中
3.poll_get_entry
98 #define POLL_TABLE_FULL(table) \
99 ((unsigned long)((table)->entry+1) > PAGE_SIZE + (unsigned long)(table))
155 static struct poll_table_entry *poll_get_entry(struct poll_wqueues *p)
156 {
157 struct poll_table_page *table = p->table;
158
159 if (p->inline_index < N_INLINE_POLL_ENTRIES)
160 return p->inline_entries + p->inline_index++;
161
162 if (!table || POLL_TABLE_FULL(table)) {
163 struct poll_table_page *new_table;
164
165 new_table = (struct poll_table_page *) __get_free_page(GFP_KERNEL);
166 if (!new_table) {
167 p->error = -ENOMEM;
168 return NULL;
169 }
170 new_table->entry = new_table->entries;
171 new_table->next = table;
172 p->table = new_table;
173 table = new_table;
174 }
175
176 return table->entry++;
177 }a.poll_get_entry用于获取poll_wqueues中的poll_table_entry
b.如果poll_wqueues的INLINE空间有空闲entry，则从INLINE空间中分配entry
c.如果INLINE空间没有空闲entry，则分配新页帧作为poll_table_page；新poll_table_page插入链表头，以便下次分配只查看首结点就能知道是否有空闲entry
iii.文件poll唤醒
当复用函数被阻塞后，如果有异步事件出现而使文件能非阻塞的进行key标识的I/O操作时，会调用wake_up_interruptible_sync_poll唤醒被阻塞的复用函数
tcp数据接收事件唤醒复用函数：tcp_protocol->tcp_v4_rcv->tcp_v4_do_rcv->tcp_rcv_established->sk_data_ready->sock_def_readable->wake_up_interruptible_sync_poll
pipe写事件唤醒复用函数：pipe_write->wake_up_interruptible_sync_poll
164 #define wake_up_interruptible_sync(x) __wake_up_sync((x), TASK_INTERRUPTIBLE, 1)
5897 /*
5898 * The core wakeup function. Non-exclusive wakeups (nr_exclusive == 0) just
5899 * wake everything up. If it's an exclusive wakeup (nr_exclusive == small +ve
5900 * number) then we wake all the non-exclusive tasks and one exclusive task.
5901 *
5902 * There are circumstances in which we can try to wake a task which has already
5903 * started to run but is not in state TASK_RUNNING. try_to_wake_up() returns
5904 * zero in this (rare) case, and we handle it by continuing to scan the queue.
5905 */
5906 static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
5907 int nr_exclusive, int wake_flags, void *key)
5908 {
5909 wait_queue_t *curr, *next;
5910
5911 list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
5912 unsigned flags = curr->flags;
5913
5914 if (curr->func(curr, mode, wake_flags, key) &&
5915 (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
5916 break;
5917 }
5918 }
5954 /**
5955 * __wake_up_sync_key - wake up threads blocked on a waitqueue.
5956 * @q: the waitqueue
5957 * @mode: which threads
5958 * @nr_exclusive: how many wake-one or wake-many threads to wake up
5959 * @key: opaque value to be passed to wakeup targets
5960 *
5961 * The sync wakeup differs that the waker knows that it will schedule
5962 * away soon, so while the target thread will be woken up, it will not
5963 * be migrated to another CPU - ie. the two threads are 'synchronized'
5964 * with each other. This can prevent needless bouncing between CPUs.
5965 *
5966 * On UP it can prevent extra preemption.
5967 *
5968 * It may be assumed that this function implies a write memory barrier before
5969 * changing the task state if and only if any tasks are woken up.
5970 */
5971 void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
5972 int nr_exclusive, void *key)
5973 {
5974 unsigned long flags;
5975 int wake_flags = WF_SYNC;
5976
5977 if (unlikely(!q))
5978 return;
5979
5980 if (unlikely(!nr_exclusive))
5981 wake_flags = 0;
5982
5983 spin_lock_irqsave(&q->lock, flags);
5984 __wake_up_common(q, mode, nr_exclusive, wake_flags, key);
5985 spin_unlock_irqrestore(&q->lock, flags);
5986 }
5987 EXPORT_SYMBOL_GPL(__wake_up_sync_key);
5988
5989 /*
5990 * __wake_up_sync - see __wake_up_sync_key()
5991 */
5992 void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
5993 {
5994 __wake_up_sync_key(q, mode, nr_exclusive, NULL);
5995 }
5996 EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */wake_up_interruptible_sync同步唤醒一个等待进程
__wake_up_common中的func是由__pollwait设置成的pollwake
179 static int __pollwake(wait_queue_t *wait, unsigned mode, int sync, void *key)
180 {
181 struct poll_wqueues *pwq = wait->private;
182 DECLARE_WAITQUEUE(dummy_wait, pwq->polling_task);
183
184 /*
185 * Although this function is called under waitqueue lock, LOCK
186 * doesn't imply write barrier and the users expect write
187 * barrier semantics on wakeup functions. The following
188 * smp_wmb() is equivalent to smp_wmb() in try_to_wake_up()
189 * and is paired with set_mb() in poll_schedule_timeout.
190 */
191 smp_wmb();
192 pwq->triggered = 1;
193
194 /*
195 * Perform the default wake up operation using a dummy
196 * waitqueue.
197 *
198 * TODO: This is hacky but there currently is no interface to
199 * pass in @sync. @sync is scheduled to be removed and once
200 * that happens, wake_up_process() can be used directly.
201 */
202 return default_wake_function(&dummy_wait, mode, sync, key);
203 }
204
205 static int pollwake(wait_queue_t *wait, unsigned mode, int sync, void *key)
206 {
207 struct poll_table_entry *entry;
208
209 entry = container_of(wait, struct poll_table_entry, wait);
210 if (key && !((unsigned long)key & entry->key))
211 return 0;
212 return __pollwake(wait, mode, sync, key);
213 }1.如果唤醒进程的事件不是复用函数所关心的事件，则不会去唤醒复用函数；如果是关心的事件，则调用__pollwake唤醒复用函数
2.将triggered置1 ；在遍历完复用函数所提供的文件描述符表后，如果没有满足的描述符时会阻塞进程；但是如果已经遍历的文件在遍历的过程中，有异步事件出现而使文件能非阻塞的进行key标识的I/O操作时，则不会去阻塞进程；阻塞进程时会检查triggered标识，如果是0才会去阻塞进程 ，否则不会去阻塞。
3.通过default_wake_function->try_to_wake_up唤醒复用函数的调用进程(当进程已经是TASK_RUNNING时，则直接返回)
iv.poll_wqueues释放
127 static void free_poll_entry(struct poll_table_entry *entry)
128 {
129 remove_wait_queue(entry->wait_address, &entry->wait);
130 fput(entry->filp);
131 }
132
133 void poll_freewait(struct poll_wqueues *pwq)
134 {
135 struct poll_table_page * p = pwq->table;
136 int i;
137 for (i = 0; i < pwq->inline_index; i++)
138 free_poll_entry(pwq->inline_entries + i);
139 while (p) {
140 struct poll_table_entry * entry;
141 struct poll_table_page *old;
142
143 entry = p->entry;
144 do {
145 entry--;
146 free_poll_entry(entry);
147 } while (entry > p->entries);
148 old = p;
149 p = p->next;
150 free_page((unsigned long) old);
151 }
152 }1.由于在遍历描述符表中文件的过程中，不知道未遍历到的文件能否非阻塞的进行key标识的I/O操作；所以当前文件不能非阻塞的进行key标识的I/O操作时，就会将进程添加到文件的poll等待队列中，以便后续文件不能非阻塞的进行I/O操作时不用再遍历描述符表去将进程添加到文件的poll等待队列中。
2.不管是阻塞被唤醒（进程添加到描述符表中所有文件的poll队列中）还是未阻塞（进程已经添加到描述符表中可进行非阻塞I/O操作文件之前的所有文件的poll队列中），在复用函数退出时，都会调用poll_freewait将poll_wqueues中所有的waiter从文件的等待队列中清空，及释放相应的文件及内存
IV.select实现
i.select
fs/select.c：
596 SYSCALL_DEFINE5(select, int, n, fd_set __user *, inp, fd_set __user *, outp,
597 fd_set __user *, exp, struct timeval __user *, tvp)
598 {
599 struct timespec end_time, *to = NULL;
600 struct timeval tv;
601 int ret;
602
603 if (tvp) {
604 if (copy_from_user(&tv, tvp, sizeof(tv)))
605 return -EFAULT;
606
607 to = &end_time;
608 if (poll_select_set_timeout(to,
609 tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
610 (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))
611 return -EINVAL;
612 }
613
614 ret = core_sys_select(n, inp, outp, exp, to);
615 ret = poll_select_copy_remaining(&end_time, tvp, 1, ret);
616
617 return ret;
618 }1.将超时参数timeout由用户空间复制到内核空间，并将其由timeval类型转换成timespec类型
2.调用core_sys_select
3.计算超时剩余时间
ii.core_sys_select
521 int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
522 fd_set __user *exp, struct timespec *end_time)
523 {
524 fd_set_bits fds;
525 void *bits;
526 int ret, max_fds;
527 unsigned int size;
528 struct fdtable *fdt;
529 /* Allocate small arguments on the stack to save memory and be faster */
530 long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
531
532 ret = -EINVAL;
533 if (n < 0)
534 goto out_nofds;
535
536 /* max_fds can increase, so grab it once to avoid race */
537 rcu_read_lock();
538 fdt = files_fdtable(current->files);
539 max_fds = fdt->max_fds;
540 rcu_read_unlock();
541 if (n > max_fds)
542 n = max_fds;
543
544 /*
545 * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
546 * since we used fdset we need to allocate memory in units of
547 * long-words.
548 */
549 size = FDS_BYTES(n);
550 bits = stack_fds;
551 if (size > sizeof(stack_fds) / 6) {
552 /* Not enough space in on-stack array; must use kmalloc */
553 ret = -ENOMEM;
554 bits = kmalloc(6 * size, GFP_KERNEL);
555 if (!bits)
556 goto out_nofds;
557 }
558 fds.in = bits;
559 fds.out = bits + size;
560 fds.ex = bits + 2*size;
561 fds.res_in = bits + 3*size;
562 fds.res_out = bits + 4*size;
563 fds.res_ex = bits + 5*size;
564
565 if ((ret = get_fd_set(n, inp, fds.in)) ||
566 (ret = get_fd_set(n, outp, fds.out)) ||
567 (ret = get_fd_set(n, exp, fds.ex)))
568 goto out;
569 zero_fd_set(n, fds.res_in);
570 zero_fd_set(n, fds.res_out);
571 zero_fd_set(n, fds.res_ex);
572
573 ret = do_select(n, &fds, end_time);
575 if (ret < 0)
576 goto out;
577 if (!ret) {
578 ret = -ERESTARTNOHAND;
579 if (signal_pending(current))
580 goto out;
581 ret = 0;
582 }
583
584 if (set_fd_set(n, inp, fds.res_in) ||
585 set_fd_set(n, outp, fds.res_out) ||
586 set_fd_set(n, exp, fds.res_ex))
587 ret = -EFAULT;
588
589 out:
590 if (bits != stack_fds)
591 kfree(bits);
592 out_nofds:
593 return ret;
594 }1.输入参数n(描述符表大小)检查，如果大于进程打开的最大描述符，则以打开的最大文件描述符为准
2.将读、写、异常描述符表位图从用户空间复制到内核空间，并由fd_set_bits标识出位图超始位置；并将返回读、写、异常描述符表位图置0
3.调用do_select
4.当有信号产生时返回ERESTARTNOHAND，通知内核信号处理完成后自动重新调用select5.将返回文件描述符表位图由内核空间复制到用户空间
5.将返回文件描述符表位图由内核空间复制到用户空间
iii.do_select
396 int do_select(int n, fd_set_bits *fds, struct timespec *end_time)
397 {
398 ktime_t expire, *to = NULL;
399 struct poll_wqueues table;
400 poll_table *wait;
401 int retval, i, timed_out = 0;
402 unsigned long slack = 0;
403
404 rcu_read_lock();
405 retval = max_select_fd(n, fds);
406 rcu_read_unlock();
407
408 if (retval < 0)
409 return retval;
410 n = retval;
411
412 poll_initwait(&table);
413 wait = &table.pt;
414 if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {
415 wait = NULL;
416 timed_out = 1;
417 }
418
419 if (end_time && !timed_out)
420 slack = estimate_accuracy(end_time);
421
422 retval = 0;
423 for (;;) {
424 unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
425
426 inp = fds->in; outp = fds->out; exp = fds->ex;
427 rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
428
429 for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
430 unsigned long in, out, ex, all_bits, bit = 1, mask, j;
431 unsigned long res_in = 0, res_out = 0, res_ex = 0;
432 const struct file_operations *f_op = NULL;
433 struct file *file = NULL;
434
435 in = *inp++; out = *outp++; ex = *exp++;
436 all_bits = in | out | ex;
437 if (all_bits == 0) {
438 i += __NFDBITS;
439 continue;
440 }
441
442 for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
443 int fput_needed;
444 if (i >= n)
445 break;
446 if (!(bit & all_bits))
447 continue;
448 file = fget_light(i, &fput_needed);
449 if (file) {
450 f_op = file->f_op;
451 mask = DEFAULT_POLLMASK;
452 if (f_op && f_op->poll) {
453 wait_key_set(wait, in, out, bit);
454 mask = (*f_op->poll)(file, wait);
455 }
456 fput_light(file, fput_needed);
457 if ((mask & POLLIN_SET) && (in & bit)) {
458 res_in |= bit;
459 retval++;
460 wait = NULL;
461 }
462 if ((mask & POLLOUT_SET) && (out & bit)) {
463 res_out |= bit;
464 retval++;
465 wait = NULL;
466 }
467 if ((mask & POLLEX_SET) && (ex & bit)) {
468 res_ex |= bit;
469 retval++;
470 wait = NULL;
471 }
472 }
473 }
474 if (res_in)
475 *rinp = res_in;
476 if (res_out)
477 *routp = res_out;
478 if (res_ex)
479 *rexp = res_ex;
480 cond_resched();
481 }
482 wait = NULL;
483 if (retval || timed_out || signal_pending(current))
484 break;
485 if (table.error) {
486 retval = table.error;
487 break;
488 }
489
490 /*
491 * If this is the first loop and we have a timeout
492 * given, then we convert to ktime_t and set the to
493 * pointer to the expiry value.
494 */
495 if (end_time && !to) {
496 expire = timespec_to_ktime(*end_time);
497 to = &expire;
498 }
499
500 if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE,
501 to, slack))
502 timed_out = 1;
503 }
504
505 poll_freewait(&table);
506
507 return retval;
508 }1.取读、写、异常文件描述符表位图中最大文件描述符，并做合法性检查（检查位图中置位的文件是否打开,如果未打开则返回EBADF)
2.初始化poll_wqueues，包括poll_table及poll_table的回调函数等
3.遍历描述符表位图中的文件，并对每个文件进行poll操作
a.如果文件不能非阻塞的进行key标识的I/O操作，则poll会自动将进程添加到文件的poll等待队列中(见poll阻塞)；
b.如果文件能非阻塞的进行key标识的I/O操作，则poll返回相应的poll事件，并记录到返回文件描述符位图中；将poll_table置成NULL，即不用再将进程添加到文件的poll等待队列中；即使该文件不能进行非阻塞的I/O操作也不用将进程添加到文件的等待队列中，因为复用函数只需要有一个文件可进行非阻塞I/O操作即可
4.遍历结束后
A.如果描述符表中有文件能非阻塞的进行key标识的I/O操作，则走5
B.如果描述符表中没有文件能非阻塞的进行key标识的I/O操作且未超时
a.triggered=1（在遍历的过程中，异步收到数据等情况时，文件能非阻塞的进行key标识的I/O操作），跳转到步骤3重新遍历描述符表位图
b.triggered=0，则会阻塞进程，被唤醒后跳转到步骤3重新遍历描述符表位图
C.超时，则超时退出，跳转到步骤5释放poll_wqueues
5.释放poll_wqueues
iv.poll_schedule_timeout
232 int poll_schedule_timeout(struct poll_wqueues *pwq, int state,
233 ktime_t *expires, unsigned long slack)
234 {
235 int rc = -EINTR;
236
237 set_current_state(state);
238 if (!pwq->triggered)
239 rc = schedule_hrtimeout_range(expires, slack, HRTIMER_MODE_ABS);
240 __set_current_state(TASK_RUNNING);
241
242 /*
243 * Prepare for the next iteration.
244 *
245 * The following set_mb() serves two purposes. First, it's
246 * the counterpart rmb of the wmb in pollwake() such that data
247 * written before wake up is always visible after wake up.
248 * Second, the full barrier guarantees that triggered clearing
249 * doesn't pass event check of the next iteration. Note that
250 * this problem doesn't exist for the first iteration as
251 * add_wait_queue() has full barrier semantics.
252 */
253 set_mb(pwq->triggered, 0);
254
255 return rc;
256 }1.当pwq->triggered=0时，则阻塞进程并超时等待；
2.否则，表示已经有文件触发waiter，不用阻塞进程
扫一扫
604
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
