Epoll and IO Multiplexing

/** epoll_create
 *  Creates an epoll instance and returns a file descriptor for it.
 *  Needs to be closed afterward, as epfd also consumes the system's fd resources.
 *  size: Indicates the number of file descriptors to be monitored by epfd.
 */
int epoll_create(int size);

/** epoll_ctl
 *  Adds or modifies a file descriptor to be monitored by epoll.
 *  epfd: The epoll file descriptor.
 *  op: Operation type.
 *       EPOLL_CTL_ADD: Add a new fd to epfd.
 *       EPOLL_CTL_MOD: Modify an already registered fd.
 *       EPOLL_CTL_DEL: Remove an fd from epfd.
 *  fd: The file descriptor to be monitored.
 *  event: Specifies the type of event to be monitored.
 *         EPOLLIN: Indicates the fd is ready for reading (including when the peer socket is closed).
 *         EPOLLOUT: Indicates the fd is ready for writing.
 *         EPOLLPRI: Indicates urgent data can be read.
 *         EPOLLERR: Indicates an error occurred on the fd.
 *         EPOLLHUP: Indicates the fd has been hung up.
 *         EPOLLET: Sets epoll to Edge Triggered (ET) mode, as opposed to Level Triggered (LT).
 *         EPOLLONESHOT: Only listen for the event once. If continued monitoring is required, the socket must be re-added to epfd.
 */
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

/** epoll_wait
 *  Collects events that have been triggered and returns the number of triggered events.
 *  epfd: The epoll file descriptor.
 *  events: Array of epoll events that will be populated with triggered events.
 *  maxevents: Indicates the size of the events array.
 *  timeout: Timeout duration; 0 returns immediately, -1 blocks indefinitely, >0 waits for the specified duration.
 */
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

struct eventpoll {
    spinlock_t lock;
    struct mutex mtx;
    wait_queue_head_t wq;
    wait_queue_head_t poll_wait;
    struct list_head rdllist;
    struct rb_root rbr;
    struct epitem *ovflist;
    struct user_struct *user;
    struct file *file;
    int visited;
    struct list_head visited_list_link;
};

struct epitem {
    struct rb_node rbn;
    struct list_head rdllink;
    struct epitem *next;
    struct epoll_filefd ffd;
    int nwait;
    struct list_head pwqlist;
    struct eventpoll *ep;
    struct list_head fllink;
    struct epoll_event event;
};

for (;;) {  
    nfds = epoll_wait(epfd, events, 20, 500);  
    for (i = 0; i < nfds; ++i) {  
        if (events[i].data.fd == listenfd) {  
            connfd = accept(listenfd, (sockaddr *)&clientaddr, &clilen);  
            ev.data.fd = connfd;  
            ev.events = EPOLLIN | EPOLLET;  
            epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);  
        }  
        else if (events[i].events & EPOLLIN) {  
            n = read(sockfd, line, MAXLINE);
            ev.data.ptr = md;  
            ev.events = EPOLLOUT | EPOLLET;  
            epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);  
        }  
        else if (events[i].events & EPOLLOUT) {  
            struct myepoll_data *md = (myepoll_data *)events[i].data.ptr;  
            sockfd = md->fd;  
            send(sockfd, md->ptr, strlen((char *)md->ptr), 0);  
            ev.data.fd = sockfd;  
            ev.events = EPOLLIN | EPOLLET;  
            epoll_ctl(epfd, EPOLL_CTL_MOD, sockfd, &ev);  
        }  
        else {  
            // Other processing  
        }  
    }  
}