I/O多路复用：epoll机制详解

int epoll_create(int size);
int epoll_create1(int flags);
/* 返回值：成功返回 epoll 实例文件描述符；出错返回 -1 */

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
/* 返回值：成功返回 0；出错返回 -1 */

typedef union epoll_data {
    void        *ptr;
    int          fd;
    uint32_t     u32;
    uint64_t     u64;
} epoll_data_t;

struct epoll_event {
    uint32_t     events;      /* 事件掩码 */
    epoll_data_t data;        /* 用户数据 */
};

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
/* 返回值：就绪事件数目；超时返回 0；出错返回 -1 */

int epoll_pwait(int epfd, struct epoll_event *events, int maxevents,
                int timeout, const sigset_t *sigmask);
/* Linux 2.6.19+ */

int epoll_pwait2(int epfd, struct epoll_event *events, int maxevents,
                 const struct timespec *timeout, const sigset_t *sigmask);
/* Linux 5.11+ */

/* epoll_pwait2 使用示例：设置 100 毫秒 500 纳秒超时 */
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 100500000;  /* 100.5 ms */
int nready = epoll_pwait2(epfd, events, MAXEVENTS, &ts, NULL);

$ cat /proc/sys/fs/epoll/max_user_watches
8192

fs.epoll.max_user_watches = 100000

# 全局启用 busy poll，设置轮询时间（微秒）
$ echo 50 > /proc/sys/net/core/busy_poll
$ echo 50 > /proc/sys/net/core/busy_read

/* Linux 6.9+ per-socket busy poll 配置 */
struct epoll_event ev;
int epfd = epoll_create1(0);

/* 通过 ioctl 设置 busy poll 参数 */
struct epoll_busy_poll_cfg cfg = {
    .busy_poll_usecs = 50,    /* 轮询时间（微秒） */
    .busy_poll_budget = 64,   /* 每次轮询最大处理包数 */
};
ioctl(epfd, EPOLL_IOC_BUSY_POLL, &cfg);

#include "lib/common.h"

#define MAXEVENTS 128

char rot13_char(char c) {
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

int main(int argc, char **argv) {
    int listen_fd, socket_fd;
    int n, i;
    int efd;
    struct epoll_event event;
    struct epoll_event *events;

    listen_fd = tcp_nonblocking_server_listen(SERV_PORT);

    efd = epoll_create1(0);
    if (efd == -1) {
        error(1, errno, "epoll create failed");
    }

    event.data.fd = listen_fd;
    event.events = EPOLLIN | EPOLLET;
    if (epoll_ctl(efd, EPOLL_CTL_ADD, listen_fd, &event) == -1) {
        error(1, errno, "epoll_ctl add listen fd failed");
    }

    /* 分配返回事件数组 */
    events = calloc(MAXEVENTS, sizeof(event));

    while (1) {
        n = epoll_wait(efd, events, MAXEVENTS, -1);
        printf("epoll_wait wakeup\n");
        for (i = 0; i < n; i++) {
            if ((events[i].events & EPOLLERR) ||
                (events[i].events & EPOLLHUP) ||
                (!(events[i].events & EPOLLIN))) {
                fprintf(stderr, "epoll error\n");
                close(events[i].data.fd);
                continue;
            } else if (listen_fd == events[i].data.fd) {
                struct sockaddr_storage ss;
                socklen_t slen = sizeof(ss);
                int fd = accept(listen_fd, (struct sockaddr *) &ss, &slen);
                if (fd < 0) {
                    error(1, errno, "accept failed");
                } else {
                    make_nonblocking(fd);
                    event.data.fd = fd;
                    event.events = EPOLLIN | EPOLLET; /* 边缘触发 */
                    if (epoll_ctl(efd, EPOLL_CTL_ADD, fd, &event) == -1) {
                        error(1, errno, "epoll_ctl add connection fd failed");
                    }
                }
                continue;
            } else {
                socket_fd = events[i].data.fd;
                printf("get event on socket fd == %d \n", socket_fd);
                while (1) {
                    char buf[512];
                    if ((n = read(socket_fd, buf, sizeof(buf))) < 0) {
                        if (errno != EAGAIN) {
                            error(1, errno, "read error");
                            close(socket_fd);
                        }
                        break;
                    } else if (n == 0) {
                        close(socket_fd);
                        break;
                    } else {
                        for (i = 0; i < n; ++i) {
                            buf[i] = rot13_char(buf[i]);
                        }
                        if (write(socket_fd, buf, n) < 0) {
                            error(1, errno, "write error");
                        }
                    }
                }
            }
        }
    }

    free(events);
    close(listen_fd);
}

$ ./epoll01
epoll_wait wakeup
epoll_wait wakeup
epoll_wait wakeup
get event on socket fd == 6
epoll_wait wakeup
get event on socket fd == 5
...

$ telnet 127.0.0.1 43211
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
fasfsafas
snfsfnsnf
^]
telnet> quit
Connection closed.

$ ./epoll02
epoll_wait wakeup
epoll_wait wakeup
get event on socket fd == 5

$ ./epoll03
epoll_wait wakeup
epoll_wait wakeup
get event on socket fd == 5
epoll_wait wakeup
get event on socket fd == 5
epoll_wait wakeup
get event on socket fd == 5
...

int kqueue(void);
int kevent(int kq, const struct kevent *changelist, int nchanges,
           struct kevent *eventlist, int nevents,
           const struct timespec *timeout);
void EV_SET(struct kevent *kev, uintptr_t ident, short filter,
            u_short flags, u_int fflags, intptr_t data, void *udata);

struct event {
    unsigned long id;    /* file descriptor ID */
    unsigned long event; /* bitmask of active events */
};

int bind_event(int fd, struct event *event);
int get_events(struct event *event_array, int maxnr, struct timeval *tmout);