#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

#define BUFFER_SIZE 1024

int main() {
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    char buffer[BUFFER_SIZE];
    ssize_t bytes_read = read(fd, buffer, BUFFER_SIZE);
    if (bytes_read == -1) {
        perror("read");
        close(fd);
        return 1;
    }

    printf("Read %zd bytes: %.*s\n", bytes_read, (int)bytes_read, buffer);
    close(fd);
    return 0;
}

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

#define BUFFER_SIZE 1024

int main() {
    int fd = open("example.txt", O_RDONLY | O_NONBLOCK);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    char buffer[BUFFER_SIZE];
    while (1) {
        ssize_t bytes_read = read(fd, buffer, BUFFER_SIZE);
        if (bytes_read == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                // 數(shù)據(jù)未準備好，繼續(xù)執(zhí)行其他任務或再次輪詢
                usleep(1000); // 稍微等待一下再輪詢
                continue;
            } else {
                perror("read");
                close(fd);
                return 1;
            }
        }
        break;
    }

    printf("Read %zd bytes: %.*s\n", bytes_read, (int)bytes_read, buffer);
    close(fd);
    return 0;
}

#include <stdio.h>
#include <sys/select.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>

#define BUFFER_SIZE 1024
#define FD_SETSIZE 1024

int main() {
    int fd1 = open("file1.txt", O_RDONLY | O_NONBLOCK);
    int fd2 = open("file2.txt", O_RDONLY | O_NONBLOCK);
    if (fd1 == -1 || fd2 == -1) {
        perror("open");
        return 1;
    }

    fd_set read_fds;
    FD_ZERO(&read_fds);
    FD_SET(fd1, &read_fds);
    FD_SET(fd2, &read_fds);

    int max_fd = (fd1 > fd2)? fd1 : fd2;
    int ret = select(max_fd + 1, &read_fds, NULL, NULL, NULL);
    if (ret == -1) {
        perror("select");
        close(fd1);
        close(fd2);
        return 1;
    } else if (ret > 0) {
        char buffer[BUFFER_SIZE];
        if (FD_ISSET(fd1, &read_fds)) {
            ssize_t bytes_read = read(fd1, buffer, BUFFER_SIZE);
            if (bytes_read == -1) {
                perror("read fd1");
            } else {
                printf("Read from fd1: %.*s\n", (int)bytes_read, buffer);
            }
        }
        if (FD_ISSET(fd2, &read_fds)) {
            ssize_t bytes_read = read(fd2, buffer, BUFFER_SIZE);
            if (bytes_read == -1) {
                perror("read fd2");
            } else {
                printf("Read from fd2: %.*s\n", (int)bytes_read, buffer);
            }
        }
    }

    close(fd1);
    close(fd2);
    return 0;
}

struct io_uring_sqe {
    __u8 opcode;       // 操作類型，如 READ, WRITE, ACCEPT…
    __u8 flags;
    __u16 ioprio;
    __s32 fd;
    __u64 offset;
    __u64 addr;        // 用戶緩沖區(qū)地址
    __u32 len;
    __u64 user_data;   // 用戶自定義數(shù)據(jù)（回調(diào)、標識等）
};

struct io_uring_cqe {
    __u64 user_data; // 與 SQE 中設置的一致
    __s32 res;       // 返回值：成功時為字節(jié)數(shù)，失敗時為 -errno
    __u32 flags;
};

SYSCALL_DEFINE2(io_uring_setup, u32, entries,
                struct io_uring_params __user *, params)                                                                                                                                                           
{
        return io_uring_setup(entries, params);
}

SYSCALL_DEFINE6(io_uring_enter, unsigned int, fd, u32, to_submit,                                                                                                                                                  
                u32, min_complete, u32, flags, const void __user *, argp,
                size_t, argsz)

SYSCALL_DEFINE4(io_uring_register, unsigned int, fd, unsigned int, opcode,
                void __user *, arg, unsigned int, nr_args)

#include <liburing.h>

struct io_uring ring;
struct io_uring_params params;
int ret = io_uring_queue_init_params(ENTRIES, &ring, ?ms);
if (ret < 0) {
    // 初始化失敗處理
}

struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
if (!sqe) {
    // 獲取SQE失敗處理
}
io_uring_prep_read(sqe, fd, buffer, size, offset);

int ret = io_uring_submit(&ring);
if (ret < 0) {
    // 提交請求失敗處理
}

struct io_uring_cqe *cqe;
ret = io_uring_wait_cqe(&ring, &cqe);
if (ret < 0) {
    // 等待CQE失敗處理
}
if (cqe->res >= 0) {
    // 處理成功的結果
} else {
    // 處理失敗的結果
}
io_uring_cqe_seen(&ring, cqe);

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <liburing.h>

#define PORT 8080
#define BUFFER_SIZE 1024
#define QUEUE_DEPTH 1024

// 存儲請求上下文
struct request {
    int fd;
    struct sockaddr_in client_addr;
    socklen_t client_len;
    char buffer[BUFFER_SIZE];
};

int main() {
    int server_fd;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);

    // 創(chuàng)建服務器套接字
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 設置套接字選項
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 綁定套接字到端口
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    // 開始監(jiān)聽
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    // 初始化io_uring
    struct io_uring ring;
    if (io_uring_queue_init(QUEUE_DEPTH, &ring, 0) < 0) {
        perror("io_uring_queue_init");
        exit(EXIT_FAILURE);
    }

    // 分配請求上下文
    struct request *reqs = malloc(sizeof(struct request) * QUEUE_DEPTH);
    if (!reqs) {
        perror("malloc failed");
        exit(EXIT_FAILURE);
    }

    // 準備接受連接的請求
    struct request *accept_req = &reqs[0];
    accept_req->fd = server_fd;
    accept_req->client_len = sizeof(accept_req->client_addr);

    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_accept(sqe, server_fd, 
                         (struct sockaddr *)&accept_req->client_addr,
                         &accept_req->client_len, 0);
    io_uring_sqe_set_data(sqe, accept_req);

    io_uring_submit(&ring);
    printf("Server listening on port %d...\n", PORT);

    while (1) {
        struct io_uring_cqe *cqe;

        // 等待完成事件
        int ret = io_uring_wait_cqe(&ring, &cqe);
        if (ret < 0) {
            perror("io_uring_wait_cqe");
            break;
        }

        struct request *req = io_uring_cqe_get_data(cqe);
        int res = cqe->res;

        // 處理完成事件
        if (req->fd == server_fd) {
            // 新連接建立
            if (res < 0) {
                fprintf(stderr, "Accept error: %d\n", res);
            } else {
                int client_fd = res;
                printf("New connection: %d\n", client_fd);

                // 準備讀取請求
                struct request *read_req = &reqs[client_fd % QUEUE_DEPTH];
                read_req->fd = client_fd;

                struct io_uring_sqe *read_sqe = io_uring_get_sqe(&ring);
                io_uring_prep_recv(read_sqe, client_fd, read_req->buffer, 
                                  BUFFER_SIZE, 0);
                io_uring_sqe_set_data(read_sqe, read_req);

                // 再次提交接受請求
                struct request *new_accept_req = &reqs[(client_fd + 1) % QUEUE_DEPTH];
                new_accept_req->fd = server_fd;
                new_accept_req->client_len = sizeof(new_accept_req->client_addr);

                struct io_uring_sqe *accept_sqe = io_uring_get_sqe(&ring);
                io_uring_prep_accept(accept_sqe, server_fd,
                                    (struct sockaddr *)&new_accept_req->client_addr,
                                    &new_accept_req->client_len, 0);
                io_uring_sqe_set_data(accept_sqe, new_accept_req);

                io_uring_submit(&ring);
            }
        } else if (res > 0) {
            // 讀取到數(shù)據(jù)，準備響應
            printf("Received %d bytes from %d: %s\n", res, req->fd, req->buffer);

            // 準備響應內(nèi)容
            const char *response = "HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World!";

            struct io_uring_sqe *write_sqe = io_uring_get_sqe(&ring);
            io_uring_prep_send(write_sqe, req->fd, response, strlen(response), 0);
            io_uring_sqe_set_data(write_sqe, req);

            io_uring_submit(&ring);
        } else {
            // 關閉連接
            printf("Closing connection: %d\n", req->fd);
            close(req->fd);
        }

        io_uring_cqe_seen(&ring, cqe);
    }

    // 清理資源
    free(reqs);
    io_uring_queue_exit(&ring);
    close(server_fd);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <liburing.h>
