epoll分析

Epoll详解及源码分析

1.什么是epoll

2.Epoll API

1: #include  <sys/epoll.h>
[code]

int  size);

int epfd, int op, int fd, structepoll_event *event);

int epfd, struct epoll_event* events, int maxevents. int timeout);

① int epoll_create(int size);

②int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

1: //保存触发事件的某个文件描述符相关的数据（与具体使用方式有关）
[code]

union epoll_data {

void *ptr;

int fd;

//感兴趣的事件和被触发的事件

/* User data variable */

③ int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

3.Epoll 工作模式

4.实例

1: #include <stdio.h>
[code]

int MAX_SOCK_NUM = 1024;

struct sockaddr_in listenAddr;

int listenFd = -1;

if(-1 == epoll_init())

"epoll_init err\n");

return -1;

if((listenFd = epoll_socket(AF_INET,SOCK_STREAM,0)) == -1)

"epoll_socket err\n");

return -1;

if(-1 == bind(listenFd,(struct sockaddr*)&listenAddr,sizeof(listenAddr)))

"bind err %d\n",errno);

return -1;

if(-1 == listen(listenFd,1024))

"listen err\n");

return -1;

//Add ListenFd into epoll

if(-1 == epoll_new_conn(listenFd))

"eph_new_conn err\n");

return -1;

//LOOP

while(1)

int n;

for (int i = 0; i < n; i++)

if( (events[i].events & EPOLLERR) || ( events[i].events & EPOLLHUP ) || !(events[i].events & EPOLLIN) )

"epoll err\n");

continue;

else if(events[i].data.fd == listenFd)

while(1)

struct sockaddr inAddr;

char hbuf[1024],sbuf[NI_MAXSERV];

int inFd = -1;

int s = 0;

int flag = 0;

sizeof(inAddr);

if(inFd == -1)

if( errno == EAGAIN || errno == EWOULDBLOCK )

break;

else

"accept error\n");

break;

if (s ==  getnameinfo (&inAddr, inLen, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV))

"Accepted connection on descriptor %d (host=%s, port=%s)\n", inFd, hbuf, sbuf);

//Set Socket to non-block

if((flag = fcntl(inFd,F_GETFL,0)) < 0 || fcntl(inFd,F_SETFL,flag | O_NONBLOCK) < 0)

return -1;

else

while (1)

char buf[512];

sizeof buf);

if (count == -1)

if (errno != EAGAIN)

"read err\n");

break;

else if (count == 0)

break;

if(!(events = (struct epoll_event* ) malloc ( MAX_SOCK_NUM * sizeof(struct epoll_event))))

return -1;

if( (epollFd = epoll_create(MAX_SOCK_NUM)) < 0 )

return -1;

return 0;

int sockFd = -1;

int flag = -1;

if ((sockFd = socket(domain,type,protocol)) < 0)

return -1;

//Set Socket to non-block

if((flag = fcntl(sockFd,F_GETFL,0)) < 0 || fcntl(sockFd,F_SETFL,flag | O_NONBLOCK) < 0)

return -1;

return sockFd;

return 0;

struct epoll_event  epollEvent;

sizeof(struct epoll_event));

if (epoll_ctl(epollFd, EPOLL_CTL_ADD, sfd, &epollEvent) < 0)

return -1;

return 0;

5.Epoll为什么高效

6.Epoll源码分析

1: static int __init eventpoll_init(void)
[code]

"eventpoll_epi", sizeof(struct epitem), 0, SLAB_HWCACHE_ALIGN|EPI_SLAB_DEBUG|SLAB_PANIC, NULL);

"eventpoll_pwq", sizeof(struct eppoll_entry), 0, EPI_SLAB_DEBUG|SLAB_PANIC, NULL);

return 0;

1: struct epitem
[code]

struct list_head  rdllink;  //事件就绪队列

struct epitem  *next;       //用于主结构体中的链表

struct epoll_filefd  ffd;   //这个结构体对应的被监听的文件描述符信息

int  nwait;                 //poll操作中事件的个数

struct list_head  pwqlist;  //双向链表，保存着被监视文件的等待队列，功能类似于select/poll中的poll_table

struct eventpoll  *ep;      //该项属于哪个主结构体（多个epitm从属于一个eventpoll）

struct list_head  fllink;   //双向链表，用来链接被监视的文件描述符对应的struct file。因为file里有f_ep_link,用来保存所有监视这个文件的epoll节点

struct epoll_event  event;  //注册的感兴趣的事件,也就是用户空间的epoll_event

1: struct eventpoll
[code]

struct mutex      mtx;              //防止使用时被删除

//sys_epoll_wait() 使用的等待队列

//file->poll()使用的等待队列

struct list_head    rdllist;        //事件满足条件的链表

struct rb_root      rbr;            //用于管理所有fd的红黑树（树根）

struct epitem      *ovflist;       //将事件到达的fd进行链接起来发送至用户空间

1: long sys_epoll_create(int size)
[code]

struct eventpoll *ep;

//为ep分配内存并进行初始化

"[eventpoll]", &eventpoll_fops, ep, O_RDWR | (flags & O_CLOEXEC));

return fd;

