# Build
make build

# Run all demonstrations
./basic-read-write demo

# Write from stdin to file
echo "Hello, io_uring!" | ./basic-read-write write output.txt

# Read file to stdout
./basic-read-write read output.txt

# Copy a file
./basic-read-write copy source.txt destination.txt

# Run performance benchmark
./basic-read-write bench

# Run tests
make test

# Run benchmarks
make bench

# Run fuzzing
make fuzz

/*
 * basic-read-write.c - Simple file read/write operations using io_uring
 *
 * This sample demonstrates the fundamentals of using io_uring for basic
 * file I/O operations including read, write, and file copy operations.
 */

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

#define QUEUE_DEPTH 16
#define BLK_SIZE 4096

struct io_data {
    int read_fd;
    int write_fd;
    off_t offset;
    size_t remaining;
    char *buffer;
};

/* Write a file using io_uring */
static int write_file(struct io_uring *ring, const char *filename, 
                      const void *data, size_t size)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    int fd, ret;
    
    fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        return -1;
    }
    
    sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "Failed to get SQE\n");
        close(fd);
        return -1;
    }
    
    io_uring_prep_write(sqe, fd, data, size, 0);
    sqe->user_data = 1;
    
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0) {
        fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    if (cqe->res < 0) {
        fprintf(stderr, "Write failed: %s\n", strerror(-cqe->res));
        io_uring_cqe_seen(ring, cqe);
        close(fd);
        return -1;
    }
    
    printf("Wrote %d bytes to %s\n", cqe->res, filename);
    io_uring_cqe_seen(ring, cqe);
    
    close(fd);
    return 0;
}

/* Read a file using io_uring */
static int read_file(struct io_uring *ring, const char *filename,
                     void *buffer, size_t size)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    int fd, ret;
    
    fd = open(filename, O_RDONLY);
    if (fd < 0) {
        perror("open");
        return -1;
    }
    
    sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "Failed to get SQE\n");
        close(fd);
        return -1;
    }
    
    io_uring_prep_read(sqe, fd, buffer, size, 0);
    sqe->user_data = 2;
    
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0) {
        fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    if (cqe->res < 0) {
        fprintf(stderr, "Read failed: %s\n", strerror(-cqe->res));
        io_uring_cqe_seen(ring, cqe);
        close(fd);
        return -1;
    }
    
    printf("Read %d bytes from %s\n", cqe->res, filename);
    io_uring_cqe_seen(ring, cqe);
    
    close(fd);
    return cqe->res;
}

/* Copy a file using io_uring - simple sequential version */
static int copy_file(struct io_uring *ring, const char *src, const char *dst)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    struct stat st;
    int src_fd, dst_fd;
    off_t offset = 0;
    size_t remaining;
    char *buffer;
    int ret = 0;
    
    /* Open source file */
    src_fd = open(src, O_RDONLY);
    if (src_fd < 0) {
        perror("open source");
        return -1;
    }
    
    /* Get file size */
    if (fstat(src_fd, &st) < 0) {
        perror("fstat");
        close(src_fd);
        return -1;
    }
    remaining = st.st_size;
    
    /* Open destination file */
    dst_fd = open(dst, O_CREAT | O_WRONLY | O_TRUNC, st.st_mode);
    if (dst_fd < 0) {
        perror("open destination");
        close(src_fd);
        return -1;
    }
    
    /* Allocate buffer */
    buffer = malloc(BLK_SIZE);
    if (!buffer) {
        perror("malloc");
        close(src_fd);
        close(dst_fd);
        return -1;
    }
    
    printf("Copying %s to %s (%zu bytes)...\n", src, dst, remaining);
    
    /* Copy loop - simple read then write */
    while (remaining > 0) {
        size_t to_read = remaining > BLK_SIZE ? BLK_SIZE : remaining;
        
        /* Read from source */
        sqe = io_uring_get_sqe(ring);
        if (!sqe) {
            fprintf(stderr, "Failed to get SQE for read\n");
            ret = -1;
            break;
        }
        
        io_uring_prep_read(sqe, src_fd, buffer, to_read, offset);
        sqe->user_data = 1;
        
        ret = io_uring_submit(ring);
        if (ret < 0) {
            fprintf(stderr, "io_uring_submit read: %s\n", strerror(-ret));
            break;
        }
        
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0) {
            fprintf(stderr, "io_uring_wait_cqe read: %s\n", strerror(-ret));
            break;
        }
        
        if (cqe->res < 0) {
            fprintf(stderr, "Read failed: %s\n", strerror(-cqe->res));
            io_uring_cqe_seen(ring, cqe);
            ret = -1;
            break;
        }
        
        int bytes_read = cqe->res;
        io_uring_cqe_seen(ring, cqe);
        
        if (bytes_read == 0) {
            break; /* EOF */
        }
        
        /* Write to destination */
        sqe = io_uring_get_sqe(ring);
        if (!sqe) {
            fprintf(stderr, "Failed to get SQE for write\n");
            ret = -1;
            break;
        }
        
        io_uring_prep_write(sqe, dst_fd, buffer, bytes_read, offset);
        sqe->user_data = 2;
        
        ret = io_uring_submit(ring);
        if (ret < 0) {
            fprintf(stderr, "io_uring_submit write: %s\n", strerror(-ret));
            break;
        }
        
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0) {
            fprintf(stderr, "io_uring_wait_cqe write: %s\n", strerror(-ret));
            break;
        }
        
        if (cqe->res < 0) {
            fprintf(stderr, "Write failed: %s\n", strerror(-cqe->res));
            io_uring_cqe_seen(ring, cqe);
            ret = -1;
            break;
        }
        
        io_uring_cqe_seen(ring, cqe);
        
        offset += bytes_read;
        remaining -= bytes_read;
    }
    
    printf("Copy complete!\n");
    
    free(buffer);
    close(src_fd);
    close(dst_fd);
    
    return ret;
}

// FIXME: this should be changed to show how a read after write works correctly. ie we should see the data we just wrote. 
/* Demonstrate sequential read/write operations */
static int sequential_io_demo(struct io_uring *ring)
{
    const char *test_data = "Hello, io_uring! This is a test of basic read/write operations.\n";
    char buffer[256];
    int ret;
    
    printf("\n=== Sequential I/O Demo ===\n");
    
    /* Write test data */
    ret = write_file(ring, "test.txt", test_data, strlen(test_data));
    if (ret < 0) {
        return ret;
    }
    
    /* Read it back */
    memset(buffer, 0, sizeof(buffer));
    ret = read_file(ring, "test.txt", buffer, sizeof(buffer));
    if (ret < 0) {
        return ret;
    }
    
    printf("Data read: %s", buffer);
    
    return 0;
}

