腾讯一面：epoll不支持文件IO，kqueue怎么做到的！

//三板斧api
int epoll_create(int size); 

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);  

int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
                 
result = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);

[vagrant@localhost epoll]$ gcc epoll.c -o epoll
[vagrant@localhost epoll]$ ./epoll
epoll_ctl(): Operation not permitted

     epoll_ctl()调用时检查file_operations->poll函数：  
     if (!tfile->f_op || !tfile->f_op->poll) 
         return -EPERM;  // 普通文件无poll方法，直接报错

const struct file_operations ext4_file_operations = {
.llseek         = generic_file_llseek,
.read           = do_sync_read,
.write          = do_sync_write,
.aio_read       = generic_file_aio_read,
.aio_write      = ext4_file_write,
.unlocked_ioctl = ext4_ioctl,
.mmap           = ext4_file_mmap,
.open           = ext4_file_open,
.release        = ext4_release_file,
.fsync          = ext4_sync_file,
.splice_read    = generic_file_splice_read,
.splice_write   = generic_file_splice_write,

  EVFILT_AIO    Events for this  filter  are  not  registered  with
      kevent()   directly but  are  registered  via  the
      aio_sigevent member of an asynchronous I/O  request
      when it is scheduled via an asynchronous I/O system
      call  such as aio_read().  The filter returns under
      the same conditions as aio_error(). For  more  de-
      tails on this filter see sigevent(3) and aio(4).

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/event.h>
#include <aio.h>
#include <string.h>
#define BUFFER_SIZE 4096
#define AIO_EVENT_ID 12345  // 自定义事件标识符
// 封装 AIO 上下文
struct aio_context {
    struct aiocb aio_cb;    // AIO 控制块
    char buffer[BUFFER_SIZE]; // 数据缓冲区
    void (*handler)(struct aio_context*); // 完成回调函数
};
// AIO 完成回调函数
void aio_completion_handler(struct aio_context *ctx) {
    // 检查 AIO 操作状态
    if (aio_error(&ctx->aio_cb) != 0) {
        perror("aio_error");
        return;
    }
    // 获取实际读取字节数
    ssize_t bytes_read = aio_return(&ctx->aio_cb);
    if (bytes_read <= 0) {
        perror("aio_return");
        return;
    }
    // 处理数据（此处打印内容）
    printf("Read %zd bytes: %.*s\n", bytes_read, (int)bytes_read, ctx->buffer);
}
int main() {
    int kq = kqueue();  // 创建 kqueue 实例
    if (kq == -1) {
        perror("kqueue");
        exit(EXIT_FAILURE);
    }
    // 打开目标文件（非阻塞模式）
    int fd = open("test.txt", O_RDONLY | O_NONBLOCK);
    if (fd == -1) {
        perror("open");
        close(kq);
        exit(EXIT_FAILURE);
    }
    // 初始化 AIO 上下文
    struct aio_context ctx;
    memset(&ctx, 0, sizeof(ctx));
    ctx.handler = aio_completion_handler;
    ctx.aio_cb.aio_fildes = fd;          // 目标文件描述符
    ctx.aio_cb.aio_buf = ctx.buffer;      // 数据缓冲区
    ctx.aio_cb.aio_nbytes = BUFFER_SIZE;   // 缓冲区大小
    ctx.aio_cb.aio_offset = 0;            // 文件偏移量
    // 配置 kqueue 事件通知
    ctx.aio_cb.aio_sigevent.sigev_notify = SIGEV_KEVENT; // 使用 kqueue 通知
    ctx.aio_cb.aio_sigevent.sigev_notify_kqueue = kq;    // 指定 kqueue 实例
    ctx.aio_cb.aio_sigevent.sigev_value.sival_ptr = &ctx; // 传递上下文指针
    ctx.aio_cb.aio_sigevent.sigev_filter = EVFILT_AIO;    // 事件类型为 AIO
    ctx.aio_cb.aio_sigevent.sigev_ident = AIO_EVENT_ID;  // 自定义事件标识符
    // 提交异步读请求
    if (aio_read(&ctx.aio_cb) == -1) {
        perror("aio_read");
        close(fd);
        close(kq);
        exit(EXIT_FAILURE);
    }
    // 监听 kqueue 事件
    struct kevent event;
    struct timespec timeout = { .tv_sec = 5, .tv_nsec = 0 }; // 5秒超时
    while (1) {
        int nev = kevent(kq, NULL, 0, &event, 1, &timeout);
        if (nev == -1) {
            perror("kevent");
            break;
        } else if (nev == 0) {
            printf("Timeout: No events\n");
            break;
        }
        // 检查是否为 EVFILT_AIO 事件
        if (event.filter == EVFILT_AIO && event.ident == AIO_EVENT_ID) {
            struct aio_context *ctx_ptr = (struct aio_context *)event.udata;
            ctx_ptr->handler(ctx_ptr); // 调用回调处理数据
            break;
        }
    }
    // 清理资源
    close(fd);
    close(kq);
    return 0;
}