flare.runtime.io_uring_abi

5.1+. No-op; useful for testing the SQ/CQ round-trip.

5.1+. Vectored read.

5.1+. Vectored write — what flare uses to coalesce status + headers + body in a single submission (the writev(2) path on the io_uring backend; subsumes the epoll-fallback writev(2)).

5.1+. fsync(2) async.

5.1+. Read into a pre-registered buffer (file-serve fast path).

5.1+. Write from a pre-registered buffer.

5.1+. Async poll on an fd.

5.1+. Cancel a previous POLL_ADD.

5.3+. sendmsg(2) async.

5.3+. recvmsg(2) async.

5.4+. Timeout on a CQE; useful for arming a wakeup.

5.5+. Cancel a previous TIMEOUT.

5.5+. accept4(2) async — the listener-socket fast path.

5.5+. Cancel an in-flight SQE by user_data; the Cancel.SHUTDOWN plumbing on the io_uring backend uses this to interrupt long-running multishot recvs.

5.5+. Linked timeout.

5.5+. connect(2) async.

5.6+. close(2) async — used to drop the per-connection fd without a syscall round-trip on the response-completion path.

5.7+. Register a pool of buffers for IOSQE_BUFFER_SELECT recvs. Slow path -- one SQE per refill. flare ships a faster ring-mapped variant via :data:IORING_REGISTER_PBUF_RING (5.19+, 2.7x faster per Linux kernel benchmarks); see UringReactor.register_pbuf_ring.

5.1+. Register fixed buffers for IORING_OP_READ_FIXED / WRITE_FIXED. Not used by flare's HTTP path.

5.19+. Register a kernel-mapped provided-buffer ring for use with IOSQE_BUFFER_SELECT. Replaces the per-CQE IORING_OP_PROVIDE_BUFFERS SQE refill with a userspace tail-bump on shared memory -- 2.7x faster (27M vs 10M ops/sec kernel-bench, replenish-1 measurement). The ring memory is sizeof(struct io_uring_buf) * ring_entries (16 bytes each), page-aligned, shared with the kernel.

5.19+. Companion to :data:IORING_REGISTER_PBUF_RING.

5.1+. Block-IO polling instead of interrupt-driven completions. Not for network sockets.

5.1+. Kernel polls the SQ; userspace doesn't need to call io_uring_enter for submission. Trades one always-busy kernel thread per ring for zero-syscall submission. Useful for very high SQE rates (> 1 M/s) but requires CAP_SYS_NICE on some kernels OR registered file descriptors.

5.1+. Pin the SQPOLL thread to sq_thread_cpu.

5.1+. Use params.cq_entries to override the default 2 * sq_entries CQ size.

5.6+. Clamp entries / cq_entries to the kernel max instead of failing with EINVAL.

5.6+. Share the io-wq workers with another ring (specified in params.wq_fd).

5.10+. Start the ring in disabled state; enable later via io_uring_register(IORING_REGISTER_ENABLE_RINGS).

5.18+. io_uring_enter continues processing the SQ on a per-SQE error rather than aborting the batch. Eliminates the 'first SQE in batch errored, rest of batch lost' failure mode under SQ pressure.

5.19+. Don't use IPI-driven task work; instead, run task work cooperatively at io_uring_enter boundaries. Lower CPU overhead for the common case of a single thread per ring (which flare's per-worker UringReactor is). Combined with TASKRUN_FLAG below it tells userspace when to call enter.

5.19+. Sets IORING_SQ_TASKRUN in sq_ring->flags when there's pending task work. Userspace can poll the flag to know when to call io_uring_enter to run pending completions. Pairs with COOP_TASKRUN.

5.19+. Doubles SQE size to 128 bytes. flare's SQE codecs still target 64-byte SQEs; not enabled.

5.19+. Doubles CQE size to 32 bytes. flare's CQE codecs still target 16-byte CQEs; not enabled.

6.0+. Promise to the kernel that only one thread will submit SQEs to this ring. Lets the kernel skip atomic operations on the SQ submit path. flare's per-worker UringReactor matches this contract (each worker owns its own ring + drives it from one pthread). Required by DEFER_TASKRUN.

6.1+. The kernel runs task work ONLY when the app calls io_uring_enter (with the GETEVENTS flag). Batches CQE delivery to enter boundaries; eliminates the IPI-driven mid-syscall task work that interferes with the dispatch loop's CQE-drain rhythm. Highest-impact flag for the bufring throughput throttle when paired with SINGLE_ISSUER.

6.5+. Userspace allocates the SQ/CQ rings; kernel mmaps into them. Not used by flare.

6.5+. Only registered fds can be passed to SQEs. Not used by flare.