/* Demonstrate concurrent I/O operations */
static int concurrent_io_demo(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    const char *filenames[] = {"file1.txt", "file2.txt", "file3.txt"};
    const char *data[] = {
        "This is file 1\n",
        "This is file 2\n",
        "This is file 3\n"
    };
    int fds[3];
    int i, ret;
    
    printf("\n=== Concurrent I/O Demo ===\n");
    
    /* Open all files */
    for (i = 0; i < 3; i++) {
        fds[i] = open(filenames[i], O_CREAT | O_WRONLY | O_TRUNC, 0644);
        if (fds[i] < 0) {
            perror("open");
            /* Close already opened files */
            while (--i >= 0) {
                close(fds[i]);
            }
            return -1;
        }
    }
    
    /* Submit all writes concurrently */
    for (i = 0; i < 3; i++) {
        sqe = io_uring_get_sqe(ring);
        if (!sqe) {
            fprintf(stderr, "Failed to get SQE\n");
            ret = -1;
            goto cleanup;
        }
        
        io_uring_prep_write(sqe, fds[i], data[i], strlen(data[i]), 0);
        sqe->user_data = i;
    }
    
    /* Submit all at once */
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        goto cleanup;
    }
    printf("Submitted %d write operations\n", ret);
    
    /* Wait for all completions */
    for (i = 0; i < 3; i++) {
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0) {
            fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
            goto cleanup;
        }
        
        if (cqe->res < 0) {
            fprintf(stderr, "Write %llu failed: %s\n", 
                    cqe->user_data, strerror(-cqe->res));
        } else {
            printf("Write %llu completed: %d bytes\n", 
                   cqe->user_data, cqe->res);
        }
        
        io_uring_cqe_seen(ring, cqe);
    }
    
    ret = 0;
    
cleanup:
    for (i = 0; i < 3; i++) {
        close(fds[i]);
    }
    
    return ret;
}

/* Benchmark read/write performance */
static int benchmark_io(struct io_uring *ring)
{
    const size_t file_size = 100 * 1024 * 1024; /* 100MB */
    const size_t block_size = 4096;
    char *buffer;
    int fd;
    struct timespec start, end;
    double elapsed;
    double throughput;
    int ret = 0;
    
    printf("\n=== I/O Benchmark ===\n");
    printf("File size: %zu MB\n", file_size / (1024 * 1024));
    printf("Block size: %zu bytes\n", block_size);
    
    /* Allocate buffer with pattern */
    buffer = malloc(block_size);
    if (!buffer) {
        perror("malloc");
        return -1;
    }
    for (size_t i = 0; i < block_size; i++) {
        buffer[i] = i & 0xFF;
    }
    
    /* Write benchmark */
    fd = open("benchmark.dat", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        free(buffer);
        return -1;
    }
    
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    for (size_t offset = 0; offset < file_size; offset += block_size) {
        struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
        if (!sqe) {
            fprintf(stderr, "Failed to get SQE\n");
            ret = -1;
            break;
        }
        
        io_uring_prep_write(sqe, fd, buffer, block_size, offset);
        io_uring_submit(ring);
        
        struct io_uring_cqe *cqe;
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0 || cqe->res < 0) {
            fprintf(stderr, "Write failed\n");
            if (cqe) io_uring_cqe_seen(ring, cqe);
            ret = -1;
            break;
        }
        io_uring_cqe_seen(ring, cqe);
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    elapsed = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
    throughput = (file_size / (1024.0 * 1024.0)) / elapsed;
    
    printf("Write: %.2f MB/s (%.3f seconds)\n", throughput, elapsed);
    close(fd);
    
    /* Read benchmark */
    fd = open("benchmark.dat", O_RDONLY);
    if (fd < 0) {
        perror("open");
        free(buffer);
        return -1;
    }
    
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    for (size_t offset = 0; offset < file_size; offset += block_size) {
        struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
        if (!sqe) {
            fprintf(stderr, "Failed to get SQE\n");
            ret = -1;
            break;
        }
        
        io_uring_prep_read(sqe, fd, buffer, block_size, offset);
        io_uring_submit(ring);
        
        struct io_uring_cqe *cqe;
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0 || cqe->res < 0) {
            fprintf(stderr, "Read failed\n");
            if (cqe) io_uring_cqe_seen(ring, cqe);
            ret = -1;
            break;
        }
        io_uring_cqe_seen(ring, cqe);
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    elapsed = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
    throughput = (file_size / (1024.0 * 1024.0)) / elapsed;
    
    printf("Read: %.2f MB/s (%.3f seconds)\n", throughput, elapsed);
    
    close(fd);
    free(buffer);
    unlink("benchmark.dat");
    
    return ret;
}

static void usage(const char *prog)
{
    printf("Usage: %s [options] <command> [args...]\n", prog);
    printf("\nCommands:\n");
    printf("  demo              Run all demonstrations\n");
    printf("  write <file>      Write stdin to file\n");
    printf("  read <file>       Read file to stdout\n");
    printf("  copy <src> <dst>  Copy source file to destination\n");
    printf("  bench             Run I/O benchmark\n");
    printf("\nOptions:\n");
    printf("  -h, --help        Show this help\n");
}

int main(int argc, char *argv[])
{
    struct io_uring ring;
    int ret;
    
    if (argc < 2) {
        usage(argv[0]);
        return 1;
    }
    
    /* Initialize io_uring */
    ret = io_uring_queue_init(QUEUE_DEPTH, &ring, 0);
    if (ret < 0) {
        fprintf(stderr, "io_uring_queue_init: %s\n", strerror(-ret));
        return 1;
    }
    
    /* Parse command */
    if (strcmp(argv[1], "demo") == 0) {
        ret = sequential_io_demo(&ring);
        if (ret == 0) {
            ret = concurrent_io_demo(&ring);
        }
        if (ret == 0) {
            ret = copy_file(&ring, "test.txt", "test_copy.txt");
        }
    } else if (strcmp(argv[1], "write") == 0 && argc >= 3) {
        /* Read from stdin and write to file */
        char buffer[65536];
        size_t total = 0;
        ssize_t n;
        
        while ((n = read(STDIN_FILENO, buffer, sizeof(buffer))) > 0) {
            total += n;
        }
        
        if (total > 0) {
            ret = write_file(&ring, argv[2], buffer, total);
        }
    } else if (strcmp(argv[1], "read") == 0 && argc >= 3) {
        /* Read file and write to stdout */
        char buffer[65536];
        int n = read_file(&ring, argv[2], buffer, sizeof(buffer));
        if (n > 0) {
            write(STDOUT_FILENO, buffer, n);
            ret = 0;
        } else {
            ret = -1;
        }
    } else if (strcmp(argv[1], "copy") == 0 && argc >= 4) {
        ret = copy_file(&ring, argv[2], argv[3]);
    } else if (strcmp(argv[1], "bench") == 0) {
        ret = benchmark_io(&ring);
    } else if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
        usage(argv[0]);
        ret = 0;
    } else {
        fprintf(stderr, "Unknown command: %s\n", argv[1]);
        usage(argv[0]);
        ret = 1;
    }
    
    /* Cleanup */
    io_uring_queue_exit(&ring);
    
    /* Clean up demo files */
    if (strcmp(argv[1], "demo") == 0 && ret == 0) {
        unlink("test.txt");
        unlink("test_copy.txt");
        unlink("file1.txt");
        unlink("file2.txt");
        unlink("file3.txt");
    }
    
    return ret < 0 ? 1 : 0;
}```

---

## vectored-io

# vectored-io

## Description

This sample demonstrates scattered/gathered I/O operations using io_uring's readv and writev support. Vectored I/O allows reading from or writing to multiple buffers in a single operation, which can be more efficient than multiple individual operations.

Key features demonstrated:

- Basic vectored write operations (writev)
- Basic vectored read operations (readv)
- Gathering data from multiple buffers into a single write
- Scattering read data into multiple buffers
- Concurrent vectored I/O operations
- Performance comparison of vectored vs non-vectored I/O

## Architecture

The sample showcases several vectored I/O patterns:

1. **Basic Vectored I/O**: Simple demonstration of reading/writing multiple buffers
2. **Gather Write**: Collecting data from different sources (headers, timestamps, messages) into a single write operation
3. **Scatter Read**: Reading structured data into separate buffers in one operation
4. **Concurrent Operations**: Multiple vectored I/O operations submitted simultaneously
5. **Performance Benchmark**: Comparing throughput of vectored vs single-buffer I/O

Implementation details:

- Uses standard readv/writev operations through io_uring
- Demonstrates up to 16 IO vectors in a single operation
- Shows practical use cases like log file formatting and structured data handling

## How to Run

```bash
# Build
make build