1: static const struct file_operations eventpoll_fops = {
[code]

1: asmlinkage long sys_epoll_ctl(int epfd,int op,int fd,struct epoll_event __user *event) {
[code]

int error;

struct file *file,*tfile;

struct eventpoll *ep;

struct epoll_event epds;

//判断参数的合法性，将 __user *event 复制给 epds。

if(ep_op_has_event(op) && copy_from_user(&epds,event,sizeof(struct epoll_event)))

goto error_return; //省略跳转到的代码

// epoll fd 对应的文件对象

// fd 对应的文件对象

//在create时存入进去的（anon_inode_getfd），现在取用。

private->data;

//防止重复添加（在ep的红黑树中查找是否已经存在这个fd）

switch(op)

case EPOLL_CTL_ADD:  //增加监听一个fd

if(!epi)

//默认包含POLLERR和POLLHUP事件

//在ep的红黑树中插入这个fd对应的epitm结构体。

else  //重复添加（在ep的红黑树中查找已经存在这个fd）。

break;

return error;

1: static int ep_insert(struct eventpoll *ep, struct epoll_event *event, struct file *tfile, int fd)
[code]

int error ,revents,pwake = 0;

unsigned long flags ;

struct epitem *epi;

/*

struct ep_pqueue epq;

//分配一个epitem结构体来保存每个加入的fd

if(!(epi = kmem_cache_alloc(epi_cache,GFP_KERNEL)))

goto error_return;

//初始化该结构体

//安装poll回调函数

/* 调用poll函数来获取当前事件位，其实是利用它来调用注册函数ep_ptable_queue_proc（poll_wait中调用）。

//将该epi插入到ep的红黑树中

//将当前epi插入到ep->ready队列中。

if(waitqueue_active(&ep->wq))

if(waitqueue_active(&ep->poll_wait))

//唤醒等待eventpoll文件状态就绪的进程

return 0;

1: typedef struct poll_table_struct {
[code]

long key;

1: /*  在文件操作中的poll函数中调用，将epoll的回调函数加入到目标文件的唤醒队列中。
[code]

void ep_ptable_queue_proc(struct file *file, wait_queue_head_t *whead, poll_table *pt) {

struct epitem *epi = ep_item_from_epqueue(pt); //pt获取struct ep_queue的epi字段。

struct eppoll_entry *pwq;

if (epi->nwait >= 0 && (pwq = kmem_cache_alloc(pwq_cache, GFP_KERNEL))) {

else {

/* We have to signal that an error occurred */

/*

1: struct eppoll_entry {
[code]

1: static int ep_poll_callback(wait_queue_t *wait, unsigned mode, int sync, void *key) {
[code]

int pwake = 0;

unsigned long flags;

struct epitem *epi = ep_item_from_wait(wait);

struct eventpoll *ep = epi->ep;

//判断注册的感兴趣事件

if (!(epi->event.events & ~EP_PRIVATE_BITS))

goto out_unlock;

if (unlikely(ep->ovflist != EP_UNACTIVE_PTR)) {

if (epi->next == EP_UNACTIVE_PTR) {

goto out_unlock;

if (ep_is_linked(&epi->rdllink))

goto is_linked;

//***关键***，将该fd加入到epoll监听的就绪链表中

//唤醒调用epoll_wait()函数时睡眠的进程。用户层epoll_wait(...) 超时前返回。

if (waitqueue_active(&ep->poll_wait))

if (pwake)

return 1;

1: SYSCALL_DEFINE4(epoll_wait, int, epfd, struct epoll_event __user *, events, int, maxevents, int, timeout)  {
[code]

int error;

struct file *file;

struct eventpoll *ep;

/* 检查maxevents参数。 */

if (maxevents <= 0 || maxevents > EP_MAX_EVENTS)

return -EINVAL;

/* 检查用户空间传入的events指向的内存是否可写。参见__range_not_ok()。 */

if (!access_ok(VERIFY_WRITE, events, maxevents * sizeof(struct epoll_event))) {

goto error_return;

/* 获取epfd对应的eventpoll文件的file实例，file结构是在epoll_create中创建。 */

if (!file)

goto error_return;

/* 通过检查epfd对应的文件操作是不是eventpoll_fops 来判断epfd是否是一个eventpoll文件。如果不是则返回EINVAL错误。 */

if (!is_file_epoll(file))

goto error_fput;

/* At this point it is safe to assume that the "private_data" contains  */

/* Time to fish for events ... */

return error;

static int ep_poll(struct eventpoll *ep, struct epoll_event __user *events, int maxevents, long timeout) {

int res, eavail;

unsigned long flags;

long jtimeout;

/* timeout是以毫秒为单位，这里是要转换为jiffies时间。这里加上999(即1000-1)，是为了向上取整。 */

if (list_empty(&ep->rdllist)) {

/* 没有事件，所以需要睡眠。当有事件到来时，睡眠会被ep_poll_callback函数唤醒。*/

//将current进程放在wait这个等待队列中。

/* 将当前进程加入到eventpoll的等待队列中，等待文件状态就绪或直到超时，或被信号中断。 */

for (;;) {

/* 执行ep_poll_callback()唤醒时应当需要将当前进程唤醒，所以当前进程状态应该为“可唤醒”TASK_INTERRUPTIBLE  */

/* 如果就绪队列不为空，也就是说已经有文件的状态就绪或者超时，则退出循环。*/

if (!list_empty(&ep->rdllist) || !jtimeout)

break;

/* 如果当前进程接收到信号，则退出循环，返回EINTR错误 */

if (signal_pending(current)) {

break;

/* 主动让出处理器，等待ep_poll_callback()将当前进程唤醒或者超时,返回值是剩余的时间。

/* ep->ovflist链表存储的向用户传递事件时暂存就绪的文件。

/* Try to transfer events to user space. In case we get 0 events and there's still timeout left over, we go trying again in search of more luck. */

/* 如果没有被信号中断，并且有事件就绪，但是没有获取到事件(有可能被其他进程获取到了)，并且没有超时，则跳转到retry标签处，重新等待文件状态就绪。 */

if (!res && eavail && !(res = ep_send_events(ep, events, maxevents)) && jtimeout)

goto retry;

/* 返回获取到的事件的个数或者错误码 */

return res;

7.参考