ourio: add open op

src/ourio.zig

···
     connect,
     statx,
     readv,
+    open,
 
     /// userfd is meant to send file descriptors between Ring instances (using msgRing)
     userfd,
···
         fd: posix.fd_t,
         vecs: []const posix.iovec,
     },
+    open: struct {
+        path: [:0]const u8,
+        flags: posix.O,
+        mode: posix.mode_t,
+    },
 
     userfd,
     usermsg,
···
     connect: ResultError!void,
     statx: ResultError!*Statx,
     readv: ResultError!usize,
+    open: ResultError!posix.fd_t,
 
     userfd: anyerror!posix.fd_t,
     usermsg: u16,

src/ourio/Kqueue.zig

···
             self.synchronous_queue.push(task);
         },
 
+        .open => |req| {
+            self.synchronous_queue.push(task);
+
+            if (posix.open(req.path, req.flags, req.mode)) |fd| {
+                task.result = .{ .open = fd };
+            } else |_| task.result = .{ .open = error.Unexpected };
+        },
+
         .poll => |req| {
             self.in_flight.push(task);
             if (req.mask & posix.POLL.IN != 0) {
···
         .close,
         .msg_ring,
         .noop,
+        .open,
         .socket,
         .statx,
         .userfd,
···
         .close,
         .msg_ring,
         .noop,
+        .open,
         .socket,
         .statx,
         .userfd,
···
                         .deadline => .{ .deadline = error.Canceled },
                         .msg_ring => .{ .msg_ring = error.Canceled },
                         .noop => unreachable,
+                        .open => .{ .open = error.Canceled },
                         .poll => .{ .poll = error.Canceled },
                         .readv => .{ .readv = error.Canceled },
                         .recv => .{ .recv = error.Canceled },
···
         .deadline,
         .msg_ring,
         .noop,
+        .open,
         .socket,
         .statx,
         .timer,

src/ourio/Mock.zig

···
 deadline_cb: ?*const fn (*io.Task) io.Result = null,
 msg_ring_cb: ?*const fn (*io.Task) io.Result = null,
 noop_cb: ?*const fn (*io.Task) io.Result = null,
+open_cb: ?*const fn (*io.Task) io.Result = null,
 poll_cb: ?*const fn (*io.Task) io.Result = null,
 readv_cb: ?*const fn (*io.Task) io.Result = null,
 recv_cb: ?*const fn (*io.Task) io.Result = null,
···
             .deadline => if (self.deadline_cb) |cb| cb(task) else return error.NoMockCallback,
             .msg_ring => if (self.msg_ring_cb) |cb| cb(task) else return error.NoMockCallback,
             .noop => if (self.noop_cb) |cb| cb(task) else return error.NoMockCallback,
+            .open => if (self.open_cb) |cb| cb(task) else return error.NoMockCallback,
             .poll => if (self.poll_cb) |cb| cb(task) else return error.NoMockCallback,
             .readv => if (self.readv_cb) |cb| cb(task) else return error.NoMockCallback,
             .recv => if (self.recv_cb) |cb| cb(task) else return error.NoMockCallback,

src/ourio/Uring.zig

···
             self.prepDeadline(task, sqe);
         },
 
+        .open => |req| {
+            const sqe = self.getSqe();
+            sqe.prep_openat(posix.AT.FDCWD, req.path, req.flags, req.mode);
+            sqe.user_data = @intFromPtr(task);
+            self.prepDeadline(task, sqe);
+        },
+
         // user* is only sent internally between rings and higher level wrappers
         .userfd, .usermsg, .userptr => unreachable,
     }
···
             } },
 
             .readv => .{ .readv = switch (cqeToE(cqe.res)) {
+                .SUCCESS => @intCast(cqe.res),
+                .INVAL => io.ResultError.Invalid,
+                .CANCELED => io.ResultError.Canceled,
+                else => |e| unexpectedError(e),
+            } },
+
+            .open => .{ .open = switch (cqeToE(cqe.res)) {
                 .SUCCESS => @intCast(cqe.res),
                 .INVAL => io.ResultError.Invalid,
                 .CANCELED => io.ResultError.Canceled,