# Run all demonstrations
./vectored-io demo

# Run specific demonstrations
./vectored-io write      # Vectored write demo
./vectored-io read       # Vectored read demo
./vectored-io gather     # Gather write demo
./vectored-io scatter    # Scatter read demo
./vectored-io concurrent # Concurrent vectored I/O
./vectored-io bench      # Performance benchmark

# Run tests
make test

# Run benchmarks
make bench

/*
 * vectored-io.c - Scattered/gathered I/O with readv/writev operations
 *
 * This sample demonstrates vectored I/O operations using io_uring, showing
 * how to efficiently read/write multiple buffers in a single operation.
 */

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

#define QUEUE_DEPTH 16
#define MAX_IOVECS 8

/* Demonstrate basic vectored write */
static int vectored_write_demo(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    struct iovec iov[3];
    const char *data[] = {
        "First line of text\n",
        "Second line of text\n", 
        "Third line of text\n"
    };
    int fd, ret;
    
    printf("\n=== Vectored Write Demo ===\n");
    
    fd = open("vectored_output.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        return -1;
    }
    
    /* Setup IO vectors */
    for (int i = 0; i < 3; i++) {
        iov[i].iov_base = (void *)data[i];
        iov[i].iov_len = strlen(data[i]);
    }
    
    /* Submit vectored write */
    sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "Failed to get SQE\n");
        close(fd);
        return -1;
    }
    
    io_uring_prep_writev(sqe, fd, iov, 3, 0);
    sqe->user_data = 1;
    
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    /* Wait for completion */
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0) {
        fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    if (cqe->res < 0) {
        fprintf(stderr, "Vectored write failed: %s\n", strerror(-cqe->res));
        io_uring_cqe_seen(ring, cqe);
        close(fd);
        return -1;
    }
    
    printf("Wrote %d bytes using vectored I/O\n", cqe->res);
    io_uring_cqe_seen(ring, cqe);
    
    close(fd);
    return 0;
}

/* Demonstrate basic vectored read */
static int vectored_read_demo(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    struct iovec iov[3];
    char buf1[32], buf2[32], buf3[32];
    int fd, ret;
    
    printf("\n=== Vectored Read Demo ===\n");
    
    fd = open("vectored_output.txt", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return -1;
    }
    
    /* Setup IO vectors */
    memset(buf1, 0, sizeof(buf1));
    memset(buf2, 0, sizeof(buf2));
    memset(buf3, 0, sizeof(buf3));
    
    iov[0].iov_base = buf1;
    iov[0].iov_len = sizeof(buf1) - 1;
    iov[1].iov_base = buf2;
    iov[1].iov_len = sizeof(buf2) - 1;
    iov[2].iov_base = buf3;
    iov[2].iov_len = sizeof(buf3) - 1;
    
    /* Submit vectored read */
    sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "Failed to get SQE\n");
        close(fd);
        return -1;
    }
    
    io_uring_prep_readv(sqe, fd, iov, 3, 0);
    sqe->user_data = 2;
    
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    /* Wait for completion */
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0) {
        fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    if (cqe->res < 0) {
        fprintf(stderr, "Vectored read failed: %s\n", strerror(-cqe->res));
        io_uring_cqe_seen(ring, cqe);
        close(fd);
        return -1;
    }
    
    printf("Read %d bytes using vectored I/O\n", cqe->res);
    printf("Buffer 1: %s", buf1);
    printf("Buffer 2: %s", buf2);
    printf("Buffer 3: %s", buf3);
    
    io_uring_cqe_seen(ring, cqe);
    
    close(fd);
    return 0;
}

/* Demonstrate gathering data from multiple sources */
static int gather_write_demo(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    struct iovec iov[5];
    int fd, ret;
    
    /* Different data types to gather */
    const char *header = "=== Log Entry ===\n";
    time_t timestamp = time(NULL);
    char time_str[64];
    const char *message = "System event occurred\n";
    int error_code = 42;
    char error_str[32];
    const char *footer = "=================\n";
    
    printf("\n=== Gather Write Demo ===\n");
    
    /* Format data */
    snprintf(time_str, sizeof(time_str), "Time: %s", ctime(&timestamp));
    snprintf(error_str, sizeof(error_str), "Error code: %d\n", error_code);
    
    /* Setup IO vectors */
    iov[0].iov_base = (void *)header;
    iov[0].iov_len = strlen(header);
    iov[1].iov_base = time_str;
    iov[1].iov_len = strlen(time_str);
    iov[2].iov_base = (void *)message;
    iov[2].iov_len = strlen(message);
    iov[3].iov_base = error_str;
    iov[3].iov_len = strlen(error_str);
    iov[4].iov_base = (void *)footer;
    iov[4].iov_len = strlen(footer);
    
    fd = open("log_entry.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        return -1;
    }
    
    /* Submit gathered write */
    sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "Failed to get SQE\n");
        close(fd);
        return -1;
    }
    
    io_uring_prep_writev(sqe, fd, iov, 5, 0);
    sqe->user_data = 3;
    
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    /* Wait for completion */
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0) {
        fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    if (cqe->res < 0) {
        fprintf(stderr, "Gathered write failed: %s\n", strerror(-cqe->res));
        io_uring_cqe_seen(ring, cqe);
        close(fd);
        return -1;
    }
    
    printf("Wrote %d bytes from 5 different buffers\n", cqe->res);
    io_uring_cqe_seen(ring, cqe);
    
    close(fd);
    return 0;
}