5.7+. Drop a previously-provided buffer pool.

5.6+. send(2) async.

5.6+. recv(2) async — the per-connection request-read fast path on the io_uring backend (combined with IORING_RECV_MULTISHOT from 6.0+ for the steady-state).

5.6+. read(2) / pread(2) async — works on any fd (not just sockets). Used for the cross-thread wakeup eventfd: IORING_OP_RECV returns -ENOTSOCK on an eventfd, but IORING_OP_READ does the right thing.

5.6+. write(2) / pwrite(2) async — companion to IORING_OP_READ.

5.6+. openat(2) async.

5.1+. The fd field is an index into the registered-files table set up via IORING_REGISTER_FILES (skips the syscall fdtable lookup).

5.2+. Drain the SQ before submitting this SQE.

5.3+. Link the next SQE to this one — the next SQE is deferred until this one completes successfully. flare uses this to chain recv → process → send without round-tripping userspace on the keep-alive hot path.

5.5+. Like IOSQE_IO_LINK but the next SQE runs even on this one's failure.

5.6+. Force the operation to be processed by the kernel worker thread pool (vs. inline).

5.7+. The kernel picks the buffer from a previously-provided buffer pool (used with IORING_OP_RECV for the steady-state per-connection recv).

5.17+. Don't post a CQE on success — used for fire-and- forget ops like IORING_OP_CLOSE after the response has been flushed.

Kernel 6.0+. Set in sqe->ioprio (NOT msg_flags!) to make an IORING_OP_RECV rearm itself after each completion. Each CQE includes IORING_CQE_F_MORE while the multishot is still armed; the kernel disarms on terminal errors (EOF, RST, ENOBUFS, etc) which surface as a CQE without F_MORE -- userspace re-arms then. The MULTISHOT bit is extracted from the recv_flags parameter of :func:prep_recv / :func:prep_recv_buffer_select and routed to sqe->ioprio automatically; callers don't need to handle the split. Kernel source: io_uring/net.c::io_recv_prep reads it via READ_ONCE(sqe->ioprio).

Kernel 5.19+. Set in sqe->ioprio to force a poll before the recv/send is attempted. Like MULTISHOT, this bit is extracted from recv_flags / send_flags and routed to sqe->ioprio by flare's prep helpers.

5.19+. Set in the SQE op_flags (accept_flags) on IORING_OP_ACCEPT. Same idea — the listener socket keeps firing accept completions without re-submission.

5.13+. Set in the SQE len field on IORING_OP_POLL_ADD to request a multishot poll: the kernel posts a CQE every time the requested poll mask is reached, without requiring userspace to re-arm. IORING_CQE_F_MORE in the CQE's flags indicates the multishot is still armed.

This is the io_uring analog of edge-triggered epoll_wait with EPOLLET — it lets a single SQE drive an arbitrary number of readiness notifications, which is the substrate that the upcoming server-loop dispatch swap (B0 wire-in) uses to replace the per-poll epoll_wait syscall on the io_uring backend.

5.13+. Set in the SQE len field on IORING_OP_POLL_REMOVE to indicate the SQE is a modify of an existing poll's event mask, not a remove.

5.13+. Set in the SQE len field on IORING_OP_POLL_REMOVE to indicate the SQE is a modify of an existing poll's user_data tag.

Data ready to read (analog of EPOLLIN).

Urgent data ready (analog of EPOLLPRI).

Writable without blocking (analog of EPOLLOUT).

Error condition (analog of EPOLLERR).

Peer hung up (analog of EPOLLHUP).

Peer closed for writing (analog of EPOLLRDHUP). Linux-specific; not in POSIX.

The CQE's flags high 16 bits encode the buffer-id picked by IOSQE_BUFFER_SELECT.

More CQEs are coming for this SQE (multishot accept / recv). When unset, the multishot has finished and the userspace driver must re-arm if it still wants events.

5.19+. The socket's recv buffer still has data after the completion drained one chunk; the driver should keep reaping without re-arming poll.

Wait for completions in io_uring_enter.

Wake the SQ-poll thread (only relevant with IORING_SETUP_SQPOLL).

Wait for the SQ to drain before returning.

5.11+. io_uring_enter's fifth argument points at an io_uring_getevents_arg (carrying a wait timeout) instead of a signal mask.

Size of the kernel struct io_uring_sqe. Constant since 5.1; IORING_SETUP_SQE128 (5.19+) doubles it but flare doesn't enable that mode.

Size of the kernel struct io_uring_cqe. Constant since 5.1; IORING_SETUP_CQE32 (5.19+) doubles it but flare doesn't enable that mode.