#include <errno.h>

#define QUEUE_DEPTH 256
#define BLOCK_SIZE 4096
#define LOG_ENTRY_SIZE 512
#define MAX_TRANSACTIONS 100

// 數(shù)據(jù)庫操作類型
typedef enum {
    OP_READ,
    OP_WRITE,
    OP_LOG
} OpType;

// 數(shù)據(jù)庫操作請求
struct db_request {
    OpType type;          // 操作類型
    int fd;               // 文件描述符
    off_t offset;         // 操作偏移量
    size_t size;          // 數(shù)據(jù)大小
    char *buffer;         // 數(shù)據(jù)緩沖區(qū)
    char *log_entry;      // 日志條目
    int transaction_id;   // 事務ID
};

// 初始化io_uring
int init_io_uring(struct io_uring *ring) {
    int ret = io_uring_queue_init(QUEUE_DEPTH, ring, 0);
    if (ret < 0) {
        fprintf(stderr, "io_uring初始化失敗: %s\n", strerror(-ret));
        return -1;
    }
    return 0;
}

// 提交數(shù)據(jù)庫讀請求
void submit_read_request(struct io_uring *ring, struct db_request *req) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "無法獲取SQE\n");
        return;
    }

    io_uring_prep_read(sqe, req->fd, req->buffer, req->size, req->offset);
    io_uring_sqe_set_data(sqe, req);
}

// 提交數(shù)據(jù)庫寫請求
void submit_write_request(struct io_uring *ring, struct db_request *req) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "無法獲取SQE\n");
        return;
    }

    io_uring_prep_write(sqe, req->fd, req->buffer, req->size, req->offset);
    io_uring_sqe_set_data(sqe, req);
}

// 提交日志寫入請求
void submit_log_request(struct io_uring *ring, struct db_request *req) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "無法獲取SQE\n");
        return;
    }

    // 日志通常追加到文件末尾
    io_uring_prep_write(sqe, req->fd, req->log_entry, LOG_ENTRY_SIZE, -1);
    io_uring_sqe_set_data(sqe, req);
}

// 處理完成的I/O請求
void handle_completion(struct io_uring *ring, struct io_uring_cqe *cqe) {
    struct db_request *req = io_uring_cqe_get_data(cqe);
    int res = cqe->res;

    if (res < 0) {
        fprintf(stderr, "操作失敗 (類型: %d, 事務: %d): %s\n", 
                req->type, req->transaction_id, strerror(-res));
    } else {
        switch (req->type) {
            case OP_READ:
                printf("讀取完成 - 事務: %d, 大小: %d bytes\n", 
                       req->transaction_id, res);
                break;
            case OP_WRITE:
                printf("寫入完成 - 事務: %d, 大小: %d bytes\n", 
                       req->transaction_id, res);
                break;
            case OP_LOG:
                printf("日志完成 - 事務: %d, 大小: %d bytes\n", 
                       req->transaction_id, res);
                break;
        }
    }

    // 釋放緩沖區(qū)
    if (req->buffer) free(req->buffer);
    if (req->log_entry) free(req->log_entry);
    free(req);
}