/* Demonstrate scatter read into multiple buffers */
static int scatter_read_demo(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    struct iovec iov[4];
    char header[32];
    char data1[64];
    char data2[64];
    char footer[32];
    int fd, ret;
    
    printf("\n=== Scatter Read Demo ===\n");
    
    /* First create a test file with known structure */
    const char *test_data = "HEADER:TestFile\n"
                           "DATA1:This is the first data section with some content\n"
                           "DATA2:This is the second data section with more content\n"
                           "FOOTER:EndOfFile\n";
    
    fd = open("structured_data.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open write");
        return -1;
    }
    write(fd, test_data, strlen(test_data));
    close(fd);
    
    /* Now read it back into separate buffers */
    fd = open("structured_data.txt", O_RDONLY);
    if (fd < 0) {
        perror("open read");
        return -1;
    }
    
    /* Setup IO vectors for scatter read */
    memset(header, 0, sizeof(header));
    memset(data1, 0, sizeof(data1));
    memset(data2, 0, sizeof(data2));
    memset(footer, 0, sizeof(footer));
    
    iov[0].iov_base = header;
    iov[0].iov_len = 16;  /* Read header */
    iov[1].iov_base = data1;
    iov[1].iov_len = 54;  /* Read first data section */
    iov[2].iov_base = data2;
    iov[2].iov_len = 55;  /* Read second data section */
    iov[3].iov_base = footer;
    iov[3].iov_len = 18;  /* Read footer */
    
    /* Submit scatter read */
    sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "Failed to get SQE\n");
        close(fd);
        return -1;
    }
    
    io_uring_prep_readv(sqe, fd, iov, 4, 0);
    sqe->user_data = 4;
    
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    /* Wait for completion */
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0) {
        fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
        close(fd);
        return -1;
    }
    
    if (cqe->res < 0) {
        fprintf(stderr, "Scatter read failed: %s\n", strerror(-cqe->res));
        io_uring_cqe_seen(ring, cqe);
        close(fd);
        return -1;
    }
    
    printf("Read %d bytes into 4 separate buffers:\n", cqe->res);
    printf("Header: %.16s\n", header);
    printf("Data1: %.54s\n", data1);
    printf("Data2: %.55s\n", data2);
    printf("Footer: %.18s\n", footer);
    
    io_uring_cqe_seen(ring, cqe);
    
    close(fd);
    return 0;
}

/* Demonstrate concurrent vectored I/O operations */
static int concurrent_vectored_io(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    struct iovec write_iovs[3][2];
    const char *file_names[] = {"vec1.txt", "vec2.txt", "vec3.txt"};
    int fds[3];
    int ret, i, completed = 0;
    
    printf("\n=== Concurrent Vectored I/O Demo ===\n");
    
    /* Prepare data for each file */
    const char *headers[] = {
        "File 1 Header\n",
        "File 2 Header\n",
        "File 3 Header\n"
    };
    const char *bodies[] = {
        "This is the content of file 1\n",
        "This is the content of file 2\n",
        "This is the content of file 3\n"
    };
    
    /* Open all files */
    for (i = 0; i < 3; i++) {
        fds[i] = open(file_names[i], O_CREAT | O_WRONLY | O_TRUNC, 0644);
        if (fds[i] < 0) {
            perror("open");
            /* Clean up already opened files */
            while (--i >= 0) {
                close(fds[i]);
            }
            return -1;
        }
        
        /* Setup IO vectors for each file */
        write_iovs[i][0].iov_base = (void *)headers[i];
        write_iovs[i][0].iov_len = strlen(headers[i]);
        write_iovs[i][1].iov_base = (void *)bodies[i];
        write_iovs[i][1].iov_len = strlen(bodies[i]);
    }
    
    /* Submit all vectored writes concurrently */
    for (i = 0; i < 3; i++) {
        sqe = io_uring_get_sqe(ring);
        if (!sqe) {
            fprintf(stderr, "Failed to get SQE\n");
            ret = -1;
            goto cleanup;
        }
        
        io_uring_prep_writev(sqe, fds[i], write_iovs[i], 2, 0);
        sqe->user_data = i + 10;
    }
    
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        goto cleanup;
    }
    printf("Submitted %d vectored write operations\n", ret);
    
    /* Wait for all completions */
    while (completed < 3) {
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0) {
            fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
            goto cleanup;
        }
        
        if (cqe->res < 0) {
            fprintf(stderr, "Vectored write %llu failed: %s\n",
                    cqe->user_data - 10, strerror(-cqe->res));
        } else {
            printf("File %llu: wrote %d bytes\n",
                   cqe->user_data - 10, cqe->res);
        }
        
        io_uring_cqe_seen(ring, cqe);
        completed++;
    }
    
    ret = 0;
    
cleanup:
    for (i = 0; i < 3; i++) {
        close(fds[i]);
    }
    
    return ret;
}

/* Benchmark vectored vs non-vectored I/O */
static int benchmark_vectored_io(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    struct iovec iov[16];
    char *buffers[16];
    char *single_buffer;
    struct timespec start, end;
    double elapsed_vec, elapsed_single;
    const size_t chunk_size = 4096;
    const size_t total_size = chunk_size * 16;
    const int iterations = 1000;
    int fd, ret, i, j;
    
    printf("\n=== Vectored I/O Benchmark ===\n");
    printf("Chunk size: %zu bytes\n", chunk_size);
    printf("Total size per operation: %zu bytes\n", total_size);
    printf("Iterations: %d\n", iterations);
    
    /* Allocate buffers */
    for (i = 0; i < 16; i++) {
        buffers[i] = malloc(chunk_size);
        if (!buffers[i]) {
            perror("malloc");
            /* Free already allocated */
            while (--i >= 0) {
                free(buffers[i]);
            }
            return -1;
        }
        memset(buffers[i], 'A' + i, chunk_size);
        iov[i].iov_base = buffers[i];
        iov[i].iov_len = chunk_size;
    }
    
    single_buffer = malloc(total_size);
    if (!single_buffer) {
        perror("malloc single");
        for (i = 0; i < 16; i++) {
            free(buffers[i]);
        }
        return -1;
    }
    memset(single_buffer, 'X', total_size);
    
    /* Benchmark vectored writes */
    fd = open("bench_vec.dat", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        ret = -1;
        goto cleanup;
    }
    
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    for (j = 0; j < iterations; j++) {
        sqe = io_uring_get_sqe(ring);
        if (!sqe) {
            fprintf(stderr, "Failed to get SQE\n");
            close(fd);
            ret = -1;
            goto cleanup;
        }
        
        io_uring_prep_writev(sqe, fd, iov, 16, j * total_size);
        io_uring_submit(ring);
        
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0 || cqe->res < 0) {
            fprintf(stderr, "Vectored write failed\n");
            if (cqe) io_uring_cqe_seen(ring, cqe);
            close(fd);
            ret = -1;
            goto cleanup;
        }
        io_uring_cqe_seen(ring, cqe);
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    elapsed_vec = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
    close(fd);
    
    /* Benchmark single buffer writes */
    fd = open("bench_single.dat", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        ret = -1;
        goto cleanup;
    }
    
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    for (j = 0; j < iterations; j++) {
        sqe = io_uring_get_sqe(ring);
        if (!sqe) {
            fprintf(stderr, "Failed to get SQE\n");
            close(fd);
            ret = -1;
            goto cleanup;
        }
        
        io_uring_prep_write(sqe, fd, single_buffer, total_size, j * total_size);
        io_uring_submit(ring);
        
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0 || cqe->res < 0) {
            fprintf(stderr, "Single write failed\n");
            if (cqe) io_uring_cqe_seen(ring, cqe);
            close(fd);
            ret = -1;
            goto cleanup;
        }
        io_uring_cqe_seen(ring, cqe);
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    elapsed_single = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
    close(fd);
    
    printf("\nResults:\n");
    printf("Vectored I/O (16 chunks): %.3f seconds (%.2f MB/s)\n",
           elapsed_vec, (iterations * total_size / (1024.0 * 1024.0)) / elapsed_vec);
    printf("Single buffer I/O: %.3f seconds (%.2f MB/s)\n",
           elapsed_single, (iterations * total_size / (1024.0 * 1024.0)) / elapsed_single);
    printf("Vectored I/O is %.2fx %s\n",
           elapsed_vec < elapsed_single ? elapsed_single/elapsed_vec : elapsed_vec/elapsed_single,
           elapsed_vec < elapsed_single ? "faster" : "slower");
    
    ret = 0;
    
cleanup:
    for (i = 0; i < 16; i++) {
        free(buffers[i]);
    }
    free(single_buffer);
    unlink("bench_vec.dat");
    unlink("bench_single.dat");
    
    return ret;
}

