Commit 29e418cbfb3d5e5800ac2ad267b21cf2b8942c2c | zig

author	Andrew Kelley <andrew@ziglang.org> 2025-11-27 08:42:06-08:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-12-01 19:17:52-08:00
log	29e418cbfb3d5e5800ac2ad267b21cf2b8942c2c
tree	fd28b3a438e564c13137d5e178248e3087c35328
parent	95f93a0b281e32583edef36808231a5f61fb7de1

std.Io.Threaded: fix the cancellation race

Now, before a syscall is entered, beginSyscall is called, which may
return error.Canceled. After syscall returns, whether error or success,
endSyscall is called. If the syscall returns EINTR then checkCancel is
called.

`cancelRequested` is removed from the std.Io VTable for now, with plans
to replace it with a more powerful API that allows protection against
cancellation requests.

closes #25751

2 files changed, 1910 insertions(+), 1114 deletions(-)

lib
- std
  - Io.zig
  - Io
    Threaded.zig

lib/std/Io.zig-5

...	...	@@ -620,11 +620,6 @@ pub const VTable = struct {
620	620	result: []u8,
621	621	result_alignment: std.mem.Alignment,
622	622	) void,
623		/// Returns whether the current thread of execution is known to have
624		/// been requested to cancel.
625		///
626		/// Thread-safe.
627		cancelRequested: const fn (?anyopaque) bool,
628	623
629	624	/// When this function returns, implementation guarantees that `start` has
630	625	/// either already been called, or a unit of concurrency has been assigned

lib/std/Io/Threaded.zig+1910-1109

...	...	@@ -50,6 +50,8 @@ cpu_count_error: ?std.Thread.CpuCountError,
50	50	/// available count, subtract this from either `async_limit` or
51	51	/// `concurrent_limit`.
52	52	busy_count: usize = 0,
	53	main_thread: Thread,
	54	pid: Pid = .unknown,
53	55
54	56	wsa: if (is_windows) Wsa else struct {} = .{},
55	57
...	...	@@ -57,7 +59,79 @@ have_signal_handler: bool,
57	59	old_sig_io: if (have_sig_io) posix.Sigaction else void,
58	60	old_sig_pipe: if (have_sig_pipe) posix.Sigaction else void,
59	61
60		threadlocal var current_closure: ?*Closure = null;
	62	pub const Pid = if (native_os == .linux) enum(posix.pid_t) {
	63	unknown = 0,
	64	_,
	65	} else enum(u0) { unknown = 0 };
	66
	67	const Thread = struct {
	68	/// The value that needs to be passed to pthread_kill or tgkill in order to
	69	/// send a signal.
	70	signal_id: SignalId,
	71	current_closure: ?*Closure = null,
	72
	73	const SignalId = if (std.Thread.use_pthreads) std.c.pthread_t else std.Thread.Id;
	74
	75	threadlocal var current: ?*Thread = null;
	76
	77	fn getCurrent(t: Threaded) Thread {
	78	return current orelse return &t.main_thread;
	79	}
	80
	81	fn checkCancel(thread: *Thread) error{Canceled}!void {
	82	const closure = thread.current_closure orelse return;
	83	switch (@cmpxchgStrong(
	84	CancelStatus,
	85	&closure.cancel_status,
	86	.requested,
	87	.acknowledged,
	88	.acq_rel,
	89	.acquire,
	90	) orelse return error.Canceled) {
	91	.none => return,
	92	.requested => unreachable,
	93	.acknowledged => unreachable,
	94	_ => return,
	95	}
	96	}
	97
	98	fn beginSyscall(thread: *Thread) error{Canceled}!void {
	99	const closure = thread.current_closure orelse return;
	100
	101	switch (@cmpxchgStrong(
	102	CancelStatus,
	103	&closure.cancel_status,
	104	.none,
	105	.fromSignalId(thread.signal_id),
	106	.acq_rel,
	107	.acquire,
	108	) orelse return) {
	109	.none => unreachable,
	110	.requested => {
	111	@atomicStore(CancelStatus, &closure.cancel_status, .acknowledged, .release);
	112	return error.Canceled;
	113	},
	114	.acknowledged => unreachable,
	115	_ => unreachable,
	116	}
	117	}
	118
	119	fn endSyscall(thread: *Thread) void {
	120	const closure = thread.current_closure orelse return;
	121	_ = @cmpxchgStrong(
	122	CancelStatus,
	123	&closure.cancel_status,
	124	.fromSignalId(thread.signal_id),
	125	.none,
	126	.acq_rel,
	127	.acquire,
	128	);
	129	}
	130
	131	fn currentSignalId() SignalId {
	132	return if (std.Thread.use_pthreads) std.c.pthread_self() else std.Thread.getCurrentId();
	133	}
	134	};
