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

#include "liburing.h"

#define BS 4096
#define QD 32
#define MAX_OBJECTS 5

static struct io_uring ring[MAX_OBJECTS];
static int dev_fd;
static int ios;
static bool sqpoll;
static struct iovec iov;

static void *setup_iov_base(size_t size)
{
        void *buf;
        int fd;

        if (posix_memalign(&buf, BS, size) != 0) {
                printf("mem aligned failed\n");
                return NULL;
        }

        fd = open("/dev/urandom", O_RDONLY);
        if (fd < 0) {
                printf("Failed to open urandom. rc=%d\n", fd);
                return NULL;
        }

        read(fd, buf, size);
        close(fd);

        return buf;
}

static int init(void)
{
        struct io_uring_params p = { 0 };
        int i, rc;

        if (sqpoll) {
                p.flags = IORING_SETUP_SQPOLL;
                printf("Initializing liburing with SQPOLL flag\n");
        }

        dev_fd = open("/dev/nvme1n1", O_RDWR | O_DIRECT);
        if (dev_fd < 0) {
                printf("Failed to open nvme device. rc=%d\n", dev_fd);
                return dev_fd;
        }

         for (i = 0; i < MAX_OBJECTS; i++) {
                rc = io_uring_queue_init_params(QD, &ring[i], &p);
                if (rc != 0) {
                        printf("queue_init failed. rc=%d\n", rc);
                        return rc;
                }

                if (sqpoll) {
                        rc = io_uring_register_files(&ring[i], &dev_fd, 1);
                        if (rc < 0) {
                                printf("Failed to register files. rc=%d\n", rc);
                                return rc;
                        }
                }
        }

        iov.iov_base = setup_iov_base(BS);
        iov.iov_len = BS;

        return 0;
}

static inline void submit_to_kernel(char *failure_message, int thread_id)
{
        int rc;

        rc = io_uring_submit(&ring[thread_id]);
        if (rc < 0) {
                printf("%s. rc=%d\n", failure_message, rc);
        }
}

static struct io_uring_sqe *get_sqe(int tid, int *yield)
{
        struct io_uring_sqe *sqe;

        while ((sqe = io_uring_get_sqe(&ring[tid])) == NULL) {
                submit_to_kernel("Failure to wake napping thread", tid);
                *yield = *yield + 1;
                pthread_yield();
        }

        return sqe;
}

static void *submit_io(void *input)
{
        off_t offset = 0;
        int thread_id = *((int *)input);
        int total_ios = ios;
        int yield = 0;
                                                                                                                                                                                                    
        while (total_ios != 0) {
                struct io_uring_sqe *sqe = get_sqe(thread_id, &yield);

                if (sqpoll) {
                        io_uring_prep_writev(sqe, 0, &iov, 1, offset);
                        sqe->flags |= IOSQE_FIXED_FILE;
                } else {
                        io_uring_prep_writev(sqe, dev_fd, &iov, 1, offset);
                }

                sqe->user_data = offset;

                total_ios--;
                if (total_ios % QD == 0) {
                        submit_to_kernel("Failed to submit new IO", thread_id);
                }

                offset += BS;
        }

        printf("[thread_id=%d] Submission complete. yield=%d\n", thread_id, yield);

        return NULL;
}

static void *reap_io_completions(void *input)
{
        int thread_id = *((int *)input);
        int failed_ios = 0, rc;
        int total_ios = ios;

        while (total_ios != 0) {
                struct io_uring_cqe *cqe = NULL;

                rc = io_uring_wait_cqe(&ring[thread_id], &cqe);
                if (rc < 0 || cqe->res != BS) {
                        printf("thread_id=%d rc=%d cqe->res=%d offset=%llu\n", thread_id, rc, cqe->res, cqe->user_data);
                        failed_ios++;
                }

                total_ios--;
                io_uring_cqe_seen(&ring[thread_id], cqe);
        }

        printf("[thread_id=%d] Failed IO count=%d\n", thread_id, failed_ios);

        return NULL;
}

