EPOLL(7)                    Linux Programmer's Manual                    EPOLL(7)
NAME       epoll - I/O event notification facility
SYNOPSIS       #include <sys/epoll.h>
DESCRIPTION       The epoll API performs a similar task to poll(2): monitoring multiple file       descriptors to see if I/O is possible on any of them.  The epoll  API  can       be  used  either  as  an edge-triggered or a level-triggered interface and       scales well to large numbers of watched file descriptors.   The  following       system calls are provided to create and manage an epoll instance:
       *  epoll_create(2) creates an epoll instance and returns a file descriptor          referring to that instance.  (The more recent epoll_create1(2)  extends          the functionality of epoll_create(2).)
       *  Interest   in  particular  file  descriptors  is  then  registered  via          epoll_ctl(2).  The set of file descriptors currently registered  on  an          epoll instance is sometimes called an epoll set.       *  epoll_wait(2)  waits  for I/O events, blocking the calling thread if no          events are currently available.

struct eventpoll {	/*	 * This mutex is used to ensure that files are not removed	 * while epoll is using them. This is held during the event	 * collection loop, the file cleanup path, the epoll file exit	 * code and the ctl operations.	 */	struct mutex mtx;
	/* Wait queue used by sys_epoll_wait() */	wait_queue_head_t wq;
	/* Wait queue used by file->poll() */	wait_queue_head_t poll_wait;
	/* List of ready file descriptors */	struct list_head rdllist;//就绪列表，采用双向链表
	/* RB tree root used to store monitored fd structs */	struct rb_root_cached rbr;//红黑树，保存存活的fd
	/*	 * This is a single linked list that chains all the "struct epitem" that	 * happened while transferring ready events to userspace w/out	 * holding ->wq.lock.	 */	struct epitem *ovflist;
	/* wakeup_source used when ep_scan_ready_list is running */	struct wakeup_source *ws;
	/* The user that created the eventpoll descriptor */	struct user_struct *user;
	struct file *file;
	/* used to optimize loop detection check */	int visited;	struct list_head visited_list_link;
#ifdef CONFIG_NET_RX_BUSY_POLL	/* used to track busy poll napi_id */	unsigned int napi_id;#endif};

aeEventLoop *aeCreateEventLoop(int setsize) {    aeEventLoop *eventLoop;    int i;
    if ((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL) goto err;    eventLoop->events = zmalloc(sizeof(aeFileEvent)*setsize);    eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*setsize);    if (eventLoop->events == NULL || eventLoop->fired == NULL) goto err;    eventLoop->setsize = setsize;    eventLoop->lastTime = time(NULL);    eventLoop->timeEventHead = NULL;    eventLoop->timeEventNextId = 0;    eventLoop->stop = 0;    eventLoop->maxfd = -1;    eventLoop->beforesleep = NULL;    eventLoop->aftersleep = NULL;    eventLoop->flags = 0;    if (aeApiCreate(eventLoop) == -1) goto err;    /* Events with mask == AE_NONE are not set. So let's initialize the     * vector with it. */    for (i = 0; i < setsize; i++)        eventLoop->events[i].mask = AE_NONE;    return eventLoop;
err:    if (eventLoop) {        zfree(eventLoop->events);        zfree(eventLoop->fired);        zfree(eventLoop);    }    return NULL;}

static int aeApiCreate(aeEventLoop *eventLoop) {    aeApiState *state = zmalloc(sizeof(aeApiState));
    if (!state) return -1;    state->events = zmalloc(sizeof(struct epoll_event)*eventLoop->setsize);    if (!state->events) {        zfree(state);        return -1;    }    state->epfd = epoll_create(1024); /* 1024 is just a hint for the kernel */    if (state->epfd == -1) {        zfree(state->events);        zfree(state);        return -1;    }    eventLoop->apidata = state;    return 0;}

/* File event structure */typedef struct aeFileEvent {    int mask; /* one of AE_(READABLE|WRITABLE|BARRIER) */    aeFileProc *rfileProc;//读    aeFileProc *wfileProc;//写    void *clientData;} aeFileEvent;

static int aeApiAddEvent(aeEventLoop *eventLoop, int fd, int mask) {    aeApiState *state = eventLoop->apidata;    struct epoll_event ee = {0}; /* avoid valgrind warning */    /* If the fd was already monitored for some event, we need a MOD     * operation. Otherwise we need an ADD operation. */    int op = eventLoop->events[fd].mask == AE_NONE ?            EPOLL_CTL_ADD : EPOLL_CTL_MOD;
    ee.events = 0;    mask |= eventLoop->events[fd].mask; /* Merge old events */    if (mask & AE_READABLE) ee.events |= EPOLLIN;    if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;    ee.data.fd = fd;    if (epoll_ctl(state->epfd,op,fd,&ee) == -1) return -1;    return 0;}

void aeMain(aeEventLoop *eventLoop) {    eventLoop->stop = 0;    while (!eventLoop->stop) {        if (eventLoop->beforesleep != NULL)            eventLoop->beforesleep(eventLoop);        aeProcessEvents(eventLoop, AE_ALL_EVENTS|AE_CALL_AFTER_SLEEP);    }}

static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {    aeApiState *state = eventLoop->apidata;    int retval, numevents = 0;
    retval = epoll_wait(state->epfd,state->events,eventLoop->setsize,            tvp ? (tvp->tv_sec*1000 + tvp->tv_usec/1000) : -1);    if (retval > 0) {        int j;
        numevents = retval;        for (j = 0; j < numevents; j++) {            int mask = 0;            struct epoll_event *e = state->events+j;
            if (e->events & EPOLLIN) mask |= AE_READABLE;            if (e->events & EPOLLOUT) mask |= AE_WRITABLE;            if (e->events & EPOLLERR) mask |= AE_WRITABLE|AE_READABLE;            if (e->events & EPOLLHUP) mask |= AE_WRITABLE|AE_READABLE;            eventLoop->fired[j].fd = e->data.fd;            eventLoop->fired[j].mask = mask;        }    }    return numevents;}