static void usage(const char *prog)
{
    printf("Usage: %s [command]\n", prog);
    printf("\nCommands:\n");
    printf("  demo       Run all demonstrations\n");
    printf("  write      Demonstrate vectored write\n");
    printf("  read       Demonstrate vectored read\n");
    printf("  gather     Demonstrate gather write\n");
    printf("  scatter    Demonstrate scatter read\n");
    printf("  concurrent Run concurrent vectored I/O\n");
    printf("  bench      Benchmark vectored vs single buffer I/O\n");
    printf("  help       Show this help\n");
}

int main(int argc, char *argv[])
{
    struct io_uring ring;
    const char *cmd = "demo";
    int ret;
    
    if (argc > 1) {
        cmd = argv[1];
    }
    
    if (strcmp(cmd, "help") == 0 || strcmp(cmd, "-h") == 0) {
        usage(argv[0]);
        return 0;
    }
    
    /* Initialize io_uring */
    ret = io_uring_queue_init(QUEUE_DEPTH, &ring, 0);
    if (ret < 0) {
        fprintf(stderr, "io_uring_queue_init: %s\n", strerror(-ret));
        return 1;
    }
    
    /* Execute command */
    if (strcmp(cmd, "demo") == 0) {
        ret = vectored_write_demo(&ring);
        if (ret == 0) ret = vectored_read_demo(&ring);
        if (ret == 0) ret = gather_write_demo(&ring);
        if (ret == 0) ret = scatter_read_demo(&ring);
        if (ret == 0) ret = concurrent_vectored_io(&ring);
    } else if (strcmp(cmd, "write") == 0) {
        ret = vectored_write_demo(&ring);
    } else if (strcmp(cmd, "read") == 0) {
        ret = vectored_read_demo(&ring);
    } else if (strcmp(cmd, "gather") == 0) {
        ret = gather_write_demo(&ring);
    } else if (strcmp(cmd, "scatter") == 0) {
        ret = scatter_read_demo(&ring);
    } else if (strcmp(cmd, "concurrent") == 0) {
        ret = concurrent_vectored_io(&ring);
    } else if (strcmp(cmd, "bench") == 0) {
        ret = benchmark_vectored_io(&ring);
    } else {
        fprintf(stderr, "Unknown command: %s\n", cmd);
        usage(argv[0]);
        ret = -1;
    }
    
    /* Cleanup */
    io_uring_queue_exit(&ring);
    
    /* Clean up demo files */
    if (strcmp(cmd, "demo") == 0 && ret == 0) {
        unlink("vectored_output.txt");
        unlink("log_entry.txt");
        unlink("structured_data.txt");
        unlink("vec1.txt");
        unlink("vec2.txt");
        unlink("vec3.txt");
    }
    
    return ret < 0 ? 1 : 0;
}```

---

## direct-io

# direct-io

## Description

This sample demonstrates Direct I/O operations using io_uring with the O_DIRECT flag. Direct I/O bypasses the kernel's page cache, providing lower latency and more predictable performance for certain workloads like databases and high-performance storage systems.

Key features demonstrated:

- Basic direct write and read operations
- Alignment requirements for Direct I/O (buffer, size, and offset)
- Performance comparison between buffered and direct I/O
- Mixed buffered and direct I/O operations
- Block size impact on Direct I/O performance
- Error handling for filesystems that don't support O_DIRECT

## Architecture

The sample showcases several Direct I/O patterns:

1. **Basic Direct I/O**: Simple read/write with O_DIRECT flag
2. **Alignment Demo**: Shows the strict alignment requirements (512-byte typical)
3. **Performance Comparison**: Benchmarks buffered vs direct I/O
4. **Mixed I/O**: Concurrent buffered and direct operations
5. **Block Size Analysis**: Tests performance with different I/O sizes

Implementation details:

- Uses posix_memalign() for properly aligned buffers
- All I/O sizes must be sector-aligned (typically 512 bytes)
- File offsets must also be sector-aligned
- Demonstrates fallback when O_DIRECT is not supported

## How to Run

```bash
# Build
make build

# Run all demonstrations
./direct-io demo

# Run specific demonstrations
./direct-io write      # Direct write demo
./direct-io read       # Direct read demo
./direct-io compare    # Compare buffered vs direct I/O
./direct-io mixed      # Mixed I/O operations
./direct-io alignment  # Alignment requirements demo
./direct-io bench      # Block size benchmarks

# Run tests
make test

# Run benchmarks
make bench

/*
 * direct-io.c - Direct I/O operations bypassing page cache
 *
 * This sample demonstrates the use of O_DIRECT flag with io_uring for
 * bypassing the kernel page cache, achieving lower latency and more
 * predictable performance for certain workloads.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <linux/fs.h>
#include <liburing.h>
#include <errno.h>
#include <time.h>
#include <sys/types.h>

#define QUEUE_DEPTH 32
#define ALIGNMENT 512    /* Direct I/O typically requires 512-byte alignment */
#define DIO_BLOCK_SIZE 4096

/* Allocate aligned memory for Direct I/O */
static void* aligned_alloc_wrapper(size_t alignment, size_t size)
{
    void *ptr;
    if (posix_memalign(&ptr, alignment, size) != 0) {
        return NULL;
    }
    return ptr;
}

/* Get the block size for a file descriptor */
static int get_block_size(int fd)
{
    struct stat st;
    int blksize;
    
    if (fstat(fd, &st) < 0) {
        return -1;
    }
    
    /* Try to get the optimal block size */
    if (ioctl(fd, BLKBSZGET, &blksize) == 0) {
        return blksize;
    }
    
    /* Fall back to filesystem block size */
    return st.st_blksize > 0 ? st.st_blksize : 4096;
}

/* Write using Direct I/O */
static int direct_write_demo(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    void *buffer;
    int fd, ret;
    size_t buffer_size = 1024 * 1024; /* 1MB */
    off_t offset = 0;
    
    printf("\n=== Direct Write Demo ===\n");
    
    /* Open file with O_DIRECT */
    fd = open("direct_write.dat", O_CREAT | O_WRONLY | O_TRUNC | O_DIRECT, 0644);
    if (fd < 0) {
        if (errno == EINVAL) {
            printf("O_DIRECT not supported on this filesystem\n");
            return -1;
        }
        perror("open");
        return -1;
    }
    
    /* Get block size */
    int block_size = get_block_size(fd);
    if (block_size < 0) {
        block_size = DIO_BLOCK_SIZE;
    }
    printf("Using block size: %d bytes\n", block_size);
    
    /* Allocate aligned buffer */
    buffer = aligned_alloc_wrapper(ALIGNMENT, buffer_size);
    if (!buffer) {
        perror("aligned_alloc");
        close(fd);
        return -1;
    }
    
    /* Fill buffer with pattern */
    memset(buffer, 'D', buffer_size);
    
    /* Submit direct write */
    sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "Failed to get SQE\n");
        free(buffer);
        close(fd);
        return -1;
    }
    
    io_uring_prep_write(sqe, fd, buffer, buffer_size, offset);
    sqe->user_data = 1;
    
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        free(buffer);
        close(fd);
        return -1;
    }
    
    /* Wait for completion */
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0) {
        fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
        free(buffer);
        close(fd);
        return -1;
    }
    
    if (cqe->res < 0) {
        fprintf(stderr, "Direct write failed: %s\n", strerror(-cqe->res));
        io_uring_cqe_seen(ring, cqe);
        free(buffer);
        close(fd);
        return -1;
    }
    
    printf("Direct write completed: %d bytes\n", cqe->res);
    io_uring_cqe_seen(ring, cqe);
    
    /* Sync to ensure data is on disk */
    fsync(fd);
    
    free(buffer);
    close(fd);
    return 0;
}