int main(int argc, char *argv[])
{
        pthread_t submit[MAX_OBJECTS], complete[MAX_OBJECTS];
        int t_ids[MAX_OBJECTS];
        int i, rc;

        if (argc != 3) {
                printf("Expected three arguments\n");
                return -EINVAL;
        }
        ios = atoi(argv[1]);
        sqpoll = atoi(argv[2]) == 1;

        rc = init();
        if (rc != 0) {
                return rc;
        }

        for (i = 0; i < MAX_OBJECTS; i++) {
                t_ids[i] = i;

                rc = pthread_create(&submit[i], NULL, submit_io, &t_ids[i]);
                if (rc < 0) {
                        printf("Failed to create submit thread. rc=%d\n", rc);
                        return rc;
                }

                rc = pthread_create(&complete[i], NULL, reap_io_completions, &t_ids[i]);
                if (rc < 0) {
                        printf("Failed to create complete thread. rc=%d\n", rc);
                        return rc;
                }
        }

        for (i = 0; i < MAX_OBJECTS; i++) {
                pthread_join(submit[i], NULL);
                printf("Reaped submit thread_id=%d\n", i);

                pthread_join(complete[i], NULL);
                printf("Reaped complete thread_id=%d\n", i);

                io_uring_queue_exit(&ring[i]);
        }

        close(dev_fd);

        return 0;
}

struct io_uring_params {
	__u32 sq_entries;
	__u32 cq_entries;
	__u32 flags;
	__u32 sq_thread_cpu;
	__u32 sq_thread_idle;
	__u32 features;
    __u32 op_last; /* IORING_OP_LAST set by kernel */
	__u32 resv[3];
	struct io_sqring_offsets sq_off;
	struct io_cqring_offsets cq_off;
};

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>

#include <liburing.h>

int main() {
    char buffer[1024];
    struct io_uring ring;
    struct sockaddr_in saddr;
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    int sockfd = 0, clientfd = 0, ret;

    io_uring_queue_init(32, &ring, 0);

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket");
        goto err;
    }

    saddr = (struct sockaddr_in) {
        .sin_family = AF_INET,
        .sin_addr = {
            .s_addr = htonl(INADDR_ANY),
        },
        .sin_port = htons(12345),
    };

    ret = bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if (ret < 0) {
        perror("bind");
        goto err;
    }

    ret = listen(sockfd, 32);
    if (ret < 0) {
        perror("listen");
        goto err;
    }

    clientfd = accept(sockfd, NULL, NULL);
    if (clientfd < 0) {
        perror("accept");
        goto err;
    }

    sqe = io_uring_get_sqe(&ring);
    io_uring_prep_recv(sqe, clientfd, buffer, sizeof(buffer), 0);

    ret = io_uring_submit_and_wait(&ring, 1);
    if (ret <= 0) {
        perror("io_uring_submit_and_wait");
        goto err;
    }

    io_uring_peek_cqe(&ring, &cqe);

    if (cqe->res < 0) {
        printf("recv failed: %d\n", cqe->res);
        goto err;
    }

err:
    io_uring_queue_exit(&ring);
    close(clientfd);
    close(sockfd);
}

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

char str1[32768];
char str2[32768];

struct io_uring ring;

void prep(int fd, char *str) {
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    struct iovec iov = {
        .iov_base = str,
        .iov_len = sizeof(str1),
    };
    io_uring_prep_readv(sqe, fd, &iov, 1, 0);
    sqe->user_data = fd;
    io_uring_submit(&ring);
    printf("SUBMIT: %d\n", fd);
}

void wait() {
    struct io_uring_cqe *cqe;
    io_uring_wait_cqe(&ring, &cqe);
    io_uring_cqe_seen(&ring, cqe);
    printf("FINISH: %d with res %d\n", (int)cqe->user_data, cqe->res);
}

int main() {
    io_uring_queue_init(32, &ring, 0);
    int fd1 = open("/path/to/large/file1", O_RDONLY);
    int fd2 = open("/path/to/large/file2", O_RDONLY);

    prep(fd1, str1);
    prep(fd2, str2);
    wait();
    wait();

    close(fd2);
    close(fd1);
    io_uring_queue_exit(&ring);
}