// 處理事務 - 包含數(shù)據(jù)讀寫和日志記錄
void process_transaction(struct io_uring *ring, int db_fd, int log_fd, int tx_id) {
    // 分配事務所需的請求結構
    struct db_request *read_req = malloc(sizeof(struct db_request));
    struct db_request *write_req = malloc(sizeof(struct db_request));
    struct db_request *log_req = malloc(sizeof(struct db_request));

    // 初始化讀請求
    read_req->type = OP_READ;
    read_req->fd = db_fd;
    read_req->offset = (tx_id % 100) * BLOCK_SIZE;  // 模擬不同數(shù)據(jù)塊
    read_req->size = BLOCK_SIZE;
    read_req->buffer = malloc(BLOCK_SIZE);
    read_req->log_entry = NULL;
    read_req->transaction_id = tx_id;

    // 初始化寫請求
    write_req->type = OP_WRITE;
    write_req->fd = db_fd;
    write_req->offset = (tx_id % 100) * BLOCK_SIZE;
    write_req->size = BLOCK_SIZE;
    write_req->buffer = malloc(BLOCK_SIZE);
    snprintf(write_req->buffer, BLOCK_SIZE, "事務 %d 的數(shù)據(jù)", tx_id);
    write_req->log_entry = NULL;
    write_req->transaction_id = tx_id;

    // 初始化日志請求
    log_req->type = OP_LOG;
    log_req->fd = log_fd;
    log_req->offset = 0;  // 會被忽略，使用追加模式
    log_req->size = LOG_ENTRY_SIZE;
    log_req->buffer = NULL;
    log_req->log_entry = malloc(LOG_ENTRY_SIZE);
    snprintf(log_req->log_entry, LOG_ENTRY_SIZE, 
             "事務 %d 已提交 - 操作日志", tx_id);
    log_req->transaction_id = tx_id;

    // 提交請求到io_uring
    submit_read_request(ring, read_req);
    submit_write_request(ring, write_req);
    submit_log_request(ring, log_req);
}

int main() {
    struct io_uring ring;
    int db_fd, log_fd;
    int i;

    // 初始化io_uring
    if (init_io_uring(&ring) < 0) {
        return 1;
    }

    // 打開數(shù)據(jù)庫文件和日志文件
    db_fd = open("database.dat", O_RDWR | O_CREAT, 0644);
    log_fd = open("transaction.log", O_WRONLY | O_CREAT | O_APPEND, 0644);

    if (db_fd < 0 || log_fd < 0) {
        perror("文件打開失敗");
        return 1;
    }

    printf("開始處理 %d 個事務...\n", MAX_TRANSACTIONS);

    // 提交一批事務處理請求
    for (i = 0; i < MAX_TRANSACTIONS; i++) {
        process_transaction(&ring, db_fd, log_fd, i);

        // 每提交QUEUE_DEPTH個請求就提交一次
        if ((i + 1) % QUEUE_DEPTH == 0 || i == MAX_TRANSACTIONS - 1) {
            io_uring_submit(&ring);
        }
    }

    // 處理所有完成的請求
    for (i = 0; i < MAX_TRANSACTIONS * 3; i++) {  // 每個事務有3個操作
        struct io_uring_cqe *cqe;
        int ret = io_uring_wait_cqe(&ring, &cqe);

        if (ret < 0) {
            fprintf(stderr, "等待完成事件失敗: %s\n", strerror(-ret));
            break;
        }

        handle_completion(&ring, cqe);
        io_uring_cqe_seen(&ring, cqe);
    }

    printf("所有事務處理完成\n");

    // 清理資源
    close(db_fd);
    close(log_fd);
    io_uring_queue_exit(&ring);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <liburing.h>
#include <errno.h>
#include <sys/stat.h>

#define QUEUE_DEPTH 128
#define BLOCK_SIZE 1024*1024  // 1MB塊大小，適合大文件傳輸
#define MAX_FILES 10         // 同時處理的最大文件數(shù)量

// 傳輸請求結構
struct transfer_request {
    int src_fd;               // 源文件描述符
    int dest_fd;              // 目標文件描述符
    off_t offset;             // 當前傳輸偏移量
    size_t remaining;         // 剩余傳輸大小
    char *buffer;             // 數(shù)據(jù)緩沖區(qū)
    struct iovec iov;         // 用于零拷貝的iovec結構
    char filename[256];       // 文件名，用于日志
};

// 初始化io_uring
int init_uring(struct io_uring *ring) {
    int ret = io_uring_queue_init(QUEUE_DEPTH, ring, IORING_SETUP_IOPOLL);
    if (ret < 0) {
        fprintf(stderr, "io_uring初始化失敗: %s\n", strerror(-ret));
        return -1;
    }
    return 0;
}

// 獲取文件大小
off_t get_file_size(int fd) {
    struct stat st;
    if (fstat(fd, &st) < 0) {
        perror("獲取文件大小失敗");
        return -1;
    }
    return st.st_size;
}

// 提交讀請求
void submit_read_request(struct io_uring *ring, struct transfer_request *req) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "無法獲取SQE\n");
        return;
    }

    size_t read_size = req->remaining < BLOCK_SIZE ? req->remaining : BLOCK_SIZE;

    // 準備讀取請求
    io_uring_prep_readv(sqe, req->src_fd, &req->iov, 1, req->offset);
    req->iov.iov_len = read_size;
    io_uring_sqe_set_data(sqe, req);
}