/* Read using Direct I/O */
static int direct_read_demo(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    void *buffer;
    int fd, ret;
    size_t buffer_size = 1024 * 1024; /* 1MB */
    off_t offset = 0;
    
    printf("\n=== Direct Read Demo ===\n");
    
    /* Open file with O_DIRECT */
    fd = open("direct_write.dat", O_RDONLY | O_DIRECT);
    if (fd < 0) {
        if (errno == EINVAL) {
            printf("O_DIRECT not supported on this filesystem\n");
            return -1;
        }
        perror("open");
        return -1;
    }
    
    /* Allocate aligned buffer */
    buffer = aligned_alloc_wrapper(ALIGNMENT, buffer_size);
    if (!buffer) {
        perror("aligned_alloc");
        close(fd);
        return -1;
    }
    
    /* Submit direct read */
    sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "Failed to get SQE\n");
        free(buffer);
        close(fd);
        return -1;
    }
    
    io_uring_prep_read(sqe, fd, buffer, buffer_size, offset);
    sqe->user_data = 2;
    
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        free(buffer);
        close(fd);
        return -1;
    }
    
    /* Wait for completion */
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0) {
        fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
        free(buffer);
        close(fd);
        return -1;
    }
    
    if (cqe->res < 0) {
        fprintf(stderr, "Direct read failed: %s\n", strerror(-cqe->res));
        io_uring_cqe_seen(ring, cqe);
        free(buffer);
        close(fd);
        return -1;
    }
    
    printf("Direct read completed: %d bytes\n", cqe->res);
    printf("First 32 bytes: %.32s\n", (char *)buffer);
    io_uring_cqe_seen(ring, cqe);
    
    free(buffer);
    close(fd);
    return 0;
}

/* Compare buffered vs direct I/O performance */
static int compare_buffered_direct(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    void *aligned_buffer, *regular_buffer;
    int fd;
    struct timespec start, end;
    double buffered_time, direct_time;
    const size_t io_size = 16 * 1024 * 1024; /* 16MB */
    const size_t block_size = 128 * 1024; /* 128KB blocks */
    int ret;
    
    printf("\n=== Buffered vs Direct I/O Comparison ===\n");
    printf("Total I/O size: %zu MB\n", io_size / (1024 * 1024));
    printf("Block size: %zu KB\n", block_size / 1024);
    
    /* Allocate buffers */
    aligned_buffer = aligned_alloc_wrapper(ALIGNMENT, block_size);
    regular_buffer = malloc(block_size);
    if (!aligned_buffer || !regular_buffer) {
        perror("buffer allocation");
        free(aligned_buffer);
        free(regular_buffer);
        return -1;
    }
    
    /* Fill buffers with data */
    memset(aligned_buffer, 'A', block_size);
    memset(regular_buffer, 'B', block_size);
    
    /* Test 1: Buffered I/O Write */
    printf("\nBuffered I/O Write Test:\n");
    fd = open("buffered_test.dat", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open buffered");
        free(aligned_buffer);
        free(regular_buffer);
        return -1;
    }
    
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    for (size_t offset = 0; offset < io_size; offset += block_size) {
        sqe = io_uring_get_sqe(ring);
        if (!sqe) {
            fprintf(stderr, "Failed to get SQE\n");
            close(fd);
            free(aligned_buffer);
            free(regular_buffer);
            return -1;
        }
        
        io_uring_prep_write(sqe, fd, regular_buffer, block_size, offset);
        io_uring_submit(ring);
        
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0 || cqe->res < 0) {
            fprintf(stderr, "Buffered write failed\n");
            if (cqe) io_uring_cqe_seen(ring, cqe);
            close(fd);
            free(aligned_buffer);
            free(regular_buffer);
            return -1;
        }
        io_uring_cqe_seen(ring, cqe);
    }
    
    fsync(fd); /* Ensure data is written */
    clock_gettime(CLOCK_MONOTONIC, &end);
    buffered_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
    
    printf("Time: %.3f seconds (%.2f MB/s)\n",
           buffered_time, (io_size / (1024.0 * 1024.0)) / buffered_time);
    close(fd);
    
    /* Test 2: Direct I/O Write */
    printf("\nDirect I/O Write Test:\n");
    fd = open("direct_test.dat", O_CREAT | O_WRONLY | O_TRUNC | O_DIRECT, 0644);
    if (fd < 0) {
        if (errno == EINVAL) {
            printf("O_DIRECT not supported, skipping direct I/O test\n");
            free(aligned_buffer);
            free(regular_buffer);
            unlink("buffered_test.dat");
            return 0;
        }
        perror("open direct");
        free(aligned_buffer);
        free(regular_buffer);
        return -1;
    }
    
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    for (size_t offset = 0; offset < io_size; offset += block_size) {
        sqe = io_uring_get_sqe(ring);
        if (!sqe) {
            fprintf(stderr, "Failed to get SQE\n");
            close(fd);
            free(aligned_buffer);
            free(regular_buffer);
            return -1;
        }
        
        io_uring_prep_write(sqe, fd, aligned_buffer, block_size, offset);
        io_uring_submit(ring);
        
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0 || cqe->res < 0) {
            fprintf(stderr, "Direct write failed\n");
            if (cqe) io_uring_cqe_seen(ring, cqe);
            close(fd);
            free(aligned_buffer);
            free(regular_buffer);
            return -1;
        }
        io_uring_cqe_seen(ring, cqe);
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    direct_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
    
    printf("Time: %.3f seconds (%.2f MB/s)\n",
           direct_time, (io_size / (1024.0 * 1024.0)) / direct_time);
    close(fd);
    
    /* Summary */
    printf("\nSummary:\n");
    printf("Buffered I/O: %.3f seconds\n", buffered_time);
    printf("Direct I/O: %.3f seconds\n", direct_time);
    printf("Direct I/O is %.2fx %s than buffered I/O\n",
           direct_time < buffered_time ? buffered_time/direct_time : direct_time/buffered_time,
           direct_time < buffered_time ? "faster" : "slower");
    
    free(aligned_buffer);
    free(regular_buffer);
    unlink("buffered_test.dat");
    unlink("direct_test.dat");
    
    return 0;
}