// connect.c
#include <liburing.h>
#include <stdio.h>
#include <netdb.h>
#include <sys/socket.h>
#include <unistd.h>

int main() {
    struct addrinfo hints = {
        .ai_family = AF_UNSPEC,
        .ai_socktype = SOCK_STREAM,
    }, *addr;

    if (getaddrinfo("github.com", "http", &hints, &addr) < 0) {
        return 1;
    }
    int clientfd = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
    if (clientfd < 0) return 2;

#ifndef USE_PLAIN_CONNECT
    struct io_uring ring;
    io_uring_queue_init(32, &ring, 0);

    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_connect(sqe, clientfd, addr->ai_addr, addr->ai_addrlen);
    io_uring_submit(&ring);

    struct io_uring_cqe *cqe;
    io_uring_wait_cqe(&ring, &cqe);
    io_uring_cqe_seen(&ring, cqe);
    int ret = cqe->res;

    io_uring_queue_exit(&ring);
#else
    int ret = connect(clientfd, addr->ai_addr, addr->ai_addrlen);
#endif

    printf("%d\n", ret);
    close(clientfd);
    return 0;
}

#include <unistd.h>
#include <sys/signalfd.h>
#include <sys/poll.h>

#include <liburing.h>

int main() {
    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask, SIGINT);

    sigprocmask(SIG_BLOCK, &mask, NULL);
    int sfd = signalfd(-1, &mask, SFD_NONBLOCK);

    struct io_uring ring;
    io_uring_queue_init(32, &ring, 0);

    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_poll_add(sqe, sfd, POLLIN);
    io_uring_submit(&ring);

    struct io_uring_cqe *cqe;
    io_uring_wait_cqe(&ring, &cqe);
    io_uring_cqe_seen(&ring, cqe);
    io_uring_queue_exit(&ring);

    close(sfd);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>

#include <liburing.h>


int main() {
    char buffer[1024];
    struct io_uring ring;
    struct iovec iov;
    struct sockaddr_in saddr;
    struct msghdr msg;
    struct io_uring_sqe *sqe;
    struct io_uring_cqe *cqe;
    int sockfd = 0, clientfd = 0, ret;

    io_uring_queue_init(32, &ring, 0);

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket");
        goto err;
    }

    saddr = (struct sockaddr_in) {
        .sin_family = AF_INET,
        .sin_addr = {
            .s_addr = htonl(INADDR_ANY),
        },
        .sin_port = htons(12345),
    };

    ret = bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr));
    if (ret < 0) {
        perror("bind");
        goto err;
    }

    ret = listen(sockfd, 32);
    if (ret < 0) {
        perror("listen");
        goto err;
    }

    clientfd = accept(sockfd, NULL, NULL);
    if (clientfd < 0) {
        perror("accept");
        goto err;
    }

    iov = (struct iovec) {
        .iov_base = buffer,
        .iov_len = sizeof(buffer),
    };

    msg = (struct msghdr) {
        .msg_namelen = sizeof(struct sockaddr_in),
        .msg_iov = &iov,
        .msg_iovlen = 1,
    };

    sqe = io_uring_get_sqe(&ring);
    io_uring_prep_recvmsg(sqe, clientfd, &msg, 0);

    ret = io_uring_submit_and_wait(&ring, 1);
    if (ret <= 0) {
        perror("io_uring_submit_and_wait");
        goto err;
    }

    io_uring_peek_cqe(&ring, &cqe);

    if (cqe->res < 0) {
        printf("recvmsg failed: %d\n", cqe->res);
        goto err;
    }

err:
    io_uring_queue_exit(&ring);
    close(clientfd);
    close(sockfd);
}

#include <unistd.h>
#include <liburing.h>