// 提交寫請求
void submit_write_request(struct io_uring *ring, struct transfer_request *req) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "無法獲取SQE\n");
        return;
    }

    // 準備寫入請求，使用從讀取操作得到的數(shù)據(jù)
    io_uring_prep_writev(sqe, req->dest_fd, &req->iov, 1, req->offset);
    io_uring_sqe_set_data(sqe, req);
}

// 處理完成的請求
void handle_completion(struct io_uring *ring, struct io_uring_cqe *cqe) {
    struct transfer_request *req = io_uring_cqe_get_data(cqe);
    int res = cqe->res;

    if (res < 0) {
        fprintf(stderr, "文件 %s 操作失敗: %s\n", req->filename, strerror(-res));
        return;
    } else if (res == 0) {
        // 讀取完成（EOF）
        printf("文件 %s 傳輸完成\n", req->filename);
        close(req->src_fd);
        close(req->dest_fd);
        free(req->buffer);
        free(req);
        return;
    }

    // 根據(jù)當前偏移量判斷是讀完成還是寫完成
    if (req->offset == 0 || req->remaining + res == req->iov.iov_len) {
        // 讀操作完成，提交寫操作
        submit_write_request(ring, req);
    } else {
        // 寫操作完成，更新偏移量并繼續(xù)讀取
        req->offset += res;
        req->remaining -= res;

        if (req->remaining > 0) {
            submit_read_request(ring, req);
        } else {
            printf("文件 %s 傳輸完成\n", req->filename);
            close(req->src_fd);
            close(req->dest_fd);
            free(req->buffer);
            free(req);
        }
    }
}

// 初始化文件傳輸請求
int init_transfer_request(const char *src_path, const char *dest_path, 
                         struct io_uring *ring) {
    // 打開源文件和目標文件
    int src_fd = open(src_path, O_RDONLY);
    int dest_fd = open(dest_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);

    if (src_fd < 0 || dest_fd < 0) {
        perror("文件打開失敗");
        if (src_fd >= 0) close(src_fd);
        if (dest_fd >= 0) close(dest_fd);
        return -1;
    }

    // 獲取文件大小
    off_t file_size = get_file_size(src_fd);
    if (file_size < 0) {
        close(src_fd);
        close(dest_fd);
        return -1;
    }

    // 分配請求結構和緩沖區(qū)
    struct transfer_request *req = malloc(sizeof(struct transfer_request));
    if (!req) {
        perror("內(nèi)存分配失敗");
        close(src_fd);
        close(dest_fd);
        return -1;
    }

    req->buffer = malloc(BLOCK_SIZE);
    if (!req->buffer) {
        perror("緩沖區(qū)分配失敗");
        free(req);
        close(src_fd);
        close(dest_fd);
        return -1;
    }

    // 初始化請求結構
    strncpy(req->filename, src_path, sizeof(req->filename)-1);
    req->src_fd = src_fd;
    req->dest_fd = dest_fd;
    req->offset = 0;
    req->remaining = file_size;
    req->iov.iov_base = req->buffer;
    req->iov.iov_len = BLOCK_SIZE;

    // 提交初始讀請求
    submit_read_request(ring, req);
    printf("開始傳輸文件: %s (大小: %ld bytes)\n", src_path, file_size);

    return 0;
}