/* Demonstrate mixed buffered and direct I/O */
static int mixed_io_demo(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    void *direct_buffer, *buffered_buffer;
    int direct_fd, buffered_fd;
    const size_t buffer_size = 64 * 1024; /* 64KB */
    int ret;
    
    printf("\n=== Mixed Buffered/Direct I/O Demo ===\n");
    
    /* Allocate buffers */
    direct_buffer = aligned_alloc_wrapper(ALIGNMENT, buffer_size);
    buffered_buffer = malloc(buffer_size);
    if (!direct_buffer || !buffered_buffer) {
        perror("buffer allocation");
        free(direct_buffer);
        free(buffered_buffer);
        return -1;
    }
    
    /* Prepare data */
    memset(direct_buffer, 'D', buffer_size);
    memset(buffered_buffer, 'B', buffer_size);
    
    /* Open files */
    direct_fd = open("mixed_direct.dat", O_CREAT | O_RDWR | O_TRUNC | O_DIRECT, 0644);
    if (direct_fd < 0 && errno == EINVAL) {
        printf("O_DIRECT not supported, using regular I/O for both\n");
        direct_fd = open("mixed_direct.dat", O_CREAT | O_RDWR | O_TRUNC, 0644);
    }
    if (direct_fd < 0) {
        perror("open direct");
        free(direct_buffer);
        free(buffered_buffer);
        return -1;
    }
    
    buffered_fd = open("mixed_buffered.dat", O_CREAT | O_RDWR | O_TRUNC, 0644);
    if (buffered_fd < 0) {
        perror("open buffered");
        close(direct_fd);
        free(direct_buffer);
        free(buffered_buffer);
        return -1;
    }
    
    /* Submit both writes concurrently */
    printf("Submitting concurrent writes (direct + buffered)...\n");
    
    /* Direct write */
    sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "Failed to get SQE for direct write\n");
        ret = -1;
        goto cleanup;
    }
    io_uring_prep_write(sqe, direct_fd, direct_buffer, buffer_size, 0);
    sqe->user_data = 1;
    
    /* Buffered write */
    sqe = io_uring_get_sqe(ring);
    if (!sqe) {
        fprintf(stderr, "Failed to get SQE for buffered write\n");
        ret = -1;
        goto cleanup;
    }
    io_uring_prep_write(sqe, buffered_fd, buffered_buffer, buffer_size, 0);
    sqe->user_data = 2;
    
    /* Submit both */
    ret = io_uring_submit(ring);
    if (ret < 0) {
        fprintf(stderr, "io_uring_submit: %s\n", strerror(-ret));
        goto cleanup;
    }
    printf("Submitted %d operations\n", ret);
    
    /* Wait for both completions */
    for (int i = 0; i < 2; i++) {
        ret = io_uring_wait_cqe(ring, &cqe);
        if (ret < 0) {
            fprintf(stderr, "io_uring_wait_cqe: %s\n", strerror(-ret));
            goto cleanup;
        }
        
        if (cqe->res < 0) {
            fprintf(stderr, "Write %llu failed: %s\n",
                    cqe->user_data, strerror(-cqe->res));
        } else {
            printf("Write %llu completed: %d bytes (%s)\n",
                   cqe->user_data, cqe->res,
                   cqe->user_data == 1 ? "direct" : "buffered");
        }
        
        io_uring_cqe_seen(ring, cqe);
    }
    
    ret = 0;
    
cleanup:
    close(direct_fd);
    close(buffered_fd);
    free(direct_buffer);
    free(buffered_buffer);
    unlink("mixed_direct.dat");
    unlink("mixed_buffered.dat");
    
    return ret;
}

/* Demonstrate alignment requirements for Direct I/O */
static int alignment_demo(struct io_uring *ring)
{
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    int fd, ret;
    
    printf("\n=== Direct I/O Alignment Requirements Demo ===\n");
    
    /* Open file with O_DIRECT */
    fd = open("alignment_test.dat", O_CREAT | O_RDWR | O_TRUNC | O_DIRECT, 0644);
    if (fd < 0) {
        if (errno == EINVAL) {
            printf("O_DIRECT not supported on this filesystem\n");
            return -1;
        }
        perror("open");
        return -1;
    }
    
    /* Test 1: Properly aligned buffer and size */
    printf("\nTest 1: Aligned buffer (512-byte aligned), aligned size (4096 bytes)\n");
    void *aligned_buffer = aligned_alloc_wrapper(512, 4096);
    if (!aligned_buffer) {
        perror("aligned_alloc");
        close(fd);
        return -1;
    }
    memset(aligned_buffer, 'A', 4096);
    
    sqe = io_uring_get_sqe(ring);
    io_uring_prep_write(sqe, fd, aligned_buffer, 4096, 0);
    io_uring_submit(ring);
    
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0 || cqe->res < 0) {
        printf("Result: FAILED (%s)\n", 
               cqe ? strerror(-cqe->res) : strerror(-ret));
    } else {
        printf("Result: SUCCESS (wrote %d bytes)\n", cqe->res);
    }
    if (cqe) io_uring_cqe_seen(ring, cqe);
    
    /* Test 2: Unaligned buffer */
    printf("\nTest 2: Unaligned buffer (not 512-byte aligned), aligned size\n");
    char *unaligned_buffer = (char *)aligned_buffer + 1; /* Off by 1 byte */
    
    sqe = io_uring_get_sqe(ring);
    io_uring_prep_write(sqe, fd, unaligned_buffer, 4096, 4096);
    io_uring_submit(ring);
    
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0 || cqe->res < 0) {
        printf("Result: FAILED as expected (%s)\n",
               cqe ? strerror(-cqe->res) : strerror(-ret));
    } else {
        printf("Result: Unexpectedly succeeded (wrote %d bytes)\n", cqe->res);
    }
    if (cqe) io_uring_cqe_seen(ring, cqe);
    
    /* Test 3: Unaligned size */
    printf("\nTest 3: Aligned buffer, unaligned size (not sector-size aligned)\n");
    
    sqe = io_uring_get_sqe(ring);
    io_uring_prep_write(sqe, fd, aligned_buffer, 4097, 8192); /* 4097 is not aligned */
    io_uring_submit(ring);
    
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0 || cqe->res < 0) {
        printf("Result: FAILED as expected (%s)\n",
               cqe ? strerror(-cqe->res) : strerror(-ret));
    } else {
        printf("Result: Unexpectedly succeeded (wrote %d bytes)\n", cqe->res);
    }
    if (cqe) io_uring_cqe_seen(ring, cqe);
    
    /* Test 4: Unaligned offset */
    printf("\nTest 4: Aligned buffer and size, unaligned offset\n");
    
    sqe = io_uring_get_sqe(ring);
    io_uring_prep_write(sqe, fd, aligned_buffer, 4096, 100); /* Offset 100 is not aligned */
    io_uring_submit(ring);
    
    ret = io_uring_wait_cqe(ring, &cqe);
    if (ret < 0 || cqe->res < 0) {
        printf("Result: FAILED as expected (%s)\n",
               cqe ? strerror(-cqe->res) : strerror(-ret));
    } else {
        printf("Result: Unexpectedly succeeded (wrote %d bytes)\n", cqe->res);
    }
    if (cqe) io_uring_cqe_seen(ring, cqe);
    
    free(aligned_buffer);
    close(fd);
    unlink("alignment_test.dat");
    
    return 0;
}