61	135
62	136	const max_iovecs_len = 8;
63	137	const splat_buffer_size = 64;
...	...	@@ -66,48 +140,93 @@ comptime {
66	140	if (@TypeOf(posix.IOV_MAX) != void) assert(max_iovecs_len <= posix.IOV_MAX);
67	141	}
68	142
69		const CancelId = enum(usize) {
	143	const CancelStatus = enum(usize) {
	144	/// Cancellation has neither been requested, nor checked. The async
	145	/// operation will check status before entering a blocking syscall.
	146	/// This is also the status used for uninteruptible tasks.
70	147	none = 0,
71		canceling = std.math.maxInt(usize),
	148	/// Cancellation has been requested and the status will be checked before
	149	/// entering a blocking syscall.
	150	requested = std.math.maxInt(usize) - 1,
	151	/// Cancellation has been acknowledged and is in progress. Signals should
	152	/// not be sent.
	153	acknowledged = std.math.maxInt(usize),
	154	/// Stores a `Thread.SignalId` and indicates that sending a signal to this thread
	155	/// is needed in order to cancel. This state is set before going into
	156	/// a blocking operation that needs to get unblocked via signal.
72	157	_,
73	158
74		const ThreadId = if (std.Thread.use_pthreads) std.c.pthread_t else std.Thread.Id;
	159	const Unpacked = union(enum) {
	160	none,
	161	requested,
	162	acknowledged,
	163	signal_id: Thread.SignalId,
	164	};
75	165
76		fn currentThread() CancelId {
77		if (std.Thread.use_pthreads) {
78		return @enumFromInt(@intFromPtr(std.c.pthread_self()));
79		} else {
80		return @enumFromInt(std.Thread.getCurrentId());
81		}
	166	fn unpack(cs: CancelStatus) Unpacked {
	167	return switch (cs) {
	168	.none => .none,
	169	.requested => .requested,
	170	.acknowledged => .acknowledged,
	171	_ => \|signal_id\| .{
	172	.signal_id = if (std.Thread.use_pthreads)
	173	@ptrFromInt(@intFromEnum(signal_id))
	174	else
	175	@truncate(@intFromEnum(signal_id)),
	176	},
	177	};
82	178	}
83	179
84		fn toThreadId(cancel_id: CancelId) ThreadId {
85		if (std.Thread.use_pthreads) {
86		return @ptrFromInt(@intFromEnum(cancel_id));
87		} else {
88		return @intCast(@intFromEnum(cancel_id));
89		}
	180	fn fromSignalId(signal_id: Thread.SignalId) CancelStatus {
	181	return if (std.Thread.use_pthreads)
	182	@enumFromInt(@intFromPtr(signal_id))
	183	else
	184	@enumFromInt(signal_id);
90	185	}
91	186	};
92	187
93	188	const Closure = struct {
94	189	start: Start,
95	190	node: std.SinglyLinkedList.Node = .{},
96		cancel_tid: CancelId,
97
98		const Start = const fn (Closure) void;
99
100		fn requestCancel(closure: *Closure) void {
101		switch (@atomicRmw(CancelId, &closure.cancel_tid, .Xchg, .canceling, .acq_rel)) {
102		.none, .canceling => {},
103		else => \|tid\| {
104		if (std.Thread.use_pthreads) {
105		const rc = std.c.pthread_kill(tid.toThreadId(), .IO);
106		if (is_debug) assert(rc == 0);
107		} else if (native_os == .linux) {
108		_ = std.os.linux.tgkill(std.os.linux.getpid(), @bitCast(tid.toThreadId()), .IO);
109		}
110		},
	191	cancel_status: CancelStatus,
	192
	193	const Start = const fn (Closure, *Threaded) void;
	194
	195	fn requestCancel(closure: Closure, t: Threaded) void {
	196	var signal_id = switch (@atomicRmw(CancelStatus, &closure.cancel_status, .Xchg, .requested, .monotonic).unpack()) {
	197	.none, .acknowledged, .requested => return,
	198	.signal_id => \|signal_id\| signal_id,
	199	};
	200	// The task will enter a blocking syscall before checking for cancellation again.
	201	// We can send a signal to interrupt the syscall, but if it arrives before
	202	// the syscall instruction, it will be missed. Therefore, this code tries
	203	// again until the cancellation request is acknowledged.
	204	const max_attempts = 3;
	205	for (0..max_attempts) \|_\| {
	206	if (std.Thread.use_pthreads) {
	207	const rc = std.c.pthread_kill(signal_id, .IO);
	208	if (is_debug) assert(rc == 0);
	209	} else if (native_os == .linux) {
	210	const pid: posix.pid_t = p: {
	211	const cached_pid = @atomicLoad(Pid, &t.pid, .monotonic);
	212	if (cached_pid != .unknown) break :p @intFromEnum(cached_pid);
	213	const pid = std.os.linux.getpid();
	214	@atomicStore(Pid, &t.pid, @enumFromInt(pid), .monotonic);
	215	break :p pid;
	216	};
	217	_ = std.os.linux.tgkill(pid, @bitCast(signal_id), .IO);
	218	} else {
	219	return;
	220	}
	221
	222	// TODO make this a nanosleep with 1 << attempt duration
	223	std.Thread.yield() catch {};
	224
	225	switch (@atomicRmw(CancelStatus, &closure.cancel_status, .Xchg, .requested, .monotonic).unpack()) {
	226	.requested => continue,
	227	.none, .acknowledged => return,
	228	.signal_id => \|new_signal_id\| signal_id = new_signal_id,
	229	}
111	230	}
112	231	}
113	232	};
...	...	@@ -136,6 +255,9 @@ pub fn init(
136	255	.old_sig_io = undefined,
137	256	.old_sig_pipe = undefined,
138	257	.have_signal_handler = false,
	258	.main_thread = .{
	259	.signal_id = Thread.currentSignalId(),
	260	},
139	261	};
140	262
141	263	if (posix.Sigaction != void) {
...	...	@@ -169,6 +291,7 @@ pub const init_single_threaded: Threaded = .{
169	291	.old_sig_io = undefined,
170	292	.old_sig_pipe = undefined,
171	293	.have_signal_handler = false,
	294	.main_thread = .{ .signal_id = undefined },
172	295	};
173	296
174	297	pub fn setAsyncLimit(t: *Threaded, new_limit: Io.Limit) void {
...	...	@@ -201,6 +324,11 @@ fn join(t: *Threaded) void {
201	324	}
202	325
203	326	fn worker(t: *Threaded) void {
	327	var thread: Thread = .{
	328	.signal_id = Thread.currentSignalId(),
	329	};
	330	Thread.current = &thread;
	331
204	332	defer t.wait_group.finish();
205	333
206	334	t.mutex.lock();
...	...	@@ -210,7 +338,7 @@ fn worker(t: *Threaded) void {
210	338	while (t.run_queue.popFirst()) \|closure_node\| {
211	339	t.mutex.unlock();
212	340	const closure: *Closure = @fieldParentPtr("node", closure_node);
213		closure.start(closure);
	341	closure.start(closure, t);
214	342	t.mutex.lock();
215	343	t.busy_count -= 1;
216	344	}
...	...	@@ -227,7 +355,6 @@ pub fn io(t: *Threaded) Io {
227	355	.concurrent = concurrent,
228	356	.await = await,
229	357	.cancel = cancel,
230		.cancelRequested = cancelRequested,
231	358	.select = select,
232	359
233	360	.groupAsync = groupAsync,
...	...	@@ -324,7 +451,6 @@ pub fn ioBasic(t: *Threaded) Io {
324	451	.concurrent = concurrent,
325	452	.await = await,
326	453	.cancel = cancel,
327		.cancelRequested = cancelRequested,
328	454	.select = select,
329	455
330	456	.groupAsync = groupAsync,
...	...	@@ -418,24 +544,12 @@ const AsyncClosure = struct {
418	544
419	545	const done_reset_event: *ResetEvent = @ptrFromInt(@alignOf(ResetEvent));
420	546
421		fn start(closure: *Closure) void {
	547	fn start(closure: Closure, t: Threaded) void {
422	548	const ac: *AsyncClosure = @alignCast(@fieldParentPtr("closure", closure));
423		const tid: CancelId = .currentThread();
424		if (@cmpxchgStrong(CancelId, &closure.cancel_tid, .none, tid, .acq_rel, .acquire)) \|cancel_tid\| {
425		assert(cancel_tid == .canceling);
426		// Even though we already know the task is canceled, we must still
427		// run the closure in order to make the return value valid and in
428		// case there are side effects.
429		}
430		current_closure = closure;
	549	const current_thread = Thread.getCurrent(t);
	550	current_thread.current_closure = closure;
431	551	ac.func(ac.contextPointer(), ac.resultPointer());
432		current_closure = null;
433
434		// In case a cancel happens after successful task completion, prevents
435		// signal from being delivered to the thread in `requestCancel`.
436		if (@cmpxchgStrong(CancelId, &closure.cancel_tid, tid, .none, .acq_rel, .acquire)) \|cancel_tid\| {
437		assert(cancel_tid == .canceling);
438		}
	552	current_thread.current_closure = null;
439	553
440	554	if (@atomicRmw(?*ResetEvent, &ac.select_condition, .Xchg, done_reset_event, .release)) \|select_reset\| {
441	555	assert(select_reset != done_reset_event);
...	...	@@ -476,7 +590,7 @@ const AsyncClosure = struct {
476	590	const actual_result_offset = actual_result_addr - @intFromPtr(ac);
477	591	ac.* = .{
478	592	.closure = .{
479		.cancel_tid = .none,
	593	.cancel_status = .none,
480	594	.start = start,
481	595	},
482	596	.func = func,
...	...	@@ -493,7 +607,7 @@ const AsyncClosure = struct {
493	607	fn waitAndDeinit(ac: AsyncClosure, t: Threaded, result: []u8) void {
494	608	ac.reset_event.wait(t) catch \|err\| switch (err) {
495	609	error.Canceled => {
496		ac.closure.requestCancel();
	610	ac.closure.requestCancel(t);
497	611	ac.reset_event.waitUncancelable();
498	612	},
499	613	};
...	...	@@ -604,7 +718,6 @@ fn concurrent(
604	718
605	719	const GroupClosure = struct {
606	720	closure: Closure,
607		t: *Threaded,
608	721	group: *Io.Group,
609	722	/// Points to sibling `GroupClosure`. Used for walking the group to cancel all.
610	723	node: std.SinglyLinkedList.Node,
...	...	@@ -612,26 +725,15 @@ const GroupClosure = struct {
612	725	context_alignment: Alignment,
613	726	alloc_len: usize,
614	727
615		fn start(closure: *Closure) void {
	728	fn start(closure: Closure, t: Threaded) void {
616	729	const gc: *GroupClosure = @alignCast(@fieldParentPtr("closure", closure));
617		const tid: CancelId = .currentThread();
	730	const current_thread = Thread.getCurrent(t);
618	731	const group = gc.group;
619	732	const group_state: *std.atomic.Value(usize) = @ptrCast(&group.state);
620	733	const reset_event: *ResetEvent = @ptrCast(&group.context);
621		if (@cmpxchgStrong(CancelId, &closure.cancel_tid, .none, tid, .acq_rel, .acquire)) \|cancel_tid\| {
622		assert(cancel_tid == .canceling);
623		// Even though we already know the task is canceled, we must still
624		// run the closure in case there are side effects.
625		}
626		current_closure = closure;
	734	current_thread.current_closure = closure;
627	735	gc.func(group, gc.contextPointer());
628		current_closure = null;
629
630		// In case a cancel happens after successful task completion, prevents
631		// signal from being delivered to the thread in `requestCancel`.
632		if (@cmpxchgStrong(CancelId, &closure.cancel_tid, tid, .none, .acq_rel, .acquire)) \|cancel_tid\| {
633		assert(cancel_tid == .canceling);
634		}
	736	current_thread.current_closure = null;
635	737
636	738	const prev_state = group_state.fetchSub(sync_one_pending, .acq_rel);
637	739	assert((prev_state / sync_one_pending) > 0);
...	...	@@ -647,7 +749,6 @@ const GroupClosure = struct {
647	749	/// Does not initialize the `node` field.
648	750	fn init(
649	751	gpa: Allocator,
650		t: *Threaded,
651	752	group: *Io.Group,
652	753	context: []const u8,
653	754	context_alignment: Alignment,
...	...	@@ -662,10 +763,9 @@ const GroupClosure = struct {
662	763
663	764	gc.* = .{
664	765	.closure = .{
665		.cancel_tid = .none,
	766	.cancel_status = .none,
666	767	.start = start,
667	768	},
668		.t = t,
669	769	.group = group,
670	770	.node = undefined,
671	771	.func = func,
...	...	@@ -696,7 +796,7 @@ fn groupAsync(
696	796	if (builtin.single_threaded) return start(group, context.ptr);
697	797
698	798	const gpa = t.allocator;
699		const gc = GroupClosure.init(gpa, t, group, context, context_alignment, start) catch
	799	const gc = GroupClosure.init(gpa, group, context, context_alignment, start) catch
700	800	return start(group, context.ptr);
701	801
702	802	t.mutex.lock();
...	...	@@ -752,7 +852,7 @@ fn groupConcurrent(
752	852	const t: *Threaded = @ptrCast(@alignCast(userdata));
753	853
754	854	const gpa = t.allocator;
755		const gc = GroupClosure.init(gpa, t, group, context, context_alignment, start) catch
	855	const gc = GroupClosure.init(gpa, group, context, context_alignment, start) catch
756	856	return error.ConcurrencyUnavailable;
757	857
758	858	t.mutex.lock();
...	...	@@ -806,7 +906,7 @@ fn groupWait(userdata: ?anyopaque, group: Io.Group, token: *anyopaque) void {
806	906	var node: *std.SinglyLinkedList.Node = @ptrCast(@alignCast(token));
807	907	while (true) {
808	908	const gc: *GroupClosure = @fieldParentPtr("node", node);
809		gc.closure.requestCancel();
	909	gc.closure.requestCancel(t);
810	910	node = node.next orelse break;
811	911	}
812	912	reset_event.waitUncancelable();
...	...	@@ -832,7 +932,7 @@ fn groupCancel(userdata: ?anyopaque, group: Io.Group, token: *anyopaque) void
832	932	var node: *std.SinglyLinkedList.Node = @ptrCast(@alignCast(token));
833	933	while (true) {
834	934	const gc: *GroupClosure = @fieldParentPtr("node", node);
835		gc.closure.requestCancel();
	935	gc.closure.requestCancel(t);
836	936	node = node.next orelse break;
837	937	}
838	938	}
...	...	@@ -875,30 +975,20 @@ fn cancel(
875	975	_ = result_alignment;
876	976	const t: *Threaded = @ptrCast(@alignCast(userdata));
877	977	const ac: *AsyncClosure = @ptrCast(@alignCast(any_future));
878		ac.closure.requestCancel();
	978	ac.closure.requestCancel(t);
879	979	ac.waitAndDeinit(t, result);
880	980	}
881	981
882		fn cancelRequested(userdata: ?*anyopaque) bool {
883		const t: *Threaded = @ptrCast(@alignCast(userdata));
884		_ = t;
885		const closure = current_closure orelse return false;
886		return @atomicLoad(CancelId, &closure.cancel_tid, .acquire) == .canceling;
887		}
888
889		fn checkCancel(t: *Threaded) error{Canceled}!void {
890		if (cancelRequested(t)) return error.Canceled;
891		}
892
893	982	fn mutexLock(userdata: ?anyopaque, prev_state: Io.Mutex.State, mutex: Io.Mutex) Io.Cancelable!void {
894	983	if (builtin.single_threaded) unreachable; // Interface should have prevented this.
895	984	if (native_os == .netbsd) @panic("TODO");
896	985	const t: *Threaded = @ptrCast(@alignCast(userdata));
	986	const current_thread = Thread.getCurrent(t);
897	987	if (prev_state == .contended) {
898		try futexWait(t, @ptrCast(&mutex.state), @intFromEnum(Io.Mutex.State.contended));
	988	try futexWait(current_thread, @ptrCast(&mutex.state), @intFromEnum(Io.Mutex.State.contended));
899	989	}
900	990	while (@atomicRmw(Io.Mutex.State, &mutex.state, .Xchg, .contended, .acquire) != .unlocked) {
901		try futexWait(t, @ptrCast(&mutex.state), @intFromEnum(Io.Mutex.State.contended));
	991	try futexWait(current_thread, @ptrCast(&mutex.state), @intFromEnum(Io.Mutex.State.contended));
902	992	}
903	993	}
904	994
...	...	@@ -960,6 +1050,7 @@ fn conditionWait(userdata: ?anyopaque, cond: Io.Condition, mutex: *Io.Mutex) I
960	1050	if (builtin.single_threaded) unreachable; // Deadlock.
961	1051	if (native_os == .netbsd) @panic("TODO");
962	1052	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1053	const current_thread = Thread.getCurrent(t);
963	1054	const t_io = ioBasic(t);
964	1055	comptime assert(@TypeOf(cond.state) == u64);
965	1056	const ints: *[2]std.atomic.Value(u32) = @ptrCast(&cond.state);
...	...	@@ -988,7 +1079,7 @@ fn conditionWait(userdata: ?anyopaque, cond: Io.Condition, mutex: *Io.Mutex) I
988	1079	defer mutex.lockUncancelable(t_io);
989	1080
990	1081	while (true) {
991		try futexWait(t, cond_epoch, epoch);
	1082	try futexWait(current_thread, cond_epoch, epoch);
992	1083
993	1084	epoch = cond_epoch.load(.acquire);
994	1085	state = cond_state.load(.monotonic);
...	...	@@ -1074,35 +1165,46 @@ const dirMake = switch (native_os) {
1074	1165
1075	1166	fn dirMakePosix(userdata: ?*anyopaque, dir: Io.Dir, sub_path: []const u8, mode: Io.Dir.Mode) Io.Dir.MakeError!void {
1076	1167	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1168	const current_thread = Thread.getCurrent(t);
1077	1169
1078	1170	var path_buffer: [posix.PATH_MAX]u8 = undefined;
1079	1171	const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
1080	1172
	1173	try current_thread.beginSyscall();
1081	1174	while (true) {
1082		try t.checkCancel();
1083	1175	switch (posix.errno(posix.system.mkdirat(dir.handle, sub_path_posix, mode))) {
1084		.SUCCESS => return,
1085		.INTR => continue,
1086		.CANCELED => return error.Canceled,
1087
1088		.ACCES => return error.AccessDenied,
1089		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1090		.PERM => return error.PermissionDenied,
1091		.DQUOT => return error.DiskQuota,
1092		.EXIST => return error.PathAlreadyExists,
1093		.FAULT => \|err\| return errnoBug(err),
1094		.LOOP => return error.SymLinkLoop,
1095		.MLINK => return error.LinkQuotaExceeded,
1096		.NAMETOOLONG => return error.NameTooLong,
1097		.NOENT => return error.FileNotFound,
1098		.NOMEM => return error.SystemResources,
1099		.NOSPC => return error.NoSpaceLeft,
1100		.NOTDIR => return error.NotDir,
1101		.ROFS => return error.ReadOnlyFileSystem,
1102		// dragonfly: when dir_fd is unlinked from filesystem
1103		.NOTCONN => return error.FileNotFound,
1104		.ILSEQ => return error.BadPathName,
1105		else => \|err\| return posix.unexpectedErrno(err),
	1176	.SUCCESS => {
	1177	current_thread.endSyscall();
	1178	return;
	1179	},
	1180	.INTR => {
	1181	try current_thread.checkCancel();
	1182	continue;
	1183	},
	1184	else => \|e\| {
	1185	current_thread.endSyscall();
	1186	switch (e) {
	1187	.CANCELED => return error.Canceled,
	1188	.ACCES => return error.AccessDenied,
	1189	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	1190	.PERM => return error.PermissionDenied,
	1191	.DQUOT => return error.DiskQuota,
	1192	.EXIST => return error.PathAlreadyExists,
	1193	.FAULT => \|err\| return errnoBug(err),
	1194	.LOOP => return error.SymLinkLoop,
	1195	.MLINK => return error.LinkQuotaExceeded,
	1196	.NAMETOOLONG => return error.NameTooLong,
	1197	.NOENT => return error.FileNotFound,
	1198	.NOMEM => return error.SystemResources,
	1199	.NOSPC => return error.NoSpaceLeft,
	1200	.NOTDIR => return error.NotDir,
	1201	.ROFS => return error.ReadOnlyFileSystem,
	1202	// dragonfly: when dir_fd is unlinked from filesystem
	1203	.NOTCONN => return error.FileNotFound,
	1204	.ILSEQ => return error.BadPathName,
	1205	else => \|err\| return posix.unexpectedErrno(err),
	1206	}
	1207	},
1106	1208	}
1107	1209	}
1108	1210	}
...	...	@@ -1110,11 +1212,18 @@ fn dirMakePosix(userdata: ?*anyopaque, dir: Io.Dir, sub_path: []const u8, mode:
1110	1212	fn dirMakeWasi(userdata: ?*anyopaque, dir: Io.Dir, sub_path: []const u8, mode: Io.Dir.Mode) Io.Dir.MakeError!void {
1111	1213	if (builtin.link_libc) return dirMakePosix(userdata, dir, sub_path, mode);
1112	1214	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1215	const current_thread = Thread.getCurrent(t);
	1216	try current_thread.beginSyscall();
1113	1217	while (true) {
1114		try t.checkCancel();
1115	1218	switch (std.os.wasi.path_create_directory(dir.handle, sub_path.ptr, sub_path.len)) {
1116		.SUCCESS => return,
1117		.INTR => continue,
	1219	.SUCCESS => {
	1220	current_thread.endSyscall();
	1221	return;
	1222	},
	1223	.INTR => {
	1224	try current_thread.checkCancel();
	1225	continue;
	1226	},
1118	1227	.CANCELED => return error.Canceled,
1119	1228
1120	1229	.ACCES => return error.AccessDenied,
...	...	@@ -1140,7 +1249,8 @@ fn dirMakeWasi(userdata: ?*anyopaque, dir: Io.Dir, sub_path: []const u8, mode: I
1140	1249
1141	1250	fn dirMakeWindows(userdata: ?*anyopaque, dir: Io.Dir, sub_path: []const u8, mode: Io.Dir.Mode) Io.Dir.MakeError!void {
1142	1251	const t: *Threaded = @ptrCast(@alignCast(userdata));
1143		try t.checkCancel();
	1252	const current_thread = Thread.getCurrent(t);
	1253	try current_thread.checkCancel();
1144	1254
1145	1255	const sub_path_w = try windows.sliceToPrefixedFileW(dir.handle, sub_path);
1146	1256	_ = mode;
...	...	@@ -1213,6 +1323,7 @@ fn dirMakeOpenPathWindows(
1213	1323	options: Io.Dir.OpenOptions,
1214	1324	) Io.Dir.MakeOpenPathError!Io.Dir {
1215	1325	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1326	const current_thread = Thread.getCurrent(t);
1216	1327	const w = windows;
1217	1328	const access_mask = w.STANDARD_RIGHTS_READ \| w.FILE_READ_ATTRIBUTES \| w.FILE_READ_EA \|
1218	1329	w.SYNCHRONIZE \| w.FILE_TRAVERSE \|
...	...	@@ -1226,7 +1337,7 @@ fn dirMakeOpenPathWindows(
1226	1337	};
1227	1338
1228	1339	while (true) {
1229		try t.checkCancel();
	1340	try current_thread.checkCancel();
1230	1341
1231	1342	const sub_path_w_array = try w.sliceToPrefixedFileW(dir.handle, component.path);
1232	1343	const sub_path_w = sub_path_w_array.span();
...	...	@@ -1328,8 +1439,7 @@ fn dirMakeOpenPathWasi(
1328	1439
1329	1440	fn dirStat(userdata: ?*anyopaque, dir: Io.Dir) Io.Dir.StatError!Io.Dir.Stat {
1330	1441	const t: *Threaded = @ptrCast(@alignCast(userdata));
1331		try t.checkCancel();
1332
	1442	_ = t;
1333	1443	_ = dir;
1334	1444	@panic("TODO implement dirStat");
1335	1445	}
...	...	@@ -1348,6 +1458,7 @@ fn dirStatPathLinux(
1348	1458	options: Io.Dir.StatPathOptions,
1349	1459	) Io.Dir.StatPathError!Io.File.Stat {
1350	1460	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1461	const current_thread = Thread.getCurrent(t);
1351	1462	const linux = std.os.linux;
1352	1463
1353	1464	var path_buffer: [posix.PATH_MAX]u8 = undefined;
...	...	@@ -1356,8 +1467,8 @@ fn dirStatPathLinux(
1356	1467	const flags: u32 = linux.AT.NO_AUTOMOUNT \|
1357	1468	@as(u32, if (!options.follow_symlinks) linux.AT.SYMLINK_NOFOLLOW else 0);
1358	1469
	1470	try current_thread.beginSyscall();
1359	1471	while (true) {
1360		try t.checkCancel();
1361	1472	var statx = std.mem.zeroes(linux.Statx);
1362	1473	const rc = linux.statx(
1363	1474	dir.handle,
...	...	@@ -1367,20 +1478,30 @@ fn dirStatPathLinux(
1367	1478	&statx,
1368	1479	);
1369	1480	switch (linux.errno(rc)) {
1370		.SUCCESS => return statFromLinux(&statx),
1371		.INTR => continue,
1372		.CANCELED => return error.Canceled,
1373
1374		.ACCES => return error.AccessDenied,
1375		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1376		.FAULT => \|err\| return errnoBug(err),
1377		.INVAL => \|err\| return errnoBug(err),
1378		.LOOP => return error.SymLinkLoop,
1379		.NAMETOOLONG => \|err\| return errnoBug(err), // Handled by pathToPosix() above.
1380		.NOENT => return error.FileNotFound,
1381		.NOTDIR => return error.NotDir,
1382		.NOMEM => return error.SystemResources,
1383		else => \|err\| return posix.unexpectedErrno(err),
	1481	.SUCCESS => {
	1482	current_thread.endSyscall();
	1483	return statFromLinux(&statx);
	1484	},
	1485	.INTR => {
	1486	try current_thread.checkCancel();
	1487	continue;
	1488	},
	1489	else => \|e\| {
	1490	current_thread.endSyscall();
	1491	switch (e) {
	1492	.CANCELED => return error.Canceled,
	1493	.ACCES => return error.AccessDenied,
	1494	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	1495	.FAULT => \|err\| return errnoBug(err),
	1496	.INVAL => \|err\| return errnoBug(err),
	1497	.LOOP => return error.SymLinkLoop,
	1498	.NAMETOOLONG => \|err\| return errnoBug(err), // Handled by pathToPosix() above.
	1499	.NOENT => return error.FileNotFound,
	1500	.NOTDIR => return error.NotDir,
	1501	.NOMEM => return error.SystemResources,
	1502	else => \|err\| return posix.unexpectedErrno(err),
	1503	}
	1504	},
1384	1505	}
1385	1506	}
1386	1507	}
...	...	@@ -1392,32 +1513,43 @@ fn dirStatPathPosix(
1392	1513	options: Io.Dir.StatPathOptions,
1393	1514	) Io.Dir.StatPathError!Io.File.Stat {
1394	1515	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1516	const current_thread = Thread.getCurrent(t);
1395	1517
1396	1518	var path_buffer: [posix.PATH_MAX]u8 = undefined;
1397	1519	const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
1398	1520
1399	1521	const flags: u32 = if (!options.follow_symlinks) posix.AT.SYMLINK_NOFOLLOW else 0;
1400	1522
	1523	try current_thread.beginSyscall();
1401	1524	while (true) {
1402		try t.checkCancel();
1403	1525	var stat = std.mem.zeroes(posix.Stat);
1404	1526	switch (posix.errno(fstatat_sym(dir.handle, sub_path_posix, &stat, flags))) {
1405		.SUCCESS => return statFromPosix(&stat),
1406		.INTR => continue,
1407		.CANCELED => return error.Canceled,
1408
1409		.INVAL => \|err\| return errnoBug(err),
1410		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1411		.NOMEM => return error.SystemResources,
1412		.ACCES => return error.AccessDenied,
1413		.PERM => return error.PermissionDenied,
1414		.FAULT => \|err\| return errnoBug(err),
1415		.NAMETOOLONG => return error.NameTooLong,
1416		.LOOP => return error.SymLinkLoop,
1417		.NOENT => return error.FileNotFound,
1418		.NOTDIR => return error.FileNotFound,
1419		.ILSEQ => return error.BadPathName,
1420		else => \|err\| return posix.unexpectedErrno(err),
	1527	.SUCCESS => {
	1528	current_thread.endSyscall();
	1529	return statFromPosix(&stat);
	1530	},
	1531	.INTR => {
	1532	try current_thread.checkCancel();
	1533	continue;
	1534	},
	1535	else => \|e\| {
	1536	current_thread.endSyscall();
	1537	switch (e) {
	1538	.CANCELED => return error.Canceled,
	1539	.INVAL => \|err\| return errnoBug(err),
	1540	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	1541	.NOMEM => return error.SystemResources,
	1542	.ACCES => return error.AccessDenied,
	1543	.PERM => return error.PermissionDenied,
	1544	.FAULT => \|err\| return errnoBug(err),
	1545	.NAMETOOLONG => return error.NameTooLong,
	1546	.LOOP => return error.SymLinkLoop,
	1547	.NOENT => return error.FileNotFound,
	1548	.NOTDIR => return error.FileNotFound,
	1549	.ILSEQ => return error.BadPathName,
	1550	else => \|err\| return posix.unexpectedErrno(err),
	1551	}
	1552	},
1421	1553	}
1422	1554	}
1423	1555	}
...	...	@@ -1444,29 +1576,40 @@ fn dirStatPathWasi(
1444	1576	) Io.Dir.StatPathError!Io.File.Stat {
1445	1577	if (builtin.link_libc) return dirStatPathPosix(userdata, dir, sub_path, options);
1446	1578	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1579	const current_thread = Thread.getCurrent(t);
1447	1580	const wasi = std.os.wasi;
1448	1581	const flags: wasi.lookupflags_t = .{
1449	1582	.SYMLINK_FOLLOW = options.follow_symlinks,
1450	1583	};
1451	1584	var stat: wasi.filestat_t = undefined;
	1585	try current_thread.beginSyscall();
1452	1586	while (true) {
1453		try t.checkCancel();
1454	1587	switch (wasi.path_filestat_get(dir.handle, flags, sub_path.ptr, sub_path.len, &stat)) {
1455		.SUCCESS => return statFromWasi(&stat),
1456		.INTR => continue,
1457		.CANCELED => return error.Canceled,
1458
1459		.INVAL => \|err\| return errnoBug(err),
1460		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1461		.NOMEM => return error.SystemResources,
1462		.ACCES => return error.AccessDenied,
1463		.FAULT => \|err\| return errnoBug(err),
1464		.NAMETOOLONG => return error.NameTooLong,
1465		.NOENT => return error.FileNotFound,
1466		.NOTDIR => return error.FileNotFound,
1467		.NOTCAPABLE => return error.AccessDenied,
1468		.ILSEQ => return error.BadPathName,
1469		else => \|err\| return posix.unexpectedErrno(err),
	1588	.SUCCESS => {
	1589	current_thread.endSyscall();
	1590	return statFromWasi(&stat);
	1591	},
	1592	.INTR => {
	1593	try current_thread.checkCancel();
	1594	continue;
	1595	},
	1596	else => \|e\| {
	1597	current_thread.endSyscall();
	1598	switch (e) {
	1599	.CANCELED => return error.Canceled,
	1600	.INVAL => \|err\| return errnoBug(err),
	1601	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	1602	.NOMEM => return error.SystemResources,
	1603	.ACCES => return error.AccessDenied,
	1604	.FAULT => \|err\| return errnoBug(err),
	1605	.NAMETOOLONG => return error.NameTooLong,
	1606	.NOENT => return error.FileNotFound,
	1607	.NOTDIR => return error.FileNotFound,
	1608	.NOTCAPABLE => return error.AccessDenied,
	1609	.ILSEQ => return error.BadPathName,
	1610	else => \|err\| return posix.unexpectedErrno(err),
	1611	}
	1612	},
1470	1613	}
1471	1614	}
1472	1615	}
...	...	@@ -1480,31 +1623,44 @@ const fileStat = switch (native_os) {
1480	1623
1481	1624	fn fileStatPosix(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File.Stat {
1482	1625	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1626	const current_thread = Thread.getCurrent(t);
1483	1627
1484	1628	if (posix.Stat == void) return error.Streaming;
1485	1629
	1630	try current_thread.beginSyscall();
1486	1631	while (true) {
1487		try t.checkCancel();
1488	1632	var stat = std.mem.zeroes(posix.Stat);
1489	1633	switch (posix.errno(fstat_sym(file.handle, &stat))) {
1490		.SUCCESS => return statFromPosix(&stat),
1491		.INTR => continue,
1492		.CANCELED => return error.Canceled,
1493
1494		.INVAL => \|err\| return errnoBug(err),
1495		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1496		.NOMEM => return error.SystemResources,
1497		.ACCES => return error.AccessDenied,
1498		else => \|err\| return posix.unexpectedErrno(err),
	1634	.SUCCESS => {
	1635	current_thread.endSyscall();
	1636	return statFromPosix(&stat);
	1637	},
	1638	.INTR => {
	1639	try current_thread.checkCancel();
	1640	continue;
	1641	},
	1642	else => \|e\| {
	1643	current_thread.endSyscall();
	1644	switch (e) {
	1645	.CANCELED => return error.Canceled,
	1646	.INVAL => \|err\| return errnoBug(err),
	1647	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	1648	.NOMEM => return error.SystemResources,
	1649	.ACCES => return error.AccessDenied,
	1650	else => \|err\| return posix.unexpectedErrno(err),
	1651	}
	1652	},
1499	1653	}
1500	1654	}
1501	1655	}
1502	1656
1503	1657	fn fileStatLinux(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File.Stat {
1504	1658	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1659	const current_thread = Thread.getCurrent(t);
1505	1660	const linux = std.os.linux;
	1661
	1662	try current_thread.beginSyscall();
1506	1663	while (true) {
1507		try t.checkCancel();
1508	1664	var statx = std.mem.zeroes(linux.Statx);
1509	1665	const rc = linux.statx(
1510	1666	file.handle,
...	...	@@ -1514,27 +1670,38 @@ fn fileStatLinux(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File
1514	1670	&statx,
1515	1671	);
1516	1672	switch (linux.errno(rc)) {
1517		.SUCCESS => return statFromLinux(&statx),
1518		.INTR => continue,
1519		.CANCELED => return error.Canceled,
1520
1521		.ACCES => \|err\| return errnoBug(err),
1522		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1523		.FAULT => \|err\| return errnoBug(err),
1524		.INVAL => \|err\| return errnoBug(err),
1525		.LOOP => \|err\| return errnoBug(err),
1526		.NAMETOOLONG => \|err\| return errnoBug(err),
1527		.NOENT => \|err\| return errnoBug(err),
1528		.NOMEM => return error.SystemResources,
1529		.NOTDIR => \|err\| return errnoBug(err),
1530		else => \|err\| return posix.unexpectedErrno(err),
	1673	.SUCCESS => {
	1674	current_thread.endSyscall();
	1675	return statFromLinux(&statx);
	1676	},
	1677	.INTR => {
	1678	try current_thread.checkCancel();
	1679	continue;
	1680	},
	1681	else => \|e\| {
	1682	current_thread.endSyscall();
	1683	switch (e) {
	1684	.CANCELED => return error.Canceled,
	1685	.ACCES => \|err\| return errnoBug(err),
	1686	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	1687	.FAULT => \|err\| return errnoBug(err),
	1688	.INVAL => \|err\| return errnoBug(err),
	1689	.LOOP => \|err\| return errnoBug(err),
	1690	.NAMETOOLONG => \|err\| return errnoBug(err),
	1691	.NOENT => \|err\| return errnoBug(err),
	1692	.NOMEM => return error.SystemResources,
	1693	.NOTDIR => \|err\| return errnoBug(err),
	1694	else => \|err\| return posix.unexpectedErrno(err),
	1695	}
	1696	},
1531	1697	}
1532	1698	}
1533	1699	}
1534	1700
1535	1701	fn fileStatWindows(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File.Stat {
1536	1702	const t: *Threaded = @ptrCast(@alignCast(userdata));
1537		try t.checkCancel();
	1703	const current_thread = Thread.getCurrent(t);
	1704	try current_thread.checkCancel();
1538	1705
1539	1706	var io_status_block: windows.IO_STATUS_BLOCK = undefined;
1540	1707	var info: windows.FILE_ALL_INFORMATION = undefined;
...	...	@@ -1581,21 +1748,34 @@ fn fileStatWindows(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.Fi
1581	1748
1582	1749	fn fileStatWasi(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File.Stat {
1583	1750	if (builtin.link_libc) return fileStatPosix(userdata, file);
	1751
1584	1752	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1753	const current_thread = Thread.getCurrent(t);
	1754
	1755	try current_thread.beginSyscall();
1585	1756	while (true) {
1586		try t.checkCancel();
1587	1757	var stat: std.os.wasi.filestat_t = undefined;
1588	1758	switch (std.os.wasi.fd_filestat_get(file.handle, &stat)) {
1589		.SUCCESS => return statFromWasi(&stat),
1590		.INTR => continue,
1591		.CANCELED => return error.Canceled,
1592
1593		.INVAL => \|err\| return errnoBug(err),
1594		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1595		.NOMEM => return error.SystemResources,
1596		.ACCES => return error.AccessDenied,
1597		.NOTCAPABLE => return error.AccessDenied,
1598		else => \|err\| return posix.unexpectedErrno(err),
	1759	.SUCCESS => {
	1760	current_thread.endSyscall();
	1761	return statFromWasi(&stat);
	1762	},
	1763	.INTR => {
	1764	try current_thread.checkCancel();
	1765	continue;
	1766	},
	1767	else => \|e\| {
	1768	current_thread.endSyscall();
	1769	switch (e) {
	1770	.CANCELED => return error.Canceled,
	1771	.INVAL => \|err\| return errnoBug(err),
	1772	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	1773	.NOMEM => return error.SystemResources,
	1774	.ACCES => return error.AccessDenied,
	1775	.NOTCAPABLE => return error.AccessDenied,
	1776	else => \|err\| return posix.unexpectedErrno(err),
	1777	}
	1778	},
1599	1779	}
1600	1780	}
1601	1781	}
...	...	@@ -1613,6 +1793,7 @@ fn dirAccessPosix(
1613	1793	options: Io.Dir.AccessOptions,
1614	1794	) Io.Dir.AccessError!void {
1615	1795	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1796	const current_thread = Thread.getCurrent(t);
1616	1797
1617	1798	var path_buffer: [posix.PATH_MAX]u8 = undefined;
1618	1799	const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
...	...	@@ -1624,27 +1805,37 @@ fn dirAccessPosix(
1624	1805	@as(u32, if (options.write) posix.W_OK else 0) \|
1625	1806	@as(u32, if (options.execute) posix.X_OK else 0);
1626	1807
	1808	try current_thread.beginSyscall();
1627	1809	while (true) {
1628		try t.checkCancel();
1629	1810	switch (posix.errno(posix.system.faccessat(dir.handle, sub_path_posix, mode, flags))) {
1630		.SUCCESS => return,
1631		.INTR => continue,
1632		.CANCELED => return error.Canceled,
1633
1634		.ACCES => return error.AccessDenied,
1635		.PERM => return error.PermissionDenied,
1636		.ROFS => return error.ReadOnlyFileSystem,
1637		.LOOP => return error.SymLinkLoop,
1638		.TXTBSY => return error.FileBusy,
1639		.NOTDIR => return error.FileNotFound,
1640		.NOENT => return error.FileNotFound,
1641		.NAMETOOLONG => return error.NameTooLong,
1642		.INVAL => \|err\| return errnoBug(err),
1643		.FAULT => \|err\| return errnoBug(err),
1644		.IO => return error.InputOutput,
1645		.NOMEM => return error.SystemResources,
1646		.ILSEQ => return error.BadPathName,
1647		else => \|err\| return posix.unexpectedErrno(err),
	1811	.SUCCESS => {
	1812	current_thread.endSyscall();
	1813	return;
	1814	},
	1815	.INTR => {
	1816	try current_thread.checkCancel();
	1817	continue;
	1818	},
	1819	else => \|e\| {
	1820	current_thread.endSyscall();
	1821	switch (e) {
	1822	.CANCELED => return error.Canceled,
	1823	.ACCES => return error.AccessDenied,
	1824	.PERM => return error.PermissionDenied,
	1825	.ROFS => return error.ReadOnlyFileSystem,
	1826	.LOOP => return error.SymLinkLoop,
	1827	.TXTBSY => return error.FileBusy,
	1828	.NOTDIR => return error.FileNotFound,
	1829	.NOENT => return error.FileNotFound,
	1830	.NAMETOOLONG => return error.NameTooLong,
	1831	.INVAL => \|err\| return errnoBug(err),
	1832	.FAULT => \|err\| return errnoBug(err),
	1833	.IO => return error.InputOutput,
	1834	.NOMEM => return error.SystemResources,
	1835	.ILSEQ => return error.BadPathName,
	1836	else => \|err\| return posix.unexpectedErrno(err),
	1837	}
	1838	},
1648	1839	}
1649	1840	}
1650	1841	}
...	...	@@ -1657,29 +1848,41 @@ fn dirAccessWasi(
1657	1848	) Io.Dir.AccessError!void {
1658	1849	if (builtin.link_libc) return dirAccessPosix(userdata, dir, sub_path, options);
1659	1850	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1851	const current_thread = Thread.getCurrent(t);
1660	1852	const wasi = std.os.wasi;
1661	1853	const flags: wasi.lookupflags_t = .{
1662	1854	.SYMLINK_FOLLOW = options.follow_symlinks,
1663	1855	};
1664	1856	var stat: wasi.filestat_t = undefined;
	1857
	1858	try current_thread.beginSyscall();
1665	1859	while (true) {
1666		try t.checkCancel();
1667	1860	switch (wasi.path_filestat_get(dir.handle, flags, sub_path.ptr, sub_path.len, &stat)) {
1668		.SUCCESS => break,
1669		.INTR => continue,
1670		.CANCELED => return error.Canceled,
1671
1672		.INVAL => \|err\| return errnoBug(err),
1673		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1674		.NOMEM => return error.SystemResources,
1675		.ACCES => return error.AccessDenied,
1676		.FAULT => \|err\| return errnoBug(err),
1677		.NAMETOOLONG => return error.NameTooLong,
1678		.NOENT => return error.FileNotFound,
1679		.NOTDIR => return error.FileNotFound,
1680		.NOTCAPABLE => return error.AccessDenied,
1681		.ILSEQ => return error.BadPathName,
1682		else => \|err\| return posix.unexpectedErrno(err),
	1861	.SUCCESS => {
	1862	current_thread.endSyscall();
	1863	break;
	1864	},
	1865	.INTR => {
	1866	try current_thread.checkCancel();
	1867	continue;
	1868	},
	1869	else => \|e\| {
	1870	current_thread.endSyscall();
	1871	switch (e) {
	1872	.CANCELED => return error.Canceled,
	1873	.INVAL => \|err\| return errnoBug(err),
	1874	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	1875	.NOMEM => return error.SystemResources,
	1876	.ACCES => return error.AccessDenied,
	1877	.FAULT => \|err\| return errnoBug(err),
	1878	.NAMETOOLONG => return error.NameTooLong,
	1879	.NOENT => return error.FileNotFound,
	1880	.NOTDIR => return error.FileNotFound,
	1881	.NOTCAPABLE => return error.AccessDenied,
	1882	.ILSEQ => return error.BadPathName,
	1883	else => \|err\| return posix.unexpectedErrno(err),
	1884	}
	1885	},
1683	1886	}
1684	1887	}
1685	1888
...	...	@@ -1717,7 +1920,8 @@ fn dirAccessWindows(
1717	1920	options: Io.Dir.AccessOptions,
1718	1921	) Io.Dir.AccessError!void {
1719	1922	const t: *Threaded = @ptrCast(@alignCast(userdata));
1720		try t.checkCancel();
	1923	const current_thread = Thread.getCurrent(t);
	1924	try current_thread.checkCancel();
1721	1925
1722	1926	_ = options; // TODO
1723	1927
...	...	@@ -1768,6 +1972,7 @@ fn dirCreateFilePosix(
1768	1972	flags: Io.File.CreateFlags,
1769	1973	) Io.File.OpenError!Io.File {
1770	1974	const t: *Threaded = @ptrCast(@alignCast(userdata));
	1975	const current_thread = Thread.getCurrent(t);
1771	1976
1772	1977	var path_buffer: [posix.PATH_MAX]u8 = undefined;
1773	1978	const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
...	...	@@ -1796,40 +2001,50 @@ fn dirCreateFilePosix(
1796	2001	},
1797	2002	};
1798	2003
	2004	try current_thread.beginSyscall();
1799	2005	const fd: posix.fd_t = while (true) {
1800		try t.checkCancel();
1801	2006	const rc = openat_sym(dir.handle, sub_path_posix, os_flags, flags.mode);
1802	2007	switch (posix.errno(rc)) {
1803		.SUCCESS => break @intCast(rc),
1804		.INTR => continue,
1805		.CANCELED => return error.Canceled,
1806
1807		.FAULT => \|err\| return errnoBug(err),
1808		.INVAL => return error.BadPathName,
1809		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1810		.ACCES => return error.AccessDenied,
1811		.FBIG => return error.FileTooBig,
1812		.OVERFLOW => return error.FileTooBig,
1813		.ISDIR => return error.IsDir,
1814		.LOOP => return error.SymLinkLoop,
1815		.MFILE => return error.ProcessFdQuotaExceeded,
1816		.NAMETOOLONG => return error.NameTooLong,
1817		.NFILE => return error.SystemFdQuotaExceeded,
1818		.NODEV => return error.NoDevice,
1819		.NOENT => return error.FileNotFound,
1820		.SRCH => return error.ProcessNotFound,
1821		.NOMEM => return error.SystemResources,
1822		.NOSPC => return error.NoSpaceLeft,
1823		.NOTDIR => return error.NotDir,
1824		.PERM => return error.PermissionDenied,
1825		.EXIST => return error.PathAlreadyExists,
1826		.BUSY => return error.DeviceBusy,
1827		.OPNOTSUPP => return error.FileLocksNotSupported,
1828		.AGAIN => return error.WouldBlock,
1829		.TXTBSY => return error.FileBusy,
1830		.NXIO => return error.NoDevice,
1831		.ILSEQ => return error.BadPathName,
1832		else => \|err\| return posix.unexpectedErrno(err),
	2008	.SUCCESS => {
	2009	current_thread.endSyscall();
	2010	break @intCast(rc);
	2011	},
	2012	.INTR => {
	2013	try current_thread.checkCancel();
	2014	continue;
	2015	},
	2016	else => \|e\| {
	2017	current_thread.endSyscall();
	2018	switch (e) {
	2019	.CANCELED => return error.Canceled,
	2020	.FAULT => \|err\| return errnoBug(err),
	2021	.INVAL => return error.BadPathName,
	2022	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	2023	.ACCES => return error.AccessDenied,
	2024	.FBIG => return error.FileTooBig,
	2025	.OVERFLOW => return error.FileTooBig,
	2026	.ISDIR => return error.IsDir,
	2027	.LOOP => return error.SymLinkLoop,
	2028	.MFILE => return error.ProcessFdQuotaExceeded,
	2029	.NAMETOOLONG => return error.NameTooLong,
	2030	.NFILE => return error.SystemFdQuotaExceeded,
	2031	.NODEV => return error.NoDevice,
	2032	.NOENT => return error.FileNotFound,
	2033	.SRCH => return error.ProcessNotFound,
	2034	.NOMEM => return error.SystemResources,
	2035	.NOSPC => return error.NoSpaceLeft,
	2036	.NOTDIR => return error.NotDir,
	2037	.PERM => return error.PermissionDenied,
	2038	.EXIST => return error.PathAlreadyExists,
	2039	.BUSY => return error.DeviceBusy,
	2040	.OPNOTSUPP => return error.FileLocksNotSupported,
	2041	.AGAIN => return error.WouldBlock,
	2042	.TXTBSY => return error.FileBusy,
	2043	.NXIO => return error.NoDevice,
	2044	.ILSEQ => return error.BadPathName,
	2045	else => \|err\| return posix.unexpectedErrno(err),
	2046	}
	2047	},
1833	2048	}
1834	2049	};
1835	2050	errdefer posix.close(fd);
...	...	@@ -1841,42 +2056,71 @@ fn dirCreateFilePosix(
1841	2056	.shared => posix.LOCK.SH \| lock_nonblocking,
1842	2057	.exclusive => posix.LOCK.EX \| lock_nonblocking,
1843	2058	};
	2059
	2060	try current_thread.beginSyscall();
1844	2061	while (true) {
1845		try t.checkCancel();
1846	2062	switch (posix.errno(posix.system.flock(fd, lock_flags))) {
1847		.SUCCESS => break,
1848		.INTR => continue,
1849		.CANCELED => return error.Canceled,
1850
1851		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1852		.INVAL => \|err\| return errnoBug(err), // invalid parameters
1853		.NOLCK => return error.SystemResources,
1854		.AGAIN => return error.WouldBlock,
1855		.OPNOTSUPP => return error.FileLocksNotSupported,
1856		else => \|err\| return posix.unexpectedErrno(err),
1857		}
	2063	.SUCCESS => {
	2064	current_thread.endSyscall();
	2065	break;
	2066	},
	2067	.INTR => {
	2068	try current_thread.checkCancel();
	2069	continue;
	2070	},
	2071	else => \|e\| {
	2072	current_thread.endSyscall();
	2073	switch (e) {
	2074	.CANCELED => return error.Canceled,
	2075	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	2076	.INVAL => \|err\| return errnoBug(err), // invalid parameters
	2077	.NOLCK => return error.SystemResources,
	2078	.AGAIN => return error.WouldBlock,
	2079	.OPNOTSUPP => return error.FileLocksNotSupported,
	2080	else => \|err\| return posix.unexpectedErrno(err),
	2081	}
	2082	},
	2083	}
1858	2084	}
1859	2085	}
1860	2086
1861	2087	if (have_flock_open_flags and flags.lock_nonblocking) {
	2088	try current_thread.beginSyscall();
1862	2089	var fl_flags: usize = while (true) {
1863		try t.checkCancel();
1864	2090	const rc = posix.system.fcntl(fd, posix.F.GETFL, @as(usize, 0));
1865	2091	switch (posix.errno(rc)) {
1866		.SUCCESS => break @intCast(rc),
1867		.INTR => continue,
1868		.CANCELED => return error.Canceled,
1869		else => \|err\| return posix.unexpectedErrno(err),
	2092	.SUCCESS => {
	2093	current_thread.endSyscall();
	2094	break @intCast(rc);
	2095	},
	2096	.INTR => {
	2097	try current_thread.checkCancel();
	2098	continue;
	2099	},
	2100	else => \|err\| {
	2101	current_thread.endSyscall();
	2102	return posix.unexpectedErrno(err);
	2103	},
1870	2104	}
1871	2105	};
	2106
1872	2107	fl_flags \|= @as(usize, 1 << @bitOffsetOf(posix.O, "NONBLOCK"));
	2108
	2109	try current_thread.beginSyscall();
1873	2110	while (true) {
1874		try t.checkCancel();
1875	2111	switch (posix.errno(posix.system.fcntl(fd, posix.F.SETFL, fl_flags))) {
1876		.SUCCESS => break,
1877		.INTR => continue,
1878		.CANCELED => return error.Canceled,
1879		else => \|err\| return posix.unexpectedErrno(err),
	2112	.SUCCESS => {
	2113	current_thread.endSyscall();
	2114	break;
	2115	},
	2116	.INTR => {
	2117	try current_thread.checkCancel();
	2118	continue;
	2119	},
	2120	else => \|err\| {
	2121	current_thread.endSyscall();
	2122	return posix.unexpectedErrno(err);
	2123	},
1880	2124	}
1881	2125	}
1882	2126	}
...	...	@@ -1892,7 +2136,8 @@ fn dirCreateFileWindows(
1892	2136	) Io.File.OpenError!Io.File {
1893	2137	const w = windows;
1894	2138	const t: *Threaded = @ptrCast(@alignCast(userdata));
1895		try t.checkCancel();
	2139	const current_thread = Thread.getCurrent(t);
	2140	try current_thread.checkCancel();
1896	2141
1897	2142	const sub_path_w_array = try w.sliceToPrefixedFileW(dir.handle, sub_path);
1898	2143	const sub_path_w = sub_path_w_array.span();
...	...	@@ -1939,6 +2184,7 @@ fn dirCreateFileWasi(
1939	2184	flags: Io.File.CreateFlags,
1940	2185	) Io.File.OpenError!Io.File {
1941	2186	const t: *Threaded = @ptrCast(@alignCast(userdata));
	2187	const current_thread = Thread.getCurrent(t);
1942	2188	const wasi = std.os.wasi;
1943	2189	const lookup_flags: wasi.lookupflags_t = .{};
1944	2190	const oflags: wasi.oflags_t = .{
...	...	@@ -1966,35 +2212,45 @@ fn dirCreateFileWasi(
1966	2212	};
1967	2213	const inheriting: wasi.rights_t = .{};
1968	2214	var fd: posix.fd_t = undefined;
	2215	try current_thread.beginSyscall();
1969	2216	while (true) {
1970		try t.checkCancel();
1971	2217	switch (wasi.path_open(dir.handle, lookup_flags, sub_path.ptr, sub_path.len, oflags, base, inheriting, fdflags, &fd)) {
1972		.SUCCESS => return .{ .handle = fd },
1973		.INTR => continue,
1974		.CANCELED => return error.Canceled,
1975
1976		.FAULT => \|err\| return errnoBug(err),
1977		.INVAL => return error.BadPathName,
1978		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
1979		.ACCES => return error.AccessDenied,
1980		.FBIG => return error.FileTooBig,
1981		.OVERFLOW => return error.FileTooBig,
1982		.ISDIR => return error.IsDir,
1983		.LOOP => return error.SymLinkLoop,
1984		.MFILE => return error.ProcessFdQuotaExceeded,
1985		.NAMETOOLONG => return error.NameTooLong,
1986		.NFILE => return error.SystemFdQuotaExceeded,
1987		.NODEV => return error.NoDevice,
1988		.NOENT => return error.FileNotFound,
1989		.NOMEM => return error.SystemResources,
1990		.NOSPC => return error.NoSpaceLeft,
1991		.NOTDIR => return error.NotDir,
1992		.PERM => return error.PermissionDenied,
1993		.EXIST => return error.PathAlreadyExists,
1994		.BUSY => return error.DeviceBusy,
1995		.NOTCAPABLE => return error.AccessDenied,
1996		.ILSEQ => return error.BadPathName,
1997		else => \|err\| return posix.unexpectedErrno(err),
	2218	.SUCCESS => {
	2219	current_thread.endSyscall();
	2220	return .{ .handle = fd };
	2221	},
	2222	.INTR => {
	2223	try current_thread.checkCancel();
	2224	continue;
	2225	},
	2226	else => \|e\| {
	2227	current_thread.endSyscall();
	2228	switch (e) {
	2229	.CANCELED => return error.Canceled,
	2230	.FAULT => \|err\| return errnoBug(err),
	2231	.INVAL => return error.BadPathName,
	2232	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	2233	.ACCES => return error.AccessDenied,
	2234	.FBIG => return error.FileTooBig,
	2235	.OVERFLOW => return error.FileTooBig,
	2236	.ISDIR => return error.IsDir,
	2237	.LOOP => return error.SymLinkLoop,
	2238	.MFILE => return error.ProcessFdQuotaExceeded,
	2239	.NAMETOOLONG => return error.NameTooLong,
	2240	.NFILE => return error.SystemFdQuotaExceeded,
	2241	.NODEV => return error.NoDevice,
	2242	.NOENT => return error.FileNotFound,
	2243	.NOMEM => return error.SystemResources,
	2244	.NOSPC => return error.NoSpaceLeft,
	2245	.NOTDIR => return error.NotDir,
	2246	.PERM => return error.PermissionDenied,
	2247	.EXIST => return error.PathAlreadyExists,
	2248	.BUSY => return error.DeviceBusy,
	2249	.NOTCAPABLE => return error.AccessDenied,
	2250	.ILSEQ => return error.BadPathName,
	2251	else => \|err\| return posix.unexpectedErrno(err),
	2252	}
	2253	},
1998	2254	}
1999	2255	}
2000	2256	}
...	...	@@ -2012,6 +2268,7 @@ fn dirOpenFilePosix(
2012	2268	flags: Io.File.OpenFlags,
2013	2269	) Io.File.OpenError!Io.File {
2014	2270	const t: *Threaded = @ptrCast(@alignCast(userdata));
	2271	const current_thread = Thread.getCurrent(t);
2015	2272
2016	2273	var path_buffer: [posix.PATH_MAX]u8 = undefined;
2017	2274	const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
...	...	@@ -2048,40 +2305,50 @@ fn dirOpenFilePosix(
2048	2305	},
2049	2306	};
2050	2307
	2308	try current_thread.beginSyscall();
2051	2309	const fd: posix.fd_t = while (true) {
2052		try t.checkCancel();
2053	2310	const rc = openat_sym(dir.handle, sub_path_posix, os_flags, @as(posix.mode_t, 0));
2054	2311	switch (posix.errno(rc)) {
2055		.SUCCESS => break @intCast(rc),
2056		.INTR => continue,
2057		.CANCELED => return error.Canceled,
2058
2059		.FAULT => \|err\| return errnoBug(err),
2060		.INVAL => return error.BadPathName,
2061		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
2062		.ACCES => return error.AccessDenied,
2063		.FBIG => return error.FileTooBig,
2064		.OVERFLOW => return error.FileTooBig,
2065		.ISDIR => return error.IsDir,
2066		.LOOP => return error.SymLinkLoop,
2067		.MFILE => return error.ProcessFdQuotaExceeded,
2068		.NAMETOOLONG => return error.NameTooLong,
2069		.NFILE => return error.SystemFdQuotaExceeded,
2070		.NODEV => return error.NoDevice,
2071		.NOENT => return error.FileNotFound,
2072		.SRCH => return error.ProcessNotFound,
2073		.NOMEM => return error.SystemResources,
2074		.NOSPC => return error.NoSpaceLeft,
2075		.NOTDIR => return error.NotDir,
2076		.PERM => return error.PermissionDenied,
2077		.EXIST => return error.PathAlreadyExists,
2078		.BUSY => return error.DeviceBusy,
2079		.OPNOTSUPP => return error.FileLocksNotSupported,
2080		.AGAIN => return error.WouldBlock,
2081		.TXTBSY => return error.FileBusy,
2082		.NXIO => return error.NoDevice,
2083		.ILSEQ => return error.BadPathName,
2084		else => \|err\| return posix.unexpectedErrno(err),
	2312	.SUCCESS => {
	2313	current_thread.endSyscall();
	2314	break @intCast(rc);
	2315	},
	2316	.INTR => {
	2317	try current_thread.checkCancel();
	2318	continue;
	2319	},
	2320	else => \|e\| {
	2321	current_thread.endSyscall();
	2322	switch (e) {
	2323	.CANCELED => return error.Canceled,
	2324	.FAULT => \|err\| return errnoBug(err),
	2325	.INVAL => return error.BadPathName,
	2326	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	2327	.ACCES => return error.AccessDenied,
	2328	.FBIG => return error.FileTooBig,
	2329	.OVERFLOW => return error.FileTooBig,
	2330	.ISDIR => return error.IsDir,
	2331	.LOOP => return error.SymLinkLoop,
	2332	.MFILE => return error.ProcessFdQuotaExceeded,
	2333	.NAMETOOLONG => return error.NameTooLong,
	2334	.NFILE => return error.SystemFdQuotaExceeded,
	2335	.NODEV => return error.NoDevice,
	2336	.NOENT => return error.FileNotFound,
	2337	.SRCH => return error.ProcessNotFound,
	2338	.NOMEM => return error.SystemResources,
	2339	.NOSPC => return error.NoSpaceLeft,
	2340	.NOTDIR => return error.NotDir,
	2341	.PERM => return error.PermissionDenied,
	2342	.EXIST => return error.PathAlreadyExists,
	2343	.BUSY => return error.DeviceBusy,
	2344	.OPNOTSUPP => return error.FileLocksNotSupported,
	2345	.AGAIN => return error.WouldBlock,
	2346	.TXTBSY => return error.FileBusy,
	2347	.NXIO => return error.NoDevice,
	2348	.ILSEQ => return error.BadPathName,
	2349	else => \|err\| return posix.unexpectedErrno(err),
	2350	}
	2351	},
2085	2352	}
2086	2353	};
2087	2354	errdefer posix.close(fd);
...	...	@@ -2093,42 +2360,70 @@ fn dirOpenFilePosix(
2093	2360	.shared => posix.LOCK.SH \| lock_nonblocking,
2094	2361	.exclusive => posix.LOCK.EX \| lock_nonblocking,
2095	2362	};
	2363	try current_thread.beginSyscall();
2096	2364	while (true) {
2097		try t.checkCancel();
2098	2365	switch (posix.errno(posix.system.flock(fd, lock_flags))) {
2099		.SUCCESS => break,
2100		.INTR => continue,
2101		.CANCELED => return error.Canceled,
2102
2103		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
2104		.INVAL => \|err\| return errnoBug(err), // invalid parameters
2105		.NOLCK => return error.SystemResources,
2106		.AGAIN => return error.WouldBlock,
2107		.OPNOTSUPP => return error.FileLocksNotSupported,
2108		else => \|err\| return posix.unexpectedErrno(err),
	2366	.SUCCESS => {
	2367	current_thread.endSyscall();
	2368	break;
	2369	},
	2370	.INTR => {
	2371	try current_thread.checkCancel();
	2372	continue;
	2373	},
	2374	else => \|e\| {
	2375	current_thread.endSyscall();
	2376	switch (e) {
	2377	.CANCELED => return error.Canceled,
	2378	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	2379	.INVAL => \|err\| return errnoBug(err), // invalid parameters
	2380	.NOLCK => return error.SystemResources,
	2381	.AGAIN => return error.WouldBlock,
	2382	.OPNOTSUPP => return error.FileLocksNotSupported,
	2383	else => \|err\| return posix.unexpectedErrno(err),
	2384	}
	2385	},
2109	2386	}
2110	2387	}
2111	2388	}
2112	2389
2113	2390	if (have_flock_open_flags and flags.lock_nonblocking) {
	2391	try current_thread.beginSyscall();
2114	2392	var fl_flags: usize = while (true) {
2115		try t.checkCancel();
2116	2393	const rc = posix.system.fcntl(fd, posix.F.GETFL, @as(usize, 0));
2117	2394	switch (posix.errno(rc)) {
2118		.SUCCESS => break @intCast(rc),
2119		.INTR => continue,
2120		.CANCELED => return error.Canceled,
2121		else => \|err\| return posix.unexpectedErrno(err),
	2395	.SUCCESS => {
	2396	current_thread.endSyscall();
	2397	break @intCast(rc);
	2398	},
	2399	.INTR => {
	2400	try current_thread.checkCancel();
	2401	continue;
	2402	},
	2403	else => \|err\| {
	2404	current_thread.endSyscall();
	2405	return posix.unexpectedErrno(err);
	2406	},
2122	2407	}
2123	2408	};
	2409
2124	2410	fl_flags \|= @as(usize, 1 << @bitOffsetOf(posix.O, "NONBLOCK"));
	2411
	2412	try current_thread.beginSyscall();
2125	2413	while (true) {
2126		try t.checkCancel();
2127	2414	switch (posix.errno(posix.system.fcntl(fd, posix.F.SETFL, fl_flags))) {
2128		.SUCCESS => break,
2129		.INTR => continue,
2130		.CANCELED => return error.Canceled,
2131		else => \|err\| return posix.unexpectedErrno(err),
	2415	.SUCCESS => {
	2416	current_thread.endSyscall();
	2417	break;
	2418	},
	2419	.INTR => {
	2420	try current_thread.checkCancel();
	2421	continue;
	2422	},
	2423	else => \|err\| {
	2424	current_thread.endSyscall();
	2425	return posix.unexpectedErrno(err);
	2426	},
2132	2427	}
2133	2428	}
2134	2429	}
...	...	@@ -2158,7 +2453,7 @@ pub fn dirOpenFileWtf16(
2158	2453	if (std.mem.eql(u16, sub_path_w, &.{'.'})) return error.IsDir;
2159	2454	if (std.mem.eql(u16, sub_path_w, &.{ '.', '.' })) return error.IsDir;
2160	2455	const path_len_bytes = std.math.cast(u16, sub_path_w.len * 2) orelse return error.NameTooLong;
2161
	2456	const current_thread = Thread.getCurrent(t);
2162	2457	const w = windows;
2163	2458
2164	2459	var nt_name: w.UNICODE_STRING = .{
...	...	@@ -2187,7 +2482,7 @@ pub fn dirOpenFileWtf16(
2187	2482	var attempt: u5 = 0;
2188	2483
2189	2484	const handle = while (true) {
2190		try t.checkCancel();
	2485	try current_thread.checkCancel();
2191	2486
2192	2487	var result: w.HANDLE = undefined;
2193	2488	const rc = w.ntdll.NtCreateFile(
...	...	@@ -2281,6 +2576,7 @@ fn dirOpenFileWasi(
2281	2576	) Io.File.OpenError!Io.File {
2282	2577	if (builtin.link_libc) return dirOpenFilePosix(userdata, dir, sub_path, flags);
2283	2578	const t: *Threaded = @ptrCast(@alignCast(userdata));
	2579	const current_thread = Thread.getCurrent(t);
2284	2580	const wasi = std.os.wasi;
2285	2581	var base: std.os.wasi.rights_t = .{};
2286	2582	// POLL_FD_READWRITE only grants extra rights if the corresponding FD_READ and/or FD_WRITE
...	...	@@ -2310,33 +2606,44 @@ fn dirOpenFileWasi(
2310	2606	const inheriting: wasi.rights_t = .{};
2311	2607	const fdflags: wasi.fdflags_t = .{};
2312	2608	var fd: posix.fd_t = undefined;
	2609	try current_thread.beginSyscall();
2313	2610	while (true) {
2314		try t.checkCancel();
2315	2611	switch (wasi.path_open(dir.handle, lookup_flags, sub_path.ptr, sub_path.len, oflags, base, inheriting, fdflags, &fd)) {
2316		.SUCCESS => return .{ .handle = fd },
2317		.INTR => continue,
2318		.CANCELED => return error.Canceled,
2319
2320		.FAULT => \|err\| return errnoBug(err),
2321		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
2322		.ACCES => return error.AccessDenied,
2323		.FBIG => return error.FileTooBig,
2324		.OVERFLOW => return error.FileTooBig,
2325		.ISDIR => return error.IsDir,
2326		.LOOP => return error.SymLinkLoop,
2327		.MFILE => return error.ProcessFdQuotaExceeded,
2328		.NFILE => return error.SystemFdQuotaExceeded,
2329		.NODEV => return error.NoDevice,
2330		.NOENT => return error.FileNotFound,
2331		.NOMEM => return error.SystemResources,
2332		.NOTDIR => return error.NotDir,
2333		.PERM => return error.PermissionDenied,
2334		.BUSY => return error.DeviceBusy,
2335		.NOTCAPABLE => return error.AccessDenied,
2336		.NAMETOOLONG => return error.NameTooLong,
2337		.INVAL => return error.BadPathName,
2338		.ILSEQ => return error.BadPathName,
2339		else => \|err\| return posix.unexpectedErrno(err),
	2612	.SUCCESS => {
	2613	errdefer posix.close(fd);
	2614	current_thread.endSyscall();
	2615	return .{ .handle = fd };
	2616	},
	2617	.INTR => {
	2618	try current_thread.checkCancel();
	2619	continue;
	2620	},
	2621	else => \|e\| {
	2622	current_thread.endSyscall();
	2623	switch (e) {
	2624	.CANCELED => return error.Canceled,
	2625	.FAULT => \|err\| return errnoBug(err),
	2626	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	2627	.ACCES => return error.AccessDenied,
	2628	.FBIG => return error.FileTooBig,
	2629	.OVERFLOW => return error.FileTooBig,
	2630	.ISDIR => return error.IsDir,
	2631	.LOOP => return error.SymLinkLoop,
	2632	.MFILE => return error.ProcessFdQuotaExceeded,
	2633	.NFILE => return error.SystemFdQuotaExceeded,
	2634	.NODEV => return error.NoDevice,
	2635	.NOENT => return error.FileNotFound,
	2636	.NOMEM => return error.SystemResources,
	2637	.NOTDIR => return error.NotDir,
	2638	.PERM => return error.PermissionDenied,
	2639	.BUSY => return error.DeviceBusy,
	2640	.NOTCAPABLE => return error.AccessDenied,
	2641	.NAMETOOLONG => return error.NameTooLong,
	2642	.INVAL => return error.BadPathName,
	2643	.ILSEQ => return error.BadPathName,
	2644	else => \|err\| return posix.unexpectedErrno(err),
	2645	}
	2646	},
2340	2647	}
2341	2648	}
2342	2649	}
...	...	@@ -2361,6 +2668,8 @@ fn dirOpenDirPosix(
2361	2668	return dirOpenDirWindows(t, dir, sub_path_w.span(), options);
2362	2669	}
2363	2670
	2671	const current_thread = Thread.getCurrent(t);
	2672
2364	2673	var path_buffer: [posix.PATH_MAX]u8 = undefined;
2365	2674	const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
2366	2675
...	...	@@ -2381,31 +2690,41 @@ fn dirOpenDirPosix(
2381	2690	if (@hasField(posix.O, "PATH") and !options.iterate)
2382	2691	flags.PATH = true;
2383	2692
	2693	try current_thread.beginSyscall();
2384	2694	while (true) {
2385		try t.checkCancel();
2386	2695	const rc = openat_sym(dir.handle, sub_path_posix, flags, @as(usize, 0));
2387	2696	switch (posix.errno(rc)) {
2388		.SUCCESS => return .{ .handle = @intCast(rc) },
2389		.INTR => continue,
2390		.CANCELED => return error.Canceled,
2391
2392		.FAULT => \|err\| return errnoBug(err),
2393		.INVAL => return error.BadPathName,
2394		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
2395		.ACCES => return error.AccessDenied,
2396		.LOOP => return error.SymLinkLoop,
2397		.MFILE => return error.ProcessFdQuotaExceeded,
2398		.NAMETOOLONG => return error.NameTooLong,
2399		.NFILE => return error.SystemFdQuotaExceeded,
2400		.NODEV => return error.NoDevice,
2401		.NOENT => return error.FileNotFound,
2402		.NOMEM => return error.SystemResources,
2403		.NOTDIR => return error.NotDir,
2404		.PERM => return error.PermissionDenied,
2405		.BUSY => return error.DeviceBusy,
2406		.NXIO => return error.NoDevice,
2407		.ILSEQ => return error.BadPathName,
2408		else => \|err\| return posix.unexpectedErrno(err),
	2697	.SUCCESS => {
	2698	current_thread.endSyscall();
	2699	return .{ .handle = @intCast(rc) };
	2700	},
	2701	.INTR => {
	2702	try current_thread.checkCancel();
	2703	continue;
	2704	},
	2705	else => \|e\| {
	2706	current_thread.endSyscall();
	2707	switch (e) {
	2708	.CANCELED => return error.Canceled,
	2709	.FAULT => \|err\| return errnoBug(err),
	2710	.INVAL => return error.BadPathName,
	2711	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	2712	.ACCES => return error.AccessDenied,
	2713	.LOOP => return error.SymLinkLoop,
	2714	.MFILE => return error.ProcessFdQuotaExceeded,
	2715	.NAMETOOLONG => return error.NameTooLong,
	2716	.NFILE => return error.SystemFdQuotaExceeded,
	2717	.NODEV => return error.NoDevice,
	2718	.NOENT => return error.FileNotFound,
	2719	.NOMEM => return error.SystemResources,
	2720	.NOTDIR => return error.NotDir,
	2721	.PERM => return error.PermissionDenied,
	2722	.BUSY => return error.DeviceBusy,
	2723	.NXIO => return error.NoDevice,
	2724	.ILSEQ => return error.BadPathName,
	2725	else => \|err\| return posix.unexpectedErrno(err),
	2726	}
	2727	},
2409	2728	}
2410	2729	}
2411	2730	}
...	...	@@ -2417,34 +2736,46 @@ fn dirOpenDirHaiku(
2417	2736	options: Io.Dir.OpenOptions,
2418	2737	) Io.Dir.OpenError!Io.Dir {
2419	2738	const t: *Threaded = @ptrCast(@alignCast(userdata));
	2739	const current_thread = Thread.getCurrent(t);
2420	2740
2421	2741	var path_buffer: [posix.PATH_MAX]u8 = undefined;
2422	2742	const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
2423	2743
2424	2744	_ = options;
2425	2745
	2746	try current_thread.beginSyscall();
2426	2747	while (true) {
2427		try t.checkCancel();
2428	2748	const rc = posix.system._kern_open_dir(dir.handle, sub_path_posix);
2429		if (rc >= 0) return .{ .handle = rc };
	2749	if (rc >= 0) {
	2750	current_thread.endSyscall();
	2751	return .{ .handle = rc };
	2752	}
2430	2753	switch (@as(posix.E, @enumFromInt(rc))) {
2431		.INTR => continue,
2432		.CANCELED => return error.Canceled,
2433		.FAULT => \|err\| return errnoBug(err),
2434		.INVAL => \|err\| return errnoBug(err),
2435		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
2436		.ACCES => return error.AccessDenied,
2437		.LOOP => return error.SymLinkLoop,
2438		.MFILE => return error.ProcessFdQuotaExceeded,
2439		.NAMETOOLONG => return error.NameTooLong,
2440		.NFILE => return error.SystemFdQuotaExceeded,
2441		.NODEV => return error.NoDevice,
2442		.NOENT => return error.FileNotFound,
2443		.NOMEM => return error.SystemResources,
2444		.NOTDIR => return error.NotDir,
2445		.PERM => return error.PermissionDenied,
2446		.BUSY => return error.DeviceBusy,
2447		else => \|err\| return posix.unexpectedErrno(err),
	2754	.INTR => {
	2755	try current_thread.checkCancel();
	2756	continue;
	2757	},
	2758	else => \|e\| {
	2759	current_thread.endSyscall();
	2760	switch (e) {
	2761	.CANCELED => return error.Canceled,
	2762	.FAULT => \|err\| return errnoBug(err),
	2763	.INVAL => \|err\| return errnoBug(err),
	2764	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	2765	.ACCES => return error.AccessDenied,
	2766	.LOOP => return error.SymLinkLoop,
	2767	.MFILE => return error.ProcessFdQuotaExceeded,
	2768	.NAMETOOLONG => return error.NameTooLong,
	2769	.NFILE => return error.SystemFdQuotaExceeded,
	2770	.NODEV => return error.NoDevice,
	2771	.NOENT => return error.FileNotFound,
	2772	.NOMEM => return error.SystemResources,
	2773	.NOTDIR => return error.NotDir,
	2774	.PERM => return error.PermissionDenied,
	2775	.BUSY => return error.DeviceBusy,
	2776	else => \|err\| return posix.unexpectedErrno(err),
	2777	}
	2778	},
2448	2779	}
2449	2780	}
2450	2781	}
...	...	@@ -2455,6 +2786,7 @@ pub fn dirOpenDirWindows(
2455	2786	sub_path_w: [:0]const u16,
2456	2787	options: Io.Dir.OpenOptions,
2457	2788	) Io.Dir.OpenError!Io.Dir {
	2789	const current_thread = Thread.getCurrent(t);
2458	2790	const w = windows;
2459	2791	// TODO remove some of these flags if options.access_sub_paths is false
2460	2792	const base_flags = w.STANDARD_RIGHTS_READ \| w.FILE_READ_ATTRIBUTES \| w.FILE_READ_EA \|
...	...	@@ -2478,7 +2810,7 @@ pub fn dirOpenDirWindows(
2478	2810	const open_reparse_point: w.DWORD = if (!options.follow_symlinks) w.FILE_OPEN_REPARSE_POINT else 0x0;
2479	2811	var io_status_block: w.IO_STATUS_BLOCK = undefined;
2480	2812	var result: Io.Dir = .{ .handle = undefined };
2481		try t.checkCancel();
	2813	try current_thread.checkCancel();
2482	2814	const rc = w.ntdll.NtCreateFile(
2483	2815	&result.handle,
2484	2816	access_mask,
...	...	@@ -2527,6 +2859,7 @@ fn dirOpenDirWasi(
2527	2859	) Io.Dir.OpenError!Io.Dir {
2528	2860	if (builtin.link_libc) return dirOpenDirPosix(userdata, dir, sub_path, options);
2529	2861	const t: *Threaded = @ptrCast(@alignCast(userdata));
	2862	const current_thread = Thread.getCurrent(t);
2530	2863	const wasi = std.os.wasi;
2531	2864
2532	2865	var base: std.os.wasi.rights_t = .{
...	...	@@ -2556,31 +2889,40 @@ fn dirOpenDirWasi(
2556	2889	const oflags: wasi.oflags_t = .{ .DIRECTORY = true };
2557	2890	const fdflags: wasi.fdflags_t = .{};
2558	2891	var fd: posix.fd_t = undefined;
2559
	2892	try current_thread.beginSyscall();
2560	2893	while (true) {
2561		try t.checkCancel();
2562	2894	switch (wasi.path_open(dir.handle, lookup_flags, sub_path.ptr, sub_path.len, oflags, base, base, fdflags, &fd)) {
2563		.SUCCESS => return .{ .handle = fd },
2564		.INTR => continue,
2565		.CANCELED => return error.Canceled,
2566
2567		.FAULT => \|err\| return errnoBug(err),
2568		.INVAL => return error.BadPathName,
2569		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
2570		.ACCES => return error.AccessDenied,
2571		.LOOP => return error.SymLinkLoop,
2572		.MFILE => return error.ProcessFdQuotaExceeded,
2573		.NAMETOOLONG => return error.NameTooLong,
2574		.NFILE => return error.SystemFdQuotaExceeded,
2575		.NODEV => return error.NoDevice,
2576		.NOENT => return error.FileNotFound,
2577		.NOMEM => return error.SystemResources,
2578		.NOTDIR => return error.NotDir,
2579		.PERM => return error.PermissionDenied,
2580		.BUSY => return error.DeviceBusy,
2581		.NOTCAPABLE => return error.AccessDenied,
2582		.ILSEQ => return error.BadPathName,
2583		else => \|err\| return posix.unexpectedErrno(err),
	2895	.SUCCESS => {
	2896	current_thread.endSyscall();
	2897	return .{ .handle = fd };
	2898	},
	2899	.INTR => {
	2900	try current_thread.checkCancel();
	2901	continue;
	2902	},
	2903	else => \|e\| {
	2904	current_thread.endSyscall();
	2905	switch (e) {
	2906	.CANCELED => return error.Canceled,
	2907	.FAULT => \|err\| return errnoBug(err),
	2908	.INVAL => return error.BadPathName,
	2909	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	2910	.ACCES => return error.AccessDenied,
	2911	.LOOP => return error.SymLinkLoop,
	2912	.MFILE => return error.ProcessFdQuotaExceeded,
	2913	.NAMETOOLONG => return error.NameTooLong,
	2914	.NFILE => return error.SystemFdQuotaExceeded,
	2915	.NODEV => return error.NoDevice,
	2916	.NOENT => return error.FileNotFound,
	2917	.NOMEM => return error.SystemResources,
	2918	.NOTDIR => return error.NotDir,
	2919	.PERM => return error.PermissionDenied,
	2920	.BUSY => return error.DeviceBusy,
	2921	.NOTCAPABLE => return error.AccessDenied,
	2922	.ILSEQ => return error.BadPathName,
	2923	else => \|err\| return posix.unexpectedErrno(err),
	2924	}
	2925	},
2584	2926	}
2585	2927	}
2586	2928	}
...	...	@@ -2598,6 +2940,7 @@ const fileReadStreaming = switch (native_os) {
2598	2940
2599	2941	fn fileReadStreamingPosix(userdata: ?*anyopaque, file: Io.File, data: [][]u8) Io.File.Reader.Error!usize {
2600	2942	const t: *Threaded = @ptrCast(@alignCast(userdata));
	2943	const current_thread = Thread.getCurrent(t);
2601	2944
2602	2945	var iovecs_buffer: [max_iovecs_len]posix.iovec = undefined;
2603	2946	var i: usize = 0;
...	...	@@ -2611,59 +2954,82 @@ fn fileReadStreamingPosix(userdata: ?*anyopaque, file: Io.File, data: [][]u8) Io
2611	2954	const dest = iovecs_buffer[0..i];
2612	2955	assert(dest[0].len > 0);
2613	2956
2614		if (native_os == .wasi and !builtin.link_libc) while (true) {
2615		try t.checkCancel();
2616		var nread: usize = undefined;
2617		switch (std.os.wasi.fd_read(file.handle, dest.ptr, dest.len, &nread)) {
2618		.SUCCESS => return nread,
2619		.INTR => continue,
2620		.CANCELED => return error.Canceled,
2621
2622		.INVAL => \|err\| return errnoBug(err),
2623		.FAULT => \|err\| return errnoBug(err),
2624		.BADF => return error.NotOpenForReading, // File operation on directory.
2625		.IO => return error.InputOutput,
2626		.ISDIR => return error.IsDir,
2627		.NOBUFS => return error.SystemResources,
2628		.NOMEM => return error.SystemResources,
2629		.NOTCONN => return error.SocketUnconnected,
2630		.CONNRESET => return error.ConnectionResetByPeer,
2631		.TIMEDOUT => return error.Timeout,
2632		.NOTCAPABLE => return error.AccessDenied,
2633		else => \|err\| return posix.unexpectedErrno(err),
	2957	if (native_os == .wasi and !builtin.link_libc) {
	2958	try current_thread.beginSyscall();
	2959	while (true) {
	2960	var nread: usize = undefined;
	2961	switch (std.os.wasi.fd_read(file.handle, dest.ptr, dest.len, &nread)) {
	2962	.SUCCESS => {
	2963	current_thread.endSyscall();
	2964	return nread;
	2965	},
	2966	.INTR => {
	2967	try current_thread.checkCancel();
	2968	continue;
	2969	},
	2970	else => \|e\| {
	2971	current_thread.endSyscall();
	2972	switch (e) {
	2973	.CANCELED => return error.Canceled,
	2974	.INVAL => \|err\| return errnoBug(err),
	2975	.FAULT => \|err\| return errnoBug(err),
	2976	.BADF => return error.NotOpenForReading, // File operation on directory.
	2977	.IO => return error.InputOutput,
	2978	.ISDIR => return error.IsDir,
	2979	.NOBUFS => return error.SystemResources,
	2980	.NOMEM => return error.SystemResources,
	2981	.NOTCONN => return error.SocketUnconnected,
	2982	.CONNRESET => return error.ConnectionResetByPeer,
	2983	.TIMEDOUT => return error.Timeout,
	2984	.NOTCAPABLE => return error.AccessDenied,
	2985	else => \|err\| return posix.unexpectedErrno(err),
	2986	}
	2987	},
	2988	}
2634	2989	}
2635		};
	2990	}
2636	2991
	2992	try current_thread.beginSyscall();
2637	2993	while (true) {
2638		try t.checkCancel();
2639	2994	const rc = posix.system.readv(file.handle, dest.ptr, @intCast(dest.len));
2640	2995	switch (posix.errno(rc)) {
2641		.SUCCESS => return @intCast(rc),
2642		.INTR => continue,
2643		.CANCELED => return error.Canceled,
2644
2645		.INVAL => \|err\| return errnoBug(err),
2646		.FAULT => \|err\| return errnoBug(err),
2647		.SRCH => return error.ProcessNotFound,
2648		.AGAIN => return error.WouldBlock,
2649		.BADF => \|err\| {
2650		if (native_os == .wasi) return error.NotOpenForReading; // File operation on directory.
2651		return errnoBug(err); // File descriptor used after closed.
2652		},
2653		.IO => return error.InputOutput,
2654		.ISDIR => return error.IsDir,
2655		.NOBUFS => return error.SystemResources,
2656		.NOMEM => return error.SystemResources,
2657		.NOTCONN => return error.SocketUnconnected,
2658		.CONNRESET => return error.ConnectionResetByPeer,
2659		.TIMEDOUT => return error.Timeout,
2660		else => \|err\| return posix.unexpectedErrno(err),
	2996	.SUCCESS => {
	2997	current_thread.endSyscall();
	2998	return @intCast(rc);
	2999	},
	3000	.INTR => {
	3001	try current_thread.checkCancel();
	3002	continue;
	3003	},
	3004	else => \|e\| {
	3005	current_thread.endSyscall();
	3006	switch (e) {
	3007	.CANCELED => return error.Canceled,
	3008	.INVAL => \|err\| return errnoBug(err),
	3009	.FAULT => \|err\| return errnoBug(err),
	3010	.SRCH => return error.ProcessNotFound,
	3011	.AGAIN => return error.WouldBlock,
	3012	.BADF => \|err\| {
	3013	if (native_os == .wasi) return error.NotOpenForReading; // File operation on directory.
	3014	return errnoBug(err); // File descriptor used after closed.
	3015	},
	3016	.IO => return error.InputOutput,
	3017	.ISDIR => return error.IsDir,
	3018	.NOBUFS => return error.SystemResources,
	3019	.NOMEM => return error.SystemResources,
	3020	.NOTCONN => return error.SocketUnconnected,
	3021	.CONNRESET => return error.ConnectionResetByPeer,
	3022	.TIMEDOUT => return error.Timeout,
	3023	else => \|err\| return posix.unexpectedErrno(err),
	3024	}
	3025	},
2661	3026	}
2662	3027	}
2663	3028	}
2664	3029
2665	3030	fn fileReadStreamingWindows(userdata: ?*anyopaque, file: Io.File, data: [][]u8) Io.File.Reader.Error!usize {
2666	3031	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3032	const current_thread = Thread.getCurrent(t);
2667	3033
2668	3034	const DWORD = windows.DWORD;
2669	3035	var index: usize = 0;
...	...	@@ -2672,7 +3038,7 @@ fn fileReadStreamingWindows(userdata: ?*anyopaque, file: Io.File, data: [][]u8)
2672	3038	const want_read_count: DWORD = @min(std.math.maxInt(DWORD), buffer.len);
2673	3039
2674	3040	while (true) {
2675		try t.checkCancel();
	3041	try current_thread.checkCancel();
2676	3042	var n: DWORD = undefined;
2677	3043	if (windows.kernel32.ReadFile(file.handle, buffer.ptr, want_read_count, &n, null) != 0)
2678	3044	return n;
...	...	@@ -2692,6 +3058,7 @@ fn fileReadStreamingWindows(userdata: ?*anyopaque, file: Io.File, data: [][]u8)
2692	3058
2693	3059	fn fileReadPositionalPosix(userdata: ?*anyopaque, file: Io.File, data: [][]u8, offset: u64) Io.File.ReadPositionalError!usize {
2694	3060	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3061	const current_thread = Thread.getCurrent(t);
2695	3062
2696	3063	if (!have_preadv) @compileError("TODO");
2697	3064
...	...	@@ -2707,60 +3074,82 @@ fn fileReadPositionalPosix(userdata: ?*anyopaque, file: Io.File, data: [][]u8, o
2707	3074	const dest = iovecs_buffer[0..i];
2708	3075	assert(dest[0].len > 0);
2709	3076
2710		if (native_os == .wasi and !builtin.link_libc) while (true) {
2711		try t.checkCancel();
2712		var nread: usize = undefined;
2713		switch (std.os.wasi.fd_pread(file.handle, dest.ptr, dest.len, offset, &nread)) {
2714		.SUCCESS => return nread,
2715		.INTR => continue,
2716		.CANCELED => return error.Canceled,
2717
2718		.INVAL => \|err\| return errnoBug(err),
2719		.FAULT => \|err\| return errnoBug(err),
2720		.AGAIN => \|err\| return errnoBug(err),
2721		.BADF => return error.NotOpenForReading, // File operation on directory.
2722		.IO => return error.InputOutput,
2723		.ISDIR => return error.IsDir,
2724		.NOBUFS => return error.SystemResources,
2725		.NOMEM => return error.SystemResources,
2726		.NOTCONN => return error.SocketUnconnected,
2727		.CONNRESET => return error.ConnectionResetByPeer,
2728		.TIMEDOUT => return error.Timeout,
2729		.NXIO => return error.Unseekable,
2730		.SPIPE => return error.Unseekable,
2731		.OVERFLOW => return error.Unseekable,
2732		.NOTCAPABLE => return error.AccessDenied,
2733		else => \|err\| return posix.unexpectedErrno(err),
	3077	if (native_os == .wasi and !builtin.link_libc) {
	3078	try current_thread.beginSyscall();
	3079	while (true) {
	3080	var nread: usize = undefined;
	3081	switch (std.os.wasi.fd_pread(file.handle, dest.ptr, dest.len, offset, &nread)) {
	3082	.SUCCESS => {
	3083	current_thread.endSyscall();
	3084	return nread;
	3085	},
	3086	.INTR => {
	3087	try current_thread.checkCancel();
	3088	continue;
	3089	},
	3090	else => \|e\| {
	3091	current_thread.endSyscall();
	3092	switch (e) {
	3093	.CANCELED => return error.Canceled,
	3094	.INVAL => \|err\| return errnoBug(err),
	3095	.FAULT => \|err\| return errnoBug(err),
	3096	.AGAIN => \|err\| return errnoBug(err),
	3097	.BADF => return error.NotOpenForReading, // File operation on directory.
	3098	.IO => return error.InputOutput,
	3099	.ISDIR => return error.IsDir,
	3100	.NOBUFS => return error.SystemResources,
	3101	.NOMEM => return error.SystemResources,
	3102	.NOTCONN => return error.SocketUnconnected,
	3103	.CONNRESET => return error.ConnectionResetByPeer,
	3104	.TIMEDOUT => return error.Timeout,
	3105	.NXIO => return error.Unseekable,
	3106	.SPIPE => return error.Unseekable,
	3107	.OVERFLOW => return error.Unseekable,
	3108	.NOTCAPABLE => return error.AccessDenied,
	3109	else => \|err\| return posix.unexpectedErrno(err),
	3110	}
	3111	},
	3112	}
2734	3113	}
2735		};
	3114	}
2736	3115
	3116	try current_thread.beginSyscall();
2737	3117	while (true) {
2738		try t.checkCancel();
2739	3118	const rc = preadv_sym(file.handle, dest.ptr, @intCast(dest.len), @bitCast(offset));
2740	3119	switch (posix.errno(rc)) {
2741		.SUCCESS => return @bitCast(rc),
2742		.INTR => continue,
2743		.CANCELED => return error.Canceled,
2744
2745		.INVAL => \|err\| return errnoBug(err),
2746		.FAULT => \|err\| return errnoBug(err),
2747		.SRCH => return error.ProcessNotFound,
2748		.AGAIN => return error.WouldBlock,
2749		.BADF => \|err\| {
2750		if (native_os == .wasi) return error.NotOpenForReading; // File operation on directory.
2751		return errnoBug(err); // File descriptor used after closed.
2752		},
2753		.IO => return error.InputOutput,
2754		.ISDIR => return error.IsDir,
2755		.NOBUFS => return error.SystemResources,
2756		.NOMEM => return error.SystemResources,
2757		.NOTCONN => return error.SocketUnconnected,
2758		.CONNRESET => return error.ConnectionResetByPeer,
2759		.TIMEDOUT => return error.Timeout,
2760		.NXIO => return error.Unseekable,
2761		.SPIPE => return error.Unseekable,
2762		.OVERFLOW => return error.Unseekable,
2763		else => \|err\| return posix.unexpectedErrno(err),
	3120	.SUCCESS => {
	3121	current_thread.endSyscall();
	3122	return @bitCast(rc);
	3123	},
	3124	.INTR => {
	3125	try current_thread.checkCancel();
	3126	continue;
	3127	},
	3128	else => \|e\| {
	3129	current_thread.endSyscall();
	3130	switch (e) {
	3131	.CANCELED => return error.Canceled,
	3132	.INVAL => \|err\| return errnoBug(err),
	3133	.FAULT => \|err\| return errnoBug(err),
	3134	.SRCH => return error.ProcessNotFound,
	3135	.AGAIN => return error.WouldBlock,
	3136	.BADF => \|err\| {
	3137	if (native_os == .wasi) return error.NotOpenForReading; // File operation on directory.
	3138	return errnoBug(err); // File descriptor used after closed.
	3139	},
	3140	.IO => return error.InputOutput,
	3141	.ISDIR => return error.IsDir,
	3142	.NOBUFS => return error.SystemResources,
	3143	.NOMEM => return error.SystemResources,
	3144	.NOTCONN => return error.SocketUnconnected,
	3145	.CONNRESET => return error.ConnectionResetByPeer,
	3146	.TIMEDOUT => return error.Timeout,
	3147	.NXIO => return error.Unseekable,
	3148	.SPIPE => return error.Unseekable,
	3149	.OVERFLOW => return error.Unseekable,
	3150	else => \|err\| return posix.unexpectedErrno(err),
	3151	}
	3152	},
2764	3153	}
2765	3154	}
2766	3155	}
...	...	@@ -2772,6 +3161,7 @@ const fileReadPositional = switch (native_os) {
2772	3161
2773	3162	fn fileReadPositionalWindows(userdata: ?*anyopaque, file: Io.File, data: [][]u8, offset: u64) Io.File.ReadPositionalError!usize {
2774	3163	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3164	const current_thread = Thread.getCurrent(t);
2775	3165
2776	3166	const DWORD = windows.DWORD;
2777	3167
...	...	@@ -2793,7 +3183,7 @@ fn fileReadPositionalWindows(userdata: ?*anyopaque, file: Io.File, data: [][]u8,
2793	3183	};
2794	3184
2795	3185	while (true) {
2796		try t.checkCancel();
	3186	try current_thread.checkCancel();
2797	3187	var n: DWORD = undefined;
2798	3188	if (windows.kernel32.ReadFile(file.handle, buffer.ptr, want_read_count, &n, &overlapped) != 0)
2799	3189	return n;
...	...	@@ -2813,8 +3203,7 @@ fn fileReadPositionalWindows(userdata: ?*anyopaque, file: Io.File, data: [][]u8,
2813	3203
2814	3204	fn fileSeekBy(userdata: ?*anyopaque, file: Io.File, offset: i64) Io.File.SeekError!void {
2815	3205	const t: *Threaded = @ptrCast(@alignCast(userdata));
2816		try t.checkCancel();
2817
	3206	_ = t;
2818	3207	_ = file;
2819	3208	_ = offset;
2820	3209	@panic("TODO implement fileSeekBy");
...	...	@@ -2822,63 +3211,96 @@ fn fileSeekBy(userdata: ?*anyopaque, file: Io.File, offset: i64) Io.File.SeekErr
2822	3211
2823	3212	fn fileSeekTo(userdata: ?*anyopaque, file: Io.File, offset: u64) Io.File.SeekError!void {
2824	3213	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3214	const current_thread = Thread.getCurrent(t);
2825	3215	const fd = file.handle;
2826	3216
2827		if (native_os == .linux and !builtin.link_libc and @sizeOf(usize) == 4) while (true) {
2828		try t.checkCancel();
2829		var result: u64 = undefined;
2830		switch (posix.errno(posix.system.llseek(fd, offset, &result, posix.SEEK.SET))) {
2831		.SUCCESS => return,
2832		.INTR => continue,
2833		.CANCELED => return error.Canceled,
2834
2835		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
2836		.INVAL => return error.Unseekable,
2837		.OVERFLOW => return error.Unseekable,
2838		.SPIPE => return error.Unseekable,
2839		.NXIO => return error.Unseekable,
2840		else => \|err\| return posix.unexpectedErrno(err),
	3217	if (native_os == .linux and !builtin.link_libc and @sizeOf(usize) == 4) {
	3218	try current_thread.beginSyscall();
	3219	while (true) {
	3220	var result: u64 = undefined;
	3221	switch (posix.errno(posix.system.llseek(fd, offset, &result, posix.SEEK.SET))) {
	3222	.SUCCESS => {
	3223	current_thread.endSyscall();
	3224	return;
	3225	},
	3226	.INTR => {
	3227	try current_thread.checkCancel();
	3228	continue;
	3229	},
	3230	else => \|e\| {
	3231	current_thread.endSyscall();
	3232	switch (e) {
	3233	.CANCELED => return error.Canceled,
	3234	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	3235	.INVAL => return error.Unseekable,
	3236	.OVERFLOW => return error.Unseekable,
	3237	.SPIPE => return error.Unseekable,
	3238	.NXIO => return error.Unseekable,
	3239	else => \|err\| return posix.unexpectedErrno(err),
	3240	}
	3241	},
	3242	}
2841	3243	}
2842		};
	3244	}
2843	3245
2844	3246	if (native_os == .windows) {
2845		try t.checkCancel();
	3247	try current_thread.checkCancel();
2846	3248	return windows.SetFilePointerEx_BEGIN(fd, offset);
2847	3249	}
2848	3250
2849	3251	if (native_os == .wasi and !builtin.link_libc) while (true) {
2850		try t.checkCancel();
2851	3252	var new_offset: std.os.wasi.filesize_t = undefined;
	3253	try current_thread.beginSyscall();
2852	3254	switch (std.os.wasi.fd_seek(fd, @bitCast(offset), .SET, &new_offset)) {
2853		.SUCCESS => return,
2854		.INTR => continue,
2855		.CANCELED => return error.Canceled,
2856
2857		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
2858		.INVAL => return error.Unseekable,
2859		.OVERFLOW => return error.Unseekable,
2860		.SPIPE => return error.Unseekable,
2861		.NXIO => return error.Unseekable,
2862		.NOTCAPABLE => return error.AccessDenied,
2863		else => \|err\| return posix.unexpectedErrno(err),
	3255	.SUCCESS => {
	3256	current_thread.endSyscall();
	3257	return;
	3258	},
	3259	.INTR => {
	3260	try current_thread.checkCancel();
	3261	continue;
	3262	},
	3263	else => \|e\| {
	3264	current_thread.endSyscall();
	3265	switch (e) {
	3266	.CANCELED => return error.Canceled,
	3267	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	3268	.INVAL => return error.Unseekable,
	3269	.OVERFLOW => return error.Unseekable,
	3270	.SPIPE => return error.Unseekable,
	3271	.NXIO => return error.Unseekable,
	3272	.NOTCAPABLE => return error.AccessDenied,
	3273	else => \|err\| return posix.unexpectedErrno(err),
	3274	}
	3275	},
2864	3276	}
2865	3277	};
2866	3278
2867	3279	if (posix.SEEK == void) return error.Unseekable;
2868	3280
	3281	try current_thread.beginSyscall();
2869	3282	while (true) {
2870		try t.checkCancel();
2871	3283	switch (posix.errno(lseek_sym(fd, @bitCast(offset), posix.SEEK.SET))) {
2872		.SUCCESS => return,
2873		.INTR => continue,
2874		.CANCELED => return error.Canceled,
2875
2876		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
2877		.INVAL => return error.Unseekable,
2878		.OVERFLOW => return error.Unseekable,
2879		.SPIPE => return error.Unseekable,
2880		.NXIO => return error.Unseekable,
2881		else => \|err\| return posix.unexpectedErrno(err),
	3284	.SUCCESS => {
	3285	current_thread.endSyscall();
	3286	return;
	3287	},
	3288	.INTR => {
	3289	try current_thread.checkCancel();
	3290	continue;
	3291	},
	3292	else => \|e\| {
	3293	current_thread.endSyscall();
	3294	switch (e) {
	3295	.CANCELED => return error.Canceled,
	3296	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	3297	.INVAL => return error.Unseekable,
	3298	.OVERFLOW => return error.Unseekable,
	3299	.SPIPE => return error.Unseekable,
	3300	.NXIO => return error.Unseekable,
	3301	else => \|err\| return posix.unexpectedErrno(err),
	3302	}
	3303	},
2882	3304	}
2883	3305	}
2884	3306	}
...	...	@@ -2907,8 +3329,8 @@ fn fileWritePositional(
2907	3329	offset: u64,
2908	3330	) Io.File.WritePositionalError!usize {
2909	3331	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3332	_ = t;
2910	3333	while (true) {
2911		try t.checkCancel();
2912	3334	_ = file;
2913	3335	_ = buffer;
2914	3336	_ = offset;
...	...	@@ -2918,8 +3340,8 @@ fn fileWritePositional(
2918	3340
2919	3341	fn fileWriteStreaming(userdata: ?*anyopaque, file: Io.File, buffer: [][]const u8) Io.File.WriteStreamingError!usize {
2920	3342	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3343	_ = t;
2921	3344	while (true) {
2922		try t.checkCancel();
2923	3345	_ = file;
2924	3346	_ = buffer;
2925	3347	@panic("TODO implement fileWriteStreaming");
...	...	@@ -2997,6 +3419,7 @@ const sleep = switch (native_os) {
2997	3419
2998	3420	fn sleepLinux(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
2999	3421	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3422	const current_thread = Thread.getCurrent(t);
3000	3423	const clock_id: posix.clockid_t = clockToPosix(switch (timeout) {
3001	3424	.none => .awake,
3002	3425	.duration => \|d\| d.clock,
...	...	@@ -3008,25 +3431,37 @@ fn sleepLinux(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
3008	3431	.deadline => \|deadline\| deadline.raw.nanoseconds,
3009	3432	};
3010	3433	var timespec: posix.timespec = timestampToPosix(deadline_nanoseconds);
	3434	try current_thread.beginSyscall();
3011	3435	while (true) {
3012		try t.checkCancel();
3013	3436	switch (std.os.linux.errno(std.os.linux.clock_nanosleep(clock_id, .{ .ABSTIME = switch (timeout) {
3014	3437	.none, .duration => false,
3015	3438	.deadline => true,
3016	3439	} }, &timespec, &timespec))) {
3017		.SUCCESS => return,
3018		.INTR => continue,
3019		.CANCELED => return error.Canceled,
3020		.INVAL => return error.UnsupportedClock,
3021		else => \|err\| return posix.unexpectedErrno(err),
	3440	.SUCCESS => {
	3441	current_thread.endSyscall();
	3442	return;
	3443	},
	3444	.INTR => {
	3445	try current_thread.checkCancel();
	3446	continue;
	3447	},
	3448	else => \|e\| {
	3449	current_thread.endSyscall();
	3450	switch (e) {
	3451	.CANCELED => return error.Canceled,
	3452	.INVAL => return error.UnsupportedClock,
	3453	else => \|err\| return posix.unexpectedErrno(err),
	3454	}
	3455	},
3022	3456	}
3023	3457	}
3024	3458	}
3025	3459
3026	3460	fn sleepWindows(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
3027	3461	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3462	const current_thread = Thread.getCurrent(t);
3028	3463	const t_io = ioBasic(t);
3029		try t.checkCancel();
	3464	try current_thread.checkCancel();
3030	3465	const ms = ms: {
3031	3466	const d = (try timeout.toDurationFromNow(t_io)) orelse
3032	3467	break :ms std.math.maxInt(windows.DWORD);
...	...	@@ -3038,9 +3473,8 @@ fn sleepWindows(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
3038	3473
3039	3474	fn sleepWasi(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
3040	3475	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3476	const current_thread = Thread.getCurrent(t);
3041	3477	const t_io = ioBasic(t);
3042		try t.checkCancel();
3043
3044	3478	const w = std.os.wasi;
3045	3479
3046	3480	const clock: w.subscription_clock_t = if (try timeout.toDurationFromNow(t_io)) \|d\| .{
...	...	@@ -3063,11 +3497,14 @@ fn sleepWasi(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
3063	3497	};
3064	3498	var event: w.event_t = undefined;
3065	3499	var nevents: usize = undefined;
	3500	try current_thread.beginSyscall();
3066	3501	_ = w.poll_oneoff(&in, &event, 1, &nevents);
	3502	current_thread.endSyscall();
3067	3503	}
3068	3504
3069	3505	fn sleepPosix(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
3070	3506	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3507	const current_thread = Thread.getCurrent(t);
3071	3508	const t_io = ioBasic(t);
3072	3509	const sec_type = @typeInfo(posix.timespec).@"struct".fields[0].type;
3073	3510	const nsec_type = @typeInfo(posix.timespec).@"struct".fields[1].type;
...	...	@@ -3079,12 +3516,18 @@ fn sleepPosix(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
3079	3516	};
3080	3517	break :t timestampToPosix(d.raw.toNanoseconds());
3081	3518	};
	3519	try current_thread.beginSyscall();
3082	3520	while (true) {
3083		try t.checkCancel();
3084	3521	switch (posix.errno(posix.system.nanosleep(&timespec, &timespec))) {
3085		.INTR => continue,
3086		.CANCELED => return error.Canceled,
3087		else => return, // This prong handles success as well as unexpected errors.
	3522	.INTR => {
	3523	try current_thread.checkCancel();
	3524	continue;
	3525	},
	3526	else => {
	3527	// This prong handles success as well as unexpected errors.
	3528	current_thread.endSyscall();
	3529	return;
	3530	},
3088	3531	}
3089	3532	}
3090	3533	}
...	...	@@ -3127,34 +3570,48 @@ fn netListenIpPosix(
3127	3570	) IpAddress.ListenError!net.Server {
3128	3571	if (!have_networking) return error.NetworkDown;
3129	3572	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3573	const current_thread = Thread.getCurrent(t);
3130	3574	const family = posixAddressFamily(&address);
3131		const socket_fd = try openSocketPosix(t, family, .{
	3575	const socket_fd = try openSocketPosix(current_thread, family, .{
3132	3576	.mode = options.mode,
3133	3577	.protocol = options.protocol,
3134	3578	});
3135	3579	errdefer posix.close(socket_fd);
3136	3580
3137	3581	if (options.reuse_address) {
3138		try setSocketOption(t, socket_fd, posix.SOL.SOCKET, posix.SO.REUSEADDR, 1);
	3582	try setSocketOption(current_thread, socket_fd, posix.SOL.SOCKET, posix.SO.REUSEADDR, 1);
3139	3583	if (@hasDecl(posix.SO, "REUSEPORT"))
3140		try setSocketOption(t, socket_fd, posix.SOL.SOCKET, posix.SO.REUSEPORT, 1);
	3584	try setSocketOption(current_thread, socket_fd, posix.SOL.SOCKET, posix.SO.REUSEPORT, 1);
3141	3585	}
3142	3586
3143	3587	var storage: PosixAddress = undefined;
3144	3588	var addr_len = addressToPosix(&address, &storage);
3145		try posixBind(t, socket_fd, &storage.any, addr_len);
	3589	try posixBind(current_thread, socket_fd, &storage.any, addr_len);
3146	3590
	3591	try current_thread.beginSyscall();
3147	3592	while (true) {
3148		try t.checkCancel();
3149	3593	switch (posix.errno(posix.system.listen(socket_fd, options.kernel_backlog))) {
3150		.SUCCESS => break,
3151		.ADDRINUSE => return error.AddressInUse,
3152		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
3153		else => \|err\| return posix.unexpectedErrno(err),
	3594	.SUCCESS => {
	3595	current_thread.endSyscall();
	3596	break;
	3597	},
	3598	.INTR => {
	3599	try current_thread.checkCancel();
	3600	continue;
	3601	},
	3602	else => \|e\| {
	3603	current_thread.endSyscall();
	3604	switch (e) {
	3605	.CANCELED => return error.Canceled,
	3606	.ADDRINUSE => return error.AddressInUse,
	3607	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	3608	else => \|err\| return posix.unexpectedErrno(err),
	3609	}
	3610	},
3154	3611	}
3155	3612	}
3156	3613
3157		try posixGetSockName(t, socket_fd, &storage.any, &addr_len);
	3614	try posixGetSockName(current_thread, socket_fd, &storage.any, &addr_len);
3158	3615	return .{
3159	3616	.socket = .{
3160	3617	.handle = socket_fd,
...	...	@@ -3170,8 +3627,9 @@ fn netListenIpWindows(
3170	3627	) IpAddress.ListenError!net.Server {
3171	3628	if (!have_networking) return error.NetworkDown;
3172	3629	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3630	const current_thread = Thread.getCurrent(t);
3173	3631	const family = posixAddressFamily(&address);
3174		const socket_handle = try openSocketWsa(t, family, .{
	3632	const socket_handle = try openSocketWsa(t, current_thread, family, .{
3175	3633	.mode = options.mode,
3176	3634	.protocol = options.protocol,
3177	3635	});
...	...	@@ -3183,52 +3641,73 @@ fn netListenIpWindows(
3183	3641	var storage: WsaAddress = undefined;
3184	3642	var addr_len = addressToWsa(&address, &storage);
3185	3643
	3644	try current_thread.beginSyscall();
3186	3645	while (true) {
3187		try t.checkCancel();
3188	3646	const rc = ws2_32.bind(socket_handle, &storage.any, addr_len);
3189	3647	if (rc != ws2_32.SOCKET_ERROR) break;
3190	3648	switch (ws2_32.WSAGetLastError()) {
3191		.EINTR => continue,
3192		.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	3649	.EINTR => {
	3650	try current_thread.checkCancel();
	3651	continue;
	3652	},
3193	3653	.NOTINITIALISED => {
3194	3654	try initializeWsa(t);
	3655	try current_thread.checkCancel();
3195	3656	continue;
3196	3657	},
3197		.EADDRINUSE => return error.AddressInUse,
3198		.EADDRNOTAVAIL => return error.AddressUnavailable,
3199		.ENOTSOCK => \|err\| return wsaErrorBug(err),
3200		.EFAULT => \|err\| return wsaErrorBug(err),
3201		.EINVAL => \|err\| return wsaErrorBug(err),
3202		.ENOBUFS => return error.SystemResources,
3203		.ENETDOWN => return error.NetworkDown,
3204		else => \|err\| return windows.unexpectedWSAError(err),
	3658	else => \|e\| {
	3659	current_thread.endSyscall();
	3660	switch (e) {
	3661	.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	3662	.EADDRINUSE => return error.AddressInUse,
	3663	.EADDRNOTAVAIL => return error.AddressUnavailable,
	3664	.ENOTSOCK => \|err\| return wsaErrorBug(err),
	3665	.EFAULT => \|err\| return wsaErrorBug(err),
	3666	.EINVAL => \|err\| return wsaErrorBug(err),
	3667	.ENOBUFS => return error.SystemResources,
	3668	.ENETDOWN => return error.NetworkDown,
	3669	else => \|err\| return windows.unexpectedWSAError(err),
	3670	}
	3671	},
3205	3672	}
3206	3673	}
3207	3674
	3675	try current_thread.checkCancel();
3208	3676	while (true) {
3209		try t.checkCancel();
3210	3677	const rc = ws2_32.listen(socket_handle, options.kernel_backlog);
3211		if (rc != ws2_32.SOCKET_ERROR) break;
	3678	if (rc != ws2_32.SOCKET_ERROR) {
	3679	current_thread.endSyscall();
	3680	break;
	3681	}
3212	3682	switch (ws2_32.WSAGetLastError()) {
3213		.EINTR => continue,
3214		.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	3683	.EINTR => {
	3684	try current_thread.checkCancel();
	3685	continue;
	3686	},
3215	3687	.NOTINITIALISED => {
3216	3688	try initializeWsa(t);
	3689	try current_thread.checkCancel();
3217	3690	continue;
3218	3691	},
3219		.ENETDOWN => return error.NetworkDown,
3220		.EADDRINUSE => return error.AddressInUse,
3221		.EISCONN => \|err\| return wsaErrorBug(err),
3222		.EINVAL => \|err\| return wsaErrorBug(err),
3223		.EMFILE, .ENOBUFS => return error.SystemResources,
3224		.ENOTSOCK => \|err\| return wsaErrorBug(err),
3225		.EOPNOTSUPP => \|err\| return wsaErrorBug(err),
3226		.EINPROGRESS => \|err\| return wsaErrorBug(err),
3227		else => \|err\| return windows.unexpectedWSAError(err),
	3692	else => \|e\| {
	3693	current_thread.endSyscall();
	3694	switch (e) {
	3695	.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	3696	.ENETDOWN => return error.NetworkDown,
	3697	.EADDRINUSE => return error.AddressInUse,
	3698	.EISCONN => \|err\| return wsaErrorBug(err),
	3699	.EINVAL => \|err\| return wsaErrorBug(err),
	3700	.EMFILE, .ENOBUFS => return error.SystemResources,
	3701	.ENOTSOCK => \|err\| return wsaErrorBug(err),
	3702	.EOPNOTSUPP => \|err\| return wsaErrorBug(err),
	3703	.EINPROGRESS => \|err\| return wsaErrorBug(err),
	3704	else => \|err\| return windows.unexpectedWSAError(err),
	3705	}
	3706	},
3228	3707	}
3229	3708	}
3230	3709
3231		try wsaGetSockName(t, socket_handle, &storage.any, &addr_len);
	3710	try wsaGetSockName(t, current_thread, socket_handle, &storage.any, &addr_len);
3232	3711
3233	3712	return .{
3234	3713	.socket = .{
...	...	@@ -3256,7 +3735,8 @@ fn netListenUnixPosix(
3256	3735	) net.UnixAddress.ListenError!net.Socket.Handle {
3257	3736	if (!net.has_unix_sockets) return error.AddressFamilyUnsupported;
3258	3737	const t: *Threaded = @ptrCast(@alignCast(userdata));
3259		const socket_fd = openSocketPosix(t, posix.AF.UNIX, .{ .mode = .stream }) catch \|err\| switch (err) {
	3738	const current_thread = Thread.getCurrent(t);
	3739	const socket_fd = openSocketPosix(current_thread, posix.AF.UNIX, .{ .mode = .stream }) catch \|err\| switch (err) {
3260	3740	error.ProtocolUnsupportedBySystem => return error.AddressFamilyUnsupported,
3261	3741	error.ProtocolUnsupportedByAddressFamily => return error.AddressFamilyUnsupported,
3262	3742	error.SocketModeUnsupported => return error.AddressFamilyUnsupported,
...	...	@@ -3267,15 +3747,28 @@ fn netListenUnixPosix(
3267	3747
3268	3748	var storage: UnixAddress = undefined;
3269	3749	const addr_len = addressUnixToPosix(address, &storage);
3270		try posixBindUnix(t, socket_fd, &storage.any, addr_len);
	3750	try posixBindUnix(current_thread, socket_fd, &storage.any, addr_len);
3271	3751
	3752	try current_thread.beginSyscall();
3272	3753	while (true) {
3273		try t.checkCancel();
3274	3754	switch (posix.errno(posix.system.listen(socket_fd, options.kernel_backlog))) {
3275		.SUCCESS => break,
3276		.ADDRINUSE => return error.AddressInUse,
3277		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
3278		else => \|err\| return posix.unexpectedErrno(err),
	3755	.SUCCESS => {
	3756	current_thread.endSyscall();
	3757	break;
	3758	},
	3759	.INTR => {
	3760	try current_thread.checkCancel();
	3761	continue;
	3762	},
	3763	else => \|e\| {
	3764	current_thread.endSyscall();
	3765	switch (e) {
	3766	.CANCELED => return error.Canceled,
	3767	.ADDRINUSE => return error.AddressInUse,
	3768	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	3769	else => \|err\| return posix.unexpectedErrno(err),
	3770	}
	3771	},
3279	3772	}
3280	3773	}
3281	3774
...	...	@@ -3289,8 +3782,9 @@ fn netListenUnixWindows(
3289	3782	) net.UnixAddress.ListenError!net.Socket.Handle {
3290	3783	if (!net.has_unix_sockets) return error.AddressFamilyUnsupported;
3291	3784	const t: *Threaded = @ptrCast(@alignCast(userdata));
	3785	const current_thread = Thread.getCurrent(t);
3292	3786
3293		const socket_handle = openSocketWsa(t, posix.AF.UNIX, .{ .mode = .stream }) catch \|err\| switch (err) {
	3787	const socket_handle = openSocketWsa(t, current_thread, posix.AF.UNIX, .{ .mode = .stream }) catch \|err\| switch (err) {
3294	3788	error.ProtocolUnsupportedByAddressFamily => return error.AddressFamilyUnsupported,
3295	3789	else => \|e\| return e,
3296	3790	};
...	...	@@ -3299,52 +3793,67 @@ fn netListenUnixWindows(
3299	3793	var storage: WsaAddress = undefined;
3300	3794	const addr_len = addressUnixToWsa(address, &storage);
3301	3795
	3796	try current_thread.beginSyscall();
3302	3797	while (true) {
3303		try t.checkCancel();
3304	3798	const rc = ws2_32.bind(socket_handle, &storage.any, addr_len);
3305	3799	if (rc != ws2_32.SOCKET_ERROR) break;
3306	3800	switch (ws2_32.WSAGetLastError()) {
3307		.EINTR => continue,
3308		.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	3801	.EINTR => {
	3802	try current_thread.checkCancel();
	3803	continue;
	3804	},
3309	3805	.NOTINITIALISED => {
3310	3806	try initializeWsa(t);
	3807	try current_thread.checkCancel();
3311	3808	continue;
3312	3809	},
3313		.EADDRINUSE => return error.AddressInUse,
3314		.EADDRNOTAVAIL => return error.AddressUnavailable,
3315		.ENOTSOCK => \|err\| return wsaErrorBug(err),
3316		.EFAULT => \|err\| return wsaErrorBug(err),
3317		.EINVAL => \|err\| return wsaErrorBug(err),
3318		.ENOBUFS => return error.SystemResources,
3319		.ENETDOWN => return error.NetworkDown,
3320		else => \|err\| return windows.unexpectedWSAError(err),
	3810	else => \|e\| {
	3811	current_thread.endSyscall();
	3812	switch (e) {
	3813	.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	3814	.EADDRINUSE => return error.AddressInUse,
	3815	.EADDRNOTAVAIL => return error.AddressUnavailable,
	3816	.ENOTSOCK => \|err\| return wsaErrorBug(err),
	3817	.EFAULT => \|err\| return wsaErrorBug(err),
	3818	.EINVAL => \|err\| return wsaErrorBug(err),
	3819	.ENOBUFS => return error.SystemResources,
	3820	.ENETDOWN => return error.NetworkDown,
	3821	else => \|err\| return windows.unexpectedWSAError(err),
	3822	}
	3823	},
3321	3824	}
3322	3825	}
3323	3826
3324	3827	while (true) {
3325		try t.checkCancel();
	3828	try current_thread.checkCancel();
3326	3829	const rc = ws2_32.listen(socket_handle, options.kernel_backlog);
3327		if (rc != ws2_32.SOCKET_ERROR) break;
	3830	if (rc != ws2_32.SOCKET_ERROR) {
	3831	current_thread.endSyscall();
	3832	return socket_handle;
	3833	}
3328	3834	switch (ws2_32.WSAGetLastError()) {
3329	3835	.EINTR => continue,
3330		.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
3331	3836	.NOTINITIALISED => {
3332	3837	try initializeWsa(t);
3333	3838	continue;
3334	3839	},
3335		.ENETDOWN => return error.NetworkDown,
3336		.EADDRINUSE => return error.AddressInUse,
3337		.EISCONN => \|err\| return wsaErrorBug(err),
3338		.EINVAL => \|err\| return wsaErrorBug(err),
3339		.EMFILE, .ENOBUFS => return error.SystemResources,
3340		.ENOTSOCK => \|err\| return wsaErrorBug(err),
3341		.EOPNOTSUPP => \|err\| return wsaErrorBug(err),
3342		.EINPROGRESS => \|err\| return wsaErrorBug(err),
3343		else => \|err\| return windows.unexpectedWSAError(err),
	3840	else => \|e\| {
	3841	current_thread.endSyscall();
	3842	switch (e) {
	3843	.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	3844	.ENETDOWN => return error.NetworkDown,
	3845	.EADDRINUSE => return error.AddressInUse,
	3846	.EISCONN => \|err\| return wsaErrorBug(err),
	3847	.EINVAL => \|err\| return wsaErrorBug(err),
	3848	.EMFILE, .ENOBUFS => return error.SystemResources,
	3849	.ENOTSOCK => \|err\| return wsaErrorBug(err),
	3850	.EOPNOTSUPP => \|err\| return wsaErrorBug(err),
	3851	.EINPROGRESS => \|err\| return wsaErrorBug(err),
	3852	else => \|err\| return windows.unexpectedWSAError(err),
	3853	}
	3854	},
3344	3855	}
3345	3856	}
3346
3347		return socket_handle;
3348	3857	}
3349	3858
3350	3859	fn netListenUnixUnavailable(
...	...	@@ -3358,172 +3867,275 @@ fn netListenUnixUnavailable(
3358	3867	return error.AddressFamilyUnsupported;
3359	3868	}
3360	3869
3361		fn posixBindUnix(t: Threaded, fd: posix.socket_t, addr: const posix.sockaddr, addr_len: posix.socklen_t) !void {
	3870	fn posixBindUnix(
	3871	current_thread: *Thread,
	3872	fd: posix.socket_t,
	3873	addr: *const posix.sockaddr,
	3874	addr_len: posix.socklen_t,
	3875	) !void {
	3876	try current_thread.beginSyscall();
3362	3877	while (true) {
3363		try t.checkCancel();
3364	3878	switch (posix.errno(posix.system.bind(fd, addr, addr_len))) {
3365		.SUCCESS => break,
3366		.INTR => continue,
3367		.CANCELED => return error.Canceled,
3368
3369		.ACCES => return error.AccessDenied,
3370		.ADDRINUSE => return error.AddressInUse,
3371		.AFNOSUPPORT => return error.AddressFamilyUnsupported,
3372		.ADDRNOTAVAIL => return error.AddressUnavailable,
3373		.NOMEM => return error.SystemResources,
3374
3375		.LOOP => return error.SymLinkLoop,
3376		.NOENT => return error.FileNotFound,
3377		.NOTDIR => return error.NotDir,
3378		.ROFS => return error.ReadOnlyFileSystem,
3379		.PERM => return error.PermissionDenied,
3380
3381		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
3382		.INVAL => \|err\| return errnoBug(err), // invalid parameters
3383		.NOTSOCK => \|err\| return errnoBug(err), // invalid `sockfd`
3384		.FAULT => \|err\| return errnoBug(err), // invalid `addr` pointer
3385		.NAMETOOLONG => \|err\| return errnoBug(err),
3386		else => \|err\| return posix.unexpectedErrno(err),
	3879	.SUCCESS => {
	3880	current_thread.endSyscall();
	3881	break;
	3882	},
	3883	.INTR => {
	3884	try current_thread.checkCancel();
	3885	continue;
	3886	},
	3887	else => \|e\| {
	3888	current_thread.endSyscall();
	3889	switch (e) {
	3890	.CANCELED => return error.Canceled,
	3891	.ACCES => return error.AccessDenied,
	3892	.ADDRINUSE => return error.AddressInUse,
	3893	.AFNOSUPPORT => return error.AddressFamilyUnsupported,
	3894	.ADDRNOTAVAIL => return error.AddressUnavailable,
	3895	.NOMEM => return error.SystemResources,
	3896
	3897	.LOOP => return error.SymLinkLoop,
	3898	.NOENT => return error.FileNotFound,
	3899	.NOTDIR => return error.NotDir,
	3900	.ROFS => return error.ReadOnlyFileSystem,
	3901	.PERM => return error.PermissionDenied,
	3902
	3903	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	3904	.INVAL => \|err\| return errnoBug(err), // invalid parameters
	3905	.NOTSOCK => \|err\| return errnoBug(err), // invalid `sockfd`
	3906	.FAULT => \|err\| return errnoBug(err), // invalid `addr` pointer
	3907	.NAMETOOLONG => \|err\| return errnoBug(err),
	3908	else => \|err\| return posix.unexpectedErrno(err),
	3909	}
	3910	},
3387	3911	}
3388	3912	}
3389	3913	}
3390	3914
3391		fn posixBind(t: Threaded, socket_fd: posix.socket_t, addr: const posix.sockaddr, addr_len: posix.socklen_t) !void {
	3915	fn posixBind(
	3916	current_thread: *Thread,
	3917	socket_fd: posix.socket_t,
	3918	addr: *const posix.sockaddr,
	3919	addr_len: posix.socklen_t,
	3920	) !void {
	3921	try current_thread.beginSyscall();
3392	3922	while (true) {
3393		try t.checkCancel();
3394	3923	switch (posix.errno(posix.system.bind(socket_fd, addr, addr_len))) {
3395		.SUCCESS => break,
3396		.INTR => continue,
3397		.CANCELED => return error.Canceled,
3398
3399		.ADDRINUSE => return error.AddressInUse,
3400		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
3401		.INVAL => \|err\| return errnoBug(err), // invalid parameters
3402		.NOTSOCK => \|err\| return errnoBug(err), // invalid `sockfd`
3403		.AFNOSUPPORT => return error.AddressFamilyUnsupported,
3404		.ADDRNOTAVAIL => return error.AddressUnavailable,
3405		.FAULT => \|err\| return errnoBug(err), // invalid `addr` pointer
3406		.NOMEM => return error.SystemResources,
3407		else => \|err\| return posix.unexpectedErrno(err),
	3924	.SUCCESS => {
	3925	current_thread.endSyscall();
	3926	break;
	3927	},
	3928	.INTR => {
	3929	try current_thread.checkCancel();
	3930	continue;
	3931	},
	3932	else => \|e\| {
	3933	current_thread.endSyscall();
	3934	switch (e) {
	3935	.CANCELED => return error.Canceled,
	3936	.ADDRINUSE => return error.AddressInUse,
	3937	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	3938	.INVAL => \|err\| return errnoBug(err), // invalid parameters
	3939	.NOTSOCK => \|err\| return errnoBug(err), // invalid `sockfd`
	3940	.AFNOSUPPORT => return error.AddressFamilyUnsupported,
	3941	.ADDRNOTAVAIL => return error.AddressUnavailable,
	3942	.FAULT => \|err\| return errnoBug(err), // invalid `addr` pointer
	3943	.NOMEM => return error.SystemResources,
	3944	else => \|err\| return posix.unexpectedErrno(err),
	3945	}
	3946	},
3408	3947	}
3409	3948	}
3410	3949	}
3411	3950
3412		fn posixConnect(t: Threaded, socket_fd: posix.socket_t, addr: const posix.sockaddr, addr_len: posix.socklen_t) !void {
	3951	fn posixConnect(
	3952	current_thread: *Thread,
	3953	socket_fd: posix.socket_t,
	3954	addr: *const posix.sockaddr,
	3955	addr_len: posix.socklen_t,
	3956	) !void {
	3957	try current_thread.beginSyscall();
3413	3958	while (true) {
3414		try t.checkCancel();
3415	3959	switch (posix.errno(posix.system.connect(socket_fd, addr, addr_len))) {
3416		.SUCCESS => return,
3417		.INTR => continue,
3418		.CANCELED => return error.Canceled,
3419
3420		.ADDRNOTAVAIL => return error.AddressUnavailable,
3421		.AFNOSUPPORT => return error.AddressFamilyUnsupported,
3422		.AGAIN, .INPROGRESS => return error.WouldBlock,
3423		.ALREADY => return error.ConnectionPending,
3424		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
3425		.CONNREFUSED => return error.ConnectionRefused,
3426		.CONNRESET => return error.ConnectionResetByPeer,
3427		.FAULT => \|err\| return errnoBug(err),
3428		.ISCONN => \|err\| return errnoBug(err),
3429		.HOSTUNREACH => return error.HostUnreachable,
3430		.NETUNREACH => return error.NetworkUnreachable,
3431		.NOTSOCK => \|err\| return errnoBug(err),
3432		.PROTOTYPE => \|err\| return errnoBug(err),
3433		.TIMEDOUT => return error.Timeout,
3434		.CONNABORTED => \|err\| return errnoBug(err),
3435		.ACCES => return error.AccessDenied,
3436		.PERM => \|err\| return errnoBug(err),
3437		.NOENT => \|err\| return errnoBug(err),
3438		.NETDOWN => return error.NetworkDown,
3439		else => \|err\| return posix.unexpectedErrno(err),
	3960	.SUCCESS => {
	3961	current_thread.endSyscall();
	3962	return;
	3963	},
	3964	.INTR => {
	3965	try current_thread.checkCancel();
	3966	continue;
	3967	},
	3968	else => \|e\| {
	3969	current_thread.endSyscall();
	3970	switch (e) {
	3971	.CANCELED => return error.Canceled,
	3972	.ADDRNOTAVAIL => return error.AddressUnavailable,
	3973	.AFNOSUPPORT => return error.AddressFamilyUnsupported,
	3974	.AGAIN, .INPROGRESS => return error.WouldBlock,
	3975	.ALREADY => return error.ConnectionPending,
	3976	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	3977	.CONNREFUSED => return error.ConnectionRefused,
	3978	.CONNRESET => return error.ConnectionResetByPeer,
	3979	.FAULT => \|err\| return errnoBug(err),
	3980	.ISCONN => \|err\| return errnoBug(err),
	3981	.HOSTUNREACH => return error.HostUnreachable,
	3982	.NETUNREACH => return error.NetworkUnreachable,
	3983	.NOTSOCK => \|err\| return errnoBug(err),
	3984	.PROTOTYPE => \|err\| return errnoBug(err),
	3985	.TIMEDOUT => return error.Timeout,
	3986	.CONNABORTED => \|err\| return errnoBug(err),
	3987	.ACCES => return error.AccessDenied,
	3988	.PERM => \|err\| return errnoBug(err),
	3989	.NOENT => \|err\| return errnoBug(err),
	3990	.NETDOWN => return error.NetworkDown,
	3991	else => \|err\| return posix.unexpectedErrno(err),
	3992	}
	3993	},
3440	3994	}
3441	3995	}
3442	3996	}
3443	3997
3444		fn posixConnectUnix(t: Threaded, fd: posix.socket_t, addr: const posix.sockaddr, addr_len: posix.socklen_t) !void {
	3998	fn posixConnectUnix(
	3999	current_thread: *Thread,
	4000	fd: posix.socket_t,
	4001	addr: *const posix.sockaddr,
	4002	addr_len: posix.socklen_t,
	4003	) !void {
	4004	try current_thread.beginSyscall();
3445	4005	while (true) {
3446		try t.checkCancel();
3447	4006	switch (posix.errno(posix.system.connect(fd, addr, addr_len))) {
3448		.SUCCESS => return,
3449		.INTR => continue,
3450		.CANCELED => return error.Canceled,
3451
3452		.AFNOSUPPORT => return error.AddressFamilyUnsupported,
3453		.AGAIN => return error.WouldBlock,
3454		.INPROGRESS => return error.WouldBlock,
3455		.ACCES => return error.AccessDenied,
3456
3457		.LOOP => return error.SymLinkLoop,
3458		.NOENT => return error.FileNotFound,
3459		.NOTDIR => return error.NotDir,
3460		.ROFS => return error.ReadOnlyFileSystem,
3461		.PERM => return error.PermissionDenied,
3462
3463		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
3464		.CONNABORTED => \|err\| return errnoBug(err),
3465		.FAULT => \|err\| return errnoBug(err),
3466		.ISCONN => \|err\| return errnoBug(err),
3467		.NOTSOCK => \|err\| return errnoBug(err),
3468		.PROTOTYPE => \|err\| return errnoBug(err),
3469		else => \|err\| return posix.unexpectedErrno(err),
	4007	.SUCCESS => {
	4008	current_thread.endSyscall();
	4009	return;
	4010	},
	4011	.INTR => {
	4012	try current_thread.checkCancel();
	4013	continue;
	4014	},
	4015	else => \|e\| {
	4016	current_thread.endSyscall();
	4017	switch (e) {
	4018	.CANCELED => return error.Canceled,
	4019	.AFNOSUPPORT => return error.AddressFamilyUnsupported,
	4020	.AGAIN => return error.WouldBlock,
	4021	.INPROGRESS => return error.WouldBlock,
	4022	.ACCES => return error.AccessDenied,
	4023
	4024	.LOOP => return error.SymLinkLoop,
	4025	.NOENT => return error.FileNotFound,
	4026	.NOTDIR => return error.NotDir,
	4027	.ROFS => return error.ReadOnlyFileSystem,
	4028	.PERM => return error.PermissionDenied,
	4029
	4030	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	4031	.CONNABORTED => \|err\| return errnoBug(err),
	4032	.FAULT => \|err\| return errnoBug(err),
	4033	.ISCONN => \|err\| return errnoBug(err),
	4034	.NOTSOCK => \|err\| return errnoBug(err),
	4035	.PROTOTYPE => \|err\| return errnoBug(err),
	4036	else => \|err\| return posix.unexpectedErrno(err),
	4037	}
	4038	},
3470	4039	}
3471	4040	}
3472	4041	}
3473	4042
3474		fn posixGetSockName(t: Threaded, socket_fd: posix.fd_t, addr: posix.sockaddr, addr_len: *posix.socklen_t) !void {
	4043	fn posixGetSockName(
	4044	current_thread: *Thread,
	4045	socket_fd: posix.fd_t,
	4046	addr: *posix.sockaddr,
	4047	addr_len: *posix.socklen_t,
	4048	) !void {
	4049	try current_thread.beginSyscall();
3475	4050	while (true) {
3476		try t.checkCancel();
3477	4051	switch (posix.errno(posix.system.getsockname(socket_fd, addr, addr_len))) {
3478		.SUCCESS => break,
3479		.INTR => continue,
3480		.CANCELED => return error.Canceled,
3481
3482		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
3483		.FAULT => \|err\| return errnoBug(err),
3484		.INVAL => \|err\| return errnoBug(err), // invalid parameters
3485		.NOTSOCK => \|err\| return errnoBug(err), // always a race condition
3486		.NOBUFS => return error.SystemResources,
3487		else => \|err\| return posix.unexpectedErrno(err),
	4052	.SUCCESS => {
	4053	current_thread.endSyscall();
	4054	break;
	4055	},
	4056	.INTR => {
	4057	try current_thread.checkCancel();
	4058	continue;
	4059	},
	4060	else => \|e\| {
	4061	current_thread.endSyscall();
	4062	switch (e) {
	4063	.CANCELED => return error.Canceled,
	4064	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	4065	.FAULT => \|err\| return errnoBug(err),
	4066	.INVAL => \|err\| return errnoBug(err), // invalid parameters
	4067	.NOTSOCK => \|err\| return errnoBug(err), // always a race condition
	4068	.NOBUFS => return error.SystemResources,
	4069	else => \|err\| return posix.unexpectedErrno(err),
	4070	}
	4071	},
3488	4072	}
3489	4073	}
3490	4074	}
3491	4075
3492		fn wsaGetSockName(t: Threaded, handle: ws2_32.SOCKET, addr: ws2_32.sockaddr, addr_len: *i32) !void {
	4076	fn wsaGetSockName(
	4077	t: *Threaded,
	4078	current_thread: *Thread,
	4079	handle: ws2_32.SOCKET,
	4080	addr: *ws2_32.sockaddr,
	4081	addr_len: *i32,
	4082	) !void {
	4083	try current_thread.beginSyscall();
3493	4084	while (true) {
3494		try t.checkCancel();
3495	4085	const rc = ws2_32.getsockname(handle, addr, addr_len);
3496		if (rc != ws2_32.SOCKET_ERROR) break;
	4086	if (rc != ws2_32.SOCKET_ERROR) {
	4087	current_thread.endSyscall();
	4088	return;
	4089	}
3497	4090	switch (ws2_32.WSAGetLastError()) {
3498		.EINTR => continue,
3499		.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4091	.EINTR => {
	4092	try current_thread.checkCancel();
	4093	continue;
	4094	},
3500	4095	.NOTINITIALISED => {
3501	4096	try initializeWsa(t);
	4097	try current_thread.checkCancel();
3502	4098	continue;
3503	4099	},
3504		.ENETDOWN => return error.NetworkDown,
3505		.EFAULT => \|err\| return wsaErrorBug(err),
3506		.ENOTSOCK => \|err\| return wsaErrorBug(err),
3507		.EINVAL => \|err\| return wsaErrorBug(err),
3508		else => \|err\| return windows.unexpectedWSAError(err),
	4100	else => \|e\| {
	4101	current_thread.endSyscall();
	4102	switch (e) {
	4103	.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4104	.ENETDOWN => return error.NetworkDown,
	4105	.EFAULT => \|err\| return wsaErrorBug(err),
	4106	.ENOTSOCK => \|err\| return wsaErrorBug(err),
	4107	.EINVAL => \|err\| return wsaErrorBug(err),
	4108	else => \|err\| return windows.unexpectedWSAError(err),
	4109	}
	4110	},
3509	4111	}
3510	4112	}
3511	4113	}
3512	4114
3513		fn setSocketOption(t: *Threaded, fd: posix.fd_t, level: i32, opt_name: u32, option: u32) !void {
	4115	fn setSocketOption(current_thread: *Thread, fd: posix.fd_t, level: i32, opt_name: u32, option: u32) !void {
3514	4116	const o: []const u8 = @ptrCast(&option);
	4117	try current_thread.beginSyscall();
3515	4118	while (true) {
3516		try t.checkCancel();
3517	4119	switch (posix.errno(posix.system.setsockopt(fd, level, opt_name, o.ptr, @intCast(o.len)))) {
3518		.SUCCESS => return,
3519		.INTR => continue,
3520		.CANCELED => return error.Canceled,
3521
3522		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
3523		.NOTSOCK => \|err\| return errnoBug(err),
3524		.INVAL => \|err\| return errnoBug(err),
3525		.FAULT => \|err\| return errnoBug(err),
3526		else => \|err\| return posix.unexpectedErrno(err),
	4120	.SUCCESS => {
	4121	current_thread.endSyscall();
	4122	return;
	4123	},
	4124	.INTR => {
	4125	try current_thread.checkCancel();
	4126	continue;
	4127	},
	4128	else => \|e\| {
	4129	current_thread.endSyscall();
	4130	switch (e) {
	4131	.CANCELED => return error.Canceled,
	4132	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	4133	.NOTSOCK => \|err\| return errnoBug(err),
	4134	.INVAL => \|err\| return errnoBug(err),
	4135	.FAULT => \|err\| return errnoBug(err),
	4136	else => \|err\| return posix.unexpectedErrno(err),
	4137	}
	4138	},
3527	4139	}
3528	4140	}
3529	4141	}
...	...	@@ -3557,16 +4169,17 @@ fn netConnectIpPosix(
3557	4169	if (!have_networking) return error.NetworkDown;
3558	4170	if (options.timeout != .none) @panic("TODO implement netConnectIpPosix with timeout");
3559	4171	const t: *Threaded = @ptrCast(@alignCast(userdata));
	4172	const current_thread = Thread.getCurrent(t);
3560	4173	const family = posixAddressFamily(address);
3561		const socket_fd = try openSocketPosix(t, family, .{
	4174	const socket_fd = try openSocketPosix(current_thread, family, .{
3562	4175	.mode = options.mode,
3563	4176	.protocol = options.protocol,
3564	4177	});
3565	4178	errdefer posix.close(socket_fd);
3566	4179	var storage: PosixAddress = undefined;
3567	4180	var addr_len = addressToPosix(address, &storage);
3568		try posixConnect(t, socket_fd, &storage.any, addr_len);
3569		try posixGetSockName(t, socket_fd, &storage.any, &addr_len);
	4181	try posixConnect(current_thread, socket_fd, &storage.any, addr_len);
	4182	try posixGetSockName(current_thread, socket_fd, &storage.any, &addr_len);
3570	4183	return .{ .socket = .{
3571	4184	.handle = socket_fd,
3572	4185	.address = addressFromPosix(&storage),
...	...	@@ -3581,8 +4194,9 @@ fn netConnectIpWindows(
3581	4194	if (!have_networking) return error.NetworkDown;
3582	4195	if (options.timeout != .none) @panic("TODO implement netConnectIpWindows with timeout");
3583	4196	const t: *Threaded = @ptrCast(@alignCast(userdata));
	4197	const current_thread = Thread.getCurrent(t);
3584	4198	const family = posixAddressFamily(address);
3585		const socket_handle = try openSocketWsa(t, family, .{
	4199	const socket_handle = try openSocketWsa(t, current_thread, family, .{
3586	4200	.mode = options.mode,
3587	4201	.protocol = options.protocol,
3588	4202	});
...	...	@@ -3591,36 +4205,48 @@ fn netConnectIpWindows(
3591	4205	var storage: WsaAddress = undefined;
3592	4206	var addr_len = addressToWsa(address, &storage);
3593	4207
	4208	try current_thread.beginSyscall();
3594	4209	while (true) {
3595	4210	const rc = ws2_32.connect(socket_handle, &storage.any, addr_len);
3596		if (rc != ws2_32.SOCKET_ERROR) break;
	4211	if (rc != ws2_32.SOCKET_ERROR) {
	4212	current_thread.endSyscall();
	4213	break;
	4214	}
3597	4215	switch (ws2_32.WSAGetLastError()) {
3598		.EINTR => continue,
3599		.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4216	.EINTR => {
	4217	try current_thread.checkCancel();
	4218	continue;
	4219	},
3600	4220	.NOTINITIALISED => {
3601	4221	try initializeWsa(t);
	4222	try current_thread.checkCancel();
3602	4223	continue;
3603	4224	},
3604
3605		.EADDRNOTAVAIL => return error.AddressUnavailable,
3606		.ECONNREFUSED => return error.ConnectionRefused,
3607		.ECONNRESET => return error.ConnectionResetByPeer,
3608		.ETIMEDOUT => return error.Timeout,
3609		.EHOSTUNREACH => return error.HostUnreachable,
3610		.ENETUNREACH => return error.NetworkUnreachable,
3611		.EFAULT => \|err\| return wsaErrorBug(err),
3612		.EINVAL => \|err\| return wsaErrorBug(err),
3613		.EISCONN => \|err\| return wsaErrorBug(err),
3614		.ENOTSOCK => \|err\| return wsaErrorBug(err),
3615		.EWOULDBLOCK => return error.WouldBlock,
3616		.EACCES => return error.AccessDenied,
3617		.ENOBUFS => return error.SystemResources,
3618		.EAFNOSUPPORT => return error.AddressFamilyUnsupported,
3619		else => \|err\| return windows.unexpectedWSAError(err),
	4225	else => \|e\| {
	4226	current_thread.endSyscall();
	4227	switch (e) {
	4228	.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4229	.EADDRNOTAVAIL => return error.AddressUnavailable,
	4230	.ECONNREFUSED => return error.ConnectionRefused,
	4231	.ECONNRESET => return error.ConnectionResetByPeer,
	4232	.ETIMEDOUT => return error.Timeout,
	4233	.EHOSTUNREACH => return error.HostUnreachable,
	4234	.ENETUNREACH => return error.NetworkUnreachable,
	4235	.EFAULT => \|err\| return wsaErrorBug(err),
	4236	.EINVAL => \|err\| return wsaErrorBug(err),
	4237	.EISCONN => \|err\| return wsaErrorBug(err),
	4238	.ENOTSOCK => \|err\| return wsaErrorBug(err),
	4239	.EWOULDBLOCK => return error.WouldBlock,
	4240	.EACCES => return error.AccessDenied,
	4241	.ENOBUFS => return error.SystemResources,
	4242	.EAFNOSUPPORT => return error.AddressFamilyUnsupported,
	4243	else => \|err\| return windows.unexpectedWSAError(err),
	4244	}
	4245	},
3620	4246	}
3621	4247	}
3622	4248
3623		try wsaGetSockName(t, socket_handle, &storage.any, &addr_len);
	4249	try wsaGetSockName(t, current_thread, socket_handle, &storage.any, &addr_len);
3624	4250
3625	4251	return .{ .socket = .{
3626	4252	.handle = socket_handle,
...	...	@@ -3645,14 +4271,15 @@ fn netConnectUnixPosix(
3645	4271	) net.UnixAddress.ConnectError!net.Socket.Handle {
3646	4272	if (!net.has_unix_sockets) return error.AddressFamilyUnsupported;
3647	4273	const t: *Threaded = @ptrCast(@alignCast(userdata));
3648		const socket_fd = openSocketPosix(t, posix.AF.UNIX, .{ .mode = .stream }) catch \|err\| switch (err) {
	4274	const current_thread = Thread.getCurrent(t);
	4275	const socket_fd = openSocketPosix(current_thread, posix.AF.UNIX, .{ .mode = .stream }) catch \|err\| switch (err) {
3649	4276	error.OptionUnsupported => return error.Unexpected,
3650	4277	else => \|e\| return e,
3651	4278	};
3652	4279	errdefer posix.close(socket_fd);
3653	4280	var storage: UnixAddress = undefined;
3654	4281	const addr_len = addressUnixToPosix(address, &storage);
3655		try posixConnectUnix(t, socket_fd, &storage.any, addr_len);
	4282	try posixConnectUnix(current_thread, socket_fd, &storage.any, addr_len);
3656	4283	return socket_fd;
3657	4284	}
3658	4285
...	...	@@ -3662,8 +4289,9 @@ fn netConnectUnixWindows(
3662	4289	) net.UnixAddress.ConnectError!net.Socket.Handle {
3663	4290	if (!net.has_unix_sockets) return error.AddressFamilyUnsupported;
3664	4291	const t: *Threaded = @ptrCast(@alignCast(userdata));
	4292	const current_thread = Thread.getCurrent(t);
3665	4293
3666		const socket_handle = try openSocketWsa(t, posix.AF.UNIX, .{ .mode = .stream });
	4294	const socket_handle = try openSocketWsa(t, current_thread, posix.AF.UNIX, .{ .mode = .stream });
3667	4295	errdefer closeSocketWindows(socket_handle);
3668	4296	var storage: WsaAddress = undefined;
3669	4297	const addr_len = addressUnixToWsa(address, &storage);
...	...	@@ -3711,13 +4339,14 @@ fn netBindIpPosix(
3711	4339	) IpAddress.BindError!net.Socket {
3712	4340	if (!have_networking) return error.NetworkDown;
3713	4341	const t: *Threaded = @ptrCast(@alignCast(userdata));
	4342	const current_thread = Thread.getCurrent(t);
3714	4343	const family = posixAddressFamily(address);
3715		const socket_fd = try openSocketPosix(t, family, options);
	4344	const socket_fd = try openSocketPosix(current_thread, family, options);
3716	4345	errdefer posix.close(socket_fd);
3717	4346	var storage: PosixAddress = undefined;
3718	4347	var addr_len = addressToPosix(address, &storage);
3719		try posixBind(t, socket_fd, &storage.any, addr_len);
3720		try posixGetSockName(t, socket_fd, &storage.any, &addr_len);
	4348	try posixBind(current_thread, socket_fd, &storage.any, addr_len);
	4349	try posixGetSockName(current_thread, socket_fd, &storage.any, &addr_len);
3721	4350	return .{
3722	4351	.handle = socket_fd,
3723	4352	.address = addressFromPosix(&storage),
...	...	@@ -3731,8 +4360,9 @@ fn netBindIpWindows(
3731	4360	) IpAddress.BindError!net.Socket {
3732	4361	if (!have_networking) return error.NetworkDown;
3733	4362	const t: *Threaded = @ptrCast(@alignCast(userdata));
	4363	const current_thread = Thread.getCurrent(t);
3734	4364	const family = posixAddressFamily(address);
3735		const socket_handle = try openSocketWsa(t, family, .{
	4365	const socket_handle = try openSocketWsa(t, current_thread, family, .{
3736	4366	.mode = options.mode,
3737	4367	.protocol = options.protocol,
3738	4368	});
...	...	@@ -3741,29 +4371,41 @@ fn netBindIpWindows(
3741	4371	var storage: WsaAddress = undefined;
3742	4372	var addr_len = addressToWsa(address, &storage);
3743	4373
	4374	try current_thread.beginSyscall();
3744	4375	while (true) {
3745		try t.checkCancel();
3746	4376	const rc = ws2_32.bind(socket_handle, &storage.any, addr_len);
3747		if (rc != ws2_32.SOCKET_ERROR) break;
	4377	if (rc != ws2_32.SOCKET_ERROR) {
	4378	current_thread.endSyscall();
	4379	break;
	4380	}
3748	4381	switch (ws2_32.WSAGetLastError()) {
3749		.EINTR => continue,
3750		.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4382	.EINTR => {
	4383	try current_thread.checkCancel();
	4384	continue;
	4385	},
3751	4386	.NOTINITIALISED => {
3752	4387	try initializeWsa(t);
	4388	try current_thread.checkCancel();
3753	4389	continue;
3754	4390	},
3755		.EADDRINUSE => return error.AddressInUse,
3756		.EADDRNOTAVAIL => return error.AddressUnavailable,
3757		.ENOTSOCK => \|err\| return wsaErrorBug(err),
3758		.EFAULT => \|err\| return wsaErrorBug(err),
3759		.EINVAL => \|err\| return wsaErrorBug(err),
3760		.ENOBUFS => return error.SystemResources,
3761		.ENETDOWN => return error.NetworkDown,
3762		else => \|err\| return windows.unexpectedWSAError(err),
	4391	else => \|e\| {
	4392	current_thread.endSyscall();
	4393	switch (e) {
	4394	.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4395	.EADDRINUSE => return error.AddressInUse,
	4396	.EADDRNOTAVAIL => return error.AddressUnavailable,
	4397	.ENOTSOCK => \|err\| return wsaErrorBug(err),
	4398	.EFAULT => \|err\| return wsaErrorBug(err),
	4399	.EINVAL => \|err\| return wsaErrorBug(err),
	4400	.ENOBUFS => return error.SystemResources,
	4401	.ENETDOWN => return error.NetworkDown,
	4402	else => \|err\| return windows.unexpectedWSAError(err),
	4403	}
	4404	},
3763	4405	}
3764	4406	}
3765	4407
3766		try wsaGetSockName(t, socket_handle, &storage.any, &addr_len);
	4408	try wsaGetSockName(t, current_thread, socket_handle, &storage.any, &addr_len);
3767	4409
3768	4410	return .{
3769	4411	.handle = socket_handle,
...	...	@@ -3783,7 +4425,7 @@ fn netBindIpUnavailable(
3783	4425	}
3784	4426
3785	4427	fn openSocketPosix(
3786		t: *Threaded,
	4428	current_thread: *Thread,
3787	4429	family: posix.sa_family_t,
3788	4430	options: IpAddress.BindOptions,
3789	4431	) error{
...	...	@@ -3800,8 +4442,8 @@ fn openSocketPosix(
3800	4442	}!posix.socket_t {
3801	4443	const mode = posixSocketMode(options.mode);
3802	4444	const protocol = posixProtocol(options.protocol);
	4445	try current_thread.beginSyscall();
3803	4446	const socket_fd = while (true) {
3804		try t.checkCancel();
3805	4447	const flags: u32 = mode \| if (socket_flags_unsupported) 0 else posix.SOCK.CLOEXEC;
3806	4448	const socket_rc = posix.system.socket(family, flags, protocol);
3807	4449	switch (posix.errno(socket_rc)) {
...	...	@@ -3809,60 +4451,90 @@ fn openSocketPosix(
3809	4451	const fd: posix.fd_t = @intCast(socket_rc);
3810	4452	errdefer posix.close(fd);
3811	4453	if (socket_flags_unsupported) while (true) {
3812		try t.checkCancel();
	4454	try current_thread.checkCancel();
3813	4455	switch (posix.errno(posix.system.fcntl(fd, posix.F.SETFD, @as(usize, posix.FD_CLOEXEC)))) {
3814	4456	.SUCCESS => break,
3815	4457	.INTR => continue,
3816		.CANCELED => return error.Canceled,
3817		else => \|err\| return posix.unexpectedErrno(err),
	4458	else => \|e\| {
	4459	current_thread.endSyscall();
	4460	switch (e) {
	4461	.CANCELED => return error.Canceled,
	4462	else => \|err\| return posix.unexpectedErrno(err),
	4463	}
	4464	},
3818	4465	}
3819	4466	};
	4467	current_thread.endSyscall();
3820	4468	break fd;
3821	4469	},
3822		.INTR => continue,
3823		.CANCELED => return error.Canceled,
3824
3825		.AFNOSUPPORT => return error.AddressFamilyUnsupported,
3826		.INVAL => return error.ProtocolUnsupportedBySystem,
3827		.MFILE => return error.ProcessFdQuotaExceeded,
3828		.NFILE => return error.SystemFdQuotaExceeded,
3829		.NOBUFS => return error.SystemResources,
3830		.NOMEM => return error.SystemResources,
3831		.PROTONOSUPPORT => return error.ProtocolUnsupportedByAddressFamily,
3832		.PROTOTYPE => return error.SocketModeUnsupported,
3833		else => \|err\| return posix.unexpectedErrno(err),
	4470	.INTR => {
	4471	try current_thread.checkCancel();
	4472	continue;
	4473	},
	4474	else => \|e\| {
	4475	current_thread.endSyscall();
	4476	switch (e) {
	4477	.CANCELED => return error.Canceled,
	4478	.AFNOSUPPORT => return error.AddressFamilyUnsupported,
	4479	.INVAL => return error.ProtocolUnsupportedBySystem,
	4480	.MFILE => return error.ProcessFdQuotaExceeded,
	4481	.NFILE => return error.SystemFdQuotaExceeded,
	4482	.NOBUFS => return error.SystemResources,
	4483	.NOMEM => return error.SystemResources,
	4484	.PROTONOSUPPORT => return error.ProtocolUnsupportedByAddressFamily,
	4485	.PROTOTYPE => return error.SocketModeUnsupported,
	4486	else => \|err\| return posix.unexpectedErrno(err),
	4487	}
	4488	},
3834	4489	}
3835	4490	};
3836	4491	errdefer posix.close(socket_fd);
3837	4492
3838	4493	if (options.ip6_only) {
3839	4494	if (posix.IPV6 == void) return error.OptionUnsupported;
3840		try setSocketOption(t, socket_fd, posix.IPPROTO.IPV6, posix.IPV6.V6ONLY, 0);
	4495	try setSocketOption(current_thread, socket_fd, posix.IPPROTO.IPV6, posix.IPV6.V6ONLY, 0);
3841	4496	}
3842	4497
3843	4498	return socket_fd;
3844	4499	}
3845	4500
3846		fn openSocketWsa(t: *Threaded, family: posix.sa_family_t, options: IpAddress.BindOptions) !ws2_32.SOCKET {
	4501	fn openSocketWsa(
	4502	t: *Threaded,
	4503	current_thread: *Thread,
	4504	family: posix.sa_family_t,
	4505	options: IpAddress.BindOptions,
	4506	) !ws2_32.SOCKET {
3847	4507	const mode = posixSocketMode(options.mode);
3848	4508	const protocol = posixProtocol(options.protocol);
3849	4509	const flags: u32 = ws2_32.WSA_FLAG_OVERLAPPED \| ws2_32.WSA_FLAG_NO_HANDLE_INHERIT;
	4510	try current_thread.beginSyscall();
3850	4511	while (true) {
3851		try t.checkCancel();
3852	4512	const rc = ws2_32.WSASocketW(family, @bitCast(mode), @bitCast(protocol), null, 0, flags);
3853		if (rc != ws2_32.INVALID_SOCKET) return rc;
	4513	if (rc != ws2_32.INVALID_SOCKET) {
	4514	current_thread.endSyscall();
	4515	return rc;
	4516	}
3854	4517	switch (ws2_32.WSAGetLastError()) {
3855		.EINTR => continue,
3856		.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4518	.EINTR => {
	4519	try current_thread.checkCancel();
	4520	continue;
	4521	},
3857	4522	.NOTINITIALISED => {
3858	4523	try initializeWsa(t);
	4524	try current_thread.checkCancel();
3859	4525	continue;
3860	4526	},
3861		.EAFNOSUPPORT => return error.AddressFamilyUnsupported,
3862		.EMFILE => return error.ProcessFdQuotaExceeded,
3863		.ENOBUFS => return error.SystemResources,
3864		.EPROTONOSUPPORT => return error.ProtocolUnsupportedByAddressFamily,
3865		else => \|err\| return windows.unexpectedWSAError(err),
	4527	else => \|e\| {
	4528	current_thread.endSyscall();
	4529	switch (e) {
	4530	.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4531	.EAFNOSUPPORT => return error.AddressFamilyUnsupported,
	4532	.EMFILE => return error.ProcessFdQuotaExceeded,
	4533	.ENOBUFS => return error.SystemResources,
	4534	.EPROTONOSUPPORT => return error.ProtocolUnsupportedByAddressFamily,
	4535	else => \|err\| return windows.unexpectedWSAError(err),
	4536	}
	4537	},
3866	4538	}
3867	4539	}
3868	4540	}
...	...	@@ -3870,10 +4542,11 @@ fn openSocketWsa(t: *Threaded, family: posix.sa_family_t, options: IpAddress.Bin
3870	4542	fn netAcceptPosix(userdata: ?*anyopaque, listen_fd: net.Socket.Handle) net.Server.AcceptError!net.Stream {
3871	4543	if (!have_networking) return error.NetworkDown;
3872	4544	const t: *Threaded = @ptrCast(@alignCast(userdata));
	4545	const current_thread = Thread.getCurrent(t);
3873	4546	var storage: PosixAddress = undefined;
3874	4547	var addr_len: posix.socklen_t = @sizeOf(PosixAddress);
	4548	try current_thread.beginSyscall();
3875	4549	const fd = while (true) {
3876		try t.checkCancel();
3877	4550	const rc = if (have_accept4)
3878	4551	posix.system.accept4(listen_fd, &storage.any, &addr_len, posix.SOCK.CLOEXEC)
3879	4552	else
...	...	@@ -3883,33 +4556,43 @@ fn netAcceptPosix(userdata: ?*anyopaque, listen_fd: net.Socket.Handle) net.Serve
3883	4556	const fd: posix.fd_t = @intCast(rc);
3884	4557	errdefer posix.close(fd);
3885	4558	if (!have_accept4) while (true) {
3886		try t.checkCancel();
	4559	try current_thread.checkCancel();
3887	4560	switch (posix.errno(posix.system.fcntl(fd, posix.F.SETFD, @as(usize, posix.FD_CLOEXEC)))) {
3888	4561	.SUCCESS => break,
3889	4562	.INTR => continue,
3890		.CANCELED => return error.Canceled,
3891		else => \|err\| return posix.unexpectedErrno(err),
	4563	else => \|err\| {
	4564	current_thread.endSyscall();
	4565	return posix.unexpectedErrno(err);
	4566	},
3892	4567	}
3893	4568	};
	4569	current_thread.endSyscall();
3894	4570	break fd;
3895	4571	},
3896		.INTR => continue,
3897		.CANCELED => return error.Canceled,
3898
3899		.AGAIN => \|err\| return errnoBug(err),
3900		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
3901		.CONNABORTED => return error.ConnectionAborted,
3902		.FAULT => \|err\| return errnoBug(err),
3903		.INVAL => return error.SocketNotListening,
3904		.NOTSOCK => \|err\| return errnoBug(err),
3905		.MFILE => return error.ProcessFdQuotaExceeded,
3906		.NFILE => return error.SystemFdQuotaExceeded,
3907		.NOBUFS => return error.SystemResources,
3908		.NOMEM => return error.SystemResources,
3909		.OPNOTSUPP => \|err\| return errnoBug(err),
3910		.PROTO => return error.ProtocolFailure,
3911		.PERM => return error.BlockedByFirewall,
3912		else => \|err\| return posix.unexpectedErrno(err),
	4572	.INTR => {
	4573	try current_thread.checkCancel();
	4574	continue;
	4575	},
	4576	else => \|e\| {
	4577	current_thread.endSyscall();
	4578	switch (e) {
	4579	.CANCELED => return error.Canceled,
	4580	.AGAIN => \|err\| return errnoBug(err),
	4581	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	4582	.CONNABORTED => return error.ConnectionAborted,
	4583	.FAULT => \|err\| return errnoBug(err),
	4584	.INVAL => return error.SocketNotListening,
	4585	.NOTSOCK => \|err\| return errnoBug(err),
	4586	.MFILE => return error.ProcessFdQuotaExceeded,
	4587	.NFILE => return error.SystemFdQuotaExceeded,
	4588	.NOBUFS => return error.SystemResources,
	4589	.NOMEM => return error.SystemResources,
	4590	.OPNOTSUPP => \|err\| return errnoBug(err),
	4591	.PROTO => return error.ProtocolFailure,
	4592	.PERM => return error.BlockedByFirewall,
	4593	else => \|err\| return posix.unexpectedErrno(err),
	4594	}
	4595	},
3913	4596	}
3914	4597	};
3915	4598	return .{ .socket = .{
...	...	@@ -3921,31 +4604,44 @@ fn netAcceptPosix(userdata: ?*anyopaque, listen_fd: net.Socket.Handle) net.Serve
3921	4604	fn netAcceptWindows(userdata: ?*anyopaque, listen_handle: net.Socket.Handle) net.Server.AcceptError!net.Stream {
3922	4605	if (!have_networking) return error.NetworkDown;
3923	4606	const t: *Threaded = @ptrCast(@alignCast(userdata));
	4607	const current_thread = Thread.getCurrent(t);
3924	4608	var storage: WsaAddress = undefined;
3925	4609	var addr_len: i32 = @sizeOf(WsaAddress);
	4610	try current_thread.beginSyscall();
3926	4611	while (true) {
3927		try t.checkCancel();
3928	4612	const rc = ws2_32.accept(listen_handle, &storage.any, &addr_len);
3929		if (rc != ws2_32.INVALID_SOCKET) return .{ .socket = .{
3930		.handle = rc,
3931		.address = addressFromWsa(&storage),
3932		} };
	4613	if (rc != ws2_32.INVALID_SOCKET) {
	4614	current_thread.endSyscall();
	4615	return .{ .socket = .{
	4616	.handle = rc,
	4617	.address = addressFromWsa(&storage),
	4618	} };
	4619	}
3933	4620	switch (ws2_32.WSAGetLastError()) {
3934		.EINTR => continue,
3935		.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4621	.EINTR => {
	4622	try current_thread.checkCancel();
	4623	continue;
	4624	},
3936	4625	.NOTINITIALISED => {
3937	4626	try initializeWsa(t);
	4627	try current_thread.checkCancel();
3938	4628	continue;
3939	4629	},
3940		.ECONNRESET => return error.ConnectionAborted,
3941		.EFAULT => \|err\| return wsaErrorBug(err),
3942		.ENOTSOCK => \|err\| return wsaErrorBug(err),
3943		.EINVAL => \|err\| return wsaErrorBug(err),
3944		.EMFILE => return error.ProcessFdQuotaExceeded,
3945		.ENETDOWN => return error.NetworkDown,
3946		.ENOBUFS => return error.SystemResources,
3947		.EOPNOTSUPP => \|err\| return wsaErrorBug(err),
3948		else => \|err\| return windows.unexpectedWSAError(err),
	4630	else => \|e\| {
	4631	current_thread.endSyscall();
	4632	switch (e) {
	4633	.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4634	.ECONNRESET => return error.ConnectionAborted,
	4635	.EFAULT => \|err\| return wsaErrorBug(err),
	4636	.ENOTSOCK => \|err\| return wsaErrorBug(err),
	4637	.EINVAL => \|err\| return wsaErrorBug(err),
	4638	.EMFILE => return error.ProcessFdQuotaExceeded,
	4639	.ENETDOWN => return error.NetworkDown,
	4640	.ENOBUFS => return error.SystemResources,
	4641	.EOPNOTSUPP => \|err\| return wsaErrorBug(err),
	4642	else => \|err\| return windows.unexpectedWSAError(err),
	4643	}
	4644	},
3949	4645	}
3950	4646	}
3951	4647	}
...	...	@@ -3959,6 +4655,7 @@ fn netAcceptUnavailable(userdata: ?*anyopaque, listen_handle: net.Socket.Handle)
3959	4655	fn netReadPosix(userdata: ?*anyopaque, fd: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize {
3960	4656	if (!have_networking) return error.NetworkDown;
3961	4657	const t: *Threaded = @ptrCast(@alignCast(userdata));
	4658	const current_thread = Thread.getCurrent(t);
3962	4659
3963	4660	var iovecs_buffer: [max_iovecs_len]posix.iovec = undefined;
3964	4661	var i: usize = 0;
...	...	@@ -3972,48 +4669,70 @@ fn netReadPosix(userdata: ?*anyopaque, fd: net.Socket.Handle, data: [][]u8) net.
3972	4669	const dest = iovecs_buffer[0..i];
3973	4670	assert(dest[0].len > 0);
3974	4671
3975		if (native_os == .wasi and !builtin.link_libc) while (true) {
3976		try t.checkCancel();
3977		var n: usize = undefined;
3978		switch (std.os.wasi.fd_read(fd, dest.ptr, dest.len, &n)) {
3979		.SUCCESS => return n,
3980		.INTR => continue,
3981		.CANCELED => return error.Canceled,
3982
3983		.INVAL => \|err\| return errnoBug(err),
3984		.FAULT => \|err\| return errnoBug(err),
3985		.AGAIN => \|err\| return errnoBug(err),
3986		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
3987		.NOBUFS => return error.SystemResources,
3988		.NOMEM => return error.SystemResources,
3989		.NOTCONN => return error.SocketUnconnected,
3990		.CONNRESET => return error.ConnectionResetByPeer,
3991		.TIMEDOUT => return error.Timeout,
3992		.NOTCAPABLE => return error.AccessDenied,
3993		else => \|err\| return posix.unexpectedErrno(err),
	4672	if (native_os == .wasi and !builtin.link_libc) {
	4673	try current_thread.beginSyscall();
	4674	while (true) {
	4675	var n: usize = undefined;
	4676	switch (std.os.wasi.fd_read(fd, dest.ptr, dest.len, &n)) {
	4677	.SUCCESS => {
	4678	current_thread.endSyscall();
	4679	return n;
	4680	},
	4681	.INTR => {
	4682	try current_thread.checkCancel();
	4683	continue;
	4684	},
	4685	else => \|e\| {
	4686	current_thread.endSyscall();
	4687	switch (e) {
	4688	.CANCELED => return error.Canceled,
	4689	.INVAL => \|err\| return errnoBug(err),
	4690	.FAULT => \|err\| return errnoBug(err),
	4691	.AGAIN => \|err\| return errnoBug(err),
	4692	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	4693	.NOBUFS => return error.SystemResources,
	4694	.NOMEM => return error.SystemResources,
	4695	.NOTCONN => return error.SocketUnconnected,
	4696	.CONNRESET => return error.ConnectionResetByPeer,
	4697	.TIMEDOUT => return error.Timeout,
	4698	.NOTCAPABLE => return error.AccessDenied,
	4699	else => \|err\| return posix.unexpectedErrno(err),
	4700	}
	4701	},
	4702	}
3994	4703	}
3995		};
	4704	}
3996	4705
	4706	try current_thread.beginSyscall();
3997	4707	while (true) {
3998		try t.checkCancel();
3999	4708	const rc = posix.system.readv(fd, dest.ptr, @intCast(dest.len));
4000	4709	switch (posix.errno(rc)) {
4001		.SUCCESS => return @intCast(rc),
4002		.INTR => continue,
4003		.CANCELED => return error.Canceled,
4004
4005		.INVAL => \|err\| return errnoBug(err),
4006		.FAULT => \|err\| return errnoBug(err),
4007		.AGAIN => \|err\| return errnoBug(err),
4008		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
4009		.NOBUFS => return error.SystemResources,
4010		.NOMEM => return error.SystemResources,
4011		.NOTCONN => return error.SocketUnconnected,
4012		.CONNRESET => return error.ConnectionResetByPeer,
4013		.TIMEDOUT => return error.Timeout,
4014		.PIPE => return error.SocketUnconnected,
4015		.NETDOWN => return error.NetworkDown,
4016		else => \|err\| return posix.unexpectedErrno(err),
	4710	.SUCCESS => {
	4711	current_thread.endSyscall();
	4712	return @intCast(rc);
	4713	},
	4714	.INTR => {
	4715	try current_thread.checkCancel();
	4716	continue;
	4717	},
	4718	else => \|e\| {
	4719	current_thread.endSyscall();
	4720	switch (e) {
	4721	.CANCELED => return error.Canceled,
	4722	.INVAL => \|err\| return errnoBug(err),
	4723	.FAULT => \|err\| return errnoBug(err),
	4724	.AGAIN => \|err\| return errnoBug(err),
	4725	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	4726	.NOBUFS => return error.SystemResources,
	4727	.NOMEM => return error.SystemResources,
	4728	.NOTCONN => return error.SocketUnconnected,
	4729	.CONNRESET => return error.ConnectionResetByPeer,
	4730	.TIMEDOUT => return error.Timeout,
	4731	.PIPE => return error.SocketUnconnected,
	4732	.NETDOWN => return error.NetworkDown,
	4733	else => \|err\| return posix.unexpectedErrno(err),
	4734	}
	4735	},
4017	4736	}
4018	4737	}
4019	4738	}
...	...	@@ -4021,6 +4740,7 @@ fn netReadPosix(userdata: ?*anyopaque, fd: net.Socket.Handle, data: [][]u8) net.
4021	4740	fn netReadWindows(userdata: ?*anyopaque, handle: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize {
4022	4741	if (!have_networking) return error.NetworkDown;
4023	4742	const t: *Threaded = @ptrCast(@alignCast(userdata));
	4743	const current_thread = Thread.getCurrent(t);
4024	4744
4025	4745	const bufs = b: {
4026	4746	var iovec_buffer: [max_iovecs_len]ws2_32.WSABUF = undefined;
...	...	@@ -4048,7 +4768,7 @@ fn netReadWindows(userdata: ?*anyopaque, handle: net.Socket.Handle, data: [][]u8
4048	4768	};
4049	4769
4050	4770	while (true) {
4051		try t.checkCancel();
	4771	try current_thread.checkCancel();
4052	4772
4053	4773	var flags: u32 = 0;
4054	4774	var overlapped: windows.OVERLAPPED = std.mem.zeroes(windows.OVERLAPPED);
...	...	@@ -4108,6 +4828,7 @@ fn netSendPosix(
4108	4828	) struct { ?net.Socket.SendError, usize } {
4109	4829	if (!have_networking) return .{ error.NetworkDown, 0 };
4110	4830	const t: *Threaded = @ptrCast(@alignCast(userdata));
	4831	const current_thread = Thread.getCurrent(t);
4111	4832
4112	4833	const posix_flags: u32 =
4113	4834	@as(u32, if (@hasDecl(posix.MSG, "CONFIRM") and flags.confirm) posix.MSG.CONFIRM else 0) \|
...	...	@@ -4120,10 +4841,10 @@ fn netSendPosix(
4120	4841	var i: usize = 0;
4121	4842	while (messages.len - i != 0) {
4122	4843	if (have_sendmmsg) {
4123		i += netSendMany(t, handle, messages[i..], posix_flags) catch \|err\| return .{ err, i };
	4844	i += netSendMany(current_thread, handle, messages[i..], posix_flags) catch \|err\| return .{ err, i };
4124	4845	continue;
4125	4846	}
4126		netSendOne(t, handle, &messages[i], posix_flags) catch \|err\| return .{ err, i };
	4847	netSendOne(t, current_thread, handle, &messages[i], posix_flags) catch \|err\| return .{ err, i };
4127	4848	i += 1;
4128	4849	}
4129	4850	return .{ null, i };
...	...	@@ -4159,6 +4880,7 @@ fn netSendUnavailable(
4159	4880
4160	4881	fn netSendOne(
4161	4882	t: *Threaded,
	4883	current_thread: *Thread,
4162	4884	handle: net.Socket.Handle,
4163	4885	message: *net.OutgoingMessage,
4164	4886	flags: u32,
...	...	@@ -4175,75 +4897,92 @@ fn netSendOne(
4175	4897	.controllen = @intCast(message.control.len),
4176	4898	.flags = 0,
4177	4899	};
	4900	try current_thread.beginSyscall();
4178	4901	while (true) {
4179		try t.checkCancel();
4180	4902	const rc = posix.system.sendmsg(handle, &msg, flags);
4181	4903	if (is_windows) {
4182		if (rc == ws2_32.SOCKET_ERROR) {
4183		switch (ws2_32.WSAGetLastError()) {
4184		.EINTR => continue,
4185		.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
4186		.NOTINITIALISED => {
4187		try initializeWsa(t);
4188		continue;
4189		},
4190		.EACCES => return error.AccessDenied,
4191		.EADDRNOTAVAIL => return error.AddressUnavailable,
4192		.ECONNRESET => return error.ConnectionResetByPeer,
4193		.EMSGSIZE => return error.MessageOversize,
4194		.ENOBUFS => return error.SystemResources,
4195		.ENOTSOCK => return error.FileDescriptorNotASocket,
4196		.EAFNOSUPPORT => return error.AddressFamilyUnsupported,
4197		.EDESTADDRREQ => unreachable, // A destination address is required.
4198		.EFAULT => unreachable, // The lpBuffers, lpTo, lpOverlapped, lpNumberOfBytesSent, or lpCompletionRoutine parameters are not part of the user address space, or the lpTo parameter is too small.
4199		.EHOSTUNREACH => return error.NetworkUnreachable,
4200		.EINVAL => unreachable,
4201		.ENETDOWN => return error.NetworkDown,
4202		.ENETRESET => return error.ConnectionResetByPeer,
4203		.ENETUNREACH => return error.NetworkUnreachable,
4204		.ENOTCONN => return error.SocketUnconnected,
4205		.ESHUTDOWN => \|err\| return wsaErrorBug(err),
4206		else => \|err\| return windows.unexpectedWSAError(err),
4207		}
4208		} else {
	4904	if (rc != ws2_32.SOCKET_ERROR) {
	4905	current_thread.endSyscall();
4209	4906	message.data_len = @intCast(rc);
4210	4907	return;
4211	4908	}
	4909	switch (ws2_32.WSAGetLastError()) {
	4910	.EINTR => {
	4911	try current_thread.checkCancel();
	4912	continue;
	4913	},
	4914	.NOTINITIALISED => {
	4915	try initializeWsa(t);
	4916	try current_thread.checkCancel();
	4917	continue;
	4918	},
	4919	else => \|e\| {
	4920	current_thread.endSyscall();
	4921	switch (e) {
	4922	.ECANCELLED, .E_CANCELLED, .OPERATION_ABORTED => return error.Canceled,
	4923	.EACCES => return error.AccessDenied,
	4924	.EADDRNOTAVAIL => return error.AddressUnavailable,
	4925	.ECONNRESET => return error.ConnectionResetByPeer,
	4926	.EMSGSIZE => return error.MessageOversize,
	4927	.ENOBUFS => return error.SystemResources,
	4928	.ENOTSOCK => return error.FileDescriptorNotASocket,
	4929	.EAFNOSUPPORT => return error.AddressFamilyUnsupported,
	4930	.EDESTADDRREQ => unreachable, // A destination address is required.
	4931	.EFAULT => unreachable, // The lpBuffers, lpTo, lpOverlapped, lpNumberOfBytesSent, or lpCompletionRoutine parameters are not part of the user address space, or the lpTo parameter is too small.
	4932	.EHOSTUNREACH => return error.NetworkUnreachable,
	4933	.EINVAL => unreachable,
	4934	.ENETDOWN => return error.NetworkDown,
	4935	.ENETRESET => return error.ConnectionResetByPeer,
	4936	.ENETUNREACH => return error.NetworkUnreachable,
	4937	.ENOTCONN => return error.SocketUnconnected,
	4938	.ESHUTDOWN => \|err\| return wsaErrorBug(err),
	4939	else => \|err\| return windows.unexpectedWSAError(err),
	4940	}
	4941	},
	4942	}
4212	4943	}
4213	4944	switch (posix.errno(rc)) {
4214	4945	.SUCCESS => {
	4946	current_thread.endSyscall();
4215	4947	message.data_len = @intCast(rc);
4216	4948	return;
4217	4949	},
4218		.INTR => continue,
4219		.CANCELED => return error.Canceled,
4220
4221		.ACCES => return error.AccessDenied,
4222		.ALREADY => return error.FastOpenAlreadyInProgress,
4223		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
4224		.CONNRESET => return error.ConnectionResetByPeer,
4225		.DESTADDRREQ => \|err\| return errnoBug(err),
4226		.FAULT => \|err\| return errnoBug(err),
4227		.INVAL => \|err\| return errnoBug(err),
4228		.ISCONN => \|err\| return errnoBug(err),
4229		.MSGSIZE => return error.MessageOversize,
4230		.NOBUFS => return error.SystemResources,
4231		.NOMEM => return error.SystemResources,
4232		.NOTSOCK => \|err\| return errnoBug(err),
4233		.OPNOTSUPP => \|err\| return errnoBug(err),
4234		.PIPE => return error.SocketUnconnected,
4235		.AFNOSUPPORT => return error.AddressFamilyUnsupported,
4236		.HOSTUNREACH => return error.HostUnreachable,
4237		.NETUNREACH => return error.NetworkUnreachable,
4238		.NOTCONN => return error.SocketUnconnected,
4239		.NETDOWN => return error.NetworkDown,
4240		else => \|err\| return posix.unexpectedErrno(err),
	4950	.INTR => {
	4951	try current_thread.checkCancel();
	4952	continue;
	4953	},
	4954	else => \|e\| {
	4955	current_thread.endSyscall();
	4956	switch (e) {
	4957	.CANCELED => return error.Canceled,
	4958	.ACCES => return error.AccessDenied,
	4959	.ALREADY => return error.FastOpenAlreadyInProgress,
	4960	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	4961	.CONNRESET => return error.ConnectionResetByPeer,
	4962	.DESTADDRREQ => \|err\| return errnoBug(err),
	4963	.FAULT => \|err\| return errnoBug(err),
	4964	.INVAL => \|err\| return errnoBug(err),
	4965	.ISCONN => \|err\| return errnoBug(err),
	4966	.MSGSIZE => return error.MessageOversize,
	4967	.NOBUFS => return error.SystemResources,
	4968	.NOMEM => return error.SystemResources,
	4969	.NOTSOCK => \|err\| return errnoBug(err),
	4970	.OPNOTSUPP => \|err\| return errnoBug(err),
	4971	.PIPE => return error.SocketUnconnected,
	4972	.AFNOSUPPORT => return error.AddressFamilyUnsupported,
	4973	.HOSTUNREACH => return error.HostUnreachable,
	4974	.NETUNREACH => return error.NetworkUnreachable,
	4975	.NOTCONN => return error.SocketUnconnected,
	4976	.NETDOWN => return error.NetworkDown,
	4977	else => \|err\| return posix.unexpectedErrno(err),
	4978	}
	4979	},
4241	4980	}
4242	4981	}
4243	4982	}
4244	4983
4245	4984	fn netSendMany(
4246		t: *Threaded,
	4985	current_thread: *Thread,
4247	4986	handle: net.Socket.Handle,
4248	4987	messages: []net.OutgoingMessage,
4249	4988	flags: u32,
...	...	@@ -4273,40 +5012,48 @@ fn netSendMany(
4273	5012	};
4274	5013	}
4275	5014
	5015	try current_thread.beginSyscall();
4276	5016	while (true) {
4277		try t.checkCancel();
4278	5017	const rc = posix.system.sendmmsg(handle, clamped_msgs.ptr, @intCast(clamped_msgs.len), flags);
4279	5018	switch (posix.errno(rc)) {
4280	5019	.SUCCESS => {
	5020	current_thread.endSyscall();
4281	5021	const n: usize = @intCast(rc);
4282	5022	for (clamped_messages[0..n], clamped_msgs[0..n]) \|message, msg\| {
4283	5023	message.data_len = msg.len;
4284	5024	}
4285	5025	return n;
4286	5026	},
4287		.INTR => continue,
4288		.CANCELED => return error.Canceled,
4289
4290		.AGAIN => \|err\| return errnoBug(err),
4291		.ALREADY => return error.FastOpenAlreadyInProgress,
4292		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
4293		.CONNRESET => return error.ConnectionResetByPeer,
4294		.DESTADDRREQ => \|err\| return errnoBug(err), // The socket is not connection-mode, and no peer address is set.
4295		.FAULT => \|err\| return errnoBug(err), // An invalid user space address was specified for an argument.
4296		.INVAL => \|err\| return errnoBug(err), // Invalid argument passed.
4297		.ISCONN => \|err\| return errnoBug(err), // connection-mode socket was connected already but a recipient was specified
4298		.MSGSIZE => return error.MessageOversize,
4299		.NOBUFS => return error.SystemResources,
4300		.NOMEM => return error.SystemResources,
4301		.NOTSOCK => \|err\| return errnoBug(err), // The file descriptor sockfd does not refer to a socket.
4302		.OPNOTSUPP => \|err\| return errnoBug(err), // Some bit in the flags argument is inappropriate for the socket type.
4303		.PIPE => return error.SocketUnconnected,
4304		.AFNOSUPPORT => return error.AddressFamilyUnsupported,
4305		.HOSTUNREACH => return error.HostUnreachable,
4306		.NETUNREACH => return error.NetworkUnreachable,
4307		.NOTCONN => return error.SocketUnconnected,
4308		.NETDOWN => return error.NetworkDown,
4309		else => \|err\| return posix.unexpectedErrno(err),
	5027	.INTR => {
	5028	try current_thread.checkCancel();
	5029	continue;
	5030	},
	5031	else => \|e\| {
	5032	current_thread.endSyscall();
	5033	switch (e) {
	5034	.CANCELED => return error.Canceled,
	5035	.AGAIN => \|err\| return errnoBug(err),
	5036	.ALREADY => return error.FastOpenAlreadyInProgress,
	5037	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	5038	.CONNRESET => return error.ConnectionResetByPeer,
	5039	.DESTADDRREQ => \|err\| return errnoBug(err), // The socket is not connection-mode, and no peer address is set.
	5040	.FAULT => \|err\| return errnoBug(err), // An invalid user space address was specified for an argument.
	5041	.INVAL => \|err\| return errnoBug(err), // Invalid argument passed.
	5042	.ISCONN => \|err\| return errnoBug(err), // connection-mode socket was connected already but a recipient was specified
	5043	.MSGSIZE => return error.MessageOversize,
	5044	.NOBUFS => return error.SystemResources,
	5045	.NOMEM => return error.SystemResources,
	5046	.NOTSOCK => \|err\| return errnoBug(err), // The file descriptor sockfd does not refer to a socket.
	5047	.OPNOTSUPP => \|err\| return errnoBug(err), // Some bit in the flags argument is inappropriate for the socket type.
	5048	.PIPE => return error.SocketUnconnected,
	5049	.AFNOSUPPORT => return error.AddressFamilyUnsupported,
	5050	.HOSTUNREACH => return error.HostUnreachable,
	5051	.NETUNREACH => return error.NetworkUnreachable,
	5052	.NOTCONN => return error.SocketUnconnected,
	5053	.NETDOWN => return error.NetworkDown,
	5054	else => \|err\| return posix.unexpectedErrno(err),
	5055	}
	5056	},
4310	5057	}
4311	5058	}
4312	5059	}
...	...	@@ -4321,6 +5068,7 @@ fn netReceivePosix(
4321	5068	) struct { ?net.Socket.ReceiveTimeoutError, usize } {
4322	5069	if (!have_networking) return .{ error.NetworkDown, 0 };
4323	5070	const t: *Threaded = @ptrCast(@alignCast(userdata));
	5071	const current_thread = Thread.getCurrent(t);
4324	5072	const t_io = io(t);
4325	5073
4326	5074	// recvmmsg is useless, here's why:
...	...	@@ -4351,8 +5099,6 @@ fn netReceivePosix(
4351	5099	const deadline = timeout.toDeadline(t_io) catch \|err\| return .{ err, message_i };
4352	5100
4353	5101	recv: while (true) {
4354		t.checkCancel() catch \|err\| return .{ err, message_i };
4355
4356	5102	if (message_buffer.len - message_i == 0) return .{ null, message_i };
4357	5103	const message = &message_buffer[message_i];
4358	5104	const remaining_data_buffer = data_buffer[data_i..];
...	...	@@ -4368,7 +5114,9 @@ fn netReceivePosix(
4368	5114	.flags = undefined,
4369	5115	};
4370	5116
	5117	current_thread.beginSyscall() catch \|err\| return .{ err, message_i };
4371	5118	const recv_rc = posix.system.recvmsg(handle, &msg, posix_flags);
	5119	current_thread.endSyscall();
4372	5120	switch (posix.errno(recv_rc)) {
4373	5121	.SUCCESS => {
4374	5122	const data = remaining_data_buffer[0..@intCast(recv_rc)];
...	...	@@ -4389,7 +5137,6 @@ fn netReceivePosix(
4389	5137	continue;
4390	5138	},
4391	5139	.AGAIN => while (true) {
4392		t.checkCancel() catch \|err\| return .{ err, message_i };
4393	5140	if (message_i != 0) return .{ null, message_i };
4394	5141
4395	5142	const max_poll_ms = std.math.maxInt(u31);
...	...	@@ -4399,7 +5146,10 @@ fn netReceivePosix(
4399	5146	break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
4400	5147	} else max_poll_ms;
4401	5148
	5149	current_thread.beginSyscall() catch \|err\| return .{ err, message_i };
4402	5150	const poll_rc = posix.system.poll(&poll_fds, poll_fds.len, timeout_ms);
	5151	current_thread.endSyscall();
	5152
4403	5153	switch (posix.errno(poll_rc)) {
4404	5154	.SUCCESS => {
4405	5155	if (poll_rc == 0) {
...	...	@@ -4486,6 +5236,7 @@ fn netWritePosix(
4486	5236	) net.Stream.Writer.Error!usize {
4487	5237	if (!have_networking) return error.NetworkDown;
4488	5238	const t: *Threaded = @ptrCast(@alignCast(userdata));
	5239	const current_thread = Thread.getCurrent(t);
4489	5240
4490	5241	var iovecs: [max_iovecs_len]posix.iovec_const = undefined;
4491	5242	var msg: posix.msghdr_const = .{
...	...	@@ -4526,35 +5277,45 @@ fn netWritePosix(
4526	5277	},
4527	5278	};
4528	5279	const flags = posix.MSG.NOSIGNAL;
	5280	try current_thread.beginSyscall();
4529	5281	while (true) {
4530		try t.checkCancel();
4531	5282	const rc = posix.system.sendmsg(fd, &msg, flags);
4532	5283	switch (posix.errno(rc)) {
4533		.SUCCESS => return @intCast(rc),
4534		.INTR => continue,
4535		.CANCELED => return error.Canceled,
4536
4537		.ACCES => \|err\| return errnoBug(err),
4538		.AGAIN => \|err\| return errnoBug(err),
4539		.ALREADY => return error.FastOpenAlreadyInProgress,
4540		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
4541		.CONNRESET => return error.ConnectionResetByPeer,
4542		.DESTADDRREQ => \|err\| return errnoBug(err), // The socket is not connection-mode, and no peer address is set.
4543		.FAULT => \|err\| return errnoBug(err), // An invalid user space address was specified for an argument.
4544		.INVAL => \|err\| return errnoBug(err), // Invalid argument passed.
4545		.ISCONN => \|err\| return errnoBug(err), // connection-mode socket was connected already but a recipient was specified
4546		.MSGSIZE => \|err\| return errnoBug(err),
4547		.NOBUFS => return error.SystemResources,
4548		.NOMEM => return error.SystemResources,
4549		.NOTSOCK => \|err\| return errnoBug(err), // The file descriptor sockfd does not refer to a socket.
4550		.OPNOTSUPP => \|err\| return errnoBug(err), // Some bit in the flags argument is inappropriate for the socket type.
4551		.PIPE => return error.SocketUnconnected,
4552		.AFNOSUPPORT => return error.AddressFamilyUnsupported,
4553		.HOSTUNREACH => return error.HostUnreachable,
4554		.NETUNREACH => return error.NetworkUnreachable,
4555		.NOTCONN => return error.SocketUnconnected,
4556		.NETDOWN => return error.NetworkDown,
4557		else => \|err\| return posix.unexpectedErrno(err),
	5284	.SUCCESS => {
	5285	current_thread.endSyscall();
	5286	return @intCast(rc);
	5287	},
	5288	.INTR => {
	5289	try current_thread.checkCancel();
	5290	continue;
	5291	},
	5292	else => \|e\| {
	5293	current_thread.endSyscall();
	5294	switch (e) {
	5295	.CANCELED => return error.Canceled,
	5296	.ACCES => \|err\| return errnoBug(err),
	5297	.AGAIN => \|err\| return errnoBug(err),
	5298	.ALREADY => return error.FastOpenAlreadyInProgress,
	5299	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	5300	.CONNRESET => return error.ConnectionResetByPeer,
	5301	.DESTADDRREQ => \|err\| return errnoBug(err), // The socket is not connection-mode, and no peer address is set.
	5302	.FAULT => \|err\| return errnoBug(err), // An invalid user space address was specified for an argument.
	5303	.INVAL => \|err\| return errnoBug(err), // Invalid argument passed.
	5304	.ISCONN => \|err\| return errnoBug(err), // connection-mode socket was connected already but a recipient was specified
	5305	.MSGSIZE => \|err\| return errnoBug(err),
	5306	.NOBUFS => return error.SystemResources,
	5307	.NOMEM => return error.SystemResources,
	5308	.NOTSOCK => \|err\| return errnoBug(err), // The file descriptor sockfd does not refer to a socket.
	5309	.OPNOTSUPP => \|err\| return errnoBug(err), // Some bit in the flags argument is inappropriate for the socket type.
	5310	.PIPE => return error.SocketUnconnected,
	5311	.AFNOSUPPORT => return error.AddressFamilyUnsupported,
	5312	.HOSTUNREACH => return error.HostUnreachable,
	5313	.NETUNREACH => return error.NetworkUnreachable,
	5314	.NOTCONN => return error.SocketUnconnected,
	5315	.NETDOWN => return error.NetworkDown,
	5316	else => \|err\| return posix.unexpectedErrno(err),
	5317	}
	5318	},
4558	5319	}
4559	5320	}
4560	5321	}
...	...	@@ -4567,6 +5328,7 @@ fn netWriteWindows(
4567	5328	splat: usize,
4568	5329	) net.Stream.Writer.Error!usize {
4569	5330	const t: *Threaded = @ptrCast(@alignCast(userdata));
	5331	const current_thread = Thread.getCurrent(t);
4570	5332	comptime assert(native_os == .windows);
4571	5333
4572	5334	var iovecs: [max_iovecs_len]ws2_32.WSABUF = undefined;
...	...	@@ -4600,7 +5362,7 @@ fn netWriteWindows(
4600	5362	};
4601	5363
4602	5364	while (true) {
4603		try t.checkCancel();
	5365	try current_thread.checkCancel();
4604	5366
4605	5367	var n: u32 = undefined;
4606	5368	var overlapped: windows.OVERLAPPED = std.mem.zeroes(windows.OVERLAPPED);
...	...	@@ -4707,9 +5469,10 @@ fn netInterfaceNameResolve(
4707	5469	) net.Interface.Name.ResolveError!net.Interface {
4708	5470	if (!have_networking) return error.InterfaceNotFound;
4709	5471	const t: *Threaded = @ptrCast(@alignCast(userdata));
	5472	const current_thread = Thread.getCurrent(t);
4710	5473
4711	5474	if (native_os == .linux) {
4712		const sock_fd = openSocketPosix(t, posix.AF.UNIX, .{ .mode = .dgram }) catch \|err\| switch (err) {
	5475	const sock_fd = openSocketPosix(current_thread, posix.AF.UNIX, .{ .mode = .dgram }) catch \|err\| switch (err) {
4713	5476	error.ProcessFdQuotaExceeded => return error.SystemResources,
4714	5477	error.SystemFdQuotaExceeded => return error.SystemResources,
4715	5478	error.AddressFamilyUnsupported => return error.Unexpected,
...	...	@@ -4726,32 +5489,42 @@ fn netInterfaceNameResolve(
4726	5489	.ifru = undefined,
4727	5490	};
4728	5491
	5492	try current_thread.beginSyscall();
4729	5493	while (true) {
4730		try t.checkCancel();
4731	5494	switch (posix.errno(posix.system.ioctl(sock_fd, posix.SIOCGIFINDEX, @intFromPtr(&ifr)))) {
4732		.SUCCESS => return .{ .index = @bitCast(ifr.ifru.ivalue) },
4733		.INTR => continue,
4734		.CANCELED => return error.Canceled,
4735
4736		.INVAL => \|err\| return errnoBug(err), // Bad parameters.
4737		.NOTTY => \|err\| return errnoBug(err),
4738		.NXIO => \|err\| return errnoBug(err),
4739		.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
4740		.FAULT => \|err\| return errnoBug(err), // Bad pointer parameter.
4741		.IO => \|err\| return errnoBug(err), // sock_fd is not a file descriptor
4742		.NODEV => return error.InterfaceNotFound,
4743		else => \|err\| return posix.unexpectedErrno(err),
	5495	.SUCCESS => {
	5496	current_thread.endSyscall();
	5497	return .{ .index = @bitCast(ifr.ifru.ivalue) };
	5498	},
	5499	.INTR => {
	5500	try current_thread.checkCancel();
	5501	continue;
	5502	},
	5503	else => \|e\| {
	5504	current_thread.endSyscall();
	5505	switch (e) {
	5506	.CANCELED => return error.Canceled,
	5507	.INVAL => \|err\| return errnoBug(err), // Bad parameters.
	5508	.NOTTY => \|err\| return errnoBug(err),
	5509	.NXIO => \|err\| return errnoBug(err),
	5510	.BADF => \|err\| return errnoBug(err), // File descriptor used after closed.
	5511	.FAULT => \|err\| return errnoBug(err), // Bad pointer parameter.
	5512	.IO => \|err\| return errnoBug(err), // sock_fd is not a file descriptor
	5513	.NODEV => return error.InterfaceNotFound,
	5514	else => \|err\| return posix.unexpectedErrno(err),
	5515	}
	5516	},
4744	5517	}
4745	5518	}
4746	5519	}
4747	5520
4748	5521	if (native_os == .windows) {
4749		try t.checkCancel();
	5522	try current_thread.checkCancel();
4750	5523	@panic("TODO implement netInterfaceNameResolve for Windows");
4751	5524	}
4752	5525
4753	5526	if (builtin.link_libc) {
4754		try t.checkCancel();
	5527	try current_thread.checkCancel();
4755	5528	const index = std.c.if_nametoindex(&name.bytes);
4756	5529	if (index == 0) return error.InterfaceNotFound;
4757	5530	return .{ .index = @bitCast(index) };
...	...	@@ -4771,7 +5544,8 @@ fn netInterfaceNameResolveUnavailable(
4771	5544
4772	5545	fn netInterfaceName(userdata: ?*anyopaque, interface: net.Interface) net.Interface.NameError!net.Interface.Name {
4773	5546	const t: *Threaded = @ptrCast(@alignCast(userdata));
4774		try t.checkCancel();
	5547	const current_thread = Thread.getCurrent(t);
	5548	try current_thread.checkCancel();
4775	5549
4776	5550	if (native_os == .linux) {
4777	5551	_ = interface;
...	...	@@ -4802,8 +5576,9 @@ fn netLookup(
4802	5576	options: HostName.LookupOptions,
4803	5577	) void {
4804	5578	const t: *Threaded = @ptrCast(@alignCast(userdata));
	5579	const current_thread = Thread.getCurrent(t);
4805	5580	const t_io = io(t);
4806		resolved.putOneUncancelable(t_io, .{ .end = netLookupFallible(t, host_name, resolved, options) });
	5581	resolved.putOneUncancelable(t_io, .{ .end = netLookupFallible(t, current_thread, host_name, resolved, options) });
4807	5582	}
4808	5583
4809	5584	fn netLookupUnavailable(
...	...	@@ -4821,6 +5596,7 @@ fn netLookupUnavailable(
4821	5596
4822	5597	fn netLookupFallible(
4823	5598	t: *Threaded,
	5599	current_thread: *Thread,
4824	5600	host_name: HostName,
4825	5601	resolved: *Io.Queue(HostName.LookupResult),
4826	5602	options: HostName.LookupOptions,
...	...	@@ -4866,7 +5642,7 @@ fn netLookupFallible(
4866	5642	var res: *ws2_32.ADDRINFOEXW = undefined;
4867	5643	const timeout: ?*ws2_32.timeval = null;
4868	5644	while (true) {
4869		try t.checkCancel(); // TODO make requestCancel call GetAddrInfoExCancel
	5645	try current_thread.checkCancel(); // TODO make requestCancel call GetAddrInfoExCancel
4870	5646	// TODO make this append to the queue eagerly rather than blocking until
4871	5647	// the whole thing finishes
4872	5648	const rc: ws2_32.WinsockError = @enumFromInt(ws2_32.GetAddrInfoExW(name_w, port_w, .DNS, null, &hints, &res, timeout, null, null, cancel_handle));
...	...	@@ -5013,23 +5789,39 @@ fn netLookupFallible(
5013	5789	.next = null,
5014	5790	};
5015	5791	var res: ?*posix.addrinfo = null;
	5792	try current_thread.beginSyscall();
5016	5793	while (true) {
5017		try t.checkCancel();
5018	5794	switch (posix.system.getaddrinfo(name_c.ptr, port_c.ptr, &hints, &res)) {
5019		@as(posix.system.EAI, @enumFromInt(0)) => break,
5020		.ADDRFAMILY => return error.AddressFamilyUnsupported,
5021		.AGAIN => return error.NameServerFailure,
5022		.FAIL => return error.NameServerFailure,
5023		.FAMILY => return error.AddressFamilyUnsupported,
5024		.MEMORY => return error.SystemResources,
5025		.NODATA => return error.UnknownHostName,
5026		.NONAME => return error.UnknownHostName,
	5795	@as(posix.system.EAI, @enumFromInt(0)) => {
	5796	current_thread.endSyscall();
	5797	break;
	5798	},
5027	5799	.SYSTEM => switch (posix.errno(-1)) {
5028		.INTR => continue,
5029		.CANCELED => return error.Canceled,
5030		else => \|e\| return posix.unexpectedErrno(e),
	5800	.INTR => {
	5801	try current_thread.checkCancel();
	5802	continue;
	5803	},
	5804	else => \|e\| {
	5805	current_thread.endSyscall();
	5806	switch (e) {
	5807	.CANCELED => return error.Canceled,
	5808	else => \|inner\| return posix.unexpectedErrno(inner),
	5809	}
	5810	},
	5811	},
	5812	else => \|e\| {
	5813	current_thread.endSyscall();
	5814	switch (e) {
	5815	.ADDRFAMILY => return error.AddressFamilyUnsupported,
	5816	.AGAIN => return error.NameServerFailure,
	5817	.FAIL => return error.NameServerFailure,
	5818	.FAMILY => return error.AddressFamilyUnsupported,
	5819	.MEMORY => return error.SystemResources,
	5820	.NODATA => return error.UnknownHostName,
	5821	.NONAME => return error.UnknownHostName,
	5822	else => return error.Unexpected,
	5823	}
5031	5824	},
5032		else => return error.Unexpected,
5033	5825	}
5034	5826	}
5035	5827	defer if (res) \|some\| posix.system.freeaddrinfo(some);
...	...	@@ -5726,12 +6518,12 @@ fn copyCanon(canonical_name_buffer: *[HostName.max_len]u8, name: []const u8) Hos
5726	6518	/// ulock_wait2() uses 64-bit nano-second timeouts (with the same convention)
5727	6519	const darwin_supports_ulock_wait2 = builtin.os.version_range.semver.min.major >= 11;
5728	6520
5729		fn futexWait(t: Threaded, ptr: const std.atomic.Value(u32), expect: u32) Io.Cancelable!void {
	6521	fn futexWait(current_thread: Thread, ptr: const std.atomic.Value(u32), expect: u32) Io.Cancelable!void {
5730	6522	@branchHint(.cold);
5731	6523
5732	6524	if (builtin.cpu.arch.isWasm()) {
5733	6525	comptime assert(builtin.cpu.has(.wasm, .atomics));
5734		try t.checkCancel();
	6526	try current_thread.checkCancel();
5735	6527	const timeout: i64 = -1;
5736	6528	const signed_expect: i32 = @bitCast(expect);
5737	6529	const result = asm volatile (
...	...	@@ -5754,8 +6546,9 @@ fn futexWait(t: Threaded, ptr: const std.atomic.Value(u32), expect: u32) Io.Ca
5754	6546	} else switch (native_os) {
5755	6547	.linux => {
5756	6548	const linux = std.os.linux;
5757		try t.checkCancel();
	6549	try current_thread.beginSyscall();
5758	6550	const rc = linux.futex_4arg(ptr, .{ .cmd = .WAIT, .private = true }, expect, null);
	6551	current_thread.endSyscall();
5759	6552	if (is_debug) switch (linux.errno(rc)) {
5760	6553	.SUCCESS => {}, // notified by `wake()`
5761	6554	.INTR => {}, // gives caller a chance to check cancellation
...	...	@@ -5772,11 +6565,12 @@ fn futexWait(t: Threaded, ptr: const std.atomic.Value(u32), expect: u32) Io.Ca
5772	6565	.op = .COMPARE_AND_WAIT,
5773	6566	.NO_ERRNO = true,
5774	6567	};
5775		try t.checkCancel();
	6568	try current_thread.beginSyscall();
5776	6569	const status = if (darwin_supports_ulock_wait2)
5777	6570	c.__ulock_wait2(flags, ptr, expect, 0, 0)
5778	6571	else
5779	6572	c.__ulock_wait(flags, ptr, expect, 0);
	6573	current_thread.endSyscall();
5780	6574
5781	6575	if (status >= 0) return;
5782	6576
...	...	@@ -5791,7 +6585,7 @@ fn futexWait(t: Threaded, ptr: const std.atomic.Value(u32), expect: u32) Io.Ca
5791	6585	};
5792	6586	},
5793	6587	.windows => {
5794		try t.checkCancel();
	6588	try current_thread.checkCancel();
5795	6589	switch (windows.ntdll.RtlWaitOnAddress(ptr, &expect, @sizeOf(@TypeOf(expect)), null)) {
5796	6590	.SUCCESS => {},
5797	6591	.CANCELLED => return error.Canceled,
...	...	@@ -5800,8 +6594,9 @@ fn futexWait(t: Threaded, ptr: const std.atomic.Value(u32), expect: u32) Io.Ca
5800	6594	},
5801	6595	.freebsd => {
5802	6596	const flags = @intFromEnum(std.c.UMTX_OP.WAIT_UINT_PRIVATE);
5803		try t.checkCancel();
	6597	try current_thread.beginSyscall();
5804	6598	const rc = std.c._umtx_op(@intFromPtr(&ptr.raw), flags, @as(c_ulong, expect), 0, 0);
	6599	current_thread.endSyscall();
5805	6600	if (is_debug) switch (posix.errno(rc)) {
5806	6601	.SUCCESS => {},
5807	6602	.FAULT => unreachable, // one of the args points to invalid memory
...	...	@@ -6050,8 +6845,9 @@ const ResetEventFutex = enum(u32) {
6050	6845	if (state == .unset) {
6051	6846	state = @cmpxchgStrong(ResetEventFutex, ref, state, .waiting, .acquire, .acquire) orelse .waiting;
6052	6847	}
	6848	const current_thread = Thread.getCurrent(t);
6053	6849	while (state == .waiting) {
6054		try futexWait(t, @ptrCast(ref), @intFromEnum(ResetEventFutex.waiting));
	6850	try futexWait(current_thread, @ptrCast(ref), @intFromEnum(ResetEventFutex.waiting));
6055	6851	state = @atomicLoad(ResetEventFutex, ref, .acquire);
6056	6852	}
6057	6853	assert(state == .is_set);
...	...	@@ -6140,6 +6936,7 @@ const ResetEventPosix = struct {
6140	6936	.waiting => unreachable, // Invalid state.
6141	6937	.is_set => return,
6142	6938	};
	6939	const current_thread = Thread.getCurrent(t);
6143	6940	assert(std.c.pthread_mutex_lock(&rep.mutex) == .SUCCESS);
6144	6941	defer assert(std.c.pthread_mutex_unlock(&rep.mutex) == .SUCCESS);
6145	6942	sw: switch (rep.state) {
...	...	@@ -6148,8 +6945,9 @@ const ResetEventPosix = struct {
6148	6945	continue :sw .waiting;
6149	6946	},
6150	6947	.waiting => {
6151		try t.checkCancel();
	6948	try current_thread.beginSyscall();
6152	6949	assert(std.c.pthread_cond_wait(&rep.cond, &rep.mutex) == .SUCCESS);
	6950	current_thread.endSyscall();
6153	6951	continue :sw rep.state;
6154	6952	},
6155	6953	.is_set => return,
...	...	@@ -6222,10 +7020,10 @@ const Wsa = struct {
6222	7020	} \|\| Io.UnexpectedError;
6223	7021	};
6224	7022
6225		fn initializeWsa(t: *Threaded) error{NetworkDown}!void {
	7023	fn initializeWsa(t: *Threaded) error{ NetworkDown, Canceled }!void {
6226	7024	const t_io = io(t);
6227	7025	const wsa = &t.wsa;
6228		wsa.mutex.lockUncancelable(t_io);
	7026	try wsa.mutex.lock(t_io);
6229	7027	defer wsa.mutex.unlock(t_io);
6230	7028	switch (wsa.status) {
6231	7029	.uninitialized => {
...	...	@@ -6237,12 +7035,15 @@ fn initializeWsa(t: *Threaded) error{NetworkDown}!void {
6237	7035	wsa.status = .initialized;
6238	7036	return;
6239	7037	},
6240		else => \|err_int\| switch (@as(ws2_32.WinsockError, @enumFromInt(@as(u16, @intCast(err_int))))) {
6241		.SYSNOTREADY => wsa.init_error = error.NetworkDown,
6242		.VERNOTSUPPORTED => wsa.init_error = error.VersionUnsupported,
6243		.EINPROGRESS => wsa.init_error = error.BlockingOperationInProgress,
6244		.EPROCLIM => wsa.init_error = error.ProcessFdQuotaExceeded,
6245		else => \|err\| wsa.init_error = windows.unexpectedWSAError(err),
	7038	else => \|err_int\| {
	7039	wsa.status = .failure;
	7040	wsa.init_error = switch (@as(ws2_32.WinsockError, @enumFromInt(@as(u16, @intCast(err_int))))) {
	7041	.SYSNOTREADY => error.NetworkDown,
	7042	.VERNOTSUPPORTED => error.VersionUnsupported,
	7043	.EINPROGRESS => error.BlockingOperationInProgress,
	7044	.EPROCLIM => error.ProcessFdQuotaExceeded,
	7045	else => \|err\| windows.unexpectedWSAError(err),
	7046	};
6246	7047	},
6247	7048	}
6248	7049	},