first commit

io.h

@@ -0,0 +1,164 @@
+
+#define IO_VERSION_MAJOR 0
+#define IO_VERSION_MINOR 0
+
+# ifdef _WIN32
+#   define IO_PLATFORM_WINDOWS 1
+#   define IO_PLATFORM_LINUX   0
+#   define IO_PLATFORM_OTHER   0
+# elif __linux__
+#   define IO_PLATFORM_WINDOWS 0
+#   define IO_PLATFORM_LINUX   1
+#   define IO_PLATFORM_OTHER   0
+# else
+#   define IO_PLATFORM_WINDOWS 0
+#   define IO_PLATFORM_LINUX   0
+#   define IO_PLATFORM_OTHER   0
+# endif
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#if IO_PLATFORM_LINUX
+#include <stdatomic.h>
+#include <linux/io_uring.h>
+#endif
+
+/*
+ * The OS handle type.
+ */
+#if IO_PLATFORM_LINUX
+typedef int io_handle;
+#define IO_INVALID_HANDLE -1
+#elif IO_PLATFORM_WINDOWS
+typedef void *io_handle;
+#define IO_INVALID_HANDLE ((void*) -1)
+#endif
+
+/*
+ * Windows calls this structure OVERLAPPED
+ */
+#if IO_PLATFORM_WINDOWS
+struct io_overlap {
+    unsigned long *internal;
+    unsigned long *internal_high;
+    union {
+        struct {
+            unsigned long offset;
+            unsigned long offset_high;
+        };
+        void *pointer;
+    };
+    void *event;
+};
+#endif
+
+enum io_optype {
+    IO_VOID,
+    IO_RECV,
+    IO_SEND,
+    IO_ACCEPT,
+};
+
+struct io_operation {
+    enum io_optype type; // =IO_VOID when the struct is unused
+    void *user;
+
+    #if IO_PLATFORM_WINDOWS
+    struct io_overlap ov;
+    #endif
+};
+
+/*
+ * io_uring's input queue
+ */
+#if IO_PLATFORM_LINUX
+struct io_submission_queue {
+    _Atomic unsigned int *head;
+    _Atomic unsigned int *tail;
+    unsigned int *mask;
+    unsigned int *array;
+    unsigned int limit;
+    struct io_uring_sqe *entries;
+};
+#endif
+
+/*
+ * io_uring's output queue
+ */
+#if IO_PLATFORM_LINUX
+struct io_completion_queue {
+    _Atomic unsigned int *head;
+    _Atomic unsigned int *tail;
+    unsigned int *mask;
+    unsigned int limit;
+    struct io_uring_cqe *entries;
+};
+#endif
+
+struct io_context {
+
+    io_handle handle;
+    uint32_t max_ops;
+    struct io_operation *ops;
+
+    #if IO_PLATFORM_LINUX
+    struct io_submission_queue submissions;
+    struct io_completion_queue completions;
+    #endif
+};
+
+struct io_event {
+    bool error;
+    void *user;
+    enum io_optype type;
+
+    /*
+     * Operation-specific results
+     */
+    union {
+        uint32_t num;     // recv, send
+        io_handle handle; // accept
+    };
+};
+
+/*
+ * Initialize an I/O context
+ */
+bool io_context_init(struct io_context *ioc,
+                     struct io_operation *ops,
+                     uint32_t max_ops);
+
+/*
+ * Deinitialize an I/O context. This will not close any previously
+ * created handles.
+ */
+void io_context_free(struct io_context *ioc);
+
+/*
+ * Start an asynchronous receive operation on the handle. 
+ * Only one pending receive operation per handle is supported.
+ * 
+ * When the operation completes, one of the following calls to
+ * "io_wait" will return a completion event associated to this
+ * recv. The "num" field of the event will hold the number of
+ * bytes actually written from "dst". 
+ */
+bool io_start_recv(struct io_context *ioc, io_handle handle,
+                   void *dst, uint32_t max, void *user);
+
+/*
+ * Works like "io_start_recv" but for sending.
+ */
+bool io_start_send(struct io_context *ioc, io_handle handle,
+                   void *src, uint32_t num, void *user);
+
+
+bool io_start_accept(struct io_context *ioc, io_handle handle,
+                     void *user);
+
+/*
+ * Wait for the completion of an I/O event.
+ */
+void io_wait(struct io_context *ioc,
+             struct io_event *ev);