libevent的epoll模式剖析

接着上次的进度，上次剖析了事件处理框架，这次来剖析一下libevent的epoll模式是怎样实现的。

首先来看evepoll结构体：

struct evepoll {      //epoll的读写操作struct event *evread;struct event *evwrite;};

这个结构体将I/O的读事件和写事件封装为一个结构体。

epoll操作的结构体是epollop：

struct epollop {struct evepoll *fds;    //fd指向evepoll数组，数组索引就是fd大小，数组元素就是读写eventint nfds;                   //fd的个数struct epoll_event *events;      //epoll事件int nevents;    //epoll事件数目int epfd;   //epollfd};

epollop的作用不用多说，一看就知。

epoll模式主要有以下几个函数，其他select，kqueue等都是一样，都要和eventop结构体中类型返回值一致，之前博客已经剖析过。

//这就是eventop中的那几个函数指针，此处针对epoll实现，注意返回值和参数都要和eventop中一致static void *epoll_init(struct event_base *);static int epoll_add(void *, struct event *);static int epoll_del(void *, struct event *);static int epoll_dispatch(struct event_base *, void *, struct timeval *);static void epoll_dealloc(struct event_base *, void *);

我们知道在event_init()中，它会调用event_base_new()函数，在其内部会选择I/O mutiplexer，例如epoll。至于调用epoll_add()函数使用epoll，则是在event_add()函数中，因为添加事件的时候，自然需要为事件加上相应的I/O操作。

epoll.c里面定义了这么些个宏，其中用fcntl来设置SOCK_CLOEXEC这种做法，我们做socket的时候也用过类似的。比如：

int sockfd = socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC, 0);   //SOCK_NONBLOCK

当然这个是linux 2.6之后才加入的type | 方法。libevent库提供了close on exec机制，针对所有I/O，这样的话比较安全。父进程在fork时，不想子进程进行某些不安全的操作，在exec的子进程中就需要close调该fd。另外几个宏是一些初始值的定义。

#ifdef HAVE_SETFD  //设置close-on-exec，默认为0，设置1即可#define FD_CLOSEONEXEC(x) do { \                  if (fcntl(x, F_SETFD, 1) == -1) \                   event_warn("fcntl(%d, F_SETFD)", x); \      } while (0)#else#define FD_CLOSEONEXEC(x)#endif/* On Linux kernels at least up to 2.6.24.4, epoll can't handle timeout * values bigger than (LONG_MAX - 999ULL)/HZ.  HZ in the wild can be * as big as 1000, and LONG_MAX can be as small as (1<<31)-1, so the * largest number of msec we can support here is 2147482.  Let's * round that down by 47 seconds. */#define MAX_EPOLL_TIMEOUT_MSEC (35*60*1000)   //linux超时最大值#define INITIAL_NFILES 32     //初始的文件描述符数#define INITIAL_NEVENTS 32  //事件数#define MAX_NEVENTS 4096    //最大事件数

下面是添加epoll I/O操作的初始化函数，epoll_init()函数定义如下，它在event_base_new()中选择I/O机制时同时被调用。

static void *epoll_init(struct event_base *base){int epfd;struct epollop *epollop;/* Disable epollueue when this environment variable is set */if (evutil_getenv("EVENT_NOEPOLL"))  //禁用epollueue当这个环境变量设置,当不允许使用epoll时，返回NULLreturn (NULL);/* Initalize the kernel queue */if ((epfd = epoll_create(32000)) == -1) {   //创建一个epoll的句柄，32000为建议监听事件的数目，实际上只是一个占位if (errno != ENOSYS)      //errno.h中定义#define ENOSYS 38 /* Function not implemented */event_warn("epoll_create");return (NULL);}FD_CLOSEONEXEC(epfd);     // fcntl(epollfd, F_SETFD, 1)，出于安全性考虑，在exec程序中关掉fd。//close_on_exec另外的一大意义就是安全。比如父进程打开了某些文件，父进程fork了子进程，//但是子进程就会默认有这些文件的读取权限，但是很多时候我们并不想让子进程有这么多的权限。if (!(epollop = calloc(1, sizeof(struct epollop))))return (NULL);epollop->epfd = epfd;   /* Initalize fields */epollop->events = malloc(INITIAL_NEVENTS * sizeof(struct epoll_event));if (epollop->events == NULL) {   //对，这点很好，此处分配失败，要将上文中已分配的内存释放free(epollop);return (NULL);}epollop->nevents = INITIAL_NEVENTS;epollop->fds = calloc(INITIAL_NFILES, sizeof(struct evepoll));if (epollop->fds == NULL) {free(epollop->events);    //同理free(epollop);return (NULL);}epollop->nfds = INITIAL_NFILES;evsignal_init(base);   //把base->sig初始化，并和base关联起来，包括初始化socket pair，这会在后续博客中剖析return (epollop);}

epoll_add()函数负责添加相应操作，在event_add()函数中以evsel->add方式调用。

static intepoll_add(void *arg, struct event *ev){struct epollop *epollop = arg;   //这个隐式转换，如果换C++绝对报错struct epoll_event epev = {0, {0}};struct evepoll *evep;int fd, op, events;if (ev->ev_events & EV_SIGNAL)   //如果是信号事件，添加到信号事件队列return (evsignal_add(ev));fd = ev->ev_fd;     //对应的fd描述符if (fd >= epollop->nfds) {/* Extent the file descriptor array as necessary */if (epoll_recalc(ev->ev_base, epollop, fd) == -1)return (-1);}evep = &epollop->fds[fd];   //索引到该fd的读写操作结构体evepoll结构体op = EPOLL_CTL_ADD;events = 0;if (evep->evread != NULL) {    //读events |= EPOLLIN;op = EPOLL_CTL_MOD;}if (evep->evwrite != NULL) {    //写events |= EPOLLOUT;op = EPOLL_CTL_MOD;}if (ev->ev_events & EV_READ)events |= EPOLLIN;if (ev->ev_events & EV_WRITE)events |= EPOLLOUT;epev.data.fd = fd;epev.events = events;    //组合封装成为一个epoll_event类型，变量名为epevif (epoll_ctl(epollop->epfd, op, ev->ev_fd, &epev) == -1)return (-1);/* Update events responsible */if (ev->ev_events & EV_READ)evep->evread = ev;if (ev->ev_events & EV_WRITE)evep->evwrite = ev;return (0);}

以上就是epoll模式的主要部分，下面给出其他部分的代码，我给上了注释。

static intepoll_recalc(struct event_base *base, void *arg, int max)  //这个base参数在这里没什么用???{struct epollop *epollop = arg;if (max >= epollop->nfds) {     //如果fd最大值大于nfdsstruct evepoll *fds;int nfds;nfds = epollop->nfds;while (nfds <= max)   //nfds以扩大2倍的方式直到满足max需求nfds <<= 1;fds = realloc(epollop->fds, nfds * sizeof(struct evepoll));if (fds == NULL) {event_warn("realloc");return (-1);}epollop->fds = fds;     memset(fds + epollop->nfds, 0,     //fds是evepoll*类型，加上nfds，就是清零数组新分配的部分    (nfds - epollop->nfds) * sizeof(struct evepoll));   //要清空的大小是新recalc后的大小nfds-epollop->nfdsepollop->nfds = nfds;  //更新为新的nfds}return (0);}static intepoll_dispatch(struct event_base *base, void *arg, struct timeval *tv)   //base, evbase, tv_p{struct epollop *epollop = arg;struct epoll_event *events = epollop->events;struct evepoll *evep;int i, res, timeout = -1;if (tv != NULL)timeout = tv->tv_sec * 1000 + (tv->tv_usec + 999) / 1000;//如果tv不为空，设置超时，应该是把超时转化成ms    //因为epoll_wait超时单位是msif (timeout > MAX_EPOLL_TIMEOUT_MSEC) {     //不能大于最大/* Linux kernels can wait forever if the timeout is too big; * see comment on MAX_EPOLL_TIMEOUT_MSEC. */timeout = MAX_EPOLL_TIMEOUT_MSEC;}res = epoll_wait(epollop->epfd, events, epollop->nevents, timeout);   if (res == -1) {if (errno != EINTR) {   //EINTR是信号打断的标志event_warn("epoll_wait");return (-1);}evsignal_process(base); //如果有信号，就处理，由此可以看出libevent将信号事件和I/O事件统一用I/O复用机制来处理了return (0);                         //至于怎么统一的，我后续博客会有分析} else if (base->sig.evsignal_caught) {    //sig.evsignal_caught是是否有信号发生的标记evsignal_process(base);       //这个是正常信号处理，上面那个是EINTR，什么的非正常信号处理}event_debug(("%s: epoll_wait reports %d", __func__, res));for (i = 0; i < res; i++) {       //处理返回的res个活动事件int what = events[i].events;      struct event *evread = NULL, *evwrite = NULL;int fd = events[i].data.fd;   //活动事件描述符if (fd < 0 || fd >= epollop->nfds)    //如果<0或大于最大的继续，为什么有这两种情况???continue;evep = &epollop->fds[fd];   //通过fd索引该事件的读写操作结构体if (what & (EPOLLHUP|EPOLLERR)) {   //描述符挂断或者错误 evread = evep->evread;evwrite = evep->evwrite;} else {if (what & EPOLLIN) {   //可读evread = evep->evread;}if (what & EPOLLOUT) {   //可写evwrite = evep->evwrite;}}if (!(evread||evwrite))//其他时间类型,比如EPOLLPRI(关联的fd有紧急优先事件可以进行读操作了)，一律忽略continue;if (evread != NULL)  event_active(evread, EV_READ, 1);if (evwrite != NULL)event_active(evwrite, EV_WRITE, 1);}//如果所有的事件都被触发了，表明事件数组还是太小了，需要扩展数组的大小if (res == epollop->nevents && epollop->nevents < MAX_NEVENTS) {   //如果epoll时间数目已经到达已设置最大值，扩充为2倍/* We used all of the event space this time.  We should   be ready for more events next time. */int new_nevents = epollop->nevents * 2;struct epoll_event *new_events;new_events = realloc(epollop->events,    new_nevents * sizeof(struct epoll_event));if (new_events) {epollop->events = new_events;epollop->nevents = new_nevents;}}return (0);}static intepoll_del(void *arg, struct event *ev){struct epollop *epollop = arg;struct epoll_event epev = {0, {0}};struct evepoll *evep;int fd, events, op;int needwritedelete = 1, needreaddelete = 1;if (ev->ev_events & EV_SIGNAL)   //删信号事件return (evsignal_del(ev));fd = ev->ev_fd;if (fd >= epollop->nfds)return (0);evep = &epollop->fds[fd];op = EPOLL_CTL_DEL;events = 0;if (ev->ev_events & EV_READ)events |= EPOLLIN;if (ev->ev_events & EV_WRITE)events |= EPOLLOUT;if ((events & (EPOLLIN|EPOLLOUT)) != (EPOLLIN|EPOLLOUT)) {if ((events & EPOLLIN) && evep->evwrite != NULL) {   //如果是EPOLLIN，并且可写事件不为空，准备删除可写属性needwritedelete = 0;events = EPOLLOUT;op = EPOLL_CTL_MOD;} else if ((events & EPOLLOUT) && evep->evread != NULL) { //准备删除可读事件needreaddelete = 0;events = EPOLLIN;op = EPOLL_CTL_MOD;}}epev.events = events;epev.data.fd = fd;if (needreaddelete)evep->evread = NULL;    //删除可读，下同if (needwritedelete)evep->evwrite = NULL;if (epoll_ctl(epollop->epfd, op, fd, &epev) == -1)return (-1);return (0);}static voidepoll_dealloc(struct event_base *base, void *arg){struct epollop *epollop = arg;evsignal_dealloc(base);   //销毁有关信号的一系列东西if (epollop->fds)free(epollop->fds);if (epollop->events)free(epollop->events);if (epollop->epfd >= 0)close(epollop->epfd);memset(epollop, 0, sizeof(struct epollop));free(epollop);}

（FreeeLinux的博客：http://blog.csdn.net/freeelinux/article/details/52812857)