1.基本数据结构
分别是 eventpoll、epitem 和 eppoll_entry。
1.1 eventpoll
我们先看一下 eventpoll 这个数据结构，这个数据结构是我们在调用 epoll_create 之后内核侧创建的一个句柄，表示了一个 epoll 实例。后续如果我们再调用 epoll_ctl 和 epoll_wait 等，都是对这个 eventpoll 数据进行操作，这部分数据会被保存在 epoll_create 创建的匿名文件 file 的 private_data 字段中。
1 /* 2 * This structure is stored inside the "private_data" member of the file 3 * structure and represents the main data structure for the eventpoll 4 * interface. 5 */ 6 struct eventpoll { 7 /* Protect the access to this structure */ 8 spinlock_t lock; 9 10 /* 11 * This mutex is used to ensure that files are not removed 12 * while epoll is using them. This is held during the event 13 * collection loop, the file cleanup path, the epoll file exit 14 * code and the ctl operations. 15 */ 16 struct mutex mtx; 17 18 /* Wait queue used by sys_epoll_wait() */ 19 //这个队列里存放的是执行epoll_wait从而等待的进程队列 20 wait_queue_head_t wq; 21 22 /* Wait queue used by file->poll() */ 23 //这个队列里存放的是该eventloop作为poll对象的一个实例，加入到等待的队列 24 //这是因为eventpoll本身也是一个file, 所以也会有poll操作 25 wait_queue_head_t poll_wait; 26 27 /* List of ready file descriptors */ 28 //这里存放的是事件就绪的fd列表，链表的每个元素是下面的epitem 29 struct list_head rdllist; 30 31 /* RB tree root used to store monitored fd structs */ 32 //这是用来快速查找fd的红黑树 33 struct rb_root_cached rbr; 34 35 /* 36 * This is a single linked list that chains all the "struct epitem" that 37 * happened while transferring ready events to userspace w/out 38 * holding ->lock. 39 */ 40 struct epitem *ovflist; 41 42 /* wakeup_source used when ep_scan_ready_list is running */ 43 struct wakeup_source *ws; 44 45 /* The user that created the eventpoll descriptor */ 46 struct user_struct *user; 47 48 //这是eventloop对应的匿名文件，充分体现了Linux下一切皆文件的思想 49 struct file *file; 50 51 /* used to optimize loop detection check */ 52 int visited; 53 struct list_head visited_list_link; 54 55 #ifdef CONFIG_NET_RX_BUSY_POLL 56 /* used to track busy poll napi_id */ 57 unsigned int napi_id; 58 #endif 59 };
这个 epitem 结构是干什么用的呢？
每当我们调用 epoll_ctl 增加一个 fd 时，内核就会为我们创建出一个 epitem 实例，并且把这个实例作为红黑树的一个子节点，增加到 eventpoll 结构体中的红黑树中，对应的字段是 rbr。这之后，查找每一个 fd 上是否有事件发生都是通过红黑树上的 epitem 来操作。
1 /* 2 * Each file descriptor added to the eventpoll interface will 3 * have an entry of this type linked to the "rbr" RB tree. 4 * Avoid increasing the size of this struct, there can be many thousands 5 * of these on a server and we do not want this to take another cache line. 6 */ 7 struct epitem { 8 union { 9 /* RB tree node links this structure to the eventpoll RB tree */ 10 struct rb_node rbn; 11 /* Used to free the struct epitem */ 12 struct rcu_head rcu; 13 }; 14 15 /* List header used to link this structure to the eventpoll ready list */ 16 //将这个epitem连接到eventpoll 里面的rdllist的list指针 17 struct list_head rdllink; 18 19 /* 20 * Works together "struct eventpoll"->ovflist in keeping the 21 * single linked chain of items. 22 */ 23 struct epitem *next; 24 25 /* The file descriptor information this item refers to */ 26 //epoll监听的fd 27 struct epoll_filefd ffd; 28 29 /* Number of active wait queue attached to poll operations */ 30 //一个文件可以被多个epoll实例所监听，这里就记录了当前文件被监听的次数 31 int nwait; 32 33 /* List containing poll wait queues */ 34 struct list_head pwqlist; 35 36 /* The "container" of this item */ 37 //当前epollitem所属的eventpoll 38 struct eventpoll *ep; 39 40 /* List header used to link this item to the "struct file" items list */ 41 struct list_head fllink; 42 43 /* wakeup_source used when EPOLLWAKEUP is set */ 44 struct wakeup_source __rcu *ws; 45 46 /* The structure that describe the interested events and the source fd */ 47 struct epoll_event event; 48 };
每次当一个 fd 关联到一个 epoll 实例，就会有一个 eppoll_entry 产生。eppoll_entry 的结构如下：
1 /* Wait structure used by the poll hooks */ 2 struct eppoll_entry { 3 /* List header used to link this structure to the "struct epitem" */ 4 struct list_head llink; 5 6 /* The "base" pointer is set to the container "struct epitem" */ 7 struct epitem *base; 8 9 /* 10 * Wait queue item that will be linked to the target file wait 11 * queue head. 12 */ 13 wait_queue_entry_t wait; 14 15 /* The wait queue head that linked the "wait" wait queue item */ 16 wait_queue_head_t *whead; 17 };
epoll_create：
我们在使用 epoll 的时候，首先会调用 epoll_create 来创建一个 epoll 实例。这个函数是如何工作的呢?
首先，epoll_create 会对传入的 flags 参数做简单的验证。
1 /* Check the EPOLL_* constant for consistency. */ 2 BUILD_BUG_ON(EPOLL_CLOEXEC != O_CLOEXEC); 3 4 if (flags & ~EPOLL_CLOEXEC) 5 return -EINVAL; 6 /*
接下来，内核申请分配 eventpoll 需要的内存空间
1 /* Create the internal data structure ("struct eventpoll"). 2 */ 3 error = ep_alloc(&ep); 4 if (error < 0) 5 return error;
在接下来，epoll_create 为 epoll 实例分配了匿名文件和文件描述字，其中 fd 是文件描述字，file 是一个匿名文件。这里充分体现了 UNIX 下一切都是文件的思想。
注意，eventpoll 的实例会保存一份匿名文件的引用，通过调用 fd_install 函数将匿名文件和文件描述字完成了绑定。
这里还有一个特别需要注意的地方，在调用 anon_inode_get_file 的时候，epoll_create 将 eventpoll 作为匿名文件 file 的 private_data 保存了起来，这样，在之后通过 epoll 实例的文件描述字来查找时，就可以快速地定位到 eventpoll 对象了。最后，这个文件描述字作为 epoll 的文件句柄，被返回给 epoll_create 的调用者。
1 /* 2 * Creates all the items needed to setup an eventpoll file. That is, 3 * a file structure and a free file descriptor. 4 */ 5 fd = get_unused_fd_flags(O_RDWR | (flags & O_CLOEXEC)); 6 if (fd < 0) { 7 error = fd; 8 goto out_free_ep; 9 } 10 file = anon_inode_getfile("[eventpoll]", &eventpoll_fops, ep, 11 O_RDWR | (flags & O_CLOEXEC)); 12 if (IS_ERR(file)) { 13 error = PTR_ERR(file); 14 goto out_free_fd; 15 } 16 ep->file = file; 17 fd_install(fd, file); 18 return fd;
epoll_ctl
1 /* 2 * @epfd: epool_create创建的用于eventpoll的fd 3 * @op: 控制的命令类型 4 * @fd: 要操作的文件描述符 5 * @event:与fd相关的对象. 6 */ 7 SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd, 8 struct epoll_event __user *, event) 9 { 10 int error; 11 struct file *file, *tfile; 12 struct eventpoll *ep; 13 struct epitem *epi; 14 struct epoll_event epds; 15 16 error = -EFAULT; 17 /* 18 * 检查是否需要从用户空间拷贝event参数,如果需要拷贝,则调用 19 * copy_from_user来拷贝. 20 */ 21 if (ep_op_has_event(op) && 22 copy_from_user(&epds, event, sizeof(struct epoll_event))) 23 goto error_return; 24 25 /* Get the "struct file *" for the eventpoll file */ 26 error = -EBADF; 27 /* 28 * 获取epfd对应的file实例 29 */ 30 file = fget(epfd); 31 if (!file) 32 goto error_return; 33 34 /* Get the "struct file *" for the target file */ 35 /* 36 * 获取要操作的文件描述符对应的file实例 37 */ 38 tfile = fget(fd); 39 if (!tfile) 40 goto error_fput; 41 42 /* The target file descriptor must support poll */ 43 /* 44 * 检查fd对应的文件是否支持poll 45 */ 46 error = -EPERM; 47 if (!tfile->f_op || !tfile->f_op->poll) 48 goto error_tgt_fput; 49 50 /* 51 * We have to check that the file structure underneath the file descriptor 52 * the user passed to us _is_ an eventpoll file. And also we do not permit 53 * adding an epoll file descriptor inside itself. 54 */ 55 error = -EINVAL; 56 /* 57 * 检查fd对应的文件是否是一个eventpoll文件 58 */ 59 if (file == tfile || !is_file_epoll(file)) 60 goto error_tgt_fput; 61 62 /* 63 * At this point it is safe to assume that the "private_data" contains 64 * our own data structure. 65 */ 66 /* 67 * 获取eventpoll文件中的私有数据，该数据是在epoll_create中创建的。 68 */ 69 ep = file->private_data; 70 71 mutex_lock(&ep->mtx); 72 73 /* 74 * Try to lookup the file inside our RB tree, Since we grabbed "mtx" 75 * above, we can be sure to be able to use the item looked up by 76 * ep_find() till we release the mutex. 77 */ 78 /* 79 * 在eventpoll中存储文件描述符信息的红黑树中查找指定的fd对应的epitem实例 80 */ 81 epi = ep_find(ep, tfile, fd); 82 83 error = -EINVAL; 84 switch (op) { 85 case EPOLL_CTL_ADD: 86 /* 87 * 如果要添加的fd不存在,则调用ep_insert()插入到红黑树中, 88 * 如果已存在,则返回EEXIST错误. 89 */ 90 if (!epi) { 91 epds.events |= POLLERR | POLLHUP; 92 error = ep_insert(ep, &epds, tfile, fd); 93 } else 94 error = -EEXIST; 95 break; 96 case EPOLL_CTL_DEL: 97 if (epi) 98 error = ep_remove(ep, epi); 99 else 100 error = -ENOENT; 101 break; 102 case EPOLL_CTL_MOD: 103 if (epi) { 104 epds.events |= POLLERR | POLLHUP; 105 error = ep_modify(ep, epi, &epds); 106 } else 107 error = -ENOENT; 108 break; 109 } 110 mutex_unlock(&ep->mtx); 111 112 error_tgt_fput: 113 fput(tfile); 114 error_fput: 115 fput(file); 116 error_return: 117 118 return error; 119 }
查找 epoll 实例首先，epoll_ctl 函数通过 epoll 实例句柄来获得对应的匿名文件，这一点很好理解，UNIX 下一切都是文件，epoll 的实例也是一个匿名文件。
1 //获得epoll实例对应的匿名文件 2 f = fdget(epfd); 3 if (!f.file) 4 goto error_return;
接下来，获得添加的套接字对应的文件，这里 tf 表示的是 target file，即待处理的目标文件。
1 /* Get the "struct file *" for the target file */ 2 //获得真正的文件，如监听套接字、读写套接字 3 tf = fdget(fd); 4 if (!tf.file) 5 goto error_fput;
再接下来，进行了一系列的数据验证，以保证用户传入的参数是合法的，比如 epfd 真的是一个 epoll 实例句柄，而不是一个普通文件描述符。
1 /* The target file descriptor must support poll */ 2 //如果不支持poll，那么该文件描述字是无效的 3 error = -EPERM; 4 if (!tf.file->f_op->poll) 5 goto error_tgt_fput; 6 ...
如果获得了一个真正的 epoll 实例句柄，就可以通过 private_data 获取之前创建的 eventpoll 实例了。
1 /* 2 * At this point it is safe to assume that the "private_data" contains 3 * our own data structure. 4 */ 5 ep = f.file->private_data;
红黑树查找接下来 epoll_ctl 通过目标文件和对应描述字，在红黑树中查找是否存在该套接字，这也是 epoll 为什么高效的地方。红黑树（RB-tree）是一种常见的数据结构，这里 eventpoll 通过红黑树跟踪了当前监听的所有文件描述字，而这棵树的根就保存在 eventpoll 数据结构中
1 /* RB tree root used to store monitored fd structs */ 2 struct rb_root_cached rbr;
对于每个被监听的文件描述字，都有一个对应的 epitem 与之对应，epitem 作为红黑树中的节点就保存在红黑树中。
1 /* 2 * Try to lookup the file inside our RB tree, Since we grabbed "mtx" 3 * above, we can be sure to be able to use the item looked up by 4 * ep_find() till we release the mutex. 5 */ 6 epi = ep_find(ep, tf.file, fd);
红黑树是一棵二叉树，作为二叉树上的节点，epitem 必须提供比较能力，以便可以按大小顺序构建出一棵有序的二叉树。其排序能力是依靠 epoll_filefd 结构体来完成的，epoll_filefd 可以简单理解为需要监听的文件描述字，它对应到二叉树上的节点
可以看到这个还是比较好理解的，按照文件的地址大小排序。如果两个相同，就按照文件文件描述字来排序。
1 struct epoll_filefd {
2 struct file *file; // pointer to the target file struct corresponding to the fd
3 int fd; // target file descriptor number
4 } __packed;
5
6 /* Compare RB tree keys */
7 static inline int ep_cmp_ffd(struct epoll_filefd *p1,
8 struct epoll_filefd *p2)
9 {
10 return (p1->file > p2->file ? +1: 11 (p1->file < p2->file ? -1 : p1->fd - p2->fd)); 12 }
在进行完红黑树查找之后，如果发现是一个 ADD 操作，并且在树中没有找到对应的二叉树节点，就会调用 ep_insert 进行二叉树节点的增加。
1 case EPOLL_CTL_ADD:
2 if (!epi) {
3 epds.events |= POLLERR | POLLHUP;
4 error = ep_insert(ep, &epds, tf.file, fd, full_check);
5 } else
6 error = -EEXIST;
7 if (full_check) 8 clear_tfile_check_list(); 9 break;
ep_insert:
1 /* 2 * Must be called with "mtx" held. 3 */ 4 static int ep_insert(struct eventpoll *ep, struct epoll_event *event, 5 struct file *tfile, int fd) 6 { 7 int error, revents, pwake = 0; 8 unsigned long flags; 9 struct epitem *epi; 10 struct ep_pqueue epq; 11 12 /* 13 * 检查epoll监视的文件描述符的个数是否超过max_user_watches, 14 * max_user_watches用来存储每个用户使用epoll可以监视的文件 15 * 描述符个数 16 */ 17 if (unlikely(atomic_read(&ep->user->epoll_watches) >= 18 max_user_watches)) 19 return -ENOSPC; 20 /* 21 * 每个加入到epoll中的文件都会附加到一个epitem实例中， 22 * 分配当前文件对应的epitem实例。 23 */ 24 if (!(epi = kmem_cache_alloc(epi_cache, GFP_KERNEL))) 25 return -ENOMEM; 26 27 /* 28 * 初始化新分配的epitem实例 29 */ 30 INIT_LIST_HEAD(&epi->rdllink); 31 INIT_LIST_HEAD(&epi->fllink); 32 INIT_LIST_HEAD(&epi->pwqlist); 33 epi->ep = ep; 34 ep_set_ffd(&epi->ffd, tfile, fd); 35 epi->event = *event; 36 epi->nwait = 0; 37 epi->next = EP_UNACTIVE_PTR; 38 39 /* Initialize the poll table using the queue callback */ 40 epq.epi = epi; 41 init_poll_funcptr(&epq.pt, ep_ptable_queue_proc); 42 43 /* 44 * 如果fd是套接字，f_op为socket_file_ops，poll函数是 45 * sock_poll()。如果是TCP套接字的话，进而会调用 46 * 到tcp_poll()函数。此处调用poll函数查看当前 47 * 文件描述符的状态，存储在revents中。 48 * 在poll的处理函数(tcp_poll())中，会调用sock_poll_wait()， 49 * 在sock_poll_wait()中会调用到epq.pt.qproc指向的函数， 50 * 也就是ep_ptable_queue_proc()。 51 */ 52 revents = tfile->f_op->poll(tfile, &epq.pt); 53 54 /* 55 * ep_ptable_queue_proc()中如果分配内存失败时，会 56 * 将nwait置为-1。 57 */ 58 error = -ENOMEM; 59 if (epi->nwait < 0) 60 goto error_unregister; 61 62 /* Add the current item to the list of active epoll hook for this file */ 63 spin_lock(&tfile->f_lock); 64 /* 65 * 将当前的epitem加入tfile的f_ep_links链表中， 66 * 在从epoll中移除文件时，用户清理文件对应的 67 * epitem实例。 68 */ 69 list_add_tail(&epi->fllink, &tfile->f_ep_links); 70 spin_unlock(&tfile->f_lock); 71 72 /* 73 * 将当前的epitem加入到存储监视的所有文件的红黑树中. 74 */ 75 ep_rbtree_insert(ep, epi); 76 77 /* We have to drop the new item inside our item list to keep track of it */ 78 spin_lock_irqsave(&ep->lock, flags); 79 80 /* 81 * 如果要监视的文件状态已经就绪并且还没有加入到就绪队列中,则将当前的 82 * epitem加入到就绪队列中.如果有进程正在等待该文件的状态就绪,则 83 * 唤醒一个等待的进程. 84 */ 85 if ((revents & event->events) && !ep_is_linked(&epi->rdllink)) { 86 list_add_tail(&epi->rdllink, &ep->rdllist); 87 88 /* Notify waiting tasks that events are available */ 89 /* 90 * 如果有进程正在等待文件的状态就绪，也就是 91 * 调用epoll_wait睡眠的进程正在等待，则唤醒一个 92 * 等待进程。 93 */ 94 if (waitqueue_active(&ep->wq)) 95 wake_up_locked(&ep->wq); 96 /* 97 * 如果有进程等待eventpoll文件本身的事件就绪， 98 * 则增加临时变量pwake的值，pwake的值不为0时， 99 * 在释放lock后，会唤醒等待进程。 100 */ 101 if (waitqueue_active(&ep->poll_wait)) 102 pwake++; 103 } 104 105 spin_unlock_irqrestore(&ep->lock, flags); 106 107 /* 108 * 增加eventpoll监视的文件数量。 109 */ 110 atomic_inc(&ep->user->epoll_watches); 111 112 /* We have to call this outside the lock */ 113 /* 114 * 唤醒等待eventpoll文件状态就绪的进程 115 */ 116 * 117 if (pwake) 118 ep_poll_safewake(&ep->poll_wait); 119 120 return 0; 121 122 error_unregister: 123 ep_unregister_pollwait(ep, epi); 124 125 /* 126 * We need to do this because an event could have been arrived on some 127 * allocated wait queue. Note that we don't care about the ep->ovflist 128 * list, since that is used/cleaned only inside a section bound by "mtx". 129 * And ep_insert() is called with "mtx" held. 130 */ 131 spin_lock_irqsave(&ep->lock, flags); 132 if (ep_is_linked(&epi->rdllink)) 133 list_del_init(&epi->rdllink); 134 spin_unlock_irqrestore(&ep->lock, flags); 135 136 kmem_cache_free(epi_cache, epi); 137 138 return error; 139 }
ep_insert 首先判断当前监控的文件值是否超过了 /proc/sys/fs/epoll/max_user_watches 的预设最大值，如果超过了则直接返回错误。
1 user_watches = atomic_long_read(&ep->user->epoll_watches); 2 if (unlikely(user_watches >= max_user_watches)) 3 return -ENOSPC;
接下来是分配资源和初始化动作。
1 if (!(epi = kmem_cache_alloc(epi_cache, GFP_KERNEL))) 2 return -ENOMEM; 3 4 /* Item initialization follow here ... */ 5 INIT_LIST_HEAD(&epi->rdllink); 6 INIT_LIST_HEAD(&epi->fllink); 7 INIT_LIST_HEAD(&epi->pwqlist); 8 epi->ep = ep; 9 ep_set_ffd(&epi->ffd, tfile, fd); 10 epi->event = *event; 11 epi->nwait = 0; 12 epi->next = EP_UNACTIVE_PTR;
再接下来的事情非常重要，ep_insert 会为加入的每个文件描述字设置回调函数。这个回调函数是通过函数 ep_ptable_queue_proc 来进行设置的。这个回调函数是干什么的呢？其实，对应的文件描述字上如果有事件发生，就会调用这个函数，比如套接字缓冲区有数据了，就会回调这个函数。这个函数就是 ep_poll_callback。这里你会发现，原来内核设计也是充满了事件回调的原理。
1 /* 2 * This is the callback that is used to add our wait queue to the 3 * target file wakeup lists. 4 */ 5 static void ep_ptable_queue_proc(struct file *file, wait_queue_head_t *whead,poll_table *pt) 6 { 7 struct epitem *epi = ep_item_from_epqueue(pt); 8 struct eppoll_entry *pwq; 9 10 if (epi>nwait >= 0 && (pwq = kmem_cache_alloc(pwq_cache, GFP_KERNEL))) { 11 init_waitqueue_func_entry(&pwq->wait, ep_poll_callback); 12 pwq->whead = whead; 13 pwq->base = epi; 14 if (epi->event.events & EPOLLEXCLUSIVE) 15 add_wait_queue_exclusive(whead, &pwq->wait); 16 else 17 add_wait_queue(whead, &pwq->wait); 18 list_add_tail(&pwq->llink, &epi->pwqlist); 19 epi->nwait++; 20 } else { 21 /* We have to signal that an error occurred */ 22 epi->nwait = -1; 23 } 24 }
ep_poll_callback
ep_poll_callback 函数的作用非常重要，它将内核事件真正地和 epoll 对象联系了起来。它又是怎么实现的呢？首先，通过这个文件的 wait_queue_entry_t 对象找到对应的 epitem 对象，因为 eppoll_entry 对象里保存了 wait_quue_entry_t，根据 wait_quue_entry_t 这个对象的地址就可以简单计算出 eppoll_entry 对象的地址，从而可以获得 epitem 对象的地址。这部分工作在 ep_item_from_wait 函数中完成。一旦获得 epitem 对象，就可以寻迹找到 eventpoll 实例。
1 /* 2 * 如果文件类型支持epoll并且有事件发生，发生的事件通过 3 * 参数key来传送，参见tcp_prequeue()函数中对wake_up_interruptible_poll() 4 * 的调用。 5 * @wait: 调用ep_ptable_queue_proc()加入到文件中的唤醒队列时分配的 6 * eppoll_entry实例的wait成员的地址 7 * @mode:该参数在回调函数ep_poll_callback()中没有使用，其值为进程 8 * 睡眠时的状态 9 * @sync: 唤醒等待进程的标志 10 */ 11 static int ep_poll_callback(wait_queue_t *wait, unsigned mode, int sync, void *key) 12 { 13 int pwake = 0; 14 unsigned long flags; 15 struct epitem *epi = ep_item_from_wait(wait); 16 struct eventpoll *ep = epi->ep; 17 18 spin_lock_irqsave(&ep->lock, flags); 19 20 /* 21 * If the event mask does not contain any poll(2) event, we consider the 22 * descriptor to be disabled. This condition is likely the effect of the 23 * EPOLLONESHOT bit that disables the descriptor when an event is received, 24 * until the next EPOLL_CTL_MOD will be issued. 25 */ 26 /* 27 * epi->event.events中存储的是用户空间关心的事件，如果该成员 28 * 没有包含任何poll事件，则跳转到out_unlock处处理 29 */ 30 if (!(epi->event.events & ~EP_PRIVATE_BITS)) 31 goto out_unlock; 32 33 /* 34 * Check the events coming with the callback. At this stage, not 35 * every device reports the events in the "key" parameter of the 36 * callback. We need to be able to handle both cases here, hence the 37 * test for "key" != NULL before the event match test. 38 */ 39 /* 40 * 如果key不为NULL，也就是值不是0，但是用户关心的 41 * 事件并没有发生，则跳转到out_unlock处处理。参数key 42 * 应该不会为0 43 */ 44 if (key && !((unsigned long) key & epi->event.events)) 45 goto out_unlock; 46 47 /* 48 * If we are trasfering events to userspace, we can hold no locks 49 * (because we're accessing user memory, and because of linux f_op->poll() 50 * semantics). All the events that happens during that period of time are 51 * chained in ep->ovflist and requeued later on. 52 */ 53 /* 54 * ep_scan_ready_list()是向用户空间传递事件的处理函数， 55 * ep_scan_ready_list()函数执行时会将ovflist链表中的元素 56 * 暂存到一个临时变量中，然后将ovflist成员置为NULL， 57 * 而EP_UNACTIVE_PTR的定义如下: 58 * #define EP_UNACTIVE_PTR ((void *) -1L) 59 * 因此(ep->ovflist != EP_UNACTIVE_PTR)成立时，正在向用户空间 60 * 传递事件。 61 * 如果当前正在向用户空间传递事件，则将 62 * 当前的事件对应的epitem实例加入到ovflist链表中。 63 */ 64 if (unlikely(ep->ovflist != EP_UNACTIVE_PTR)) { 65 /* 66 * 如果epi->next不等于EP_UNACTIVE_PTR，则说明已经 67 * 添加到ovflist链表中，就不用再添加了 68 */ 69 if (epi->next == EP_UNACTIVE_PTR) { 70 epi->next = ep->ovflist; 71 ep->ovflist = epi; 72 } 73 goto out_unlock; 74 } 75 76 /* If this file is already in the ready list we exit soon */ 77 /* 78 * 如果当前没有在向用户空间传递事件，用户 79 * 关心的事件已经发生，并且还没有加入到就绪 80 * 队列中，则将当前的epitem实例加入到就绪队列中。 81 */ 82 if (!ep_is_linked(&epi->rdllink)) 83 list_add_tail(&epi->rdllink, &ep->rdllist); 84 85 /* 86 * Wake up ( if active ) both the eventpoll wait list and the ->poll() 87 * wait list. 88 */ 89 /* 90 * 唤醒调用epoll_wait()函数时睡眠的进程。 91 */ 92 if (waitqueue_active(&ep->wq)) 93 wake_up_locked(&ep->wq); 94 /* 95 * 唤醒等待eventpoll文件状态就绪的进程 96 */ 97 if (waitqueue_active(&ep->poll_wait)) 98 pwake++; 99 100 out_unlock: 101 spin_unlock_irqrestore(&ep->lock, flags); 102 103 /* We have to call this outside the lock */ 104 /* 105 * 唤醒等待eventpoll文件的状态就绪的进程 106 */ 107 if (pwake) 108 ep_poll_safewake(&ep->poll_wait); 109 110 return 1; 111 112 }