int main(int argc, char *argv[]) {
    if (argc < 3 || argc % 2 != 1) {
        fprintf(stderr, "用法: %s <源文件1> <目標文件1> [<源文件2> <目標文件2> ...]\n", argv[0]);
        return 1;
    }

    int num_files = (argc - 1) / 2;
    if (num_files > MAX_FILES) {
        fprintf(stderr, "最大支持同時傳輸 %d 個文件\n", MAX_FILES);
        return 1;
    }

    struct io_uring ring;
    if (init_uring(&ring) < 0) {
        return 1;
    }

    // 初始化所有文件傳輸請求
    for (int i = 0; i < num_files; i++) {
        const char *src = argv[1 + i*2];
        const char *dest = argv[2 + i*2];
        if (init_transfer_request(src, dest, &ring) < 0) {
            fprintf(stderr, "初始化文件傳輸失敗: %s -> %s\n", src, dest);
        }
    }

    // 提交所有請求
    io_uring_submit(&ring);

    // 處理所有完成的I/O操作
    int completed = 0;
    while (completed < num_files) {
        struct io_uring_cqe *cqe;
        int ret = io_uring_wait_cqe(&ring, &cqe);

        if (ret < 0) {
            fprintf(stderr, "等待完成事件失敗: %s\n", strerror(-ret));
            break;
        }

        handle_completion(&ring, cqe);
        io_uring_cqe_seen(&ring, cqe);
        completed++;
    }

    printf("所有文件傳輸操作已處理\n");

    // 清理資源
    io_uring_queue_exit(&ring);
    return 0;
}

gcc file_transfer_uring.c -o file_transfer_uring -luring

./file_transfer_uring 源文件1 目標文件1 源文件2 目標文件2 ...

uname -r

sudo apt update
sudo apt install linux-image-generic

sudo apt install build-essential libssl-dev

sudo yum groupinstall "Development Tools"
sudo yum install openssl-devel

git clone https://git.kernel.dk/liburing
cd liburing

./configure --cc=gcc --cxx=g++
make -j$(nproc)

sudo make install

#include <liburing.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define QUEUE_DEPTH 1
#define BUFFER_SIZE 4096

int main() {
    struct io_uring ring;
    struct io_uring_cqe *cqe;
    struct io_uring_sqe *sqe;
    int ret, fd;
    char buffer[BUFFER_SIZE];

    // 打開文件
    fd = open("testfile.txt", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }

    // 初始化io_uring實例
    ret = io_uring_queue_init(QUEUE_DEPTH, &ring, 0);
    if (ret < 0) {
        perror("io_uring_queue_init");
        return 1;
    }

    // 獲取一個提交隊列條目
    sqe = io_uring_get_sqe(&ring);
    if (!sqe) {
        fprintf(stderr, "io_uring_get_sqe failed\n");
        return 1;
    }

    // 準備讀取請求
    io_uring_prep_read(sqe, fd, buffer, BUFFER_SIZE, 0);

    // 提交請求
    ret = io_uring_submit(&ring);
    if (ret < 0) {
        perror("io_uring_submit");
        return 1;
    }

    // 等待請求完成
    ret = io_uring_wait_cqe(&ring, &cqe);
    if (ret < 0) {
        perror("io_uring_wait_cqe");
        return 1;
    }

    // 檢查請求結果
    if (cqe->res < 0) {
        fprintf(stderr, "I/O error: %s\n", strerror(-cqe->res));
        return 1;
    }

    // 輸出讀取的數(shù)據(jù)
    write(STDOUT_FILENO, buffer, cqe->res);

    // 釋放完成隊列條目
    io_uring_cqe_seen(&ring, cqe);

    // 清理
    io_uring_queue_exit(&ring);
    close(fd);

    return 0;
}

fd = open("testfile.txt", O_RDONLY);

ret = io_uring_queue_init(QUEUE_DEPTH, &ring, 0);

sqe = io_uring_get_sqe(&ring);

io_uring_prep_read(sqe, fd, buffer, BUFFER_SIZE, 0);

ret = io_uring_submit(&ring);

ret = io_uring_wait_cqe(&ring, &cqe);

if (cqe->res < 0) {
    fprintf(stderr, "I/O error: %s\n", strerror(-cqe->res));
    return 1;
}

write(STDOUT_FILENO, buffer, cqe->res);

io_uring_cqe_seen(&ring, cqe);

io_uring_queue_exit(&ring);
close(fd);