int main() {
	struct io_uring ring;
	io_uring_queue_init(8, &ring, 0);

    struct io_uring_sqe *sqe1 = io_uring_get_sqe(&ring);
    struct __kernel_timespec ts = {
        .tv_sec = 1,
        .tv_nsec = 0,
    };
    io_uring_prep_timeout(sqe1, &ts, 0, 0);
    io_uring_sqe_set_flags(sqe1, IOSQE_IO_LINK);

    struct io_uring_sqe *sqe2 = io_uring_get_sqe(&ring);
    struct iovec iov = {
        .iov_base = "OK\n",
        .iov_len = sizeof("OK\n"),
    };
    io_uring_prep_writev(sqe2, STDERR_FILENO, &iov, 1, 0);
    io_uring_submit_and_wait(&ring, 2);

    io_uring_queue_exit(&ring);
}

// test.c
#include <liburing.h>
#include <stdio.h>
#include <time.h>

int main() {
    struct io_uring ring;
    io_uring_queue_init(32, &ring, 0);
    printf("0: %ld\n", time(NULL));

{
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_nop(sqe);
    io_uring_submit(&ring);

    struct __kernel_timespec ts = {
        .tv_sec = 10,
        .tv_nsec = 0,
    };
    struct io_uring_cqe *cqe;
    io_uring_wait_cqe_timeout(&ring, &cqe, &ts);
    io_uring_cqe_seen(&ring, cqe);
    printf("1: %ld\n", time(NULL));
}
{
    struct __kernel_timespec ts = {
        .tv_sec = 1,
        .tv_nsec = 0,
    };
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
    io_uring_prep_timeout(sqe, &ts, 0, 0);
    io_uring_submit(&ring);

    struct io_uring_cqe *cqe;
    io_uring_wait_cqe(&ring, &cqe);
    io_uring_cqe_seen(&ring, cqe);
    printf("2: %ld\n", time(NULL));
}

    io_uring_queue_exit(&ring);
    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include "liburing.h"

struct thread_info_t {
	pthread_t tid;
	int num;
};

static void *doTest(void *arg) {
	struct io_uring ring;
	struct io_uring_cqe *cqe;
	struct io_uring_sqe *sqe;
	struct thread_info_t *ti;
	int ret;

	ti = (struct thread_info_t *)arg;
	printf("%d: start\n", ti->num);

	ret = io_uring_queue_init(128, &ring, 0);
	if (ret) {
		printf("%d: ring setup failed: %d\n", ti->num, ret);
		return arg;
	}

	sqe = io_uring_get_sqe(&ring);
	if (!sqe) {
		printf("%d: get sqe failed\n", ti->num);
		return arg;
	}

	io_uring_prep_nop(sqe);

	ret = io_uring_submit(&ring);
	if (ret <= 0) {
		printf("%d: sqe submit failed: %d\n", ti->num, ret);
		return arg;
	}

	ret = io_uring_wait_cqe(&ring, &cqe);
	if (ret < 0) {
		printf("%d: wait completion %d\n", ti->num, ret);
		return arg;
	}

	io_uring_cqe_seen(&ring, cqe);
	printf("%d: done\n", ti->num);
	return NULL;
}

int main(int argc, char *argv[])
{
	struct thread_info_t threads[10];
	int ret;
	void *res;

	for (int i=0; i<10; i++) {
		threads[i].num = i;
		ret = pthread_create(&threads[i].tid, NULL, doTest, &threads[i]);
		if (ret) {
			fprintf(stderr, "Thread create failed\n");
			return 1;
		}
	}

	for (int i=0; i<10; i++) {
		ret = pthread_join(threads[i].tid, &res);
		if (ret) {
			fprintf(stderr, "Thread join failed\n");
			return 1;
		}
		if (res) {
			fprintf(stderr, "Test failed\n");
			return 1;
		}
	}

	return 0;
}

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

#include "liburing.h"

#define DEVICE_SIZE (512ULL << 30)
#define BS 4096
#define QD 32

static struct io_uring ring;
static int dev_fd;

static void *setup_iov_base(size_t size)
{
        void *buf;
        int fd;

        if (posix_memalign(&buf, BS, size) != 0) {
                printf("mem aligned failed\n");
                return NULL;
        }

        fd = open("/dev/urandom", O_RDONLY);
        if (fd < 0) {
                printf("Failed to open urandom. rc=%d\n", fd);
                return NULL;
        }

        read(fd, buf, size);
        close(fd);
 
                                                                                                                                                                                         [76/282]
        return buf;
}

static int init(void)
{
        struct io_uring_params p = { 0 };
        time_t t;
        int rc;

        /* Implies no syscalls to submit IOs */
        p.flags = IORING_SETUP_SQPOLL;
        rc = io_uring_queue_init_params(QD, &ring, &p);
        if (rc != 0) {
                printf("queue_init failed. rc=%d\n", rc);
                return rc;
        }

        dev_fd = open("/dev/nvme1n1", O_RDWR | O_DIRECT);
        if (dev_fd < 0) {
                printf("Failed to open nvme device. rc=%d\n", dev_fd);
                return dev_fd;
        }

        /* SQPOLL only works with fixed files. */
        rc = io_uring_register_files(&ring, &dev_fd, 1);
        if (rc < 0) {
                printf("Failed to register files. rc=%d\n", rc);
                return rc;
        }

        srand((unsigned) time(&t));

        return 0;
}

static inline void submit_to_kernel(char *failure_message)
{
        int rc;

        rc = io_uring_submit(&ring);
        if (rc < 0) {
                printf("%s. rc=%d\n", failure_message, rc);
        }
}

static struct io_uring_sqe *get_sqe(int *yield)
{
        struct io_uring_sqe *sqe;

        while ((sqe = io_uring_get_sqe(&ring)) == NULL) {
                /* Kick kernel thread if it is taking a nap */
                submit_to_kernel("Failure to wake napping thread");

                *yield = *yield + 1;
                /* TODO: Use condition variables */
                pthread_yield();
        }

        return sqe;
}

static void *submit_io(void *input)
{
        char *buf = setup_iov_base(BS);
        off_t offset = 0;
        int total_ios = *((int *)input);
        int yield = 0;
       while (total_ios != 0) {
                struct io_uring_sqe *sqe = get_sqe(&yield);
                struct iovec iov = {
                        .iov_base = buf,
                        .iov_len = BS,
                };

                io_uring_prep_writev(sqe, 0, &iov, 1, offset);

                sqe->flags |= IOSQE_FIXED_FILE;
                sqe->user_data = offset;

                total_ios--;
                if (total_ios % QD == 0) {
                        submit_to_kernel("Failed to submit new IO");
                }

                offset += BS;
        }

        printf("submit_io yield %d times\n", yield);

        return NULL;
}

static void *reap_io_completions(void *input)
{
        int total_ios = *((int *)input);
        int failed_ios = 0;

        while (total_ios != 0) {
                struct io_uring_cqe *cqe = NULL;
                /* This call blocks if no CQE entries are available */
                int rc = io_uring_wait_cqe(&ring, &cqe);
                if (rc < 0 || cqe->res != BS) {
                        printf("rc=%d cqe->res=%d offset=%llu\n", rc, cqe->res, cqe->user_data);
                        failed_ios++;
                }

                total_ios--;
                io_uring_cqe_seen(&ring, cqe);
        }

        printf("Failed IO count=%d\n", failed_ios);

        return NULL;
}

int main(int argc, char *argv[])
{
        pthread_t submit, complete;
        int total_ios;
        int rc;

        if (argc != 2) {
                printf("Expected two arguments\n");
                return -EINVAL;
        }

        total_ios = atoi(argv[1]);

        rc = init();
        if (rc != 0) {
                return rc;
        }

        rc = pthread_create(&submit, NULL, submit_io, &total_ios);
        if (rc < 0) {
                printf("Failed to create submit thread. rc=%d\n", rc);
                return rc;
        }

        rc = pthread_create(&complete, NULL, reap_io_completions, &total_ios);

        if (rc < 0) {
                printf("Failed to create complete thread. rc=%d\n", rc);
                return rc;
        }

        pthread_join(submit, NULL);
        pthread_join(complete, NULL);

        io_uring_queue_exit(&ring);
        close(dev_fd);

        return 0;
}