Commit 1a0fa1fa7629d67250df5337948fa1dbf6cdb7ad | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2026-01-30 00:44:08+00:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-01-30 12:10:02-08:00
log	1a0fa1fa7629d67250df5337948fa1dbf6cdb7ad
tree	08fcc3971daa39a1d13583342ec9398a272c6e4a
parent	4e198dc1872253533a63468668d9b49a4a9d31dd

std.Io.Threaded: fix ntdll timeouts on Windows

1 files changed, 28 insertions(+), 13 deletions(-)

lib
- std
  - Io
    Threaded.zig

lib/std/Io/Threaded.zig+28-13

 @@ -2719,7 +2719,13 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
         }
     }
-    var delay_interval: windows.LARGE_INTEGER = timeoutToWindowsInterval(timeout);
+    const deadline: ?Io.Clock.Timestamp = timeout.toDeadline(ioBasic(t)) catch |err| switch (err) {
+        error.Unexpected => deadline: {
+            recoverableOsBugDetected();
+            break :deadline .{ .raw = .{ .nanoseconds = 0 }, .clock = .awake };
+        },
+        error.UnsupportedClock => |e| return e,
+    };
     while (true) {
         var any_pending = false;
 @@ -2741,6 +2747,16 @@ fn batchWaitWindows(t: *Threaded, b: *Io.Batch, timeout: Io.Timeout) Io.Batch.Wa
         }
         if (b.user.complete_head != complete_tail) return;
         if (!any_pending) return;
+        var delay_interval: windows.LARGE_INTEGER = interval: {
+            const d = deadline orelse break :interval std.math.minInt(windows.LARGE_INTEGER);
+            break :interval t.deadlineToWindowsInterval(d) catch |err| switch (err) {
+                error.UnsupportedClock => |e| return e,
+                error.Unexpected => {
+                    recoverableOsBugDetected();
+                    break :interval -1;
+                },
+            };
+        };
         const alertable_syscall = try AlertableSyscall.start();
         const delay_rc = windows.ntdll.NtDelayExecution(windows.TRUE, &delay_interval);
         alertable_syscall.finish();
 @@ -16784,19 +16800,18 @@ fn park(opt_deadline: ?Io.Clock.Timestamp, addr_hint: ?*const anyopaque) error{T
     }
 }
-fn timeoutToWindowsInterval(timeout: Io.Timeout) windows.LARGE_INTEGER {
+fn deadlineToWindowsInterval(t: *Io.Threaded, deadline: Io.Clock.Timestamp) Io.Clock.Error!windows.LARGE_INTEGER {
-    switch (timeout) {
+    // ntdll only supports two combinations:
-        .none => {
+    // * real-time (`.real`) sleeps with absolute deadlines
-            return std.math.minInt(windows.LARGE_INTEGER); // infinite timeout
+    // * monotonic (`.awake`/`.boot`) sleeps with relative durations
-        },
+    switch (deadline.clock) {
-        .deadline => |deadline| {
+        .cpu_process, .cpu_thread => unreachable, // cannot sleep for CPU time
-            const nanoseconds = deadline.raw.nanoseconds;
+        .real => {
-            return @intCast(@divTrunc(nanoseconds, 100));
+            return @intCast(@max(@divTrunc(deadline.raw.nanoseconds, 100), 0));
         },
-        .duration => |duration| {
+        .awake, .boot => {
-            const now_timestamp = nowWindows(duration.clock) catch unreachable;
+            const duration = try deadline.durationFromNow(ioBasic(t));
-            const deadline_ns = now_timestamp.nanoseconds + duration.raw.nanoseconds;
+            return @intCast(@min(@divTrunc(-duration.raw.nanoseconds, 100), -1));
-            return @intCast(@divTrunc(deadline_ns, 100));
         },
     }
 }