zig/ourio_block_bench.jsonl

{"repo_name": "ourio", "file_name": "/ourio/src/stda/tls.zig", "inference_info": {"prefix_code": "const std = @import(\"std\");\nconst tls = @import(\"tls\");\nconst io = @import(\"ourio\");\n\nconst Allocator = std.mem.Allocator;\nconst CertBundle = tls.config.cert.Bundle;\nconst assert = std.debug.assert;\nconst mem = std.mem;\nconst posix = std.posix;\n\npub const Client = struct {\n    gpa: Allocator,\n    fd: posix.fd_t,\n    tls: tls.nonblock.Connection,\n    recv_task: ?*io.Task = null,\n\n    read_buf: [tls.max_ciphertext_record_len]u8 = undefined,\n    read_end: usize = 0,\n\n    cleartext_buf: std.ArrayListUnmanaged(u8) = .empty,\n    ciphertext_buf: std.ArrayListUnmanaged(u8) = .empty,\n    written: usize = 0,\n\n    userdata: ?*anyopaque = null,\n    callback: *const fn (*io.Ring, io.Task) anyerror!void = io.noopCallback,\n    close_msg: u16 = 0,\n    write_msg: u16 = 0,\n    recv_msg: u16 = 0,\n\n    pub const HandshakeTask = struct {\n        userdata: ?*anyopaque,\n        callback: io.Callback,\n        msg: u16,\n\n        fd: posix.fd_t,\n        buffer: [tls.max_ciphertext_record_len]u8 = undefined,\n        read_end: usize = 0,\n        handshake: tls.nonblock.Client,\n        task: *io.Task,\n\n        pub fn handleMsg(rt: *io.Ring, task: io.Task) anyerror!void {\n            const self = task.userdataCast(HandshakeTask);\n            const result = task.result.?;\n\n            switch (result) {\n                .write => {\n                    _ = result.write catch |err| {\n                        defer rt.gpa.destroy(self);\n                        // send the error to the callback\n                        try self.callback(rt, .{\n                            .userdata = self.userdata,\n                            .msg = self.msg,\n                            .result = .{ .userptr = err },\n                            .callback = self.callback,\n                            .req = .userptr,\n                        });\n                        return;\n                    };\n\n                    ", "suffix_code": "\n\n                    // Arm a recv task\n                    self.task = try rt.recv(self.fd, &self.buffer, .{\n                        .ptr = self,\n                        .cb = handleMsg,\n                    });\n                },\n\n                .recv => {\n                    const n = result.recv catch |err| {\n                        defer rt.gpa.destroy(self);\n                        // send the error to the callback\n                        try self.callback(rt, .{\n                            .userdata = self.userdata,\n                            .msg = self.msg,\n                            .result = .{ .userptr = err },\n                            .callback = self.callback,\n                            .req = .userptr,\n                        });\n                        return;\n                    };\n\n                    self.read_end += n;\n                    const slice = self.buffer[0..self.read_end];\n                    var scratch: [tls.max_ciphertext_record_len]u8 = undefined;\n                    const r = try self.handshake.run(slice, &scratch);\n\n                    if (r.unused_recv.len > 0) {\n                        // Arm a recv task\n                        self.task = try rt.recv(self.fd, self.buffer[self.read_end..], .{\n                            .ptr = self,\n                            .cb = handleMsg,\n                        });\n                        return;\n                    }\n\n                    if (r.send.len > 0) {\n                        // Queue another send\n                        @memcpy(self.buffer[0..r.send.len], r.send);\n                        self.task = try rt.write(\n                            self.fd,\n                            self.buffer[0..r.send.len],\n                            .beginning,\n                            .{ .ptr = self, .cb = HandshakeTask.handleMsg },\n                        );\n                        return;\n                    }\n\n                    if (self.handshake.done()) {\n                        defer rt.gpa.destroy(self);\n                        // Handshake is done. Create a client and deliver it to the callback\n                        const client = try self.initClient(rt.gpa);\n                        try self.callback(rt, .{\n                            .userdata = self.userdata,\n                            .msg = self.msg,\n                            .result = .{ .userptr = client },\n                            .callback = self.callback,\n                            .req = .userptr,\n                        });\n                        return;\n                    }\n                },\n\n                else => unreachable,\n            }\n        }\n\n        fn initClient(self: *HandshakeTask, gpa: Allocator) !*Client {\n            const client = try gpa.create(Client);\n            client.* = .{\n                .gpa = gpa,\n                .fd = self.fd,\n                .tls = .{ .cipher = self.handshake.inner.cipher },\n            };\n            return client;\n        }\n\n        /// Tries to cancel the handshake. Callback will receive an error.Canceled if cancelation\n        /// was successful, otherwise handhsake will proceed\n        pub fn cancel(self: *HandshakeTask, rt: *io.Ring) void {\n            self.task.cancel(rt, null, 0, io.noopCallback) catch {};\n        }\n    };\n\n    const Msg = enum {\n        write,\n        recv,\n        close_notify,\n    };\n\n    /// Initializes a handshake, which will ultimately deliver a Client to the callback via a\n    /// userptr result\n    pub fn init(\n        rt: *io.Ring,\n        fd: posix.fd_t,\n        opts: tls.config.Client,\n        ctx: io.Context,\n    ) !*HandshakeTask {\n        const hs = try rt.gpa.create(HandshakeTask);\n        hs.* = .{\n            .userdata = ctx.ptr,\n            .callback = ctx.cb,\n            .msg = ctx.msg,\n\n            .fd = fd,\n            .handshake = .init(opts),\n            .task = undefined,\n        };\n\n        const result = try hs.handshake.run(\"\", &hs.buffer);\n        const hs_ctx: io.Context = .{ .ptr = hs, .cb = HandshakeTask.handleMsg };\n        hs.task = try rt.write(hs.fd, result.send, .beginning, hs_ctx);\n        return hs;\n    }\n\n    pub fn deinit(self: *Client, gpa: Allocator) void {\n        self.ciphertext_buf.deinit(gpa);\n        self.cleartext_buf.deinit(gpa);\n    }\n\n    pub fn close(self: *Client, gpa: Allocator, rt: *io.Ring) !void {\n        // close notify is 2 bytes long\n        const len = self.tls.encryptedLength(2);\n        try self.ciphertext_buf.ensureUnusedCapacity(gpa, len);\n        const buf = self.ciphertext_buf.unusedCapacitySlice();\n        const msg = try self.tls.close(buf);\n\n        self.ciphertext_buf.items.len += msg.len;\n        _ = try rt.write(self.fd, self.ciphertext_buf.items[self.written..], .beginning, .{\n            .ptr = self,\n            .cb = Client.onCompletion,\n            .msg = @intFromEnum(Client.Msg.close_notify),\n        });\n\n        if (self.recv_task) |task| {\n            try task.cancel(rt, .{});\n            self.recv_task = null;\n        }\n    }\n\n    fn onCompletion(rt: *io.Ring, task: io.Task) anyerror!void {\n        const self = task.userdataCast(Client);\n        const result = task.result.?;\n\n        switch (task.msgToEnum(Client.Msg)) {\n            .recv => {\n                assert(result == .recv);\n                self.recv_task = null;\n                const n = result.recv catch |err| {\n                    return self.callback(rt, .{\n                        .userdata = self.userdata,\n                        .msg = self.recv_msg,\n                        .callback = self.callback,\n                        .req = .{ .recv = .{ .fd = self.fd, .buffer = &self.read_buf } },\n                        .result = .{ .recv = err },\n                    });\n                };\n                self.read_end += n;\n                const end = self.read_end;\n                const r = try self.tls.decrypt(self.read_buf[0..end], self.read_buf[0..end]);\n\n                if (r.cleartext.len > 0) {\n                    try self.callback(rt, .{\n                        .userdata = self.userdata,\n                        .msg = self.recv_msg,\n                        .callback = self.callback,\n                        .req = .{ .recv = .{ .fd = self.fd, .buffer = &self.read_buf } },\n                        .result = .{ .recv = r.cleartext.len },\n                    });\n                }\n                mem.copyForwards(u8, &self.read_buf, r.unused_ciphertext);\n                self.read_end = r.unused_ciphertext.len;\n\n                if (r.closed) {\n                    _ = try rt.close(self.fd, self.closeContext());\n                    return;\n                }\n\n                self.recv_task = try rt.recv(\n                    self.fd,\n                    self.read_buf[self.read_end..],\n                    self.recvContext(),\n                );\n            },\n\n            .write => {\n                assert(result == .write);\n                const n = result.write catch {\n                    return self.callback(rt, .{\n                        .userdata = self.userdata,\n                        .msg = self.write_msg,\n                        .callback = self.callback,\n                        .req = .{\n                            .write = .{\n                                .fd = self.fd,\n                                .buffer = self.ciphertext_buf.items,\n                                .offset = .beginning,\n                            },\n                        },\n                        .result = .{ .write = error.Unexpected },\n                    });\n                };\n                self.written += n;\n\n                if (self.written < self.ciphertext_buf.items.len) {\n                    _ = try rt.write(\n                        self.fd,\n                        self.ciphertext_buf.items[self.written..],\n                        .beginning,\n                        self.writeContext(),\n                    );\n                } else {\n                    defer {\n                        self.written = 0;\n                        self.ciphertext_buf.clearRetainingCapacity();\n                    }\n                    return self.callback(rt, .{\n                        .userdata = self.userdata,\n                        .msg = self.write_msg,\n                        .callback = self.callback,\n                        .req = .{\n                            .write = .{\n                                .fd = self.fd,\n                                .buffer = self.ciphertext_buf.items,\n                                .offset = .beginning,\n                            },\n                        },\n                        .result = .{ .write = self.written },\n                    });\n                }\n            },\n\n            .close_notify => {\n                assert(result == .write);\n                const n = result.write catch {\n                    return self.callback(rt, .{\n                        .userdata = self.userdata,\n                        .msg = self.close_msg,\n                        .callback = self.callback,\n                        .req = .{ .close = self.fd },\n                        .result = .{ .close = error.Unexpected },\n                    });\n                };\n\n                self.written += n;\n\n                if (self.written < self.ciphertext_buf.items.len) {\n                    _ = try rt.write(self.fd, self.ciphertext_buf.items[self.written..], .beginning, .{\n                        .ptr = self,\n                        .cb = Client.onCompletion,\n                        .msg = @intFromEnum(Client.Msg.close_notify),\n                    });\n                } else {\n                    self.written = 0;\n                    self.ciphertext_buf.clearRetainingCapacity();\n                    _ = try rt.close(self.fd, self.closeContext());\n                }\n            },\n        }\n    }\n\n    pub fn recv(self: *Client, rt: *io.Ring) !void {\n        if (self.recv_task != null) return;\n        self.recv_task = try rt.recv(\n            self.fd,\n            self.read_buf[self.read_end..],\n            self.recvContext(),\n        );\n    }\n\n    pub fn write(self: *Client, gpa: Allocator, bytes: []const u8) Allocator.Error!void {\n        try self.cleartext_buf.appendSlice(gpa, bytes);\n    }\n\n    pub fn flush(self: *Client, gpa: Allocator, rt: *io.Ring) !void {\n        const len = self.tls.encryptedLength(self.cleartext_buf.items.len);\n        try self.ciphertext_buf.ensureUnusedCapacity(gpa, len);\n        const slice = self.ciphertext_buf.unusedCapacitySlice();\n        const result = try self.tls.encrypt(self.cleartext_buf.items, slice);\n        self.ciphertext_buf.items.len += result.ciphertext.len;\n        self.cleartext_buf.replaceRangeAssumeCapacity(0, result.cleartext_pos, \"\");\n\n        _ = try rt.write(\n            self.fd,\n            self.ciphertext_buf.items,\n            .{\n                .ptr = self,\n                .msg = @intFromEnum(Client.Msg.write),\n                .cb = Client.onCompletion,\n            },\n        );\n    }\n\n    fn closeContext(self: Client) io.Context {\n        return .{ .ptr = self.userdata, .cb = self.callback, .msg = self.close_msg };\n    }\n\n    fn recvContext(self: *Client) io.Context {\n        return .{\n            .ptr = self,\n            .cb = Client.onCompletion,\n            .msg = @intFromEnum(Client.Msg.recv),\n        };\n    }\n\n    fn writeContext(self: *Client) io.Context {\n        return .{\n            .ptr = self,\n            .cb = Client.onCompletion,\n            .msg = @intFromEnum(Client.Msg.write),\n        };\n    }\n};\n", "middle_code": "if (self.handshake.done()) {\n                        defer rt.gpa.destroy(self);\n                        const client = try self.initClient(rt.gpa);\n                        try self.callback(rt, .{\n                            .userdata = self.userdata,\n                            .msg = self.msg,\n                            .result = .{ .userptr = client },\n                            .callback = self.callback,\n                            .req = .userptr,\n                        });\n                        return;\n                    }", "code_description": null, "fill_type": "BLOCK_TYPE", "language_type": "zig", "sub_task_type": "if_statement"}, "context_code": [["/ourio/src/stda/net/dns.zig", "const std = @import(\"std\");\nconst stda = @import(\"../../stda.zig\");\nconst ourio = @import(\"ourio\");\n\nconst Allocator = std.mem.Allocator;\nconst Context = ourio.Context;\nconst Ring = ourio.Ring;\nconst Task = ourio.Task;\nconst assert = std.debug.assert;\nconst net = stda.net;\nconst posix = std.posix;\n\nconst default_dns = &stda.options.nameservers;\n\npub const Resolver = struct {\n    gpa: Allocator,\n    ctx: Context,\n    config: Config = .{},\n\n    const Msg = enum { open_resolv, read_resolv };\n\n    /// initialize a Resolver instance. When the resolver is complete with initialization, a userptr\n    /// result type will be delivered to ctx. The resolver will then be ready to resolve DNS queries\n    pub fn init(\n        self: *Resolver,\n        gpa: Allocator,\n        io: *Ring,\n        ctx: Context,\n    ) Allocator.Error!void {\n        self.* = .{\n            .gpa = gpa,\n            .ctx = ctx,\n        };\n\n        _ = try io.open(\"/etc/resolv.conf\", .{ .CLOEXEC = true }, 0, .{\n            .cb = Resolver.onCompletion,\n            .ptr = self,\n            .msg = @intFromEnum(Msg.open_resolv),\n        });\n    }\n\n    pub fn deinit(self: *Resolver) void {\n        self.gpa.free(self.config.nameservers);\n    }\n\n    pub fn resolveQuery(self: *Resolver, io: *Ring, query: Question, ctx: ourio.Context) !void {\n        assert(self.config.nameservers.len > 0);\n\n        const conn = try self.gpa.create(Connection);\n        conn.* = .{ .gpa = self.gpa, .ctx = ctx, .config = self.config };\n        try conn.writeQuestion(query);\n\n        try conn.tryNext(io);\n    }\n\n    pub fn onCompletion(io: *Ring, task: Task) anyerror!void {\n        const self = task.userdataCast(Resolver);\n        const msg = task.msgToEnum(Resolver.Msg);\n        const result = task.result.?;\n\n        switch (msg) {\n            .open_resolv => {\n                const fd = result.open catch {\n                    self.config.nameservers = try self.gpa.dupe(std.net.Address, default_dns);\n                    const t: Task = .{\n                        .callback = self.ctx.cb,\n                        .msg = self.ctx.msg,\n                        .userdata = self.ctx.ptr,\n                        .result = .{ .userptr = self },\n                    };\n                    try self.ctx.cb(io, t);\n                    return;\n                };\n\n                const buffer = try self.gpa.alloc(u8, 4096);\n                errdefer self.gpa.free(buffer);\n\n                _ = try io.read(fd, buffer, .beginning, .{\n                    .cb = Resolver.onCompletion,\n                    .ptr = self,\n                    .msg = @intFromEnum(Resolver.Msg.read_resolv),\n                });\n            },\n\n            .read_resolv => {\n                const buffer = task.req.read.buffer;\n                defer self.gpa.free(buffer);\n\n                _ = try io.close(task.req.read.fd, .{});\n\n                const n = result.read catch |err| {\n                    const t: Task = .{\n                        .callback = self.ctx.cb,\n                        .msg = self.ctx.msg,\n                        .userdata = self.ctx.ptr,\n                        .result = .{ .userptr = err },\n                    };\n                    try self.ctx.cb(io, t);\n                    return;\n                };\n\n                if (n >= buffer.len) {\n                    @panic(\"TODO: more to read\");\n                }\n\n                var line_iter = std.mem.splitScalar(u8, buffer[0..n], '\\n');\n                var addresses: std.ArrayListUnmanaged(std.net.Address) = .empty;\n                defer addresses.deinit(self.gpa);\n\n                while (line_iter.next()) |line| {\n                    if (line.len == 0 or line[0] == ';' or line[0] == '#') continue;\n\n                    var iter = std.mem.splitAny(u8, line, &std.ascii.whitespace);\n                    const key = iter.first();\n\n                    if (std.mem.eql(u8, key, \"nameserver\")) {\n                        const addr = try std.net.Address.parseIp(iter.rest(), 53);\n                        try addresses.append(self.gpa, addr);\n                        continue;\n                    }\n\n                    if (std.mem.eql(u8, key, \"options\")) {\n                        while (iter.next()) |opt| {\n                            if (std.mem.startsWith(u8, opt, \"timeout:\")) {\n                                const timeout = std.fmt.parseInt(u5, opt[8..], 10) catch 30;\n                                self.config.timeout_s = @min(30, timeout);\n                                continue;\n                            }\n\n                            if (std.mem.startsWith(u8, opt, \"attempts:\")) {\n                                const attempts = std.fmt.parseInt(u3, opt[9..], 10) catch 5;\n                                self.config.attempts = @max(@min(5, attempts), 1);\n                                continue;\n                            }\n\n                            if (std.mem.eql(u8, opt, \"edns0\")) {\n                                self.config.edns0 = true;\n                                continue;\n                            }\n                        }\n                    }\n                }\n\n                self.config.nameservers = try addresses.toOwnedSlice(self.gpa);\n\n                const t: Task = .{\n                    .callback = self.ctx.cb,\n                    .msg = self.ctx.msg,\n                    .userdata = self.ctx.ptr,\n                    .result = .{ .userptr = self },\n                };\n                try self.ctx.cb(io, t);\n            },\n        }\n    }\n};\n\npub const Config = struct {\n    nameservers: []const std.net.Address = &.{},\n\n    /// timeout_s is silently capped to 30 according to man resolv.conf\n    timeout_s: u5 = 30,\n\n    /// attempts is capped at 5\n    attempts: u3 = 5,\n\n    edns0: bool = false,\n};\n\npub const Header = packed struct(u96) {\n    id: u16 = 0,\n\n    flags1: packed struct(u8) {\n        recursion_desired: bool = true,\n        truncated: bool = false,\n        authoritative_answer: bool = false,\n        opcode: enum(u4) {\n            query = 0,\n            inverse_query = 1,\n            server_status_request = 2,\n        } = .query,\n        is_response: bool = false,\n    } = .{},\n\n    flags2: packed struct(u8) {\n        response_code: enum(u4) {\n            success = 0,\n            format_error = 1,\n            server_failure = 2,\n            name_error = 3,\n            not_implemented = 4,\n            refuse = 5,\n        } = .success,\n        z: u3 = 0,\n        recursion_available: bool = false,\n    } = .{},\n\n    question_count: u16 = 0,\n\n    answer_count: u16 = 0,\n\n    authority_count: u16 = 0,\n\n    additional_count: u16 = 0,\n\n    pub fn asBytes(self: Header) [12]u8 {\n        var bytes: [12]u8 = undefined;\n        var fbs = std.io.fixedBufferStream(&bytes);\n        fbs.writer().writeInt(u16, self.id, .big) catch unreachable;\n\n        fbs.writer().writeByte(@bitCast(self.flags1)) catch unreachable;\n        fbs.writer().writeByte(@bitCast(self.flags2)) catch unreachable;\n\n        fbs.writer().writeInt(u16, self.question_count, .big) catch unreachable;\n        fbs.writer().writeInt(u16, self.answer_count, .big) catch unreachable;\n        fbs.writer().writeInt(u16, self.authority_count, .big) catch unreachable;\n        fbs.writer().writeInt(u16, self.additional_count, .big) catch unreachable;\n        assert(fbs.pos == 12);\n        return bytes;\n    }\n};\n\npub const Question = struct {\n    host: []const u8,\n    type: ResourceType = .A,\n    class: enum(u16) {\n        IN = 1,\n        // CS = 2,\n        // CH = 3,\n        // HS = 4,\n        // WILDCARD = 255,\n    } = .IN,\n};\n\npub const ResourceType = enum(u16) {\n    A = 1,\n    // NS = 2,\n    // MD = 3,\n    // MF = 4,\n    CNAME = 5,\n    // SOA = 6,\n    // MB = 7,\n    // MG = 8,\n    // MR = 9,\n    // NULL = 10,\n    // WKS = 11,\n    // PTR = 12,\n    // HINFO = 13,\n    // MINFO = 14,\n    // MX = 15,\n    // TXT = 16,\n    AAAA = 28,\n    SRV = 33,\n    // OPT = 41,\n};\n\npub const Answer = union(ResourceType) {\n    A: [4]u8,\n    CNAME: []const u8,\n    AAAA: [16]u8,\n    SRV: struct {\n        priority: u16,\n        weight: u16,\n        port: u16,\n        target: []const u8,\n    },\n};\n\npub const Response = struct {\n    bytes: []const u8,\n\n    pub fn header(self: Response) Header {\n        assert(self.bytes.len >= 12);\n        const readInt = std.mem.readInt;\n\n        return .{\n            .id = readInt(u16, self.bytes[0..2], .big),\n            .flags1 = @bitCast(self.bytes[2]),\n            .flags2 = @bitCast(self.bytes[3]),\n            .question_count = readInt(u16, self.bytes[4..6], .big),\n            .answer_count = readInt(u16, self.bytes[6..8], .big),\n            .authority_count = readInt(u16, self.bytes[8..10], .big),\n            .additional_count = readInt(u16, self.bytes[10..12], .big),\n        };\n    }\n\n    pub const AnswerIterator = struct {\n        bytes: []const u8,\n        /// offset into bytes\n        offset: usize = 0,\n\n        count: usize,\n        /// number of answers we have returned\n        idx: usize = 0,\n\n        pub fn next(self: *AnswerIterator) ?Answer {\n            if (self.idx >= self.count or self.offset >= self.bytes.len) return null;\n            defer self.idx += 1;\n\n            // Read the name\n            const b = self.bytes[self.offset];\n            if (b & 0b1100_0000 == 0) {\n                // Encoded name. Get past this\n                self.offset = std.mem.indexOfScalar(u8, self.bytes[self.idx..], 0x00) orelse\n                    return null;\n            } else {\n                // Name is pointer, we can advance 2 bytes\n                self.offset += 2;\n            }\n\n            const resource_int = std.mem.readInt(\n                u16,\n                self.bytes[self.offset..][0..2],\n                .big,\n            );\n            const typ: ResourceType = @enumFromInt(resource_int);\n            self.offset += 2;\n            const class = std.mem.readInt(u16, self.bytes[self.offset..][0..2], .big);\n            assert(class == 1);\n            self.offset += 2;\n            const ttl = std.mem.readInt(u32, self.bytes[self.offset..][0..4], .big);\n            _ = ttl;\n            self.offset += 4;\n            const rd_len = std.mem.readInt(u16, self.bytes[self.offset..][0..2], .big);\n            self.offset += 2;\n            defer self.offset += rd_len;\n\n            switch (typ) {\n                .A => {\n                    assert(rd_len == 4);\n                    return .{ .A = .{\n                        self.bytes[self.offset],\n                        self.bytes[self.offset + 1],\n                        self.bytes[self.offset + 2],\n                        self.bytes[self.offset + 3],\n                    } };\n                },\n\n                .CNAME => return .{ .CNAME = self.bytes[self.offset..][0..rd_len] },\n\n                .AAAA => {\n                    assert(rd_len == 4);\n                    return .{ .AAAA = .{\n                        self.bytes[self.offset],\n                        self.bytes[self.offset + 1],\n                        self.bytes[self.offset + 2],\n                        self.bytes[self.offset + 3],\n                        self.bytes[self.offset + 4],\n                        self.bytes[self.offset + 5],\n                        self.bytes[self.offset + 6],\n                        self.bytes[self.offset + 7],\n                        self.bytes[self.offset + 8],\n                        self.bytes[self.offset + 9],\n                        self.bytes[self.offset + 10],\n                        self.bytes[self.offset + 11],\n                        self.bytes[self.offset + 12],\n                        self.bytes[self.offset + 13],\n                        self.bytes[self.offset + 14],\n                        self.bytes[self.offset + 15],\n                    } };\n                },\n\n                .SRV => {\n                    assert(rd_len > 6);\n                    const rdata = self.bytes[self.offset..];\n                    const priority = std.mem.readInt(u16, rdata[0..2], .big);\n                    const weight = std.mem.readInt(u16, rdata[2..4], .big);\n                    const port = std.mem.readInt(u16, rdata[4..6], .big);\n\n                    var buf: [256]u8 = undefined;\n                    var idx: usize = 0;\n                    var offset: usize = 6;\n                    while (true) {\n                        const len = rdata[offset];\n                        if (len == 0x00) break;\n\n                        if (idx > 0) {\n                            buf[idx] = '.';\n                            idx += 1;\n                        }\n                        offset += 1;\n                        @memcpy(buf[idx .. idx + len], rdata[offset .. offset + len]);\n                        offset += len;\n                        idx += len;\n                    }\n\n                    return .{ .SRV = .{\n                        .priority = priority,\n                        .weight = weight,\n                        .port = port,\n                        .target = buf[0..idx],\n                    } };\n                },\n            }\n        }\n    };\n\n    pub fn answerIterator(self: Response) !AnswerIterator {\n        const h = self.header();\n\n        var offset: usize = 12;\n\n        var q: u16 = 0;\n        while (q < h.question_count) {\n            offset = std.mem.indexOfScalarPos(u8, self.bytes, offset, 0x00) orelse\n                return error.InvalidResponse;\n            offset += 4; // 2 bytes for type, 2 bytes for class\n            q += 1;\n        }\n\n        return .{\n            .bytes = self.bytes[offset..],\n            .count = h.answer_count,\n        };\n    }\n};\n\npub const Connection = struct {\n    gpa: Allocator,\n    ctx: Context,\n    config: Config,\n\n    nameserver: u8 = 0,\n    attempt: u5 = 0,\n\n    read_buffer: [2048]u8 = undefined,\n    write_buffer: std.ArrayListUnmanaged(u8) = .empty,\n    deadline: i64 = 0,\n\n    const Msg = enum { connect, recv };\n\n    pub fn tryNext(self: *Connection, io: *Ring) !void {\n        self.deadline = std.time.timestamp() + self.config.timeout_s;\n\n        if (self.attempt < self.config.attempts) {\n            const addr = self.config.nameservers[self.nameserver];\n            self.attempt += 1;\n\n            _ = try net.udpConnectToAddr(io, addr, .{\n                .cb = Connection.onCompletion,\n                .msg = @intFromEnum(Connection.Msg.connect),\n                .ptr = self,\n            });\n\n            return;\n        }\n\n        self.attempt = 0;\n\n        if (self.nameserver < self.config.nameservers.len) {\n            const addr = self.config.nameservers[self.nameserver];\n            self.nameserver += 1;\n\n            _ = try net.udpConnectToAddr(io, addr, .{\n                .cb = Connection.onCompletion,\n                .msg = @intFromEnum(Connection.Msg.connect),\n                .ptr = self,\n            });\n            return;\n        }\n\n        defer self.gpa.destroy(self);\n        try self.sendResult(io, .{ .userbytes = error.Timeout });\n    }\n\n    pub fn onCompletion(io: *Ring, task: Task) anyerror!void {\n        const self = task.userdataCast(Connection);\n        const msg = task.msgToEnum(Connection.Msg);\n        const result = task.result.?;\n\n        switch (msg) {\n            .connect => {\n                const fd = result.userfd catch return self.tryNext(io);\n\n                const recv_task = try io.recv(fd, &self.read_buffer, .{\n                    .cb = Connection.onCompletion,\n                    .ptr = self,\n                    .msg = @intFromEnum(Connection.Msg.recv),\n                });\n                try recv_task.setDeadline(io, .{ .sec = self.deadline });\n\n                const write_task = try io.write(fd, self.write_buffer.items, .beginning, .{});\n                try write_task.setDeadline(io, .{ .sec = self.deadline });\n            },\n\n            .recv => {\n                const n = result.recv catch {\n                    _ = try io.close(task.req.recv.fd, .{});\n                    return self.tryNext(io);\n                };\n\n                if (n == 0) {\n                    _ = try io.close(task.req.recv.fd, .{});\n                    return self.tryNext(io);\n                }\n\n                try self.sendResult(io, .{ .userbytes = self.read_buffer[0..n] });\n                _ = try io.close(task.req.recv.fd, .{});\n                self.gpa.destroy(self);\n            },\n        }\n    }\n\n    fn sendResult(self: *Connection, io: *Ring, result: ourio.Result) !void {\n        defer self.write_buffer.deinit(self.gpa);\n        const task: ourio.Task = .{\n            .callback = self.ctx.cb,\n            .userdata = self.ctx.ptr,\n            .msg = self.ctx.msg,\n            .result = result,\n        };\n        try self.ctx.cb(io, task);\n    }\n\n    fn writeQuestion(self: *Connection, query: Question) !void {\n        const header: Header = .{ .question_count = 1 };\n        var writer = self.write_buffer.writer(self.gpa);\n        try writer.writeAll(&header.asBytes());\n\n        var iter = std.mem.splitScalar(u8, query.host, '.');\n        while (iter.next()) |val| {\n            const len: u8 = @intCast(val.len);\n            try writer.writeByte(len);\n            try writer.writeAll(val);\n        }\n        try writer.writeByte(0x00);\n        try writer.writeInt(u16, @intFromEnum(query.type), .big);\n        try writer.writeInt(u16, @intFromEnum(query.class), .big);\n    }\n};\n\ntest \"Resolver\" {\n    const Anon = struct {\n        fn onOpen(_: *Task) ourio.Result {\n            return .{ .open = 1 };\n        }\n\n        fn onRead(task: *Task) ourio.Result {\n            const @\"resolv.conf\" =\n                \\\\nameserver 1.1.1.1\n                \\\\nameserver 1.0.0.1\n                \\\\options timeout:10 attempts:3\n            ;\n            @memcpy(task.req.read.buffer[0..@\"resolv.conf\".len], @\"resolv.conf\");\n            return .{ .read = @\"resolv.conf\".len };\n        }\n\n        fn onClose(_: *Task) ourio.Result {\n            return .{ .close = {} };\n        }\n\n        fn onSocket(_: *Task) ourio.Result {\n            return .{ .socket = 1 };\n        }\n\n        fn onConnect(_: *Task) ourio.Result {\n            return .{ .connect = {} };\n        }\n\n        fn onRecv(_: *Task) ourio.Result {\n            return .{ .recv = 1 };\n        }\n\n        fn onWrite(task: *Task) ourio.Result {\n            return .{ .write = task.req.write.buffer.len };\n        }\n    };\n\n    var io: ourio.Ring = try .initMock(std.testing.allocator, 16);\n    defer io.deinit();\n\n    io.backend.mock = .{\n        .open_cb = Anon.onOpen,\n        .read_cb = Anon.onRead,\n        .close_cb = Anon.onClose,\n        .socket_cb = Anon.onSocket,\n        .connect_cb = Anon.onConnect,\n        .recv_cb = Anon.onRecv,\n        .write_cb = Anon.onWrite,\n    };\n\n    var resolver: Resolver = undefined;\n    try resolver.init(std.testing.allocator, &io, .{});\n    defer resolver.deinit();\n\n    try std.testing.expectEqual(0, resolver.config.nameservers.len);\n    try std.testing.expectEqual(5, resolver.config.attempts);\n    try std.testing.expectEqual(30, resolver.config.timeout_s);\n\n    try io.run(.until_done);\n\n    try resolver.resolveQuery(&io, .{ .host = \"timculverhouse.com\" }, .{});\n    try io.run(.until_done);\n    try std.testing.expectEqual(2, resolver.config.nameservers.len);\n    try std.testing.expectEqual(3, resolver.config.attempts);\n    try std.testing.expectEqual(10, resolver.config.timeout_s);\n}\n\ntest \"Header roundtrip\" {\n    const header: Header = .{ .question_count = 1 };\n    const bytes = header.asBytes();\n    const response: Response = .{ .bytes = &bytes };\n    const resp_header = response.header();\n    try std.testing.expectEqual(header, resp_header);\n}\n"], ["/ourio/src/ourio/Kqueue.zig", "const Kqueue = @This();\n\nconst std = @import(\"std\");\nconst builtin = @import(\"builtin\");\n\nconst io = @import(\"../ourio.zig\");\n\nconst Allocator = std.mem.Allocator;\nconst EV = std.c.EV;\nconst EVFILT = std.c.EVFILT;\nconst Queue = @import(\"queue.zig\").Intrusive;\nconst assert = std.debug.assert;\nconst posix = std.posix;\n\ngpa: Allocator,\nkq: posix.fd_t,\n/// Items we have prepared and waiting to be put into kqueue\nsubmission_queue: std.ArrayListUnmanaged(posix.Kevent) = .empty,\n\n/// Tasks that have been submitted to kqueue\nin_flight: Queue(io.Task, .in_flight) = .{},\n\n/// Tasks which were completed synchronously during submission\nsynchronous_queue: Queue(io.Task, .complete) = .{},\n\n/// Queue for other kqueue instances to send \"completion\" tasks to this thread\nmsg_ring_queue: Queue(io.Task, .complete) = .{},\n\n/// Mutex to guard access to the msg_ring_queue. We *could* merge these tasks with the\n/// synchronous_queue, however we want to limit contention and msg_ring is probably pretty rare\n/// compared to synchronous tasks\nmsg_ring_mutex: std.Thread.Mutex = .{},\n\n/// List of timers, sorted descending so when we pop we get the next timer to expire\ntimers: std.ArrayListUnmanaged(Timer) = .empty,\n\nevents: [128]posix.Kevent = undefined,\nevent_idx: usize = 0,\n\nconst Timer = union(enum) {\n    /// a deadline timer cancels a task if it fires\n    deadline: struct {\n        /// the deadline task. If the parent completes before the deadline, the parent will set the\n        /// deadline task state to .free\n        task: *io.Task,\n\n        /// the task to cancel if the deadline expires\n        parent: *io.Task,\n    },\n\n    /// a regular timer\n    timeout: struct {\n        /// The task for the timer\n        task: *io.Task,\n\n        /// Absolute time in ms the timer was added\n        added_ms: i64,\n    },\n\n    /// Timer expires in the return value milliseconds from now\n    fn expiresInMs(self: Timer, now_abs: i64) i64 {\n        switch (self) {\n            .deadline => |deadline| {\n                const ts = deadline.task.req.deadline;\n                const expires_ms = ts.sec * std.time.ms_per_s + @divTrunc(ts.nsec, std.time.ns_per_ms);\n                return expires_ms - now_abs;\n            },\n\n            // timeouts are relative, so we add the time it was added to the queue\n            .timeout => |timeout| {\n                const ts = timeout.task.req.timer;\n                const expires_ms = ts.sec * std.time.ms_per_s +\n                    @divTrunc(ts.nsec, std.time.ns_per_ms) +\n                    timeout.added_ms;\n                return expires_ms - now_abs;\n            },\n        }\n    }\n\n    /// returns a timespec suitable for a kevent timeout. Relative to now\n    fn timespec(self: Timer) posix.timespec {\n        const expires = self.expiresInMs(std.time.milliTimestamp());\n        return .{ .sec = @divFloor(expires, 1000), .nsec = @mod(expires, 1000) * std.time.ns_per_ms };\n    }\n\n    fn lessThan(now_ms: i64, lhs: Timer, rhs: Timer) bool {\n        // reverse sort (we want soonest expiring last)\n        return lhs.expiresInMs(now_ms) > rhs.expiresInMs(now_ms);\n    }\n};\n\n/// Messages we are waiting on using an EVFILT.USER\nconst UserMsg = enum {\n    /// A general wakeup message\n    wakeup,\n\n    fn fromInt(v: i64) UserMsg {\n        return @enumFromInt(v);\n    }\n};\n\n/// Initialize a Ring\npub fn init(gpa: Allocator, _: u16) !Kqueue {\n    const kq = try posix.kqueue();\n\n    // Register a wakeup EVFILT.USER to wake up this kqueue\n    var kevent = evSet(\n        @intFromEnum(UserMsg.wakeup),\n        EVFILT.USER,\n        EV.ADD | EV.CLEAR,\n        null,\n    );\n    kevent.fflags = std.c.NOTE.FFNOP;\n    _ = try posix.kevent(kq, &.{kevent}, &.{}, null);\n\n    return .{ .gpa = gpa, .kq = kq };\n}\n\npub fn deinit(self: *Kqueue, gpa: Allocator) void {\n    while (self.msg_ring_queue.pop()) |task| gpa.destroy(task);\n    while (self.in_flight.pop()) |task| gpa.destroy(task);\n\n    self.submission_queue.deinit(gpa);\n    self.timers.deinit(gpa);\n\n    posix.close(self.kq);\n    self.* = undefined;\n}\n\n/// Initializes a child Ring which can be woken up by self. This must be called from the thread\n/// which will operate the child ring. Initializes with the same queue size as the parent\npub fn initChild(self: Kqueue, entries: u16) !Kqueue {\n    return init(self.gpa, entries);\n}\n\npub fn submitAndWait(self: *Kqueue, queue: *io.SubmissionQueue) !void {\n    defer self.submission_queue.clearRetainingCapacity();\n    while (queue.pop()) |task| {\n        try self.prepTask(task);\n\n        // If this task is queued and has a deadline we need to schedule a timer\n        if (task.deadline) |deadline| {\n            try self.addTimer(.{ .deadline = .{ .task = deadline, .parent = task } });\n        }\n    }\n\n    // Sort our timers\n    const now = std.time.milliTimestamp();\n    std.sort.insertion(Timer, self.timers.items, now, Timer.lessThan);\n\n    if (self.synchronous_queue.empty()) {\n        // We don't have any synchronous completions, so we need to wait for some from kqueue\n        return self.wait();\n    }\n\n    // We already have completions from synchronous tasks. Submit our queued events and grab any new\n    // completions for processing. We do so with a 0 timeout so that we are only grabbing already\n    // completed items\n    const timeout: posix.timespec = .{ .sec = 0, .nsec = 0 };\n    self.event_idx = try posix.kevent(self.kq, self.submission_queue.items, &self.events, &timeout);\n}\n\nfn wait(self: *Kqueue) !void {\n    assert(self.synchronous_queue.empty());\n\n    // Go through our times until the first unexpired one\n    while (true) {\n        const t = self.timers.getLastOrNull() orelse break;\n        const timeout: posix.timespec = t.timespec();\n\n        self.event_idx = try posix.kevent(\n            self.kq,\n            self.submission_queue.items,\n            &self.events,\n            &timeout,\n        );\n        return;\n    }\n\n    // We had no timers so we wait indefinitely\n    self.event_idx = try posix.kevent(\n        self.kq,\n        self.submission_queue.items,\n        &self.events,\n        null,\n    );\n}\n\npub fn submit(self: *Kqueue, queue: *io.SubmissionQueue) !void {\n    defer self.submission_queue.clearRetainingCapacity();\n    while (queue.pop()) |task| {\n        try self.prepTask(task);\n\n        // If this task is queued and has a deadline we need to schedule a timer\n        if (task.state == .in_flight and task.deadline != null) {\n            const deadline = task.deadline.?;\n            try self.addTimer(.{ .deadline = .{ .task = deadline, .parent = task } });\n        }\n    }\n\n    // Sort our timers\n    const now = std.time.milliTimestamp();\n    std.sort.insertion(Timer, self.timers.items, now, Timer.lessThan);\n\n    // For submit, we don't try to reap any completions. Calls to submit will likely be relying on a\n    // `poll` of the kqueue. We check in reapCompletinos if we have no reaped events and grab them\n    // there if needed\n    const timeout: posix.timespec = .{ .sec = 0, .nsec = 0 };\n    _ = try posix.kevent(self.kq, self.submission_queue.items, &.{}, &timeout);\n}\n\n/// preps a task to be submitted into the kqueue\nfn prepTask(self: *Kqueue, task: *io.Task) !void {\n    return switch (task.req) {\n        .accept => |req| {\n            self.in_flight.push(task);\n            const kevent = evSet(@intCast(req.fd), EVFILT.READ, EV.ADD, task);\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .cancel => |req| {\n            // Cancel tasks are handled like this:\n            // 0. If the task is not in flight, we don't do anything\n            // 1. We set the cancel_task state as canceled\n            // 2. If there is a kqueue event associated with it, we prep a kevent with EV.DELETE\n            // 3. We add the task to the synchronous queue. This let's us ensure we hold the\n            //    cancel state until we've submitted the kevent associated with it. If any\n            //    completions occur while the state is canceled, we will ignore them.\n            // 4. Callbacks are not called in the submit phase. We only call the callback of the\n            //    cancel_task with error.Canceled in reapCompletions\n            // 5. In reapCompletions, we will return both the task and the cancel_task to the free\n            //    list\n\n            self.synchronous_queue.push(task);\n\n            task.result = .{ .cancel = {} };\n            switch (req) {\n                .all => {\n                    while (self.in_flight.head) |t| {\n                        defer self.synchronous_queue.push(t);\n\n                        self.cancelTask(t) catch continue;\n                    }\n\n                    while (self.timers.getLastOrNull()) |tmr| {\n                        switch (tmr) {\n                            inline else => |v| {\n                                defer self.synchronous_queue.push(v.task);\n                                self.cancelTask(v.task) catch continue;\n                            },\n                        }\n                    }\n                },\n                .task => |task_to_cancel| {\n                    switch (task_to_cancel.state) {\n                        .free, .canceled, .complete => {\n                            task.result = .{ .cancel = error.NotCanceled };\n                            return;\n                        },\n                        .in_flight => {},\n                    }\n                    try self.cancelTask(task_to_cancel);\n                },\n            }\n        },\n\n        .close => |req| {\n            task.result = .{ .close = {} };\n            self.synchronous_queue.push(task);\n            posix.close(req);\n        },\n\n        .connect => |req| {\n            // Set nonblocking. Call connect. Then add it to the kqueue. This will return as\n            // writeable when the connect is complete\n            const arg: posix.O = .{ .NONBLOCK = true };\n            const arg_u32: u32 = @bitCast(arg);\n            _ = posix.fcntl(req.fd, posix.F.SETFL, arg_u32) catch {\n                task.result = .{ .connect = error.Unexpected };\n                self.synchronous_queue.push(task);\n                return;\n            };\n\n            if (posix.connect(req.fd, req.addr, req.addr_len)) {\n                // We connected immediately. No need to add to kqueue. Just push to the synchronous\n                // queue to call the callback later\n                task.result = .{ .connect = {} };\n                self.synchronous_queue.push(task);\n            } else |err| {\n                switch (err) {\n                    error.WouldBlock => {\n                        self.in_flight.push(task);\n                        // This is the error we expect. Add the event to kqueue\n                        const kevent = evSet(@intCast(req.fd), EVFILT.WRITE, EV.ADD | EV.ONESHOT, task);\n                        try self.submission_queue.append(self.gpa, kevent);\n                    },\n                    else => {\n                        task.result = .{ .connect = error.Unexpected };\n                        self.synchronous_queue.push(task);\n                    },\n                }\n            }\n        },\n\n        // deadlines are handled separately\n        .deadline => unreachable,\n\n        .msg_ring => |req| {\n            const target = req.target;\n\n            target.backend.platform.msg_ring_mutex.lock();\n            target.backend.platform.msg_ring_queue.push(req.task);\n            target.backend.platform.msg_ring_mutex.unlock();\n\n            task.result = .{ .msg_ring = {} };\n            self.synchronous_queue.push(task);\n\n            // wake up the other ring\n            var kevent = evSet(\n                @intFromEnum(UserMsg.wakeup),\n                EVFILT.USER,\n                0,\n                null,\n            );\n            kevent.fflags |= std.c.NOTE.TRIGGER;\n            // Trigger the wakeup\n            _ = try posix.kevent(target.backend.platform.kq, &.{kevent}, &.{}, null);\n        },\n\n        .noop => {\n            task.result = .noop;\n            self.synchronous_queue.push(task);\n        },\n\n        .open => |req| {\n            self.synchronous_queue.push(task);\n            const rc = posix.open(req.path, req.flags, req.mode);\n            task.result = .{ .open = rc };\n        },\n\n        .poll => |req| {\n            self.in_flight.push(task);\n            if (req.mask & posix.POLL.IN != 0) {\n                const kevent = evSet(@intCast(req.fd), EVFILT.READ, EV.ADD | EV.ONESHOT, task);\n                try self.submission_queue.append(self.gpa, kevent);\n            }\n            if (req.mask & posix.POLL.OUT != 0) {\n                const kevent = evSet(@intCast(req.fd), EVFILT.WRITE, EV.ADD | EV.ONESHOT, task);\n                try self.submission_queue.append(self.gpa, kevent);\n            }\n        },\n\n        .read => |req| {\n            self.in_flight.push(task);\n            const kevent = evSet(@intCast(req.fd), EVFILT.READ, EV.ADD | EV.ONESHOT, task);\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .readv => |req| {\n            self.in_flight.push(task);\n            const kevent = evSet(@intCast(req.fd), EVFILT.READ, EV.ADD | EV.ONESHOT, task);\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .recv => |req| {\n            self.in_flight.push(task);\n            const kevent = evSet(@intCast(req.fd), EVFILT.READ, EV.ADD | EV.ONESHOT, task);\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .socket => |req| {\n            self.synchronous_queue.push(task);\n            if (posix.socket(req.domain, req.type, req.protocol)) |fd|\n                task.result = .{ .socket = fd }\n            else |_|\n                task.result = .{ .socket = error.Unexpected };\n        },\n\n        .splice => |req| {\n            self.in_flight.push(task);\n            const kevent = evSet(@intCast(req.fd_in), EVFILT.READ, EV.ADD | EV.ONESHOT, task);\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .statx => |*req| {\n            self.synchronous_queue.push(task);\n            const flags: u32 = if (req.symlink_follow) 0 else posix.AT.SYMLINK_NOFOLLOW;\n\n            if (posix.fstatat(posix.AT.FDCWD, req.path, flags)) |stat| {\n                req.result.* = .{\n                    .mask = 0,\n                    .blksize = @intCast(stat.blksize),\n                    .attributes = 0,\n                    .nlink = @intCast(stat.nlink),\n                    .uid = @intCast(stat.uid),\n                    .gid = @intCast(stat.gid),\n                    .mode = @intCast(stat.mode),\n                    .__pad1 = 0,\n                    .ino = @intCast(stat.ino),\n                    .size = @intCast(stat.size),\n                    .blocks = @intCast(stat.blocks),\n                    .attributes_mask = 0,\n                    .atime = .{\n                        .sec = @intCast(stat.atime().sec),\n                        .nsec = @intCast(stat.atime().nsec),\n                    },\n                    .btime = .{\n                        .sec = 0,\n                        .nsec = 0,\n                    },\n                    .ctime = .{\n                        .sec = @intCast(stat.ctime().sec),\n                        .nsec = @intCast(stat.ctime().nsec),\n                    },\n                    .mtime = .{\n                        .sec = @intCast(stat.mtime().sec),\n                        .nsec = @intCast(stat.mtime().nsec),\n                    },\n                    .rdev_major = major(@intCast(stat.rdev)),\n                    .rdev_minor = minor(@intCast(stat.rdev)),\n                    .dev_major = major(@intCast(stat.dev)),\n                    .dev_minor = major(@intCast(stat.dev)),\n                    .__pad2 = undefined,\n                };\n                task.result = .{ .statx = req.result };\n            } else |_| task.result = .{ .statx = error.Unexpected };\n        },\n\n        .timer => {\n            const now = std.time.milliTimestamp();\n            try self.addTimer(.{ .timeout = .{ .task = task, .added_ms = now } });\n        },\n\n        // user* fields are never seen by the runtime, only for internal message passing\n        .userbytes, .userfd, .usermsg, .userptr => unreachable,\n\n        .write => |req| {\n            self.in_flight.push(task);\n            const kevent = evSet(@intCast(req.fd), EVFILT.WRITE, EV.ADD | EV.ONESHOT, task);\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .writev => |req| {\n            self.in_flight.push(task);\n            const kevent = evSet(@intCast(req.fd), EVFILT.WRITE, EV.ADD | EV.ONESHOT, task);\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n    };\n}\n\nfn cancelTask(self: *Kqueue, task: *io.Task) !void {\n    task.state = .canceled;\n    if (task.deadline) |d| d.state = .canceled;\n\n    switch (task.req) {\n        // Handled synchronously. Probably we couldn't cancel it, but if we did somehow we\n        // don't need to do anything either way\n        .cancel,\n        .close,\n        .msg_ring,\n        .noop,\n        .open,\n        .socket,\n        .statx,\n        .userbytes,\n        .userfd,\n        .usermsg,\n        .userptr,\n        => {},\n\n        .accept => |cancel_req| {\n            self.in_flight.remove(task);\n            task.result = .{ .accept = error.Canceled };\n            const kevent = evSet(@intCast(cancel_req.fd), EVFILT.READ, EV.DELETE, task);\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .connect => |cancel_req| {\n            self.in_flight.remove(task);\n            task.result = .{ .connect = error.Canceled };\n            const kevent = evSet(\n                @intCast(cancel_req.fd),\n                EVFILT.WRITE,\n                EV.DELETE,\n                task,\n            );\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .deadline => {\n            // What does it mean to cancel a deadline? We remove the deadline from\n            // the parent and the timer from our list\n            for (self.timers.items, 0..) |t, i| {\n                if (t == .deadline and t.deadline.task == task) {\n                    // Set the parent deadline to null\n                    t.deadline.parent.deadline = null;\n                    // Remove the timer\n                    _ = self.timers.orderedRemove(i);\n                    task.result = .{ .deadline = error.Canceled };\n                    return;\n                }\n            } else task.result = .{ .cancel = error.EntryNotFound };\n        },\n\n        .poll => |cancel_req| {\n            self.in_flight.remove(task);\n            task.result = .{ .poll = error.Canceled };\n            if (cancel_req.mask & posix.POLL.IN != 0) {\n                const kevent = evSet(@intCast(cancel_req.fd), EVFILT.READ, EV.DELETE, task);\n                try self.submission_queue.append(self.gpa, kevent);\n            }\n            if (cancel_req.mask & posix.POLL.OUT != 0) {\n                const kevent = evSet(@intCast(cancel_req.fd), EVFILT.WRITE, EV.DELETE, task);\n                try self.submission_queue.append(self.gpa, kevent);\n            }\n        },\n\n        .read => |cancel_req| {\n            self.in_flight.remove(task);\n            task.result = .{ .read = error.Canceled };\n            const kevent = evSet(\n                @intCast(cancel_req.fd),\n                EVFILT.READ,\n                EV.DELETE,\n                task,\n            );\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .readv => |cancel_req| {\n            self.in_flight.remove(task);\n            task.result = .{ .readv = error.Canceled };\n            const kevent = evSet(\n                @intCast(cancel_req.fd),\n                EVFILT.READ,\n                EV.DELETE,\n                task,\n            );\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .recv => |cancel_req| {\n            self.in_flight.remove(task);\n            task.result = .{ .recv = error.Canceled };\n            const kevent = evSet(\n                @intCast(cancel_req.fd),\n                EVFILT.READ,\n                EV.DELETE,\n                task,\n            );\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .splice => |cancel_req| {\n            self.in_flight.remove(task);\n            task.result = .{ .read = error.Canceled };\n            const kevent = evSet(\n                @intCast(cancel_req.fd_out),\n                EVFILT.READ,\n                EV.DELETE,\n                task,\n            );\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .timer => {\n            for (self.timers.items, 0..) |t, i| {\n                if (t == .timeout and t.timeout.task == task) {\n                    // Remove the timer\n                    _ = self.timers.orderedRemove(i);\n                    task.result = .{ .timer = error.Canceled };\n                    return;\n                }\n            } else task.result = .{ .cancel = error.EntryNotFound };\n        },\n\n        .write => |cancel_req| {\n            self.in_flight.remove(task);\n            task.result = .{ .write = error.Canceled };\n            const kevent = evSet(\n                @intCast(cancel_req.fd),\n                EVFILT.WRITE,\n                EV.DELETE,\n                task,\n            );\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n\n        .writev => |cancel_req| {\n            self.in_flight.remove(task);\n            task.result = .{ .writev = error.Canceled };\n            const kevent = evSet(\n                @intCast(cancel_req.fd),\n                EVFILT.WRITE,\n                EV.DELETE,\n                task,\n            );\n            try self.submission_queue.append(self.gpa, kevent);\n        },\n    }\n}\n\nfn addTimer(self: *Kqueue, t: Timer) !void {\n    try self.timers.append(self.gpa, t);\n}\n\nfn evSet(ident: usize, filter: i16, flags: u16, ptr: ?*anyopaque) posix.Kevent {\n    return switch (builtin.os.tag) {\n        .netbsd,\n        .dragonfly,\n        .openbsd,\n        .macos,\n        .ios,\n        .tvos,\n        .watchos,\n        .visionos,\n        => .{\n            .ident = ident,\n            .filter = filter,\n            .flags = flags,\n            .fflags = 0,\n            .data = 0,\n            .udata = @intFromPtr(ptr),\n        },\n\n        .freebsd => .{\n            .ident = ident,\n            .filter = filter,\n            .flags = flags,\n            .fflags = 0,\n            .data = 0,\n            .udata = @intFromPtr(ptr),\n            ._ext = .{ 0, 0, 0, 0 },\n        },\n\n        else => @compileError(\"kqueue not supported\"),\n    };\n}\n\npub fn done(self: *Kqueue) bool {\n    if (self.timers.items.len == 0 and\n        self.in_flight.empty() and\n        self.submission_queue.items.len == 0)\n    {\n        self.msg_ring_mutex.lock();\n        defer self.msg_ring_mutex.unlock();\n        return self.msg_ring_queue.empty();\n    }\n\n    return false;\n}\n\n/// Return a file descriptor which can be used to poll the ring for completions\npub fn pollableFd(self: Kqueue) !posix.fd_t {\n    return self.kq;\n}\n\npub fn reapCompletions(self: *Kqueue, rt: *io.Ring) anyerror!void {\n    defer self.event_idx = 0;\n\n    if (self.event_idx == 0) {\n        const timeout: posix.timespec = .{ .sec = 0, .nsec = 0 };\n        self.event_idx = try posix.kevent(\n            self.kq,\n            self.submission_queue.items,\n            &self.events,\n            &timeout,\n        );\n    }\n\n    for (self.events[0..self.event_idx]) |event| {\n        // if the event is a USER filter, we check our msg_ring_queue\n        if (event.filter == EVFILT.USER) {\n            switch (UserMsg.fromInt(event.data)) {\n                .wakeup => {\n                    // We got a message in our msg_ring_queue\n                    self.msg_ring_mutex.lock();\n                    defer self.msg_ring_mutex.unlock();\n\n                    while (self.msg_ring_queue.pop()) |task| {\n                        // For canceled msg_rings we do nothing\n                        if (task.state == .canceled) continue;\n\n                        defer self.releaseTask(rt, task);\n                        if (task.result == null) task.result = .noop;\n                        try task.callback(rt, task.*);\n                    }\n                },\n            }\n            continue;\n        }\n\n        const task: *io.Task = @ptrFromInt(event.udata);\n        if (task.state == .canceled) continue;\n        try self.handleCompletion(rt, task, event);\n    }\n\n    while (self.synchronous_queue.pop()) |task| {\n        try self.handleSynchronousCompletion(rt, task);\n    }\n\n    const now = std.time.milliTimestamp();\n    while (self.timers.getLastOrNull()) |t| {\n        if (t.expiresInMs(now) > 0) break;\n        _ = self.timers.pop();\n        try self.handleExpiredTimer(rt, t);\n    }\n}\n\n/// Handle a completion which was done synchronously. The work has already been done, we just need\n/// to call the callback and return the task(s) to the free list\nfn handleSynchronousCompletion(\n    self: *Kqueue,\n    rt: *io.Ring,\n    task: *io.Task,\n) !void {\n    switch (task.req) {\n        // async tasks. These can be handled synchronously in a cancel all\n        .accept,\n        .poll,\n        .read,\n        .readv,\n        .recv,\n        .splice,\n        .write,\n        .writev,\n\n        // Timers can be handled synchronously in a cancel all\n        .deadline,\n        .timer,\n\n        .connect, // connect is handled both sync and async\n        .close,\n        .msg_ring,\n        .noop,\n        .open,\n        .socket,\n        .statx,\n        .userbytes,\n        .userfd,\n        .usermsg,\n        .userptr,\n        => {\n            assert(task.result != null);\n            defer self.releaseTask(rt, task);\n            try task.callback(rt, task.*);\n        },\n\n        .cancel => |c| {\n            assert(task.result != null);\n            defer self.releaseTask(rt, task);\n            try task.callback(rt, task.*);\n\n            switch (c) {\n                .all => {},\n\n                .task => |ct| {\n                    // If the cancel had an error, we don't need to return the task_to_cancel\n                    _ = task.result.?.cancel catch return;\n                    // On success, it is our job to call the canceled tasks' callback and return the\n                    // task to the free list\n                    defer self.releaseTask(rt, ct);\n                    const result: io.Result = switch (ct.req) {\n                        .accept => .{ .accept = error.Canceled },\n                        .cancel => .{ .cancel = error.Canceled },\n                        .close => .{ .close = error.Canceled },\n                        .connect => .{ .connect = error.Canceled },\n                        .deadline => .{ .deadline = error.Canceled },\n                        .msg_ring => .{ .msg_ring = error.Canceled },\n                        .noop => unreachable,\n                        .open => .{ .open = error.Canceled },\n                        .poll => .{ .poll = error.Canceled },\n                        .read => .{ .read = error.Canceled },\n                        .readv => .{ .readv = error.Canceled },\n                        .recv => .{ .recv = error.Canceled },\n                        .socket => .{ .socket = error.Canceled },\n                        .splice => .{ .splice = error.Canceled },\n                        .statx => .{ .statx = error.Canceled },\n                        .timer => .{ .timer = error.Canceled },\n                        .userbytes, .userfd, .usermsg, .userptr => unreachable,\n                        .write => .{ .write = error.Canceled },\n                        .writev => .{ .writev = error.Canceled },\n                    };\n                    ct.result = result;\n                    try ct.callback(rt, ct.*);\n                },\n            }\n        },\n    }\n}\n\nfn dataToE(result: i64) std.posix.E {\n    if (result > 0) {\n        return @as(std.posix.E, @enumFromInt(-result));\n    }\n    return .SUCCESS;\n}\n\nfn unexpectedError(err: posix.E) posix.UnexpectedError {\n    std.log.debug(\"unexpected posix error: {}\", .{err});\n    return error.Unexpected;\n}\n\nfn handleCompletion(\n    self: *Kqueue,\n    rt: *io.Ring,\n    task: *io.Task,\n    event: posix.Kevent,\n) !void {\n    switch (task.req) {\n        .cancel,\n        .close,\n        .deadline,\n        .msg_ring,\n        .noop,\n        .open,\n        .socket,\n        .statx,\n        .timer,\n        .userbytes,\n        .userfd,\n        .usermsg,\n        .userptr,\n        => unreachable,\n\n        .accept => |req| {\n            defer self.releaseTask(rt, task);\n            if (event.flags & EV.ERROR != 0) {\n                // Interpret data as an errno\n                const err = unexpectedError(dataToE(event.data));\n                task.result = .{ .accept = err };\n                return task.callback(rt, task.*);\n            }\n\n            if (posix.accept(req.fd, req.addr, req.addr_size, 0)) |fd|\n                task.result = .{ .accept = fd }\n            else |_|\n                task.result = .{ .accept = error.Unexpected };\n            return task.callback(rt, task.*);\n        },\n\n        .connect => {\n            defer self.releaseTask(rt, task);\n            self.in_flight.remove(task);\n            if (event.flags & EV.ERROR != 0) {\n                // Interpret data as an errno\n                const err = unexpectedError(dataToE(event.data));\n                task.result = .{ .connect = err };\n            } else task.result = .{ .connect = {} };\n            return task.callback(rt, task.*);\n        },\n\n        .poll => {\n            defer self.releaseTask(rt, task);\n            self.in_flight.remove(task);\n            if (event.flags & EV.ERROR != 0) {\n                // Interpret data as an errno\n                const err = unexpectedError(dataToE(event.data));\n                task.result = .{ .poll = err };\n            } else task.result = .{ .poll = {} };\n            return task.callback(rt, task.*);\n        },\n\n        .read => |req| {\n            defer self.releaseTask(rt, task);\n            self.in_flight.remove(task);\n            if (event.flags & EV.ERROR != 0) {\n                // Interpret data as an errno\n                const err = unexpectedError(dataToE(event.data));\n                task.result = .{ .read = err };\n                return task.callback(rt, task.*);\n            }\n\n            const result = switch (req.offset) {\n                .file => posix.read(req.fd, req.buffer) catch error.Unexpected,\n                else => posix.pread(req.fd, req.buffer, @intFromEnum(req.offset)) catch error.Unexpected,\n            };\n            task.result = .{ .read = result };\n\n            return task.callback(rt, task.*);\n        },\n\n        .readv => |req| {\n            defer self.releaseTask(rt, task);\n            self.in_flight.remove(task);\n            if (event.flags & EV.ERROR != 0) {\n                // Interpret data as an errno\n                const err = unexpectedError(dataToE(event.data));\n                task.result = .{ .readv = err };\n                return task.callback(rt, task.*);\n            }\n            if (posix.preadv(req.fd, req.vecs, @intFromEnum(req.offset))) |n|\n                task.result = .{ .readv = n }\n            else |_|\n                task.result = .{ .readv = error.Unexpected };\n            return task.callback(rt, task.*);\n        },\n\n        .recv => |req| {\n            defer self.releaseTask(rt, task);\n            self.in_flight.remove(task);\n            if (event.flags & EV.ERROR != 0) {\n                // Interpret data as an errno\n                const err = unexpectedError(dataToE(event.data));\n                task.result = .{ .recv = err };\n                return task.callback(rt, task.*);\n            }\n            if (posix.recv(req.fd, req.buffer, 0)) |n|\n                task.result = .{ .recv = n }\n            else |_|\n                task.result = .{ .recv = error.Unexpected };\n            return task.callback(rt, task.*);\n        },\n\n        .splice => |req| {\n            defer self.releaseTask(rt, task);\n            self.in_flight.remove(task);\n            if (event.flags & EV.ERROR != 0) {\n                // Interpret data as an errno\n                const err = unexpectedError(dataToE(event.data));\n                task.result = .{ .splice = err };\n                return task.callback(rt, task.*);\n            }\n            if (posix.sendfile(req.fd_out, req.fd_in, req.offset, req.nbytes, &.{}, &.{}, 0)) |n|\n                task.result = .{ .splice = n }\n            else |_|\n                task.result = .{ .splice = error.Unexpected };\n            return task.callback(rt, task.*);\n        },\n\n        .write => |req| {\n            defer self.releaseTask(rt, task);\n            self.in_flight.remove(task);\n            if (event.flags & EV.ERROR != 0) {\n                // Interpret data as an errno\n                const err = unexpectedError(dataToE(event.data));\n                task.result = .{ .write = err };\n                return task.callback(rt, task.*);\n            }\n            if (posix.pwrite(req.fd, req.buffer, @intFromEnum(req.offset))) |n|\n                task.result = .{ .write = n }\n            else |_|\n                task.result = .{ .write = error.Unexpected };\n            return task.callback(rt, task.*);\n        },\n\n        .writev => |req| {\n            defer self.releaseTask(rt, task);\n            self.in_flight.remove(task);\n            if (event.flags & EV.ERROR != 0) {\n                // Interpret data as an errno\n                const err = unexpectedError(dataToE(event.data));\n                task.result = .{ .writev = err };\n                return task.callback(rt, task.*);\n            }\n            if (posix.pwritev(req.fd, req.vecs, @intFromEnum(req.offset))) |n|\n                task.result = .{ .writev = n }\n            else |_|\n                task.result = .{ .writev = error.Unexpected };\n            return task.callback(rt, task.*);\n        },\n    }\n}\n\nfn releaseTask(self: *Kqueue, rt: *io.Ring, task: *io.Task) void {\n    rt.free_q.push(task);\n    if (task.deadline) |d| {\n        // remove the deadline\n        for (self.timers.items, 0..) |t, i| {\n            if (t == .deadline and t.deadline.task == d) {\n                // Remove the timer\n                _ = self.timers.orderedRemove(i);\n                rt.free_q.push(t.deadline.task);\n                return;\n            }\n        }\n    }\n}\n\nfn handleExpiredTimer(self: *Kqueue, rt: *io.Ring, t: Timer) !void {\n    switch (t) {\n        .deadline => |deadline| {\n            defer self.releaseTask(rt, deadline.task);\n            if (deadline.task.state == .canceled) return;\n\n            try deadline.parent.cancel(rt, .{});\n        },\n\n        .timeout => |timeout| {\n            const task = timeout.task;\n            defer self.releaseTask(rt, task);\n            if (task.state == .canceled) return;\n            task.result = .{ .timer = {} };\n            try task.callback(rt, task.*);\n        },\n    }\n}\nfn major(dev: u64) u32 {\n    return switch (@import(\"builtin\").target.os.tag) {\n        .macos, .visionos, .tvos, .ios, .watchos => @intCast((dev >> 24) & 0xff),\n        .freebsd, .openbsd, .netbsd, .dragonfly => @intCast((dev >> 8) & 0xff),\n        else => @compileError(\"unsupported OS for major()\"),\n    };\n}\n\nfn minor(dev: u64) u32 {\n    return switch (@import(\"builtin\").target.os.tag) {\n        .macos, .ios, .visionos, .tvos, .watchos => @intCast(dev & 0xffffff),\n        .openbsd => @intCast(dev & 0xff),\n        .freebsd => @intCast((dev & 0xff) | ((dev >> 12) & 0xfff00)),\n        .dragonfly => @intCast((dev & 0xff) | ((dev >> 12) & 0xfff00)),\n        .netbsd => @intCast((dev & 0xff) | ((dev >> 12) & 0xfff00)),\n        else => @compileError(\"unsupported OS for minor()\"),\n    };\n}\n"], ["/ourio/src/ourio.zig", "const std = @import(\"std\");\nconst builtin = @import(\"builtin\");\n\nconst Allocator = std.mem.Allocator;\npub const Mock = @import(\"ourio/Mock.zig\");\nconst Queue = @import(\"ourio/queue.zig\").Intrusive;\nconst io = @This();\nconst posix = std.posix;\n\npub const has_kqueue = switch (builtin.os.tag) {\n    .dragonfly,\n    .freebsd,\n    .ios,\n    .macos,\n    .netbsd,\n    .openbsd,\n    .tvos,\n    .visionos,\n    .watchos,\n    => true,\n\n    else => false,\n};\npub const has_io_uring = builtin.os.tag == .linux;\n\npub const Task = @import(\"ourio/Task.zig\");\npub const Callback = *const fn (*Ring, Task) anyerror!void;\npub fn noopCallback(_: *Ring, _: Task) anyerror!void {}\n\npub const RunCondition = enum {\n    once,\n    until_done,\n    forever,\n};\n\npub const Context = struct {\n    ptr: ?*anyopaque = null,\n    msg: u16 = 0,\n    cb: Callback = noopCallback,\n};\n\n/// Used for timeouts and deadlines. We make this struct extern because we will ptrCast it to the\n/// linux kernel timespec struct\npub const Timespec = extern struct {\n    sec: i64 = 0,\n    nsec: i64 = 0,\n\n    pub fn isZero(self: Timespec) bool {\n        return self.sec == 0 and self.nsec == 0;\n    }\n};\n\npub const Backend = union(enum) {\n    mock: Mock,\n\n    platform: switch (builtin.os.tag) {\n        .dragonfly,\n        .freebsd,\n        .ios,\n        .macos,\n        .netbsd,\n        .openbsd,\n        .tvos,\n        .visionos,\n        .watchos,\n        => @import(\"ourio/Kqueue.zig\"),\n\n        .linux => @import(\"ourio/Uring.zig\"),\n\n        else => @compileError(\"unsupported os\"),\n    },\n\n    pub fn initChild(self: *Backend, entries: u16) !Backend {\n        switch (self.*) {\n            .mock => return .{ .mock = .{} },\n            .platform => |*p| return .{ .platform = try p.initChild(entries) },\n        }\n    }\n\n    pub fn deinit(self: *Backend, gpa: Allocator) void {\n        switch (self.*) {\n            inline else => |*backend| backend.deinit(gpa),\n        }\n    }\n\n    pub fn pollableFd(self: *Backend) !posix.fd_t {\n        return switch (self.*) {\n            inline else => |*backend| backend.pollableFd(),\n        };\n    }\n\n    pub fn submitAndWait(self: *Backend, queue: *SubmissionQueue) !void {\n        return switch (self.*) {\n            inline else => |*backend| backend.submitAndWait(queue),\n        };\n    }\n\n    pub fn submit(self: *Backend, queue: *SubmissionQueue) !void {\n        return switch (self.*) {\n            inline else => |*backend| backend.submit(queue),\n        };\n    }\n\n    pub fn reapCompletions(\n        self: *Backend,\n        rt: *Ring,\n    ) !void {\n        return switch (self.*) {\n            inline else => |*backend| backend.reapCompletions(rt),\n        };\n    }\n\n    pub fn done(self: *Backend) bool {\n        return switch (self.*) {\n            inline else => |*backend| backend.done(),\n        };\n    }\n};\n\npub const CompletionQueue = Queue(Task, .complete);\npub const FreeQueue = Queue(Task, .free);\npub const SubmissionQueue = Queue(Task, .in_flight);\n\npub const Ring = struct {\n    backend: Backend,\n    gpa: Allocator,\n\n    completion_q: CompletionQueue = .{},\n    submission_q: SubmissionQueue = .{},\n    free_q: FreeQueue = .{},\n\n    pub fn init(gpa: Allocator, entries: u16) !Ring {\n        return .{\n            .backend = .{ .platform = try .init(gpa, entries) },\n            .gpa = gpa,\n        };\n    }\n\n    pub fn initChild(self: *Ring, entries: u16) !Ring {\n        return .{\n            .backend = try self.backend.initChild(entries),\n            .gpa = self.gpa,\n        };\n    }\n\n    pub fn initMock(gpa: Allocator, entries: u16) !Ring {\n        return .{\n            .backend = .{ .mock = try .init(entries) },\n            .gpa = gpa,\n            .free_q = .{},\n            .submission_q = .{},\n            .completion_q = .{},\n        };\n    }\n\n    pub fn deinit(self: *Ring) void {\n        self.backend.deinit(self.gpa);\n        while (self.free_q.pop()) |task| self.gpa.destroy(task);\n        while (self.submission_q.pop()) |task| self.gpa.destroy(task);\n        while (self.completion_q.pop()) |task| self.gpa.destroy(task);\n    }\n\n    pub fn run(self: *Ring, condition: RunCondition) !void {\n        while (true) {\n            try self.backend.submitAndWait(&self.submission_q);\n            try self.backend.reapCompletions(self);\n            switch (condition) {\n                .once => return,\n                .until_done => if (self.backend.done() and self.submission_q.empty()) return,\n                .forever => {},\n            }\n        }\n    }\n\n    pub fn getTask(self: *Ring) Allocator.Error!*Task {\n        return self.free_q.pop() orelse try self.gpa.create(Task);\n    }\n\n    pub fn noop(\n        self: *Ring,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .noop,\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn timer(\n        self: *Ring,\n        duration: Timespec,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .timer = duration },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn cancelAll(self: *Ring) Allocator.Error!void {\n        const task = try self.getTask();\n        task.* = .{\n            .req = .{ .cancel = .all },\n        };\n\n        self.submission_q.push(task);\n    }\n\n    pub fn accept(\n        self: *Ring,\n        fd: posix.fd_t,\n        addr: ?*posix.sockaddr,\n        addr_size: ?*posix.socklen_t,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .accept = .{ .fd = fd, .addr = addr, .addr_size = addr_size } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn msgRing(\n        self: *Ring,\n        target: *Ring,\n        target_task: *Task, // The task that the target ring will receive. The callbacks of\n        // this task are what will be called when the target receives the message\n\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        // This is the task to send the message\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .msg_ring = .{\n                .target = target,\n                .task = target_task,\n            } },\n        };\n        target_task.state = .in_flight;\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn recv(\n        self: *Ring,\n        fd: posix.fd_t,\n        buffer: []u8,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .recv = .{\n                .fd = fd,\n                .buffer = buffer,\n            } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn write(\n        self: *Ring,\n        fd: posix.fd_t,\n        buffer: []const u8,\n        offset: Offset,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .write = .{\n                .fd = fd,\n                .buffer = buffer,\n                .offset = offset,\n            } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn writev(\n        self: *Ring,\n        fd: posix.fd_t,\n        vecs: []const posix.iovec_const,\n        offset: Offset,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .writev = .{\n                .fd = fd,\n                .vecs = vecs,\n                .offset = offset,\n            } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn close(\n        self: *Ring,\n        fd: posix.fd_t,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .close = fd },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn poll(\n        self: *Ring,\n        fd: posix.fd_t,\n        mask: u32,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .poll = .{ .fd = fd, .mask = mask } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn socket(\n        self: *Ring,\n        domain: u32,\n        socket_type: u32,\n        protocol: u32,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .socket = .{ .domain = domain, .type = socket_type, .protocol = protocol } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn connect(\n        self: *Ring,\n        fd: posix.socket_t,\n        addr: *posix.sockaddr,\n        addr_len: posix.socklen_t,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .connect = .{ .fd = fd, .addr = addr, .addr_len = addr_len } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn stat(\n        self: *Ring,\n        path: [:0]const u8,\n        result: *Statx,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .statx = .{ .path = path, .result = result } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn lstat(\n        self: *Ring,\n        path: [:0]const u8,\n        result: *Statx,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .statx = .{ .path = path, .result = result, .symlink_follow = false } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn readv(\n        self: *Ring,\n        fd: posix.fd_t,\n        vecs: []const posix.iovec,\n        offset: Offset,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .readv = .{\n                .fd = fd,\n                .vecs = vecs,\n                .offset = offset,\n            } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn read(\n        self: *Ring,\n        fd: posix.fd_t,\n        buffer: []u8,\n        offset: Offset,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .read = .{\n                .fd = fd,\n                .buffer = buffer,\n                .offset = offset,\n            } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn open(\n        self: *Ring,\n        path: [:0]const u8,\n        flags: posix.O,\n        mode: posix.mode_t,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{ .open = .{ .path = path, .flags = flags, .mode = mode } },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    pub fn splice(\n        self: *Ring,\n        fd_in: posix.fd_t,\n        offset: usize,\n        fd_out: posix.fd_t,\n        offset_out: usize,\n        nbytes: usize,\n        ctx: Context,\n    ) Allocator.Error!*Task {\n        const task = try self.getTask();\n        task.* = .{\n            .userdata = ctx.ptr,\n            .msg = ctx.msg,\n            .callback = ctx.cb,\n            .req = .{\n                .splice = .{\n                    .fd_in = fd_in,\n                    .fd_out = fd_out,\n                    .offset = offset,\n                    .offset_out = offset_out,\n                    .nbytes = nbytes,\n                },\n            },\n        };\n\n        self.submission_q.push(task);\n        return task;\n    }\n\n    /// Spawns a thread with a Ring instance. The thread will be idle and waiting to receive work\n    /// via msgRing when this function returns. Call kill on the returned thread to signal it to\n    /// shutdown.\n    pub fn spawnThread(self: *Ring, entries: u16) !*Thread {\n        const thread = try self.gpa.create(Thread);\n        errdefer self.gpa.destroy(thread);\n\n        var wg: std.Thread.WaitGroup = .{};\n        wg.start();\n        thread.thread = try std.Thread.spawn(.{}, Thread.run, .{ thread, self, &wg, entries });\n        wg.wait();\n\n        return thread;\n    }\n};\n\npub const Thread = struct {\n    thread: std.Thread,\n    ring: io.Ring = undefined,\n\n    pub const Msg = enum {\n        kill,\n    };\n\n    pub fn run(self: *Thread, parent: *io.Ring, wg: *std.Thread.WaitGroup, entries: u16) !void {\n        self.ring = try parent.initChild(entries);\n        wg.finish();\n\n        defer self.ring.deinit();\n\n        // Run forever, because we may not start with a task. Inter-thread messaging means we could\n        // receive work at any time\n        self.ring.run(.forever) catch |err| {\n            switch (err) {\n                error.ThreadKilled => return,\n                else => return err,\n            }\n        };\n    }\n\n    /// Kill sends a message to the thread telling it to exit. Callers of this thread can safely\n    /// join and deinit the Thread in the Context callback\n    pub fn kill(self: *Thread, rt: *io.Ring, ctx: Context) Allocator.Error!*io.Task {\n        const target_task = try rt.getTask();\n        target_task.* = .{\n            .userdata = self,\n            .msg = @intFromEnum(Thread.Msg.kill),\n            .callback = Thread.onCompletion,\n            .result = .noop,\n        };\n\n        return rt.msgRing(&self.ring, target_task, ctx);\n    }\n\n    pub fn join(self: Thread) void {\n        self.thread.join();\n    }\n\n    fn onCompletion(_: *io.Ring, task: Task) anyerror!void {\n        switch (task.msgToEnum(Thread.Msg)) {\n            .kill => return error.ThreadKilled,\n        }\n    }\n};\n\npub const Op = enum {\n    noop,\n    deadline,\n    timer,\n    cancel,\n    accept,\n    msg_ring,\n    recv,\n    write,\n    writev,\n    close,\n    poll,\n    socket,\n    connect,\n    statx,\n    readv,\n    open,\n    read,\n    splice,\n\n    /// userbytes is meant to send slices of bytes between Ring instances or callbacks\n    userbytes,\n    /// userfd is meant to send file descriptors between Ring instances (using msgRing)\n    userfd,\n    /// usermsg is meant to send a u16 between runtime instances (using msgRing)\n    usermsg,\n    /// userptr is meant to send a pointer between runtime instances (using msgRing)\n    userptr,\n};\n\npub const Offset = enum(u64) {\n    file = @bitCast(@as(i64, -1)),\n    beginning = 0,\n    _,\n\n    pub fn bytes(n: anytype) Offset {\n        return @enumFromInt(n);\n    }\n};\n\npub const Request = union(Op) {\n    noop,\n    deadline: Timespec,\n    timer: Timespec,\n    cancel: union(enum) {\n        all,\n        task: *Task,\n    },\n    accept: struct {\n        fd: posix.fd_t,\n        addr: ?*posix.sockaddr = null,\n        addr_size: ?*posix.socklen_t = null,\n    },\n    msg_ring: struct {\n        target: *Ring,\n        task: *Task,\n    },\n    recv: struct {\n        fd: posix.fd_t,\n        buffer: []u8,\n    },\n    write: struct {\n        fd: posix.fd_t,\n        buffer: []const u8,\n        offset: Offset,\n    },\n    writev: struct {\n        fd: posix.fd_t,\n        vecs: []const posix.iovec_const,\n        offset: Offset,\n    },\n    close: posix.fd_t,\n    poll: struct {\n        fd: posix.fd_t,\n        mask: u32,\n    },\n    socket: struct {\n        domain: u32,\n        type: u32,\n        protocol: u32,\n    },\n    connect: struct {\n        fd: posix.socket_t,\n        addr: *posix.sockaddr,\n        addr_len: posix.socklen_t,\n    },\n    statx: struct {\n        path: [:0]const u8,\n        result: *Statx, // this will be filled in by the op\n        symlink_follow: bool = true,\n    },\n    readv: struct {\n        fd: posix.fd_t,\n        vecs: []const posix.iovec,\n        offset: Offset,\n    },\n    open: struct {\n        path: [:0]const u8,\n        flags: posix.O,\n        mode: posix.mode_t,\n    },\n    read: struct {\n        fd: posix.fd_t,\n        buffer: []u8,\n        offset: Offset,\n    },\n    splice: struct {\n        fd_in: posix.fd_t,\n        fd_out: posix.fd_t,\n        offset: usize,\n        offset_out: usize,\n        nbytes: usize,\n    },\n\n    userbytes,\n    userfd,\n    usermsg,\n    userptr,\n};\n\npub const Result = union(Op) {\n    noop,\n    deadline: ResultError!void,\n    timer: ResultError!void,\n    cancel: CancelError!void,\n    accept: ResultError!posix.fd_t,\n    msg_ring: ResultError!void,\n    recv: RecvError!usize,\n    write: ResultError!usize,\n    writev: ResultError!usize,\n    close: ResultError!void,\n    poll: ResultError!void,\n    socket: ResultError!posix.fd_t,\n    connect: ResultError!void,\n    statx: StatError!*Statx,\n    readv: ResultError!usize,\n    open: OpenError!posix.fd_t,\n    read: ResultError!usize,\n    splice: ResultError!usize,\n\n    userbytes: anyerror![]const u8,\n    userfd: anyerror!posix.fd_t,\n    usermsg: u16,\n    userptr: anyerror!?*anyopaque,\n};\n\npub const ResultError = error{\n    /// The request was invalid\n    Invalid,\n    /// The request was canceled\n    Canceled,\n    /// An unexpected error occured\n    Unexpected,\n};\n\npub const CancelError = ResultError || error{\n    /// The entry to cancel couldn't be found\n    EntryNotFound,\n    /// The entry couldn't be canceled\n    NotCanceled,\n};\n\npub const RecvError = ResultError || error{\n    /// The entry to cancel couldn't be found\n    ConnectionResetByPeer,\n};\n\npub const OpenError = ResultError || posix.OpenError;\n\npub const StatError = ResultError || error{\n    FileNotFound,\n};\n\ntest {\n    _ = @import(\"ourio/Mock.zig\");\n    _ = @import(\"ourio/queue.zig\");\n\n    if (has_io_uring) _ = @import(\"ourio/Uring.zig\");\n    if (has_kqueue) _ = @import(\"ourio/Kqueue.zig\");\n}\n\n/// Foo is only for testing\nconst Foo = struct {\n    bar: usize = 0,\n\n    fn callback(_: *io.Ring, task: io.Task) anyerror!void {\n        const self = task.userdataCast(Foo);\n        self.bar += 1;\n    }\n};\n\n/// Follows the ABI of linux statx. Not all platforms will contain all information, or may contain\n/// more information than requested\npub const Statx = extern struct {\n    /// Mask of bits indicating filled fields\n    mask: u32,\n\n    /// Block size for filesystem I/O\n    blksize: u32,\n\n    /// Extra file attribute indicators\n    attributes: u64,\n\n    /// Number of hard links\n    nlink: u32,\n\n    /// User ID of owner\n    uid: posix.uid_t,\n\n    /// Group ID of owner\n    gid: posix.gid_t,\n\n    /// File type and mode\n    mode: u16,\n    __pad1: u16,\n\n    /// Inode number\n    ino: u64,\n\n    /// Total size in bytes\n    size: u64,\n\n    /// Number of 512B blocks allocated\n    blocks: u64,\n\n    /// Mask to show what's supported in `attributes`.\n    attributes_mask: u64,\n\n    /// Last access file timestamp\n    atime: Timestamp,\n\n    /// Creation file timestamp\n    btime: Timestamp,\n\n    /// Last status change file timestamp\n    ctime: Timestamp,\n\n    /// Last modification file timestamp\n    mtime: Timestamp,\n\n    /// Major ID, if this file represents a device.\n    rdev_major: u32,\n\n    /// Minor ID, if this file represents a device.\n    rdev_minor: u32,\n\n    /// Major ID of the device containing the filesystem where this file resides.\n    dev_major: u32,\n\n    /// Minor ID of the device containing the filesystem where this file resides.\n    dev_minor: u32,\n\n    __pad2: [14]u64,\n\n    pub const Timestamp = extern struct {\n        sec: i64,\n        nsec: u32,\n        __pad: u32 = 0,\n    };\n\n    pub fn major(dev: u64) u32 {\n        return switch (@import(\"builtin\").target.os.tag) {\n            .macos, .visionos, .tvos, .ios, .watchos => @intCast((dev >> 24) & 0xff),\n            .freebsd, .openbsd, .netbsd, .dragonfly => @intCast((dev >> 8) & 0xff),\n            else => @compileError(\"unsupported OS for major()\"),\n        };\n    }\n\n    pub fn minor(dev: u64) u32 {\n        return switch (@import(\"builtin\").target.os.tag) {\n            .macos, .ios, .visionos, .tvos, .watchos => @intCast(dev & 0xffffff),\n            .openbsd => @intCast(dev & 0xff),\n            .freebsd => @intCast((dev & 0xff) | ((dev >> 12) & 0xfff00)),\n            .dragonfly => @intCast((dev & 0xff) | ((dev >> 12) & 0xfff00)),\n            .netbsd => @intCast((dev & 0xff) | ((dev >> 12) & 0xfff00)),\n            else => @compileError(\"unsupported OS for minor()\"),\n        };\n    }\n};\n\ntest \"runtime: noop\" {\n    var rt: io.Ring = try .init(std.testing.allocator, 16);\n    defer rt.deinit();\n\n    var foo: Foo = .{};\n\n    const ctx: Context = .{ .ptr = &foo, .cb = Foo.callback };\n\n    // noop is triggered synchronously with submit. If we wait, we'll be waiting forever\n    _ = try rt.noop(ctx);\n    try rt.run(.once);\n    try std.testing.expectEqual(1, foo.bar);\n    _ = try rt.noop(ctx);\n    _ = try rt.noop(ctx);\n    try rt.run(.once);\n    try std.testing.expectEqual(3, foo.bar);\n}\n\ntest \"runtime: timer\" {\n    var rt: io.Ring = try .init(std.testing.allocator, 16);\n    defer rt.deinit();\n\n    var foo: Foo = .{};\n\n    const ctx: Context = .{ .ptr = &foo, .cb = Foo.callback };\n\n    const start = std.time.nanoTimestamp();\n    const end = start + 100 * std.time.ns_per_ms;\n    _ = try rt.timer(.{ .nsec = 100 * std.time.ns_per_ms }, ctx);\n    try rt.run(.once);\n    try std.testing.expect(std.time.nanoTimestamp() > end);\n    try std.testing.expectEqual(1, foo.bar);\n}\n\ntest \"runtime: poll\" {\n    var rt: io.Ring = try .init(std.testing.allocator, 16);\n    defer rt.deinit();\n\n    var foo: Foo = .{};\n    const pipe = try posix.pipe2(.{ .CLOEXEC = true });\n\n    const ctx: Context = .{ .ptr = &foo, .cb = Foo.callback };\n\n    _ = try rt.poll(pipe[0], posix.POLL.IN, ctx);\n    try std.testing.expectEqual(1, rt.submission_q.len());\n\n    _ = try posix.write(pipe[1], \"io_uring is the best\");\n    try rt.run(.once);\n    try std.testing.expectEqual(1, foo.bar);\n}\n\ntest \"runtime: deadline doesn't call user callback\" {\n    const gpa = std.testing.allocator;\n    var rt = try io.Ring.init(gpa, 16);\n    defer rt.deinit();\n\n    var foo: Foo = .{};\n    const ctx: Context = .{ .ptr = &foo, .cb = Foo.callback };\n    const task = try rt.noop(ctx);\n    try task.setDeadline(&rt, .{ .sec = 1 });\n\n    try rt.run(.until_done);\n\n    // Callback only called once\n    try std.testing.expectEqual(1, foo.bar);\n}\n\ntest \"runtime: timeout\" {\n    const gpa = std.testing.allocator;\n    var rt = try io.Ring.init(gpa, 16);\n    defer rt.deinit();\n\n    var foo: Foo = .{};\n    const ctx: Context = .{ .ptr = &foo, .cb = Foo.callback };\n\n    const delay = 1 * std.time.ns_per_ms;\n    _ = try rt.timer(.{ .nsec = delay }, ctx);\n\n    const start = std.time.nanoTimestamp();\n    try rt.run(.until_done);\n    try std.testing.expect(start + delay < std.time.nanoTimestamp());\n    try std.testing.expectEqual(1, foo.bar);\n}\n\ntest \"runtime: cancel\" {\n    const gpa = std.testing.allocator;\n    var rt = try io.Ring.init(gpa, 16);\n    defer rt.deinit();\n\n    var foo: Foo = .{};\n    const ctx: Context = .{ .ptr = &foo, .cb = Foo.callback };\n\n    const delay = 1 * std.time.ns_per_s;\n    const task = try rt.timer(.{ .nsec = delay }, ctx);\n\n    try task.cancel(&rt, .{});\n\n    const start = std.time.nanoTimestamp();\n    try rt.run(.until_done);\n    // Expect that we didn't delay long enough\n    try std.testing.expect(start + delay > std.time.nanoTimestamp());\n    try std.testing.expectEqual(1, foo.bar);\n}\n\ntest \"runtime: cancel all\" {\n    const gpa = std.testing.allocator;\n    var rt = try io.Ring.init(gpa, 16);\n    defer rt.deinit();\n\n    const Foo2 = struct {\n        bar: usize = 0,\n\n        fn callback(_: *io.Ring, task: io.Task) anyerror!void {\n            const self = task.userdataCast(@This());\n            const result = task.result.?;\n            _ = result.timer catch |err| {\n                switch (err) {\n                    error.Canceled => self.bar += 1,\n                    else => {},\n                }\n            };\n        }\n    };\n    var foo: Foo2 = .{};\n    const ctx: Context = .{ .ptr = &foo, .cb = Foo2.callback };\n\n    const delay = 1 * std.time.ns_per_s;\n    _ = try rt.timer(.{ .nsec = delay }, ctx);\n    _ = try rt.timer(.{ .nsec = delay }, ctx);\n    _ = try rt.timer(.{ .nsec = delay }, ctx);\n    _ = try rt.timer(.{ .nsec = delay }, ctx);\n\n    try rt.cancelAll();\n    const start = std.time.nanoTimestamp();\n    try rt.run(.until_done);\n    // Expect that we didn't delay long enough\n    try std.testing.expect(start + delay > std.time.nanoTimestamp());\n    try std.testing.expectEqual(4, foo.bar);\n}\n\ntest \"runtime: msgRing\" {\n    const gpa = std.testing.allocator;\n    var rt1 = try io.Ring.init(gpa, 16);\n    defer rt1.deinit();\n\n    var rt2 = try rt1.initChild(16);\n    defer rt2.deinit();\n\n    const Foo2 = struct {\n        rt1: bool = false,\n        rt2: bool = false,\n\n        const Msg = enum { rt1, rt2 };\n\n        fn callback(_: *io.Ring, task: io.Task) anyerror!void {\n            const self = task.userdataCast(@This());\n            const msg = task.msgToEnum(Msg);\n            switch (msg) {\n                .rt1 => self.rt1 = true,\n                .rt2 => self.rt2 = true,\n            }\n        }\n    };\n\n    var foo: Foo2 = .{};\n\n    // The task we will send from rt1 to rt2\n    const target_task = try rt1.getTask();\n    target_task.* = .{\n        .userdata = &foo,\n        .callback = Foo2.callback,\n        .msg = @intFromEnum(Foo2.Msg.rt2),\n        .result = .{ .usermsg = 0 },\n    };\n\n    _ = try rt1.msgRing(\n        &rt2,\n        target_task,\n        .{ .cb = Foo2.callback, .msg = @intFromEnum(Foo2.Msg.rt1), .ptr = &foo },\n    );\n\n    try rt1.run(.until_done);\n    try std.testing.expect(foo.rt1);\n    try std.testing.expect(!foo.rt2);\n    try rt2.run(.until_done);\n    try std.testing.expect(foo.rt1);\n    try std.testing.expect(foo.rt2);\n}\n\ntest \"runtime: spawnThread\" {\n    const gpa = std.testing.allocator;\n    var rt = try io.Ring.init(gpa, 16);\n    defer rt.deinit();\n\n    const thread = try rt.spawnThread(4);\n\n    const Foo2 = struct {\n        kill: bool = false,\n        did_work: bool = false,\n\n        gpa: Allocator,\n        thread: *Thread,\n\n        const Msg = enum { kill, work };\n\n        fn callback(_: *io.Ring, task: io.Task) anyerror!void {\n            const self = task.userdataCast(@This());\n            const msg = task.msgToEnum(Msg);\n            switch (msg) {\n                .kill => {\n                    self.kill = true;\n                    self.thread.join();\n                    self.gpa.destroy(self.thread);\n                },\n                .work => self.did_work = true,\n            }\n        }\n    };\n\n    var foo: Foo2 = .{ .thread = thread, .gpa = gpa };\n\n    // Send work to the thread\n    const target_task = try rt.getTask();\n    target_task.* = .{\n        .userdata = &foo,\n        .callback = Foo2.callback,\n        .msg = @intFromEnum(Foo2.Msg.work),\n        .result = .{ .usermsg = 0 },\n    };\n\n    _ = try rt.msgRing(&thread.ring, target_task, .{});\n\n    try rt.run(.until_done);\n    _ = try thread.kill(&rt, .{\n        .ptr = &foo,\n        .cb = Foo2.callback,\n        .msg = @intFromEnum(Foo2.Msg.kill),\n    });\n    try rt.run(.until_done);\n\n    try std.testing.expect(foo.did_work);\n    try std.testing.expect(foo.kill);\n}\n\ntest \"runtime: stat\" {\n    const gpa = std.testing.allocator;\n    var rt = try io.Ring.init(gpa, 16);\n    defer rt.deinit();\n\n    var foo: Foo = .{};\n    const ctx: Context = .{ .ptr = &foo, .cb = Foo.callback };\n\n    var statx: Statx = undefined;\n    const task = try rt.stat(\"build.zig\", &statx, ctx);\n\n    try rt.run(.until_done);\n    try std.testing.expect(task.result != null);\n}\n"], ["/ourio/src/stda/net.zig", "const std = @import(\"std\");\nconst io = @import(\"ourio\");\n\nconst posix = std.posix;\nconst Allocator = std.mem.Allocator;\nconst Uri = std.Uri;\n\nconst assert = std.debug.assert;\n\npub const dns = @import(\"net/dns.zig\");\n\npub fn tcpConnectToHost(\n    rt: *io.Ring,\n    host: []const u8,\n    port: u16,\n    ctx: io.Context,\n) !*ConnectTask {\n    // TODO: getAddressList could be rewritten to be async. It accesses the filesystem and could\n    // make a DNS request\n    const list = try std.net.getAddressList(rt.gpa, host, port);\n    defer list.deinit();\n\n    const addr = for (list.addrs) |addr| {\n        break addr;\n    } else return error.AddressNotFound;\n\n    return tcpConnectToAddr(rt, addr, ctx);\n}\n\npub fn tcpConnectToAddr(\n    rt: *io.Ring,\n    addr: std.net.Address,\n    ctx: io.Context,\n) Allocator.Error!*ConnectTask {\n    const conn = try rt.gpa.create(ConnectTask);\n    errdefer rt.gpa.destroy(conn);\n\n    conn.* = .{\n        .ctx = ctx,\n        .addr = addr,\n        .fd = null,\n        .task = undefined,\n    };\n\n    conn.task = try rt.socket(\n        conn.addr.any.family,\n        posix.SOCK.STREAM | posix.SOCK.CLOEXEC,\n        posix.IPPROTO.TCP,\n        .{ .ptr = conn, .msg = @intFromEnum(ConnectTask.Msg.socket), .cb = ConnectTask.handleMsg },\n    );\n\n    return conn;\n}\n\npub fn udpConnectToAddr(\n    rt: *io.Ring,\n    addr: std.net.Address,\n    ctx: io.Context,\n) Allocator.Error!*ConnectTask {\n    const conn = try rt.gpa.create(ConnectTask);\n    errdefer rt.gpa.destroy(conn);\n\n    conn.* = .{\n        .ctx = ctx,\n        .addr = addr,\n        .fd = null,\n        .task = undefined,\n    };\n\n    conn.task = try rt.socket(\n        conn.addr.any.family,\n        posix.SOCK.DGRAM | posix.SOCK.CLOEXEC,\n        posix.IPPROTO.UDP,\n        .{ .ptr = conn, .msg = @intFromEnum(ConnectTask.Msg.socket), .cb = ConnectTask.handleMsg },\n    );\n\n    return conn;\n}\n\npub const ConnectTask = struct {\n    ctx: io.Context,\n\n    addr: std.net.Address,\n    fd: ?posix.fd_t,\n\n    /// Task is the current task we are operating on. We store this to provide cancelation\n    task: *io.Task,\n\n    pub const Msg = enum {\n        socket,\n        connect,\n    };\n\n    /// Cancels the current task. Not guaranteed to actually cancel. User's callback will get an\n    /// error.Canceled if cancelation was successful, otherwise the operation will complete as\n    /// normal and this is essentially a no-op\n    pub fn cancel(self: *ConnectTask, rt: *io.Ring) void {\n        _ = self.task.cancel(rt, null, 0, io.noopCallback) catch {};\n    }\n\n    pub fn handleMsg(rt: *io.Ring, task: io.Task) anyerror!void {\n        const self = task.userdataCast(ConnectTask);\n        const result = task.result.?;\n        switch (task.msgToEnum(Msg)) {\n            .socket => {\n                assert(result == .socket);\n                self.fd = result.socket catch |err| {\n                    defer rt.gpa.destroy(self);\n                    try self.ctx.cb(rt, .{\n                        .userdata = self.ctx.ptr,\n                        .msg = self.ctx.msg,\n                        .result = .{ .userfd = err },\n                        .callback = self.ctx.cb,\n                        .req = .userfd,\n                    });\n                    return;\n                };\n\n                self.task = try rt.connect(\n                    self.fd.?,\n                    &self.addr.any,\n                    self.addr.getOsSockLen(),\n                    .{ .ptr = self, .msg = @intFromEnum(Msg.connect), .cb = ConnectTask.handleMsg },\n                );\n            },\n\n            .connect => {\n                assert(result == .connect);\n                defer rt.gpa.destroy(self);\n\n                _ = result.connect catch |err| {\n                    try self.ctx.cb(rt, .{\n                        .userdata = self.ctx.ptr,\n                        .msg = self.ctx.msg,\n                        .result = .{ .userfd = err },\n                        .callback = self.ctx.cb,\n                        .req = .userfd,\n                    });\n                    _ = try rt.close(self.fd.?, .{});\n                    return;\n                };\n\n                try self.ctx.cb(rt, .{\n                    .userdata = self.ctx.ptr,\n                    .msg = self.ctx.msg,\n                    .result = .{ .userfd = self.fd.? },\n                    .callback = self.ctx.cb,\n                    .req = .userfd,\n                });\n            },\n        }\n    }\n};\n\ntest {\n    _ = dns;\n}\n\ntest \"tcp connect\" {\n    var rt: io.Ring = try .init(std.testing.allocator, 16);\n    defer rt.deinit();\n\n    const addr: std.net.Address = try .parseIp4(\"127.0.0.1\", 80);\n\n    {\n        // Happy path\n        const conn = try tcpConnectToAddr(&rt, addr, .{});\n        errdefer std.testing.allocator.destroy(conn);\n\n        const task1 = rt.submission_q.pop().?;\n        defer std.testing.allocator.destroy(task1);\n        try std.testing.expect(task1.req == .socket);\n        try std.testing.expect(rt.submission_q.pop() == null);\n\n        const fd: posix.fd_t = 7;\n        try ConnectTask.handleMsg(&rt, .{\n            .userdata = conn,\n            .msg = @intFromEnum(ConnectTask.Msg.socket),\n            .result = .{ .socket = fd },\n            .req = .userfd,\n        });\n\n        const task2 = rt.submission_q.pop().?;\n        defer std.testing.allocator.destroy(task2);\n        try std.testing.expect(task2.req == .connect);\n        try std.testing.expect(rt.submission_q.pop() == null);\n\n        try ConnectTask.handleMsg(&rt, .{\n            .userdata = conn,\n            .msg = @intFromEnum(ConnectTask.Msg.connect),\n            .result = .{ .connect = {} },\n            .req = .userfd,\n        });\n        try std.testing.expect(rt.submission_q.pop() == null);\n    }\n\n    {\n        // socket error\n        const conn = try tcpConnectToAddr(&rt, addr, .{});\n        errdefer std.testing.allocator.destroy(conn);\n\n        const task1 = rt.submission_q.pop().?;\n        defer std.testing.allocator.destroy(task1);\n\n        try ConnectTask.handleMsg(&rt, .{\n            .userdata = conn,\n            .msg = @intFromEnum(ConnectTask.Msg.socket),\n            .result = .{ .socket = error.Canceled },\n            .req = .userfd,\n        });\n        try std.testing.expect(rt.submission_q.pop() == null);\n    }\n\n    {\n        // connect error\n        const conn = try tcpConnectToAddr(&rt, addr, .{});\n        errdefer std.testing.allocator.destroy(conn);\n\n        const task1 = rt.submission_q.pop().?;\n        defer std.testing.allocator.destroy(task1);\n        try std.testing.expect(task1.req == .socket);\n        try std.testing.expect(rt.submission_q.pop() == null);\n\n        const fd: posix.fd_t = 7;\n        try ConnectTask.handleMsg(&rt, .{\n            .userdata = conn,\n            .msg = @intFromEnum(ConnectTask.Msg.socket),\n            .result = .{ .socket = fd },\n            .req = .userfd,\n        });\n\n        const task2 = rt.submission_q.pop().?;\n        defer std.testing.allocator.destroy(task2);\n        try std.testing.expect(task2.req == .connect);\n        try std.testing.expect(rt.submission_q.pop() == null);\n\n        try ConnectTask.handleMsg(&rt, .{\n            .userdata = conn,\n            .msg = @intFromEnum(ConnectTask.Msg.connect),\n            .result = .{ .connect = error.Canceled },\n            .req = .noop,\n        });\n        const task3 = rt.submission_q.pop().?;\n        defer std.testing.allocator.destroy(task3);\n        try std.testing.expect(task3.req == .close);\n        try std.testing.expect(rt.submission_q.pop() == null);\n    }\n}\n"], ["/ourio/src/ourio/Uring.zig", "const Uring = @This();\n\nconst std = @import(\"std\");\nconst builtin = @import(\"builtin\");\n\nconst io = @import(\"../ourio.zig\");\n\nconst Allocator = std.mem.Allocator;\nconst Queue = @import(\"queue.zig\").Intrusive;\nconst assert = std.debug.assert;\nconst linux = std.os.linux;\nconst posix = std.posix;\n\nconst msg_ring_received_cqe = 1 << 8;\n\nring: linux.IoUring,\nin_flight: Queue(io.Task, .in_flight) = .{},\neventfd: ?posix.fd_t = null,\n\n/// Initialize a Ring\npub fn init(_: Allocator, entries: u16) !Uring {\n    var params = std.mem.zeroInit(linux.io_uring_params, .{\n        .flags = supportedFlags(),\n        .sq_thread_idle = 1000,\n    });\n\n    return .{ .ring = try .init_params(entries, &params) };\n}\n\npub fn deinit(self: *Uring, gpa: Allocator) void {\n    while (self.in_flight.pop()) |task| gpa.destroy(task);\n\n    if (self.ring.fd >= 0) {\n        self.ring.deinit();\n    }\n    if (self.eventfd) |fd| {\n        posix.close(fd);\n        self.eventfd = null;\n    }\n    self.* = undefined;\n}\n\nfn supportedFlags() u32 {\n    // clamp is supported by all kernels that have io_uring\n    var flags: u32 = linux.IORING_SETUP_CLAMP;\n\n    var utsname: linux.utsname = undefined;\n    switch (linux.E.init(linux.uname(&utsname))) {\n        .SUCCESS => {},\n        else => return flags,\n    }\n\n    const release = if (std.mem.indexOfScalar(u8, &utsname.release, '-')) |idx|\n        utsname.release[0..idx]\n    else\n        &utsname.release;\n    const version = std.SemanticVersion.parse(release) catch return flags;\n    switch (version.order(.{ .major = 5, .minor = 18, .patch = 0 })) {\n        .lt => return flags,\n        else => flags |= linux.IORING_SETUP_SUBMIT_ALL,\n    }\n\n    switch (version.order(.{ .major = 5, .minor = 19, .patch = 0 })) {\n        .lt => return flags,\n        else => flags |= linux.IORING_SETUP_COOP_TASKRUN,\n    }\n\n    switch (version.order(.{ .major = 6, .minor = 0, .patch = 0 })) {\n        .lt => return flags,\n        else => flags |= linux.IORING_SETUP_SINGLE_ISSUER,\n    }\n\n    switch (version.order(.{ .major = 6, .minor = 1, .patch = 0 })) {\n        .lt => return flags,\n        else => flags |= linux.IORING_SETUP_DEFER_TASKRUN,\n    }\n\n    return flags;\n}\n\n/// Initializes a child Ring which can be woken up by self. This must be called from the thread\n/// which will operate the child ring. Initializes with the same queue size as the parent\npub fn initChild(self: Uring, entries: u16) !Uring {\n    const flags: u32 = supportedFlags() | linux.IORING_SETUP_ATTACH_WQ;\n\n    var params = std.mem.zeroInit(linux.io_uring_params, .{\n        .flags = flags,\n        .sq_thread_idle = 1000,\n        .wq_fd = @as(u32, @bitCast(self.ring.fd)),\n    });\n\n    return .{ .ring = try .init_params(entries, &params) };\n}\n\npub fn done(self: *Uring) bool {\n    return self.in_flight.empty();\n}\n\n/// Return a file descriptor which can be used to poll the ring for completions\npub fn pollableFd(self: *Uring) !posix.fd_t {\n    if (self.eventfd) |fd| return fd;\n    const fd: posix.fd_t = @intCast(linux.eventfd(0, linux.EFD.CLOEXEC | linux.EFD.NONBLOCK));\n    try self.ring.register_eventfd(fd);\n    self.eventfd = fd;\n    return fd;\n}\n\npub fn submitAndWait(self: *Uring, queue: *io.SubmissionQueue) !void {\n    var sqes_available = self.sqesAvailable();\n    while (queue.pop()) |task| {\n        const sqes_required = sqesRequired(task);\n        if (sqes_available < sqes_required) {\n            sqes_available += try self.ring.submit();\n            continue;\n        }\n        defer sqes_available -= sqes_required;\n        self.prepTask(task);\n    }\n\n    while (true) {\n        _ = self.ring.submit_and_wait(1) catch |err| {\n            switch (err) {\n                error.SignalInterrupt => continue,\n                else => return err,\n            }\n        };\n        return;\n    }\n}\n\npub fn submit(self: *Uring, queue: *io.SubmissionQueue) !void {\n    var sqes_available = self.sqesAvailable();\n    while (queue.pop()) |task| {\n        const sqes_required = sqesRequired(task);\n        if (sqes_available < sqes_required) {\n            sqes_available += try self.ring.submit();\n            continue;\n        }\n        defer sqes_available -= sqes_required;\n        self.prepTask(task);\n    }\n    const n = try self.ring.submit();\n    _ = try self.ring.enter(n, 0, linux.IORING_ENTER_GETEVENTS);\n}\n\nfn sqesRequired(task: *const io.Task) u32 {\n    return if (task.deadline == null) 1 else 2;\n}\n\nfn sqesAvailable(self: *Uring) u32 {\n    return @intCast(self.ring.sq.sqes.len - self.ring.sq_ready());\n}\n\nfn prepTask(self: *Uring, task: *io.Task) void {\n    self.in_flight.push(task);\n    switch (task.req) {\n        .noop => {\n            const sqe = self.getSqe();\n            sqe.prep_nop();\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        // Deadlines are always prepared from their parent task\n        .deadline => unreachable,\n\n        .timer => |*t| {\n            const sqe = self.getSqe();\n            sqe.prep_timeout(@ptrCast(t), 0, linux.IORING_TIMEOUT_REALTIME);\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .cancel => |c| {\n            const sqe = self.getSqe();\n            switch (c) {\n                .all => sqe.prep_cancel(0, linux.IORING_ASYNC_CANCEL_ANY),\n                .task => |t| sqe.prep_cancel(@intFromPtr(t), 0),\n            }\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .accept => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_accept(req.fd, req.addr, req.addr_size, 0);\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .msg_ring => |msg| {\n            const sqe = self.getSqe();\n            const fd = msg.target.backend.platform.ring.fd;\n            sqe.prep_rw(.MSG_RING, fd, 0, 0, @intFromPtr(msg.task));\n            sqe.user_data = @intFromPtr(task);\n            // Pass flags on the sent CQE. We use this to distinguish between a received message and\n            // a message freom our own loop\n            sqe.rw_flags |= linux.IORING_MSG_RING_FLAGS_PASS;\n            sqe.splice_fd_in |= msg_ring_received_cqe;\n            self.prepDeadline(task, sqe);\n        },\n\n        .recv => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_recv(req.fd, req.buffer, 0);\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .write => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_write(req.fd, req.buffer, @intFromEnum(req.offset));\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .writev => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_writev(req.fd, req.vecs, @intFromEnum(req.offset));\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .close => |fd| {\n            const sqe = self.getSqe();\n            sqe.prep_close(fd);\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .poll => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_poll_add(req.fd, req.mask);\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .socket => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_socket(req.domain, req.type, req.protocol, 0);\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .connect => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_connect(req.fd, req.addr, req.addr_len);\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .statx => |*req| {\n            const sqe = self.getSqe();\n            const flags: u32 = if (req.symlink_follow) 0 else linux.AT.SYMLINK_NOFOLLOW;\n            sqe.prep_statx(\n                linux.AT.FDCWD,\n                req.path,\n                flags,\n                linux.STATX_BASIC_STATS,\n                @ptrCast(req.result),\n            );\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .read => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_read(req.fd, req.buffer, @intFromEnum(req.offset));\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .readv => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_readv(req.fd, req.vecs, @intFromEnum(req.offset));\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .open => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_openat(posix.AT.FDCWD, req.path, req.flags, req.mode);\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        .splice => |req| {\n            const sqe = self.getSqe();\n            sqe.prep_splice(req.fd_in, req.offset, req.fd_out, req.offset_out, req.nbytes);\n            sqe.user_data = @intFromPtr(task);\n            self.prepDeadline(task, sqe);\n        },\n\n        // user* is only sent internally between rings and higher level wrappers\n        .userbytes, .userfd, .usermsg, .userptr => unreachable,\n    }\n}\n\nfn prepDeadline(self: *Uring, parent_task: *io.Task, parent_sqe: *linux.io_uring_sqe) void {\n    const task = parent_task.deadline orelse return;\n    self.in_flight.push(task);\n    assert(task.req == .deadline);\n    parent_sqe.flags |= linux.IOSQE_IO_LINK;\n\n    const sqe = self.getSqe();\n    const flags = linux.IORING_TIMEOUT_ABS | // absolute time\n        linux.IORING_TIMEOUT_REALTIME; // use the realtime clock (as opposed to boot time)\n    sqe.prep_link_timeout(@ptrCast(&task.req.deadline), flags);\n    sqe.user_data = @intFromPtr(task);\n}\n\n/// Get an sqe from the ring. Caller should only call this function if they are sure we have an SQE\n/// available. Asserts that we have one available\nfn getSqe(self: *Uring) *linux.io_uring_sqe {\n    assert(self.ring.sq.sqes.len > self.ring.sq_ready());\n    return self.ring.get_sqe() catch unreachable;\n}\n\npub fn reapCompletions(self: *Uring, rt: *io.Ring) anyerror!void {\n    var cqes: [64]linux.io_uring_cqe = undefined;\n    const n = self.ring.copy_cqes(&cqes, 0) catch |err| {\n        switch (err) {\n            error.SignalInterrupt => return,\n            else => return err,\n        }\n    };\n    for (cqes[0..n]) |cqe| {\n        const task: *io.Task = @ptrFromInt(cqe.user_data);\n\n        task.result = switch (task.req) {\n            .noop => .noop,\n\n            // Deadlines we don't do anything for, these are always sent to a noopCallback\n            .deadline => .{ .deadline = {} },\n\n            .timer => .{ .timer = switch (cqeToE(cqe.res)) {\n                .SUCCESS, .TIME => {},\n                .INVAL, .FAULT => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .cancel => .{ .cancel = switch (cqeToE(cqe.res)) {\n                .SUCCESS => {},\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                .NOENT => io.CancelError.EntryNotFound,\n                .ALREADY => io.CancelError.NotCanceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .accept => .{ .accept = switch (cqeToE(cqe.res)) {\n                .SUCCESS => cqe.res,\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .msg_ring => .{ .msg_ring = switch (cqeToE(cqe.res)) {\n                .SUCCESS => {},\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .recv => .{ .recv = switch (cqeToE(cqe.res)) {\n                .SUCCESS => @intCast(cqe.res),\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                .CONNRESET => io.RecvError.ConnectionResetByPeer,\n                else => |e| unexpectedError(e),\n            } },\n\n            .write => .{ .write = switch (cqeToE(cqe.res)) {\n                .SUCCESS => @intCast(cqe.res),\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .writev => .{ .writev = switch (cqeToE(cqe.res)) {\n                .SUCCESS => @intCast(cqe.res),\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .close => .{ .close = switch (cqeToE(cqe.res)) {\n                .SUCCESS => {},\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .poll => .{ .poll = switch (cqeToE(cqe.res)) {\n                .SUCCESS => {},\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .socket => .{ .socket = switch (cqeToE(cqe.res)) {\n                .SUCCESS => @intCast(cqe.res),\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .connect => .{ .connect = switch (cqeToE(cqe.res)) {\n                .SUCCESS => {},\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .statx => |req| .{ .statx = switch (cqeToE(cqe.res)) {\n                .SUCCESS => req.result,\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                .NOENT => io.StatError.FileNotFound,\n                else => |e| unexpectedError(e),\n            } },\n\n            .read => .{ .read = switch (cqeToE(cqe.res)) {\n                .SUCCESS => @intCast(cqe.res),\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .readv => .{ .readv = switch (cqeToE(cqe.res)) {\n                .SUCCESS => @intCast(cqe.res),\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .open => .{ .open = switch (cqeToE(cqe.res)) {\n                .SUCCESS => @intCast(cqe.res),\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                .NOTDIR => posix.OpenError.NotDir,\n                .ISDIR => posix.OpenError.IsDir,\n                else => |e| unexpectedError(e),\n            } },\n\n            .splice => .{ .splice = switch (cqeToE(cqe.res)) {\n                .SUCCESS => @intCast(cqe.res),\n                .INVAL => io.ResultError.Invalid,\n                .CANCELED => io.ResultError.Canceled,\n                else => |e| unexpectedError(e),\n            } },\n\n            .usermsg => .{ .usermsg = @intCast(cqe.res) },\n\n            // userfd should never reach the runtime\n            .userbytes, .userfd, .userptr => unreachable,\n        };\n\n        defer {\n            if (cqe.flags & msg_ring_received_cqe != 0) {\n                // This message was received from another ring. We don't decrement inflight for this.\n                // But we do need to set the task as free because we will add it to our free list\n                rt.free_q.push(task);\n            } else if (cqe.flags & linux.IORING_CQE_F_MORE == 0) {\n                // If the cqe doesn't have IORING_CQE_F_MORE set, then this task is complete and free to\n                // be rescheduled\n                task.state = .complete;\n                self.in_flight.remove(task);\n                rt.free_q.push(task);\n            }\n        }\n\n        try task.callback(rt, task.*);\n    }\n}\n\nfn cqeToE(result: i32) std.posix.E {\n    if (result > -4096 and result < 0) {\n        return @as(std.posix.E, @enumFromInt(-result));\n    }\n    return .SUCCESS;\n}\n\nfn unexpectedError(err: posix.E) posix.UnexpectedError {\n    std.log.debug(\"unexpected posix error: {}\", .{err});\n    return error.Unexpected;\n}\n"], ["/ourio/src/ourio/Mock.zig", "const Mock = @This();\n\nconst std = @import(\"std\");\n\nconst io = @import(\"../ourio.zig\");\n\nconst Allocator = std.mem.Allocator;\nconst Queue = @import(\"queue.zig\").Intrusive;\nconst assert = std.debug.assert;\nconst posix = std.posix;\n\ncompletions: Queue(io.Task, .complete) = .{},\nopen_fds: i64 = 0,\n\naccept_cb: ?*const fn (*io.Task) io.Result = null,\ncancel_cb: ?*const fn (*io.Task) io.Result = null,\nclose_cb: ?*const fn (*io.Task) io.Result = null,\nconnect_cb: ?*const fn (*io.Task) io.Result = null,\ndeadline_cb: ?*const fn (*io.Task) io.Result = null,\nmsg_ring_cb: ?*const fn (*io.Task) io.Result = null,\nnoop_cb: ?*const fn (*io.Task) io.Result = null,\nopen_cb: ?*const fn (*io.Task) io.Result = null,\npoll_cb: ?*const fn (*io.Task) io.Result = null,\nread_cb: ?*const fn (*io.Task) io.Result = null,\nreadv_cb: ?*const fn (*io.Task) io.Result = null,\nrecv_cb: ?*const fn (*io.Task) io.Result = null,\nsocket_cb: ?*const fn (*io.Task) io.Result = null,\nsplice_cb: ?*const fn (*io.Task) io.Result = null,\nstatx_cb: ?*const fn (*io.Task) io.Result = null,\ntimer_cb: ?*const fn (*io.Task) io.Result = null,\nwrite_cb: ?*const fn (*io.Task) io.Result = null,\nwritev_cb: ?*const fn (*io.Task) io.Result = null,\n\nuserbytes_cb: ?*const fn (*io.Task) io.Result = null,\nuserfd_cb: ?*const fn (*io.Task) io.Result = null,\nusermsg_cb: ?*const fn (*io.Task) io.Result = null,\nuserptr_cb: ?*const fn (*io.Task) io.Result = null,\n\n/// Initialize a Ring\npub fn init(_: u16) !Mock {\n    return .{};\n}\n\npub fn deinit(self: *Mock, _: Allocator) void {\n    if (self.open_fds > 0) {\n        @panic(\"file descriptor leak\");\n    }\n    if (self.open_fds < 0) {\n        @panic(\"unbalanced file descriptor close\");\n    }\n    self.* = undefined;\n}\n\npub fn done(self: *Mock) bool {\n    return self.completions.empty();\n}\n\n/// Initializes a child Ring which can be woken up by self. This must be called from the thread\n/// which will operate the child ring. Initializes with the same queue size as the parent\npub fn initChild(_: Mock, entries: u16) !Mock {\n    return init(entries);\n}\n\n/// Return a file descriptor which can be used to poll the ring for completions\npub fn pollableFd(_: *Mock) !posix.fd_t {\n    return -1;\n}\n\npub fn submitAndWait(self: *Mock, queue: *Queue(io.Task, .in_flight)) !void {\n    return self.submit(queue);\n}\n\npub fn submit(self: *Mock, queue: *Queue(io.Task, .in_flight)) !void {\n    while (queue.pop()) |task| {\n        task.result = switch (task.req) {\n            .accept => if (self.accept_cb) |cb| cb(task) else return error.NoMockCallback,\n            .cancel => if (self.cancel_cb) |cb| cb(task) else return error.NoMockCallback,\n            .close => if (self.close_cb) |cb| cb(task) else return error.NoMockCallback,\n            .connect => if (self.connect_cb) |cb| cb(task) else return error.NoMockCallback,\n            .deadline => if (self.deadline_cb) |cb| cb(task) else return error.NoMockCallback,\n            .msg_ring => if (self.msg_ring_cb) |cb| cb(task) else return error.NoMockCallback,\n            .noop => if (self.noop_cb) |cb| cb(task) else return error.NoMockCallback,\n            .open => if (self.open_cb) |cb| cb(task) else return error.NoMockCallback,\n            .poll => if (self.poll_cb) |cb| cb(task) else return error.NoMockCallback,\n            .read => if (self.read_cb) |cb| cb(task) else return error.NoMockCallback,\n            .readv => if (self.readv_cb) |cb| cb(task) else return error.NoMockCallback,\n            .recv => if (self.recv_cb) |cb| cb(task) else return error.NoMockCallback,\n            .socket => if (self.socket_cb) |cb| cb(task) else return error.NoMockCallback,\n            .splice => if (self.splice_cb) |cb| cb(task) else return error.NoMockCallback,\n            .statx => if (self.statx_cb) |cb| cb(task) else return error.NoMockCallback,\n            .timer => if (self.timer_cb) |cb| cb(task) else return error.NoMockCallback,\n            .userbytes => if (self.userbytes_cb) |cb| cb(task) else return error.NoMockCallback,\n            .userfd => if (self.userfd_cb) |cb| cb(task) else return error.NoMockCallback,\n            .usermsg => if (self.usermsg_cb) |cb| cb(task) else return error.NoMockCallback,\n            .userptr => if (self.userptr_cb) |cb| cb(task) else return error.NoMockCallback,\n            .write => if (self.write_cb) |cb| cb(task) else return error.NoMockCallback,\n            .writev => if (self.writev_cb) |cb| cb(task) else return error.NoMockCallback,\n        };\n\n        switch (task.result.?) {\n            .accept => |accept| {\n                if (accept) |_| self.open_fds += 1 else |_| {}\n            },\n            .open => |open| {\n                if (open) |_| self.open_fds += 1 else |_| {}\n            },\n            .socket => |socket| {\n                if (socket) |_| self.open_fds += 1 else |_| {}\n            },\n            .close => |close| {\n                if (close) |_| self.open_fds -= 1 else |_| {}\n            },\n            else => {},\n        }\n        self.completions.push(task);\n    }\n}\n\npub fn reapCompletions(self: *Mock, rt: *io.Ring) anyerror!void {\n    while (self.completions.pop()) |task| {\n        try task.callback(rt, task.*);\n        rt.free_q.push(task);\n        if (task.deadline) |dl| rt.free_q.push(dl);\n    }\n}\n"], ["/ourio/src/ourio/Task.zig", "const Task = @This();\n\nconst std = @import(\"std\");\nconst io = @import(\"../ourio.zig\");\n\nconst Allocator = std.mem.Allocator;\nconst Ring = io.Ring;\n\nuserdata: ?*anyopaque = null,\nmsg: u16 = 0,\ncallback: io.Callback = io.noopCallback,\nreq: io.Request = .noop,\n\nresult: ?io.Result = null,\n\nstate: enum {\n    /// The task is free to be scheduled\n    free,\n\n    /// The task is in flight and may not be rescheduled. Some operations generate multiple\n    /// completions, so it is possible to receive a task in Callback and the task is still\n    /// considered to be in flight\n    in_flight,\n\n    /// The task was completed\n    complete,\n\n    /// The operation was canceled\n    canceled,\n} = .free,\n\n/// Deadline for the task to complete, in absolute time. If 0, there is no deadline\ndeadline: ?*Task = null,\n\nnext: ?*Task = null,\nprev: ?*Task = null,\n\npub fn setDeadline(\n    self: *Task,\n    rt: *Ring,\n    deadline: io.Timespec,\n) Allocator.Error!void {\n    std.debug.assert(!deadline.isZero());\n    const task = try rt.getTask();\n\n    task.* = .{\n        .callback = io.noopCallback,\n        .userdata = null,\n        .msg = 0,\n        .req = .{ .deadline = deadline },\n    };\n\n    self.deadline = task;\n}\n\npub fn cancel(\n    self: *Task,\n    rt: *Ring,\n    ctx: io.Context,\n) Allocator.Error!void {\n    const task = try rt.getTask();\n    task.* = .{\n        .callback = ctx.cb,\n        .msg = ctx.msg,\n        .userdata = ctx.ptr,\n        .req = .{ .cancel = .{ .task = self } },\n    };\n    rt.submission_q.push(task);\n}\n\npub fn userdataCast(self: Task, comptime T: type) *T {\n    return @ptrCast(@alignCast(self.userdata));\n}\n\npub fn msgToEnum(self: Task, comptime Enum: type) Enum {\n    return @enumFromInt(self.msg);\n}\n"], ["/ourio/src/ourio/queue.zig", "// This code is mostly a copy of the intrusive queue code from libxev. I've modified it to be a\n// doubly linked list that also ensures a certain state is set on each node when put into the list\n//\n// MIT License\n//\n// Copyright (c) 2023 Mitchell Hashimoto\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and\n// associated documentation files (the \"Software\"), to deal in the Software without restriction,\n// including without limitation the rights to use, copy, modify, merge, publish, distribute,\n// sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all copies or\n// substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT\n// NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nconst std = @import(\"std\");\nconst assert = std.debug.assert;\n\n/// An intrusive queue implementation. The type T must have a field\n/// \"next\" of type `?*T` and a field \"state\" which is an enum with a value matching the passed in\n/// value\npub fn Intrusive(comptime T: type, comptime state: @Type(.enum_literal)) type {\n    return struct {\n        const Self = @This();\n\n        const set_state = state;\n\n        /// Head is the front of the queue and tail is the back of the queue.\n        head: ?*T = null,\n        tail: ?*T = null,\n\n        /// Enqueue a new element to the back of the queue.\n        pub fn push(self: *Self, v: *T) void {\n            assert(v.next == null);\n            v.state = set_state;\n\n            if (self.tail) |tail| {\n                // If we have elements in the queue, then we add a new tail.\n                tail.next = v;\n                v.prev = tail;\n                self.tail = v;\n            } else {\n                // No elements in the queue we setup the initial state.\n                self.head = v;\n                self.tail = v;\n            }\n        }\n\n        /// Dequeue the next element from the queue.\n        pub fn pop(self: *Self) ?*T {\n            // The next element is in \"head\".\n            const next = self.head orelse return null;\n\n            // If the head and tail are equal this is the last element\n            // so we also set tail to null so we can now be empty.\n            if (self.head == self.tail) self.tail = null;\n\n            // Head is whatever is next (if we're the last element,\n            // this will be null);\n            self.head = next.next;\n            if (self.head) |head| head.prev = null;\n\n            // We set the \"next\" field to null so that this element\n            // can be inserted again.\n            next.next = null;\n            next.prev = null;\n            return next;\n        }\n\n        /// Returns true if the queue is empty.\n        pub fn empty(self: Self) bool {\n            return self.head == null;\n        }\n\n        /// Removes the item from the queue. Asserts that Queue contains the item\n        pub fn remove(self: *Self, item: *T) void {\n            assert(self.hasItem(item));\n            if (item.prev) |prev| prev.next = item.next else self.head = item.next;\n\n            if (item.next) |next| next.prev = item.prev else self.tail = item.prev;\n\n            item.prev = null;\n            item.next = null;\n        }\n\n        pub fn hasItem(self: Self, item: *T) bool {\n            var maybe_node = self.head;\n            while (maybe_node) |node| {\n                if (node == item) return true;\n                maybe_node = node.next;\n            } else return false;\n        }\n\n        pub fn len(self: Self) usize {\n            var count: usize = 0;\n            var maybe_node = self.head;\n            while (maybe_node) |node| {\n                count += 1;\n                maybe_node = node.next;\n            }\n            return count;\n        }\n    };\n}\n"], ["/ourio/src/stda.zig", "const std = @import(\"std\");\n\npub const net = @import(\"stda/net.zig\");\npub const tls = @import(\"stda/tls.zig\");\n\nconst root = @import(\"root\");\npub const options: Options = if (@hasDecl(root, \"stda_options\")) root.std_options else .{};\n\npub const Options = struct {\n    /// nameservers to be used if system nameservers can't be located\n    nameservers: [2]std.net.Address = .{\n        std.net.Address.initIp4(.{ 1, 1, 1, 1 }, 53),\n        std.net.Address.initIp4(.{ 1, 0, 0, 1 }, 53),\n    },\n};\n\ntest {\n    _ = net;\n    _ = tls;\n}\n"]], "task_instance_info": {"created_time": "2025-08-21 03:53:54", "created_task_model": "DeepSeek-R1", "code_description": "This code segment functions to: Verify completion of a secure connection handshake process and instantiate a communication handler upon successful negotiation while releasing allocated resources."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```zig\n[TASK_BEGIN]\n                    self.task = try rt.recv(self.fd, self.buffer[self.read_end..], .{\n                        .ptr = self,\n                        .cb = HandshakeTask.handleMsg,\n                    });\n[TASK_END]\n```", "inference_time": "2025-08-21 03-54-04"}, "editdistance_info": {"edit_distance": 16.4706, "calculate_time": "2025-08-21 03:54:04", "true_code_clean": "if (self.handshake.done()) {\n                        defer rt.gpa.destroy(self);\n                        const client = try self.initClient(rt.gpa);\n                        try self.callback(rt, .{\n                            .userdata = self.userdata,\n                            .msg = self.msg,\n                            .result = .{ .userptr = client },\n                            .callback = self.callback,\n                            .req = .userptr,\n                        });\n                        return;\n                    }", "predict_code_clean": "self.task = try rt.recv(self.fd, self.buffer[self.read_end..], .{\n                        .ptr = self,\n                        .cb = HandshakeTask.handleMsg,\n                    });"}}