IoUring: Fix merge conflicts

use flags in Threaded

change futex signature to expect *const atomic.Value(u32)

fix IoUring timeout test

Signed-off-by: Bernard Assan <mega.alpha100@gmail.com>

Author: bernardassan

lib/std/Io/Threaded.zig

@@ -1289,8 +1289,7 @@ fn dirStatPathLinux(
     var path_buffer: [posix.PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
 
-    const flags: u32 = linux.AT.NO_AUTOMOUNT |
-        @as(u32, if (!options.follow_symlinks) linux.AT.SYMLINK_NOFOLLOW else 0);
+    const flags: linux.At = .{ .no_automount = true, .symlink_nofollow = if (!options.follow_symlinks) true else false };
 
     while (true) {
         try t.checkCancel();
@@ -1299,7 +1298,15 @@ fn dirStatPathLinux(
             dir.handle,
             sub_path_posix,
             flags,
-            linux.STATX_INO | linux.STATX_SIZE | linux.STATX_TYPE | linux.STATX_MODE | linux.STATX_ATIME | linux.STATX_MTIME | linux.STATX_CTIME,
+            .{
+                .ino = true,
+                .size = true,
+                .type = true,
+                .mode = true,
+                .atime = true,
+                .mtime = true,
+                .ctime = true,
+            },
             &statx,
         );
         switch (linux.errno(rc)) {
@@ -1445,8 +1452,16 @@ fn fileStatLinux(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File
         const rc = linux.statx(
             file.handle,
             "",
-            linux.AT.EMPTY_PATH,
-            linux.STATX_INO | linux.STATX_SIZE | linux.STATX_TYPE | linux.STATX_MODE | linux.STATX_ATIME | linux.STATX_MTIME | linux.STATX_CTIME,
+            .{ .empty_path = true },
+            .{
+                .ino = true,
+                .size = true,
+                .type = true,
+                .mode = true,
+                .atime = true,
+                .mtime = true,
+                .ctime = true,
+            },
             &statx,
         );
         switch (linux.errno(rc)) {
@@ -5862,7 +5877,7 @@ pub fn futexWake(ptr: *const std.atomic.Value(u32), max_waiters: u32) void {
         .linux => {
             const linux = std.os.linux;
             switch (linux.errno(linux.futex_3arg(
-                &ptr.raw,
+                ptr,
                 .{ .cmd = .WAKE, .private = true },
                 @min(max_waiters, std.math.maxInt(i32)),
             ))) {

lib/std/Thread.zig

@@ -1216,8 +1216,8 @@ const LinuxThreadImpl = struct {
     thread: *ThreadCompletion,
 
     const ThreadCompletion = struct {
-        completion: Completion = Completion.init(.running),
-        child_tid: std.atomic.Value(i32) = std.atomic.Value(i32).init(1),
+        completion: Completion = .init(.running),
+        child_tid: std.atomic.Value(i32) = .init(1),
         parent_tid: i32 = undefined,
         mapped: []align(std.heap.page_size_min) u8,
 
@@ -1662,7 +1662,7 @@ const LinuxThreadImpl = struct {
             if (tid == 0) break;
 
             switch (linux.errno(linux.futex_4arg(
-                @ptrCast(&self.thread.child_tid.raw),
+                @ptrCast(&self.thread.child_tid),
                 .{ .cmd = .WAIT, .private = false },
                 @bitCast(tid),
                 null,

lib/std/Thread/Futex.zig

@@ -263,7 +263,7 @@ const LinuxImpl = struct {
         }
 
         const rc = linux.futex_4arg(
-            &ptr.raw,
+            ptr,
             .{ .cmd = .WAIT, .private = true },
             expect,
             if (timeout != null) &ts else null,
@@ -285,7 +285,7 @@ const LinuxImpl = struct {
 
     fn wake(ptr: *const atomic.Value(u32), max_waiters: u32) void {
         const rc = linux.futex_3arg(
-            &ptr.raw,
+            ptr,
             .{ .cmd = .WAKE, .private = true },
             @min(max_waiters, std.math.maxInt(i32)),
         );

lib/std/os/linux.zig

@@ -4,6 +4,7 @@
 //! * Implement all the syscalls in the same way that libc functions will
 //!   provide `rename` when only the `renameat` syscall exists.
 const std = @import("../std.zig");
+const atomic = std.atomic;
 const builtin = @import("builtin");
 const assert = std.debug.assert;
 const maxInt = std.math.maxInt;
@@ -754,7 +755,7 @@ pub const futex_param4 = extern union {
 /// The futex_op parameter is a sub-command and flags.  The sub-command
 /// defines which of the subsequent paramters are relevant.
 pub fn futex(
-    uaddr: *const u32,
+    uaddr: *const atomic.Value(u32),
     futex_op: FUTEX_OP,
     val: u32,
     val2timeout: futex_param4,
@@ -774,7 +775,7 @@ pub fn futex(
 
 /// Three-argument variation of the v1 futex call.  Only suitable for a
 /// futex_op that ignores the remaining arguments (e.g., FUTUX_OP.WAKE).
-pub fn futex_3arg(uaddr: *const u32, futex_op: FUTEX_OP, val: u32) usize {
+pub fn futex_3arg(uaddr: *const atomic.Value(u32), futex_op: FUTEX_OP, val: u32) usize {
     return syscall3(
         if (@hasField(SYS, "futex") and native_arch != .hexagon) .futex else .futex_time64,
         @intFromPtr(uaddr),
@@ -785,7 +786,7 @@ pub fn futex_3arg(uaddr: *const u32, futex_op: FUTEX_OP, val: u32) usize {
 
 /// Four-argument variation on the v1 futex call.  Only suitable for
 /// futex_op that ignores the remaining arguments (e.g., FUTEX_OP.WAIT).
-pub fn futex_4arg(uaddr: *const u32, futex_op: FUTEX_OP, val: u32, timeout: ?*const timespec) usize {
+pub fn futex_4arg(uaddr: *const atomic.Value(u32), futex_op: FUTEX_OP, val: u32, timeout: ?*const timespec) usize {
     return syscall4(
         if (@hasField(SYS, "futex") and native_arch != .hexagon) .futex else .futex_time64,
         @intFromPtr(uaddr),
@@ -838,7 +839,7 @@ pub fn futex2_waitv(
 /// Requires at least kernel v6.7.
 pub fn futex2_wait(
     /// Address of the futex to wait on.
-    uaddr: *const u32,
+    uaddr: *const atomic.Value(u32),
     /// Value of `uaddr`.
     val: usize,
     /// Bitmask to match against incoming wakeup masks.  Must not be zero.
@@ -867,7 +868,7 @@ pub fn futex2_wait(
 /// Requires at least kernel v6.7.
 pub fn futex2_wake(
     /// Futex to wake
-    uaddr: *const u32,
+    uaddr: *const atomic.Value(u32),
     /// Bitmask to match against waiters.
     mask: Futex2.Bitset,
     /// Maximum number of waiters on the futex to wake.

lib/std/os/linux/IoUring.zig

@@ -1694,7 +1694,7 @@ pub fn socket(
     domain: linux.Af,
     socket_type: linux.Sock,
     protocol: linux.IpProto,
-    /// flags is unused
+    /// flags are currently unused
     flags: u32,
 ) !*Sqe {
     const sqe = try self.get_sqe();
@@ -1711,7 +1711,7 @@ pub fn socket_direct(
     domain: linux.Af,
     socket_type: linux.Sock,
     protocol: linux.IpProto,
-    /// flags is unused
+    /// flags are currently unused
     flags: u32,
     file_index: u32,
 ) !*Sqe {
@@ -1731,7 +1731,7 @@ pub fn socket_direct_alloc(
     domain: linux.Af,
     socket_type: linux.Sock,
     protocol: linux.IpProto,
-    /// flags unused
+    /// flags are currently unused
     flags: u32,
 ) !*Sqe {
     const sqe = try self.get_sqe();
@@ -5377,8 +5377,8 @@ test "timeout (after a relative time)" {
     };
     defer ring.deinit();
 
-    const ms = 10;
-    const ts: linux.kernel_timespec = .{ .sec = 0, .nsec = ms * 1000000 };
+    const ms = 5;
+    const ts: linux.kernel_timespec = .{ .sec = 0, .nsec = ms * 1_000_000 };
 
     const started = try std.Io.Clock.awake.now(io);
     const sqe = try ring.timeout(0x55555555, &ts, 0, .{});
@@ -5394,9 +5394,9 @@ test "timeout (after a relative time)" {
     }, cqe);
 
     // Tests should not depend on timings: skip test if outside margin.
-    const margin = 5;
+    const ms_margin = 5;
     const ms_elapsed = started.durationTo(stopped).toMilliseconds();
-    if (ms_elapsed > margin) return error.SkipZigTest;
+    if (ms_elapsed > ms_margin) return error.SkipZigTest;
 }
 
 test "timeout (after a number of completions)" {
@@ -5802,7 +5802,7 @@ test "shutdown" {
     // Socket bound, expect shutdown to work
     {
         // TODO: update posix later to use Typed Flags
-        const server = try posix.socket(address.any.family, @as(u32, @bitCast(linux.Sock{ .type = .stream, .flags = .{ .cloexec = true } })), 0);
+        const server = try posix.socket(address.family, @as(u32, @bitCast(linux.Sock{ .type = .stream, .flags = .{ .cloexec = true } })), 0);
         defer posix.close(server);
         try posix.setsockopt(server, posix.SOL.SOCKET, posix.SO.REUSEADDR, &mem.toBytes(@as(u32, 1)));
         try posix.bind(server, addrAny(&address), @sizeOf(linux.sockaddr.in));
@@ -7460,7 +7460,7 @@ test "bind/listen/connect" {
 
     const listen_fd = brk: {
         // Create socket
-        _ = try ring.socket(1, @enumFromInt(addr.any.family), .{ .type = .stream, .flags = .{ .cloexec = true } }, @enumFromInt(proto), 0);
+        _ = try ring.socket(1, @enumFromInt(addr.family), .{ .type = .stream, .flags = .{ .cloexec = true } }, @enumFromInt(proto), 0);
         try testing.expectEqual(1, try ring.submit());
         var cqe = try ring.copy_cqe();
         try testing.expectEqual(1, cqe.user_data);
@@ -7472,7 +7472,7 @@ test "bind/listen/connect" {
         var optval: u32 = 1;
         (try ring.setsockopt(2, listen_fd, .socket, .reuseaddr, mem.asBytes(&optval))).link_next();
         (try ring.setsockopt(3, listen_fd, .socket, .reuseport, mem.asBytes(&optval))).link_next();
-        (try ring.bind(4, listen_fd, addrAny(&addr), @sizeOf(linux.sockaddr.in), 0)).link_next();
+        (try ring.bind(4, listen_fd, addrAny(&addr), @sizeOf(linux.sockaddr.in))).link_next();
         _ = try ring.listen(5, listen_fd, 1);
         // Submit 4 operations
         try testing.expectEqual(4, try ring.submit());