// 核心数据结构定义（简化版）
struct eventpoll {
    spinlock_t lock;        // 自旋锁，保护并发访问
    struct mutex mtx;       // 互斥锁
    wait_queue_head_t wq;   // 等待队列，epoll_wait 使用
    wait_queue_head_t poll_wait;  // poll 等待队列
    struct list_head rdllist;      // 就绪描述符链表
    struct rb_root rbr;           // 红黑树根节点
    struct epitem *ovflist;        // 就绪事件临时链表
};

struct epitem {
    struct rb_node rbn;           // 红黑树节点
    struct list_head rdllink;     // 就绪链表节点
    struct epoll_filefd ffd;      // 文件描述符信息
    struct eventpoll *ep;         // 指向所属 eventpoll
    struct epoll_event event;     // 用户设置的事件
};

struct epoll_event {
    __u32 events;    // 事件类型掩码
    __u64 data;      // 用户数据
};

// epoll_create 核心逻辑
SYSCALL_DEFINE1(epoll_create, int, size)
{
    if (size < 0)
        return -EINVAL;
    return epoll_create1(0);
}

// 实际的创建函数
static int ep_alloc(struct eventpoll **pep)
{
    struct eventpoll *ep;

    // 分配 eventpoll 结构
    ep = kzalloc(sizeof(*ep), GFP_KERNEL);
    if (!ep)
        return -ENOMEM;

    // 初始化各个组件
    spin_lock_init(&ep->lock);
    mutex_init(&ep->mtx);
    init_waitqueue_head(&ep->wq);
    init_waitqueue_head(&ep->poll_wait);
    INIT_LIST_HEAD(&ep->rdllist);
    ep->rbr = RB_ROOT;

    *pep = ep;
    return 0;
}

// epoll_ctl 核心操作
SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd, struct epoll_event __user *, event)
{
    struct eventpoll *ep;
    struct epitem *epi;
    struct epoll_event epds;

    // 参数检查和拷贝
    if (ep_op_has_event(op) && copy_from_user(&epds, event, sizeof(epds)))
        return -EFAULT;

    // 获取 epoll 实例
    ep = fget(epfd);
    if (!ep)
        return -EBADF;

    switch (op) {
        case EPOLL_CTL_ADD:
            // 添加到红黑树
            ep_insert(ep, &epds, fd, full_check);
            break;
        case EPOLL_CTL_MOD:
            // 修改事件
            ep_modify(ep, epi, &epds);
            break;
        case EPOLL_CTL_DEL:
            // 从红黑树删除
            ep_remove(ep, epi);
            break;
    }
    return error;
}

// 关键的回调函数
static int ep_poll_callback(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
{
    struct epitem *epi = ep_item_from_wait(wait);
    struct eventpoll *ep = epi->ep;

    // 将就绪事件添加到就绪链表
    if (!ep_is_linked(epi)) {
        list_add_tail(&epi->rdllink, &ep->rdllist);
    }

    // 唤醒等待的进程
    if (waitqueue_active(&ep->wq))
        wake_up_locked(&ep->wq);

    return 1;
}

#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define MAX_EVENTS 64
#define BUFFER_SIZE 1024

int main() {
    int server_fd, epoll_fd, nfds;
    struct sockaddr_in addr;
    struct epoll_event ev, events[MAX_EVENTS];
    char buffer[BUFFER_SIZE];

    // 创建服务器socket
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(8080);
    bind(server_fd, (struct sockaddr*)&addr, sizeof(addr));
    listen(server_fd, SOMAXCONN);

    // 创建epoll实例
    epoll_fd = epoll_create1(0);

    // 添加服务器socket到epoll
    ev.events = EPOLLIN;
    ev.data.fd = server_fd;
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev);

    printf("Server started on port 8080...\n");

    while (1) {
        // 等待事件
        nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);

        for (int i = 0; i < nfds; i++) {
            if (events[i].data.fd == server_fd) {
                // 接受新连接
                int client_fd = accept(server_fd, NULL, NULL);

                // 边缘触发模式必须搭配非阻塞 socket，否则读取循环会阻塞
                int flags = fcntl(client_fd, F_GETFL, 0);
                fcntl(client_fd, F_SETFL, flags | O_NONBLOCK);

                ev.events = EPOLLIN | EPOLLET; // 边缘触发
                ev.data.fd = client_fd;
                epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &ev);
                printf("New client connected: %d\n", client_fd);
            } else {
                // 处理客户端数据
                int client_fd = events[i].data.fd;
                ssize_t count;

                // 边缘触发模式下必须读取所有数据
                while ((count = read(client_fd, buffer, BUFFER_SIZE)) > 0) {
                    printf("Received %zd bytes from client %d: %.*s\n",
                           count, client_fd, (int)count, buffer);
                    // 回显数据
                    write(client_fd, buffer, count);
                }

                if (count == 0 || (count == -1 && errno != EAGAIN)) {
                    // 客户端断开连接
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
                    close(client_fd);
                    printf("Client %d disconnected\n", client_fd);
                }
            }
        }
    }

    close(epoll_fd);
    close(server_fd);
    return 0;
}