/* Benchmark Direct I/O with different block sizes */
static int benchmark_block_sizes(struct io_uring *ring)
{
    const size_t test_sizes[] = {512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072};
    const int num_sizes = sizeof(test_sizes) / sizeof(test_sizes[0]);
    const size_t total_io = 64 * 1024 * 1024; /* 64MB per test */
    struct timespec start, end;
    double elapsed;
    int fd;
    
    printf("\n=== Direct I/O Block Size Benchmark ===\n");
    printf("Total I/O per test: %zu MB\n\n", total_io / (1024 * 1024));
    
    /* Open file with O_DIRECT */
    fd = open("blocksize_bench.dat", O_CREAT | O_RDWR | O_TRUNC | O_DIRECT, 0644);
    if (fd < 0) {
        if (errno == EINVAL) {
            printf("O_DIRECT not supported on this filesystem\n");
            return -1;
        }
        perror("open");
        return -1;
    }
    
    printf("Block Size\tMB/s\t\tIOPS\n");
    printf("----------\t----\t\t----\n");
    
    for (int i = 0; i < num_sizes; i++) {
        size_t block_size = test_sizes[i];
        void *buffer = aligned_alloc_wrapper(ALIGNMENT, block_size);
        if (!buffer) {
            perror("aligned_alloc");
            continue;
        }
        
        memset(buffer, 'X', block_size);
        size_t iterations = total_io / block_size;
        
        /* Rewind file */
        lseek(fd, 0, SEEK_SET);
        
        clock_gettime(CLOCK_MONOTONIC, &start);
        
        for (size_t iter = 0; iter < iterations; iter++) {
            struct io_uring_sqe *sqe = io_uring_get_sqe(ring);
            if (!sqe) {
                fprintf(stderr, "Failed to get SQE\n");
                free(buffer);
                close(fd);
                return -1;
            }
            
            io_uring_prep_write(sqe, fd, buffer, block_size, (iter * block_size) % (32 * 1024 * 1024));
            io_uring_submit(ring);
            
            struct io_uring_cqe *cqe;
            int ret = io_uring_wait_cqe(ring, &cqe);
            if (ret < 0 || cqe->res < 0) {
                fprintf(stderr, "Write failed for block size %zu\n", block_size);
                if (cqe) io_uring_cqe_seen(ring, cqe);
                free(buffer);
                continue;
            }
            io_uring_cqe_seen(ring, cqe);
        }
        
        clock_gettime(CLOCK_MONOTONIC, &end);
        elapsed = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
        
        double mb_per_sec = (total_io / (1024.0 * 1024.0)) / elapsed;
        double iops = iterations / elapsed;
        
        if (block_size < 1024) {
            printf("%zu B\t\t%.2f\t\t%.0f\n", block_size, mb_per_sec, iops);
        } else {
            printf("%zu KB\t\t%.2f\t\t%.0f\n", block_size / 1024, mb_per_sec, iops);
        }
        
        free(buffer);
    }
    
    close(fd);
    unlink("blocksize_bench.dat");
    
    return 0;
}

static void usage(const char *prog)
{
    printf("Usage: %s [command]\n", prog);
    printf("\nCommands:\n");
    printf("  demo       Run all demonstrations\n");
    printf("  write      Demonstrate direct write\n");
    printf("  read       Demonstrate direct read\n");
    printf("  compare    Compare buffered vs direct I/O\n");
    printf("  mixed      Mixed buffered/direct I/O demo\n");
    printf("  alignment  Show alignment requirements\n");
    printf("  bench      Benchmark different block sizes\n");
    printf("  help       Show this help\n");
}

int main(int argc, char *argv[])
{
    struct io_uring ring;
    const char *cmd = "demo";
    int ret;
    
    if (argc > 1) {
        cmd = argv[1];
    }
    
    if (strcmp(cmd, "help") == 0 || strcmp(cmd, "-h") == 0) {
        usage(argv[0]);
        return 0;
    }
    
    /* Initialize io_uring */
    ret = io_uring_queue_init(QUEUE_DEPTH, &ring, 0);
    if (ret < 0) {
        fprintf(stderr, "io_uring_queue_init: %s\n", strerror(-ret));
        return 1;
    }
    
    /* Execute command */
    if (strcmp(cmd, "demo") == 0) {
        ret = direct_write_demo(&ring);
        if (ret == 0) ret = direct_read_demo(&ring);
        if (ret == 0) ret = compare_buffered_direct(&ring);
        if (ret == 0) ret = mixed_io_demo(&ring);
        if (ret == 0) ret = alignment_demo(&ring);
    } else if (strcmp(cmd, "write") == 0) {
        ret = direct_write_demo(&ring);
    } else if (strcmp(cmd, "read") == 0) {
        ret = direct_write_demo(&ring); /* Create file first */
        if (ret == 0) ret = direct_read_demo(&ring);
    } else if (strcmp(cmd, "compare") == 0) {
        ret = compare_buffered_direct(&ring);
    } else if (strcmp(cmd, "mixed") == 0) {
        ret = mixed_io_demo(&ring);
    } else if (strcmp(cmd, "alignment") == 0) {
        ret = alignment_demo(&ring);
    } else if (strcmp(cmd, "bench") == 0) {
        ret = benchmark_block_sizes(&ring);
    } else {
        fprintf(stderr, "Unknown command: %s\n", cmd);
        usage(argv[0]);
        ret = -1;
    }
    
    /* Cleanup */
    io_uring_queue_exit(&ring);
    
    /* Clean up any remaining files */
    if (strcmp(cmd, "demo") == 0 && ret == 0) {
        unlink("direct_write.dat");
    }
    
    return ret < 0 ? 1 : 0;
}```

---

## buffered-io

# buffered-io

## Description

This sample demonstrates various buffered I/O patterns using io_uring, showing how to efficiently manage application-level buffers for optimal I/O performance. It covers buffer pooling, double buffering, ring buffers, and pipeline patterns commonly used in high-performance applications.

Key features demonstrated:

- Buffer pool management for efficient memory usage
- Double buffering for overlapping I/O and processing
- Ring buffer implementation for streaming I/O
- Pipeline pattern for multi-stage processing
- Performance comparison of different buffer sizes
- Concurrent read/write operations with shared buffers

## Architecture

The sample showcases several buffering patterns:

1. **Buffer Pool**: Manages a pool of reusable buffers to avoid frequent allocations
2. **Double Buffering**: Overlaps I/O operations with data processing using two buffers
3. **Ring Buffer**: Implements circular buffer for continuous streaming operations
4. **Pipeline Pattern**: Multi-stage processing with buffers moving through pipeline
5. **Benchmark Suite**: Tests performance with various buffer sizes

Implementation details:

- Custom buffer pool with allocation tracking
- Request context attached to io_uring operations via user_data
- Demonstrates both sequential and concurrent I/O patterns
- Shows how to implement flow control with limited buffers

## How to Run

```bash
# Build
make build

# Run all demonstrations
./buffered-io demo

# Run specific demonstrations
./buffered-io basic      # Basic buffer pool demo
./buffered-io double     # Double buffering
./buffered-io ring       # Ring buffer streaming
./buffered-io pipeline   # Pipeline pattern
./buffered-io bench      # Buffer size benchmarks

# Run tests
make test

# Run benchmarks
make bench