// 高级epoll事件循环框架
struct epoll_loop {
    int epoll_fd;
    int max_events;
    struct epoll_event *events;
    int running;
};

struct epoll_loop *epoll_loop_create(int max_events) {
    struct epoll_loop *loop = malloc(sizeof(*loop));
    loop->epoll_fd = epoll_create1(0);
    loop->max_events = max_events;
    loop->events = malloc(sizeof(struct epoll_event) * max_events);
    loop->running = 1;
    return loop;
}

void epoll_loop_add_fd(struct epoll_loop *loop, int fd, uint32_t events, void *user_data) {
    struct epoll_event ev;
    ev.events = events;
    ev.data.ptr = user_data; // 使用ptr传递更多数据
    if (epoll_ctl(loop->epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
        perror("epoll_ctl add");
    }
}

void epoll_loop_run(struct epoll_loop *loop) {
    while (loop->running) {
        int nfds = epoll_wait(loop->epoll_fd, loop->events, loop->max_events, -1);
        for (int i = 0; i < nfds; i++) {
            struct epoll_event *ev = &loop->events[i];

            // 根据事件类型分发给不同的处理器
            if (ev->events & EPOLLIN) {
                // 处理读事件
                handle_read_event(ev->data.ptr);
            }
            if (ev->events & EPOLLOUT) {
                // 处理写事件
                handle_write_event(ev->data.ptr);
            }
            if (ev->events & (EPOLLERR | EPOLLHUP)) {
                // 处理错误事件
                handle_error_event(ev->data.ptr);
            }
        }
    }
}

# 查看进程打开的epoll实例
lsof -p <PID> | grep epoll

# 监控epoll相关系统调用
strace -e epoll_create,epoll_ctl,epoll_wait ./server

# 查看文件描述符状态
cat /proc/<PID>/fdinfo/<FD>

# 性能分析
perf record -e syscalls:sys_enter_epoll* ./server
perf report

// epoll 调试工具函数
void debug_epoll_event(struct epoll_event *ev) {
    printf("Event: ");
    if (ev->events & EPOLLIN) printf("IN ");
    if (ev->events & EPOLLOUT) printf("OUT ");
    if (ev->events & EPOLLERR) printf("ERR ");
    if (ev->events & EPOLLHUP) printf("HUP ");
    if (ev->events & EPOLLRDHUP) printf("RDHUP ");
    if (ev->events & EPOLLET) printf("ET ");
    printf("| Data: %d\n", ev->data.fd);
}

// 检查epoll操作错误
int safe_epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev) {
    int ret = epoll_ctl(epfd, op, fd, ev);
    if (ret == -1) {
        fprintf(stderr, "epoll_ctl failed: %s (op=%d, fd=%d)\n",
                strerror(errno), op, fd);
    }
    return ret;
}