authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-10-15 12:51:34-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-10-29 06:20:49-07:00
log10bfbd7d60b721af9bed3f74fa7ab5171471ee46
tree5a41d119a37b7210c9c16c622776ad9f2f0f5a94
parent870a682cd84e49b2213dffd59c9848d7fd12b7a1

std.Io.Threaded: rename from "pool"

2 files changed, 276 insertions(+), 276 deletions(-)

BRANCH_TODO+1-1
......@@ -1,7 +1,7 @@
1* Threaded: rename Pool to Threaded
21* Threaded: finish linux impl (all tests passing)
32* Threaded: finish macos impl
43* Threaded: finish windows impl
4* Threaded: glibc impl of netLookup
55
66* fix Group.wait not handling cancelation (need to move impl of ResetEvent to Threaded)
77* implement cancelRequest for non-linux posix
lib/std/Io/Threaded.zig+275-275
......@@ -1,4 +1,4 @@
1const Pool = @This();
1const Threaded = @This();
22
33const builtin = @import("builtin");
44const native_os = builtin.os.tag;
......@@ -76,18 +76,18 @@ pub fn init(
7676 /// If these functions are avoided, then `Allocator.failing` may be passed
7777 /// here.
7878 gpa: Allocator,
79) Pool {
80 var pool: Pool = .{
79) Threaded {
80 var t: Threaded = .{
8181 .allocator = gpa,
8282 .threads = .empty,
8383 .stack_size = std.Thread.SpawnConfig.default_stack_size,
8484 .cpu_count = std.Thread.getCpuCount(),
8585 .concurrent_count = 0,
8686 };
87 if (pool.cpu_count) |n| {
88 pool.threads.ensureTotalCapacityPrecise(gpa, n - 1) catch {};
87 if (t.cpu_count) |n| {
88 t.threads.ensureTotalCapacityPrecise(gpa, n - 1) catch {};
8989 } else |_| {}
90 return pool;
90 return t;
9191}
9292
9393/// Statically initialize such that any call to the following functions will
......@@ -96,7 +96,7 @@ pub fn init(
9696/// * `Io.VTable.concurrent`
9797/// * `Io.VTable.groupAsync`
9898/// When initialized this way, `deinit` is safe, but unnecessary to call.
99pub const init_single_threaded: Pool = .{
99pub const init_single_threaded: Threaded = .{
100100 .allocator = .failing,
101101 .threads = .empty,
102102 .stack_size = std.Thread.SpawnConfig.default_stack_size,
......@@ -104,48 +104,48 @@ pub const init_single_threaded: Pool = .{
104104 .concurrent_count = 0,
105105};
106106
107pub fn deinit(pool: *Pool) void {
108 const gpa = pool.allocator;
109 pool.join();
110 pool.threads.deinit(gpa);
111 pool.* = undefined;
107pub fn deinit(t: *Threaded) void {
108 const gpa = t.allocator;
109 t.join();
110 t.threads.deinit(gpa);
111 t.* = undefined;
112112}
113113
114fn join(pool: *Pool) void {
114fn join(t: *Threaded) void {
115115 if (builtin.single_threaded) return;
116116 {
117 pool.mutex.lock();
118 defer pool.mutex.unlock();
119 pool.join_requested = true;
117 t.mutex.lock();
118 defer t.mutex.unlock();
119 t.join_requested = true;
120120 }
121 pool.cond.broadcast();
122 for (pool.threads.items) |thread| thread.join();
121 t.cond.broadcast();
122 for (t.threads.items) |thread| thread.join();
123123}
124124
125fn worker(pool: *Pool) void {
126 pool.mutex.lock();
127 defer pool.mutex.unlock();
125fn worker(t: *Threaded) void {
126 t.mutex.lock();
127 defer t.mutex.unlock();
128128
129129 while (true) {
130 while (pool.run_queue.popFirst()) |closure_node| {
131 pool.mutex.unlock();
130 while (t.run_queue.popFirst()) |closure_node| {
131 t.mutex.unlock();
132132 const closure: *Closure = @fieldParentPtr("node", closure_node);
133133 const is_concurrent = closure.is_concurrent;
134134 closure.start(closure);
135 pool.mutex.lock();
135 t.mutex.lock();
136136 if (is_concurrent) {
137137 // TODO also pop thread and join sometimes
138 pool.concurrent_count -= 1;
138 t.concurrent_count -= 1;
139139 }
140140 }
141 if (pool.join_requested) break;
142 pool.cond.wait(&pool.mutex);
141 if (t.join_requested) break;
142 t.cond.wait(&t.mutex);
143143 }
144144}
145145
146pub fn io(pool: *Pool) Io {
146pub fn io(t: *Threaded) Io {
147147 return .{
148 .userdata = pool,
148 .userdata = t,
149149 .vtable = &.{
150150 .async = async,
151151 .concurrent = concurrent,
......@@ -324,14 +324,14 @@ fn async(
324324 start(context.ptr, result.ptr);
325325 return null;
326326 }
327 const pool: *Pool = @ptrCast(@alignCast(userdata));
328 const cpu_count = pool.cpu_count catch {
327 const t: *Threaded = @ptrCast(@alignCast(userdata));
328 const cpu_count = t.cpu_count catch {
329329 return concurrent(userdata, result.len, result_alignment, context, context_alignment, start) catch {
330330 start(context.ptr, result.ptr);
331331 return null;
332332 };
333333 };
334 const gpa = pool.allocator;
334 const gpa = t.allocator;
335335 const context_offset = context_alignment.forward(@sizeOf(AsyncClosure));
336336 const result_offset = result_alignment.forward(context_offset + context.len);
337337 const n = result_offset + result.len;
......@@ -356,38 +356,38 @@ fn async(
356356
357357 @memcpy(ac.contextPointer()[0..context.len], context);
358358
359 pool.mutex.lock();
359 t.mutex.lock();
360360
361 const thread_capacity = cpu_count - 1 + pool.concurrent_count;
361 const thread_capacity = cpu_count - 1 + t.concurrent_count;
362362
363 pool.threads.ensureTotalCapacityPrecise(gpa, thread_capacity) catch {
364 pool.mutex.unlock();
363 t.threads.ensureTotalCapacityPrecise(gpa, thread_capacity) catch {
364 t.mutex.unlock();
365365 ac.free(gpa, result.len);
366366 start(context.ptr, result.ptr);
367367 return null;
368368 };
369369
370 pool.run_queue.prepend(&ac.closure.node);
370 t.run_queue.prepend(&ac.closure.node);
371371
372 if (pool.threads.items.len < thread_capacity) {
373 const thread = std.Thread.spawn(.{ .stack_size = pool.stack_size }, worker, .{pool}) catch {
374 if (pool.threads.items.len == 0) {
375 assert(pool.run_queue.popFirst() == &ac.closure.node);
376 pool.mutex.unlock();
372 if (t.threads.items.len < thread_capacity) {
373 const thread = std.Thread.spawn(.{ .stack_size = t.stack_size }, worker, .{t}) catch {
374 if (t.threads.items.len == 0) {
375 assert(t.run_queue.popFirst() == &ac.closure.node);
376 t.mutex.unlock();
377377 ac.free(gpa, result.len);
378378 start(context.ptr, result.ptr);
379379 return null;
380380 }
381381 // Rely on other workers to do it.
382 pool.mutex.unlock();
383 pool.cond.signal();
382 t.mutex.unlock();
383 t.cond.signal();
384384 return @ptrCast(ac);
385385 };
386 pool.threads.appendAssumeCapacity(thread);
386 t.threads.appendAssumeCapacity(thread);
387387 }
388388
389 pool.mutex.unlock();
390 pool.cond.signal();
389 t.mutex.unlock();
390 t.cond.signal();
391391 return @ptrCast(ac);
392392}
393393
......@@ -401,9 +401,9 @@ fn concurrent(
401401) error{OutOfMemory}!*Io.AnyFuture {
402402 if (builtin.single_threaded) unreachable;
403403
404 const pool: *Pool = @ptrCast(@alignCast(userdata));
405 const cpu_count = pool.cpu_count catch 1;
406 const gpa = pool.allocator;
404 const t: *Threaded = @ptrCast(@alignCast(userdata));
405 const cpu_count = t.cpu_count catch 1;
406 const gpa = t.allocator;
407407 const context_offset = context_alignment.forward(@sizeOf(AsyncClosure));
408408 const result_offset = result_alignment.forward(context_offset + context.len);
409409 const n = result_offset + result_len;
......@@ -424,37 +424,37 @@ fn concurrent(
424424 };
425425 @memcpy(ac.contextPointer()[0..context.len], context);
426426
427 pool.mutex.lock();
427 t.mutex.lock();
428428
429 pool.concurrent_count += 1;
430 const thread_capacity = cpu_count - 1 + pool.concurrent_count;
429 t.concurrent_count += 1;
430 const thread_capacity = cpu_count - 1 + t.concurrent_count;
431431
432 pool.threads.ensureTotalCapacity(gpa, thread_capacity) catch {
433 pool.mutex.unlock();
432 t.threads.ensureTotalCapacity(gpa, thread_capacity) catch {
433 t.mutex.unlock();
434434 ac.free(gpa, result_len);
435435 return error.OutOfMemory;
436436 };
437437
438 pool.run_queue.prepend(&ac.closure.node);
438 t.run_queue.prepend(&ac.closure.node);
439439
440 if (pool.threads.items.len < thread_capacity) {
441 const thread = std.Thread.spawn(.{ .stack_size = pool.stack_size }, worker, .{pool}) catch {
442 assert(pool.run_queue.popFirst() == &ac.closure.node);
443 pool.mutex.unlock();
440 if (t.threads.items.len < thread_capacity) {
441 const thread = std.Thread.spawn(.{ .stack_size = t.stack_size }, worker, .{t}) catch {
442 assert(t.run_queue.popFirst() == &ac.closure.node);
443 t.mutex.unlock();
444444 ac.free(gpa, result_len);
445445 return error.OutOfMemory;
446446 };
447 pool.threads.appendAssumeCapacity(thread);
447 t.threads.appendAssumeCapacity(thread);
448448 }
449449
450 pool.mutex.unlock();
451 pool.cond.signal();
450 t.mutex.unlock();
451 t.cond.signal();
452452 return @ptrCast(ac);
453453}
454454
455455const GroupClosure = struct {
456456 closure: Closure,
457 pool: *Pool,
457 t: *Threaded,
458458 group: *Io.Group,
459459 /// Points to sibling `GroupClosure`. Used for walking the group to cancel all.
460460 node: std.SinglyLinkedList.Node,
......@@ -515,9 +515,9 @@ fn groupAsync(
515515 start: *const fn (*Io.Group, context: *const anyopaque) void,
516516) void {
517517 if (builtin.single_threaded) return start(context.ptr);
518 const pool: *Pool = @ptrCast(@alignCast(userdata));
519 const cpu_count = pool.cpu_count catch 1;
520 const gpa = pool.allocator;
518 const t: *Threaded = @ptrCast(@alignCast(userdata));
519 const cpu_count = t.cpu_count catch 1;
520 const gpa = t.allocator;
521521 const n = GroupClosure.contextEnd(context_alignment, context.len);
522522 const gc: *GroupClosure = @ptrCast(@alignCast(gpa.alignedAlloc(u8, .of(GroupClosure), n) catch {
523523 return start(group, context.ptr);
......@@ -528,7 +528,7 @@ fn groupAsync(
528528 .start = GroupClosure.start,
529529 .is_concurrent = false,
530530 },
531 .pool = pool,
531 .t = t,
532532 .group = group,
533533 .node = undefined,
534534 .func = start,
......@@ -537,30 +537,30 @@ fn groupAsync(
537537 };
538538 @memcpy(gc.contextPointer()[0..context.len], context);
539539
540 pool.mutex.lock();
540 t.mutex.lock();
541541
542542 // Append to the group linked list inside the mutex to make `Io.Group.async` thread-safe.
543543 gc.node = .{ .next = @ptrCast(@alignCast(group.token)) };
544544 group.token = &gc.node;
545545
546 const thread_capacity = cpu_count - 1 + pool.concurrent_count;
546 const thread_capacity = cpu_count - 1 + t.concurrent_count;
547547
548 pool.threads.ensureTotalCapacityPrecise(gpa, thread_capacity) catch {
549 pool.mutex.unlock();
548 t.threads.ensureTotalCapacityPrecise(gpa, thread_capacity) catch {
549 t.mutex.unlock();
550550 gc.free(gpa);
551551 return start(group, context.ptr);
552552 };
553553
554 pool.run_queue.prepend(&gc.closure.node);
554 t.run_queue.prepend(&gc.closure.node);
555555
556 if (pool.threads.items.len < thread_capacity) {
557 const thread = std.Thread.spawn(.{ .stack_size = pool.stack_size }, worker, .{pool}) catch {
558 assert(pool.run_queue.popFirst() == &gc.closure.node);
559 pool.mutex.unlock();
556 if (t.threads.items.len < thread_capacity) {
557 const thread = std.Thread.spawn(.{ .stack_size = t.stack_size }, worker, .{t}) catch {
558 assert(t.run_queue.popFirst() == &gc.closure.node);
559 t.mutex.unlock();
560560 gc.free(gpa);
561561 return start(group, context.ptr);
562562 };
563 pool.threads.appendAssumeCapacity(thread);
563 t.threads.appendAssumeCapacity(thread);
564564 }
565565
566566 // This needs to be done before unlocking the mutex to avoid a race with
......@@ -568,13 +568,13 @@ fn groupAsync(
568568 const group_state: *std.atomic.Value(usize) = @ptrCast(&group.state);
569569 std.Thread.WaitGroup.startStateless(group_state);
570570
571 pool.mutex.unlock();
572 pool.cond.signal();
571 t.mutex.unlock();
572 t.cond.signal();
573573}
574574
575575fn groupWait(userdata: ?*anyopaque, group: *Io.Group, token: *anyopaque) void {
576 const pool: *Pool = @ptrCast(@alignCast(userdata));
577 const gpa = pool.allocator;
576 const t: *Threaded = @ptrCast(@alignCast(userdata));
577 const gpa = t.allocator;
578578
579579 if (builtin.single_threaded) return;
580580
......@@ -593,8 +593,8 @@ fn groupWait(userdata: ?*anyopaque, group: *Io.Group, token: *anyopaque) void {
593593}
594594
595595fn groupCancel(userdata: ?*anyopaque, group: *Io.Group, token: *anyopaque) void {
596 const pool: *Pool = @ptrCast(@alignCast(userdata));
597 const gpa = pool.allocator;
596 const t: *Threaded = @ptrCast(@alignCast(userdata));
597 const gpa = t.allocator;
598598
599599 if (builtin.single_threaded) return;
600600
......@@ -629,9 +629,9 @@ fn await(
629629 result_alignment: std.mem.Alignment,
630630) void {
631631 _ = result_alignment;
632 const pool: *Pool = @ptrCast(@alignCast(userdata));
632 const t: *Threaded = @ptrCast(@alignCast(userdata));
633633 const closure: *AsyncClosure = @ptrCast(@alignCast(any_future));
634 closure.waitAndFree(pool.allocator, result);
634 closure.waitAndFree(t.allocator, result);
635635}
636636
637637fn cancel(
......@@ -641,31 +641,31 @@ fn cancel(
641641 result_alignment: std.mem.Alignment,
642642) void {
643643 _ = result_alignment;
644 const pool: *Pool = @ptrCast(@alignCast(userdata));
644 const t: *Threaded = @ptrCast(@alignCast(userdata));
645645 const ac: *AsyncClosure = @ptrCast(@alignCast(any_future));
646646 ac.closure.requestCancel();
647 ac.waitAndFree(pool.allocator, result);
647 ac.waitAndFree(t.allocator, result);
648648}
649649
650650fn cancelRequested(userdata: ?*anyopaque) bool {
651 const pool: *Pool = @ptrCast(@alignCast(userdata));
652 _ = pool;
651 const t: *Threaded = @ptrCast(@alignCast(userdata));
652 _ = t;
653653 const closure = current_closure orelse return false;
654654 return @atomicLoad(std.Thread.Id, &closure.cancel_tid, .acquire) == Closure.canceling_tid;
655655}
656656
657fn checkCancel(pool: *Pool) error{Canceled}!void {
658 if (cancelRequested(pool)) return error.Canceled;
657fn checkCancel(t: *Threaded) error{Canceled}!void {
658 if (cancelRequested(t)) return error.Canceled;
659659}
660660
661661fn mutexLock(userdata: ?*anyopaque, prev_state: Io.Mutex.State, mutex: *Io.Mutex) Io.Cancelable!void {
662 const pool: *Pool = @ptrCast(@alignCast(userdata));
662 const t: *Threaded = @ptrCast(@alignCast(userdata));
663663 if (prev_state == .contended) {
664 try pool.checkCancel();
664 try t.checkCancel();
665665 futexWait(@ptrCast(&mutex.state), @intFromEnum(Io.Mutex.State.contended));
666666 }
667667 while (@atomicRmw(Io.Mutex.State, &mutex.state, .Xchg, .contended, .acquire) != .unlocked) {
668 try pool.checkCancel();
668 try t.checkCancel();
669669 futexWait(@ptrCast(&mutex.state), @intFromEnum(Io.Mutex.State.contended));
670670 }
671671}
......@@ -689,8 +689,8 @@ fn mutexUnlock(userdata: ?*anyopaque, prev_state: Io.Mutex.State, mutex: *Io.Mut
689689}
690690
691691fn conditionWaitUncancelable(userdata: ?*anyopaque, cond: *Io.Condition, mutex: *Io.Mutex) void {
692 const pool: *Pool = @ptrCast(@alignCast(userdata));
693 const pool_io = pool.io();
692 const t: *Threaded = @ptrCast(@alignCast(userdata));
693 const t_io = t.io();
694694 comptime assert(@TypeOf(cond.state) == u64);
695695 const ints: *[2]std.atomic.Value(u32) = @ptrCast(&cond.state);
696696 const cond_state = &ints[0];
......@@ -704,8 +704,8 @@ fn conditionWaitUncancelable(userdata: ?*anyopaque, cond: *Io.Condition, mutex:
704704 assert(state & waiter_mask != waiter_mask);
705705 state += one_waiter;
706706
707 mutex.unlock(pool_io);
708 defer mutex.lockUncancelable(pool_io);
707 mutex.unlock(t_io);
708 defer mutex.lockUncancelable(t_io);
709709
710710 while (true) {
711711 futexWait(cond_epoch, epoch);
......@@ -719,7 +719,7 @@ fn conditionWaitUncancelable(userdata: ?*anyopaque, cond: *Io.Condition, mutex:
719719}
720720
721721fn conditionWait(userdata: ?*anyopaque, cond: *Io.Condition, mutex: *Io.Mutex) Io.Cancelable!void {
722 const pool: *Pool = @ptrCast(@alignCast(userdata));
722 const t: *Threaded = @ptrCast(@alignCast(userdata));
723723 comptime assert(@TypeOf(cond.state) == u64);
724724 const ints: *[2]std.atomic.Value(u32) = @ptrCast(&cond.state);
725725 const cond_state = &ints[0];
......@@ -743,11 +743,11 @@ fn conditionWait(userdata: ?*anyopaque, cond: *Io.Condition, mutex: *Io.Mutex) I
743743 assert(state & waiter_mask != waiter_mask);
744744 state += one_waiter;
745745
746 mutex.unlock(pool.io());
747 defer mutex.lockUncancelable(pool.io());
746 mutex.unlock(t.io());
747 defer mutex.lockUncancelable(t.io());
748748
749749 while (true) {
750 try pool.checkCancel();
750 try t.checkCancel();
751751 futexWait(cond_epoch, epoch);
752752
753753 epoch = cond_epoch.load(.acquire);
......@@ -764,8 +764,8 @@ fn conditionWait(userdata: ?*anyopaque, cond: *Io.Condition, mutex: *Io.Mutex) I
764764}
765765
766766fn conditionWake(userdata: ?*anyopaque, cond: *Io.Condition, wake: Io.Condition.Wake) void {
767 const pool: *Pool = @ptrCast(@alignCast(userdata));
768 _ = pool;
767 const t: *Threaded = @ptrCast(@alignCast(userdata));
768 _ = t;
769769 comptime assert(@TypeOf(cond.state) == u64);
770770 const ints: *[2]std.atomic.Value(u32) = @ptrCast(&cond.state);
771771 const cond_state = &ints[0];
......@@ -825,13 +825,13 @@ fn conditionWake(userdata: ?*anyopaque, cond: *Io.Condition, wake: Io.Condition.
825825}
826826
827827fn dirMakePosix(userdata: ?*anyopaque, dir: Io.Dir, sub_path: []const u8, mode: Io.Dir.Mode) Io.Dir.MakeError!void {
828 const pool: *Pool = @ptrCast(@alignCast(userdata));
828 const t: *Threaded = @ptrCast(@alignCast(userdata));
829829
830830 var path_buffer: [posix.PATH_MAX]u8 = undefined;
831831 const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
832832
833833 while (true) {
834 try pool.checkCancel();
834 try t.checkCancel();
835835 switch (posix.errno(posix.system.mkdirat(dir.handle, sub_path_posix, mode))) {
836836 .SUCCESS => return,
837837 .INTR => continue,
......@@ -858,8 +858,8 @@ fn dirMakePosix(userdata: ?*anyopaque, dir: Io.Dir, sub_path: []const u8, mode:
858858}
859859
860860fn dirStat(userdata: ?*anyopaque, dir: Io.Dir) Io.Dir.StatError!Io.Dir.Stat {
861 const pool: *Pool = @ptrCast(@alignCast(userdata));
862 try pool.checkCancel();
861 const t: *Threaded = @ptrCast(@alignCast(userdata));
862 try t.checkCancel();
863863
864864 _ = dir;
865865 @panic("TODO");
......@@ -871,7 +871,7 @@ fn dirStatPathLinux(
871871 sub_path: []const u8,
872872 options: Io.Dir.StatPathOptions,
873873) Io.Dir.StatPathError!Io.File.Stat {
874 const pool: *Pool = @ptrCast(@alignCast(userdata));
874 const t: *Threaded = @ptrCast(@alignCast(userdata));
875875 const linux = std.os.linux;
876876
877877 var path_buffer: [posix.PATH_MAX]u8 = undefined;
......@@ -881,7 +881,7 @@ fn dirStatPathLinux(
881881 @as(u32, if (!options.follow_symlinks) linux.AT.SYMLINK_NOFOLLOW else 0);
882882
883883 while (true) {
884 try pool.checkCancel();
884 try t.checkCancel();
885885 var statx = std.mem.zeroes(linux.Statx);
886886 const rc = linux.statx(
887887 dir.handle,
......@@ -913,7 +913,7 @@ fn dirStatPathPosix(
913913 sub_path: []const u8,
914914 options: Io.Dir.StatPathOptions,
915915) Io.Dir.StatPathError!Io.File.Stat {
916 const pool: *Pool = @ptrCast(@alignCast(userdata));
916 const t: *Threaded = @ptrCast(@alignCast(userdata));
917917
918918 var path_buffer: [posix.PATH_MAX]u8 = undefined;
919919 const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
......@@ -921,7 +921,7 @@ fn dirStatPathPosix(
921921 const flags: u32 = if (!options.follow_symlinks) posix.AT.SYMLINK_NOFOLLOW else 0;
922922
923923 while (true) {
924 try pool.checkCancel();
924 try t.checkCancel();
925925 var stat = std.mem.zeroes(posix.Stat);
926926 switch (posix.errno(fstatat_sym(dir.handle, sub_path_posix, &stat, flags))) {
927927 .SUCCESS => return statFromPosix(stat),
......@@ -943,12 +943,12 @@ fn dirStatPathPosix(
943943}
944944
945945fn fileStatPosix(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File.Stat {
946 const pool: *Pool = @ptrCast(@alignCast(userdata));
946 const t: *Threaded = @ptrCast(@alignCast(userdata));
947947
948948 if (posix.Stat == void) return error.Streaming;
949949
950950 while (true) {
951 try pool.checkCancel();
951 try t.checkCancel();
952952 var stat = std.mem.zeroes(posix.Stat);
953953 switch (posix.errno(fstat_sym(file.handle, &stat))) {
954954 .SUCCESS => return statFromPosix(&stat),
......@@ -963,10 +963,10 @@ fn fileStatPosix(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File
963963}
964964
965965fn fileStatLinux(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File.Stat {
966 const pool: *Pool = @ptrCast(@alignCast(userdata));
966 const t: *Threaded = @ptrCast(@alignCast(userdata));
967967 const linux = std.os.linux;
968968 while (true) {
969 try pool.checkCancel();
969 try t.checkCancel();
970970 var statx = std.mem.zeroes(linux.Statx);
971971 const rc = linux.statx(
972972 file.handle,
......@@ -993,17 +993,17 @@ fn fileStatLinux(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File
993993}
994994
995995fn fileStatWindows(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File.Stat {
996 const pool: *Pool = @ptrCast(@alignCast(userdata));
997 try pool.checkCancel();
996 const t: *Threaded = @ptrCast(@alignCast(userdata));
997 try t.checkCancel();
998998 _ = file;
999999 @panic("TODO");
10001000}
10011001
10021002fn fileStatWasi(userdata: ?*anyopaque, file: Io.File) Io.File.StatError!Io.File.Stat {
10031003 if (builtin.link_libc) return fileStatPosix(userdata, file);
1004 const pool: *Pool = @ptrCast(@alignCast(userdata));
1004 const t: *Threaded = @ptrCast(@alignCast(userdata));
10051005 while (true) {
1006 try pool.checkCancel();
1006 try t.checkCancel();
10071007 var stat: std.os.wasi.filestat_t = undefined;
10081008 switch (std.os.wasi.fd_filestat_get(file.handle, &stat)) {
10091009 .SUCCESS => return statFromWasi(&stat),
......@@ -1031,7 +1031,7 @@ fn dirCreateFilePosix(
10311031 sub_path: []const u8,
10321032 flags: Io.File.CreateFlags,
10331033) Io.File.OpenError!Io.File {
1034 const pool: *Pool = @ptrCast(@alignCast(userdata));
1034 const t: *Threaded = @ptrCast(@alignCast(userdata));
10351035
10361036 var path_buffer: [posix.PATH_MAX]u8 = undefined;
10371037 const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
......@@ -1062,7 +1062,7 @@ fn dirCreateFilePosix(
10621062 };
10631063
10641064 const fd: posix.fd_t = while (true) {
1065 try pool.checkCancel();
1065 try t.checkCancel();
10661066 const rc = openat_sym(dir.handle, sub_path_posix, os_flags, flags.mode);
10671067 switch (posix.errno(rc)) {
10681068 .SUCCESS => break @intCast(rc),
......@@ -1106,7 +1106,7 @@ fn dirCreateFilePosix(
11061106 .exclusive => posix.LOCK.EX | lock_nonblocking,
11071107 };
11081108 while (true) {
1109 try pool.checkCancel();
1109 try t.checkCancel();
11101110 switch (posix.errno(posix.system.flock(fd, lock_flags))) {
11111111 .SUCCESS => break,
11121112 .INTR => continue,
......@@ -1123,7 +1123,7 @@ fn dirCreateFilePosix(
11231123
11241124 if (has_flock_open_flags and flags.lock_nonblocking) {
11251125 var fl_flags: usize = while (true) {
1126 try pool.checkCancel();
1126 try t.checkCancel();
11271127 switch (posix.errno(posix.system.fcntl(fd, posix.F.GETFL, 0))) {
11281128 .SUCCESS => break,
11291129 .INTR => continue,
......@@ -1132,7 +1132,7 @@ fn dirCreateFilePosix(
11321132 };
11331133 fl_flags &= ~@as(usize, 1 << @bitOffsetOf(posix.O, "NONBLOCK"));
11341134 while (true) {
1135 try pool.checkCancel();
1135 try t.checkCancel();
11361136 switch (posix.errno(posix.fcntl(fd, posix.F.SETFL, fl_flags))) {
11371137 .SUCCESS => break,
11381138 .INTR => continue,
......@@ -1150,7 +1150,7 @@ fn dirOpenFile(
11501150 sub_path: []const u8,
11511151 flags: Io.File.OpenFlags,
11521152) Io.File.OpenError!Io.File {
1153 const pool: *Pool = @ptrCast(@alignCast(userdata));
1153 const t: *Threaded = @ptrCast(@alignCast(userdata));
11541154
11551155 var path_buffer: [posix.PATH_MAX]u8 = undefined;
11561156 const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
......@@ -1191,7 +1191,7 @@ fn dirOpenFile(
11911191 }
11921192 }
11931193 const fd: posix.fd_t = while (true) {
1194 try pool.checkCancel();
1194 try t.checkCancel();
11951195 const rc = openat_sym(dir.handle, sub_path_posix, os_flags, @as(posix.mode_t, 0));
11961196 switch (posix.errno(rc)) {
11971197 .SUCCESS => break @intCast(rc),
......@@ -1235,7 +1235,7 @@ fn dirOpenFile(
12351235 .exclusive => posix.LOCK.EX | lock_nonblocking,
12361236 };
12371237 while (true) {
1238 try pool.checkCancel();
1238 try t.checkCancel();
12391239 switch (posix.errno(posix.system.flock(fd, lock_flags))) {
12401240 .SUCCESS => break,
12411241 .INTR => continue,
......@@ -1252,7 +1252,7 @@ fn dirOpenFile(
12521252
12531253 if (has_flock_open_flags and flags.lock_nonblocking) {
12541254 var fl_flags: usize = while (true) {
1255 try pool.checkCancel();
1255 try t.checkCancel();
12561256 switch (posix.errno(posix.system.fcntl(fd, posix.F.GETFL, 0))) {
12571257 .SUCCESS => break,
12581258 .INTR => continue,
......@@ -1261,7 +1261,7 @@ fn dirOpenFile(
12611261 };
12621262 fl_flags &= ~@as(usize, 1 << @bitOffsetOf(posix.O, "NONBLOCK"));
12631263 while (true) {
1264 try pool.checkCancel();
1264 try t.checkCancel();
12651265 switch (posix.errno(posix.fcntl(fd, posix.F.SETFL, fl_flags))) {
12661266 .SUCCESS => break,
12671267 .INTR => continue,
......@@ -1274,13 +1274,13 @@ fn dirOpenFile(
12741274}
12751275
12761276fn fileClose(userdata: ?*anyopaque, file: Io.File) void {
1277 const pool: *Pool = @ptrCast(@alignCast(userdata));
1278 _ = pool;
1277 const t: *Threaded = @ptrCast(@alignCast(userdata));
1278 _ = t;
12791279 posix.close(file.handle);
12801280}
12811281
12821282fn fileReadStreaming(userdata: ?*anyopaque, file: Io.File, data: [][]u8) Io.File.ReadStreamingError!usize {
1283 const pool: *Pool = @ptrCast(@alignCast(userdata));
1283 const t: *Threaded = @ptrCast(@alignCast(userdata));
12841284
12851285 if (is_windows) {
12861286 const DWORD = windows.DWORD;
......@@ -1288,7 +1288,7 @@ fn fileReadStreaming(userdata: ?*anyopaque, file: Io.File, data: [][]u8) Io.File
12881288 var truncate: usize = 0;
12891289 var total: usize = 0;
12901290 while (index < data.len) {
1291 try pool.checkCancel();
1291 try t.checkCancel();
12921292 {
12931293 const untruncated = data[index];
12941294 data[index] = untruncated[truncate..];
......@@ -1333,7 +1333,7 @@ fn fileReadStreaming(userdata: ?*anyopaque, file: Io.File, data: [][]u8) Io.File
13331333 assert(dest[0].len > 0);
13341334
13351335 if (native_os == .wasi and !builtin.link_libc) while (true) {
1336 try pool.checkCancel();
1336 try t.checkCancel();
13371337 var nread: usize = undefined;
13381338 switch (std.os.wasi.fd_read(file.handle, dest.ptr, dest.len, &nread)) {
13391339 .SUCCESS => return nread,
......@@ -1354,7 +1354,7 @@ fn fileReadStreaming(userdata: ?*anyopaque, file: Io.File, data: [][]u8) Io.File
13541354 };
13551355
13561356 while (true) {
1357 try pool.checkCancel();
1357 try t.checkCancel();
13581358 const rc = posix.system.readv(file.handle, dest.ptr, @intCast(dest.len));
13591359 switch (posix.errno(rc)) {
13601360 .SUCCESS => return @intCast(rc),
......@@ -1377,7 +1377,7 @@ fn fileReadStreaming(userdata: ?*anyopaque, file: Io.File, data: [][]u8) Io.File
13771377}
13781378
13791379fn fileReadPositional(userdata: ?*anyopaque, file: Io.File, data: [][]u8, offset: u64) Io.File.ReadPositionalError!usize {
1380 const pool: *Pool = @ptrCast(@alignCast(userdata));
1380 const t: *Threaded = @ptrCast(@alignCast(userdata));
13811381
13821382 if (is_windows) {
13831383 const DWORD = windows.DWORD;
......@@ -1386,7 +1386,7 @@ fn fileReadPositional(userdata: ?*anyopaque, file: Io.File, data: [][]u8, offset
13861386 var truncate: usize = 0;
13871387 var total: usize = 0;
13881388 while (true) {
1389 try pool.checkCancel();
1389 try t.checkCancel();
13901390 {
13911391 const untruncated = data[index];
13921392 data[index] = untruncated[truncate..];
......@@ -1454,7 +1454,7 @@ fn fileReadPositional(userdata: ?*anyopaque, file: Io.File, data: [][]u8, offset
14541454 assert(dest[0].len > 0);
14551455
14561456 if (native_os == .wasi and !builtin.link_libc) while (true) {
1457 try pool.checkCancel();
1457 try t.checkCancel();
14581458 var nread: usize = undefined;
14591459 switch (std.os.wasi.fd_pread(file.handle, dest.ptr, dest.len, offset, &nread)) {
14601460 .SUCCESS => return nread,
......@@ -1479,7 +1479,7 @@ fn fileReadPositional(userdata: ?*anyopaque, file: Io.File, data: [][]u8, offset
14791479 };
14801480
14811481 while (true) {
1482 try pool.checkCancel();
1482 try t.checkCancel();
14831483 const rc = preadv_sym(file.handle, dest.ptr, @intCast(dest.len), @bitCast(offset));
14841484 switch (posix.errno(rc)) {
14851485 .SUCCESS => return @bitCast(rc),
......@@ -1505,8 +1505,8 @@ fn fileReadPositional(userdata: ?*anyopaque, file: Io.File, data: [][]u8, offset
15051505}
15061506
15071507fn fileSeekBy(userdata: ?*anyopaque, file: Io.File, offset: i64) Io.File.SeekError!void {
1508 const pool: *Pool = @ptrCast(@alignCast(userdata));
1509 try pool.checkCancel();
1508 const t: *Threaded = @ptrCast(@alignCast(userdata));
1509 try t.checkCancel();
15101510
15111511 _ = file;
15121512 _ = offset;
......@@ -1514,11 +1514,11 @@ fn fileSeekBy(userdata: ?*anyopaque, file: Io.File, offset: i64) Io.File.SeekErr
15141514}
15151515
15161516fn fileSeekTo(userdata: ?*anyopaque, file: Io.File, offset: u64) Io.File.SeekError!void {
1517 const pool: *Pool = @ptrCast(@alignCast(userdata));
1517 const t: *Threaded = @ptrCast(@alignCast(userdata));
15181518 const fd = file.handle;
15191519
15201520 if (native_os == .linux and !builtin.link_libc and @sizeOf(usize) == 4) while (true) {
1521 try pool.checkCancel();
1521 try t.checkCancel();
15221522 var result: u64 = undefined;
15231523 switch (posix.errno(posix.system.llseek(fd, offset, &result, posix.SEEK.SET))) {
15241524 .SUCCESS => return,
......@@ -1533,12 +1533,12 @@ fn fileSeekTo(userdata: ?*anyopaque, file: Io.File, offset: u64) Io.File.SeekErr
15331533 };
15341534
15351535 if (native_os == .windows) {
1536 try pool.checkCancel();
1536 try t.checkCancel();
15371537 return windows.SetFilePointerEx_BEGIN(fd, offset);
15381538 }
15391539
15401540 if (native_os == .wasi and !builtin.link_libc) while (true) {
1541 try pool.checkCancel();
1541 try t.checkCancel();
15421542 var new_offset: std.os.wasi.filesize_t = undefined;
15431543 switch (std.os.wasi.fd_seek(fd, @bitCast(offset), .SET, &new_offset)) {
15441544 .SUCCESS => return,
......@@ -1556,7 +1556,7 @@ fn fileSeekTo(userdata: ?*anyopaque, file: Io.File, offset: u64) Io.File.SeekErr
15561556 if (posix.SEEK == void) return error.Unseekable;
15571557
15581558 while (true) {
1559 try pool.checkCancel();
1559 try t.checkCancel();
15601560 switch (posix.errno(lseek_sym(fd, @bitCast(offset), posix.SEEK.SET))) {
15611561 .SUCCESS => return,
15621562 .INTR => continue,
......@@ -1571,8 +1571,8 @@ fn fileSeekTo(userdata: ?*anyopaque, file: Io.File, offset: u64) Io.File.SeekErr
15711571}
15721572
15731573fn pwrite(userdata: ?*anyopaque, file: Io.File, buffer: []const u8, offset: posix.off_t) Io.File.PWriteError!usize {
1574 const pool: *Pool = @ptrCast(@alignCast(userdata));
1575 try pool.checkCancel();
1574 const t: *Threaded = @ptrCast(@alignCast(userdata));
1575 try t.checkCancel();
15761576 const fs_file: std.fs.File = .{ .handle = file.handle };
15771577 return switch (offset) {
15781578 -1 => fs_file.write(buffer),
......@@ -1581,8 +1581,8 @@ fn pwrite(userdata: ?*anyopaque, file: Io.File, buffer: []const u8, offset: posi
15811581}
15821582
15831583fn nowPosix(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
1584 const pool: *Pool = @ptrCast(@alignCast(userdata));
1585 _ = pool;
1584 const t: *Threaded = @ptrCast(@alignCast(userdata));
1585 _ = t;
15861586 const clock_id: posix.clockid_t = clockToPosix(clock);
15871587 var tp: posix.timespec = undefined;
15881588 switch (posix.errno(posix.system.clock_gettime(clock_id, &tp))) {
......@@ -1593,8 +1593,8 @@ fn nowPosix(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.Error!Io.Timestamp
15931593}
15941594
15951595fn nowWindows(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
1596 const pool: *Pool = @ptrCast(@alignCast(userdata));
1597 _ = pool;
1596 const t: *Threaded = @ptrCast(@alignCast(userdata));
1597 _ = t;
15981598 switch (clock) {
15991599 .realtime => {
16001600 // RtlGetSystemTimePrecise() has a granularity of 100 nanoseconds
......@@ -1612,8 +1612,8 @@ fn nowWindows(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.Error!Io.Timestam
16121612}
16131613
16141614fn nowWasi(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
1615 const pool: *Pool = @ptrCast(@alignCast(userdata));
1616 _ = pool;
1615 const t: *Threaded = @ptrCast(@alignCast(userdata));
1616 _ = t;
16171617 var ns: std.os.wasi.timestamp_t = undefined;
16181618 const err = std.os.wasi.clock_time_get(clockToWasi(clock), 1, &ns);
16191619 if (err != .SUCCESS) return error.Unexpected;
......@@ -1621,7 +1621,7 @@ fn nowWasi(userdata: ?*anyopaque, clock: Io.Clock) Io.Clock.Error!Io.Timestamp {
16211621}
16221622
16231623fn sleepLinux(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
1624 const pool: *Pool = @ptrCast(@alignCast(userdata));
1624 const t: *Threaded = @ptrCast(@alignCast(userdata));
16251625 const clock_id: posix.clockid_t = clockToPosix(switch (timeout) {
16261626 .none => .awake,
16271627 .duration => |d| d.clock,
......@@ -1634,7 +1634,7 @@ fn sleepLinux(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
16341634 };
16351635 var timespec: posix.timespec = timestampToPosix(deadline_nanoseconds);
16361636 while (true) {
1637 try pool.checkCancel();
1637 try t.checkCancel();
16381638 switch (std.os.linux.E.init(std.os.linux.clock_nanosleep(clock_id, .{ .ABSTIME = switch (timeout) {
16391639 .none, .duration => false,
16401640 .deadline => true,
......@@ -1648,10 +1648,10 @@ fn sleepLinux(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
16481648}
16491649
16501650fn sleepWindows(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
1651 const pool: *Pool = @ptrCast(@alignCast(userdata));
1652 try pool.checkCancel();
1651 const t: *Threaded = @ptrCast(@alignCast(userdata));
1652 try t.checkCancel();
16531653 const ms = ms: {
1654 const duration_and_clock = (try timeout.toDurationFromNow(pool.io())) orelse
1654 const duration_and_clock = (try timeout.toDurationFromNow(t.io())) orelse
16551655 break :ms std.math.maxInt(windows.DWORD);
16561656 break :ms std.math.lossyCast(windows.DWORD, duration_and_clock.duration.toMilliseconds());
16571657 };
......@@ -1659,12 +1659,12 @@ fn sleepWindows(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
16591659}
16601660
16611661fn sleepWasi(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
1662 const pool: *Pool = @ptrCast(@alignCast(userdata));
1663 try pool.checkCancel();
1662 const t: *Threaded = @ptrCast(@alignCast(userdata));
1663 try t.checkCancel();
16641664
16651665 const w = std.os.wasi;
16661666
1667 const clock: w.subscription_clock_t = if (try timeout.toDurationFromNow(pool.io())) |d| .{
1667 const clock: w.subscription_clock_t = if (try timeout.toDurationFromNow(t.io())) |d| .{
16681668 .id = clockToWasi(d.clock),
16691669 .timeout = std.math.lossyCast(u64, d.duration.nanoseconds),
16701670 .precision = 0,
......@@ -1688,19 +1688,19 @@ fn sleepWasi(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
16881688}
16891689
16901690fn sleepPosix(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
1691 const pool: *Pool = @ptrCast(@alignCast(userdata));
1691 const t: *Threaded = @ptrCast(@alignCast(userdata));
16921692 const sec_type = @typeInfo(posix.timespec).@"struct".fields[0].type;
16931693 const nsec_type = @typeInfo(posix.timespec).@"struct".fields[1].type;
16941694
16951695 var timespec: posix.timespec = t: {
1696 const d = (try timeout.toDurationFromNow(pool.io())) orelse break :t .{
1696 const d = (try timeout.toDurationFromNow(t.io())) orelse break :t .{
16971697 .sec = std.math.maxInt(sec_type),
16981698 .nsec = std.math.maxInt(nsec_type),
16991699 };
17001700 break :t timestampToPosix(d.duration.nanoseconds);
17011701 };
17021702 while (true) {
1703 try pool.checkCancel();
1703 try t.checkCancel();
17041704 switch (posix.errno(posix.system.nanosleep(&timespec, &timespec))) {
17051705 .INTR => continue,
17061706 else => return, // This prong handles success as well as unexpected errors.
......@@ -1709,8 +1709,8 @@ fn sleepPosix(userdata: ?*anyopaque, timeout: Io.Timeout) Io.SleepError!void {
17091709}
17101710
17111711fn select(userdata: ?*anyopaque, futures: []const *Io.AnyFuture) usize {
1712 const pool: *Pool = @ptrCast(@alignCast(userdata));
1713 _ = pool;
1712 const t: *Threaded = @ptrCast(@alignCast(userdata));
1713 _ = t;
17141714
17151715 var reset_event: ResetEvent = .unset;
17161716
......@@ -1745,26 +1745,26 @@ fn netListenIpPosix(
17451745 address: IpAddress,
17461746 options: IpAddress.ListenOptions,
17471747) IpAddress.ListenError!net.Server {
1748 const pool: *Pool = @ptrCast(@alignCast(userdata));
1748 const t: *Threaded = @ptrCast(@alignCast(userdata));
17491749 const family = posixAddressFamily(&address);
1750 const socket_fd = try openSocketPosix(pool, family, .{
1750 const socket_fd = try openSocketPosix(t, family, .{
17511751 .mode = options.mode,
17521752 .protocol = options.protocol,
17531753 });
17541754 errdefer posix.close(socket_fd);
17551755
17561756 if (options.reuse_address) {
1757 try setSocketOption(pool, socket_fd, posix.SOL.SOCKET, posix.SO.REUSEADDR, 1);
1757 try setSocketOption(t, socket_fd, posix.SOL.SOCKET, posix.SO.REUSEADDR, 1);
17581758 if (@hasDecl(posix.SO, "REUSEPORT"))
1759 try setSocketOption(pool, socket_fd, posix.SOL.SOCKET, posix.SO.REUSEPORT, 1);
1759 try setSocketOption(t, socket_fd, posix.SOL.SOCKET, posix.SO.REUSEPORT, 1);
17601760 }
17611761
17621762 var storage: PosixAddress = undefined;
17631763 var addr_len = addressToPosix(&address, &storage);
1764 try posixBind(pool, socket_fd, &storage.any, addr_len);
1764 try posixBind(t, socket_fd, &storage.any, addr_len);
17651765
17661766 while (true) {
1767 try pool.checkCancel();
1767 try t.checkCancel();
17681768 switch (posix.errno(posix.system.listen(socket_fd, options.kernel_backlog))) {
17691769 .SUCCESS => break,
17701770 .ADDRINUSE => return error.AddressInUse,
......@@ -1773,7 +1773,7 @@ fn netListenIpPosix(
17731773 }
17741774 }
17751775
1776 try posixGetSockName(pool, socket_fd, &storage.any, &addr_len);
1776 try posixGetSockName(t, socket_fd, &storage.any, &addr_len);
17771777 return .{
17781778 .socket = .{
17791779 .handle = socket_fd,
......@@ -1788,8 +1788,8 @@ fn netListenUnix(
17881788 options: net.UnixAddress.ListenOptions,
17891789) net.UnixAddress.ListenError!net.Socket.Handle {
17901790 if (!net.has_unix_sockets) return error.AddressFamilyUnsupported;
1791 const pool: *Pool = @ptrCast(@alignCast(userdata));
1792 const socket_fd = openSocketPosix(pool, posix.AF.UNIX, .{ .mode = .stream }) catch |err| switch (err) {
1791 const t: *Threaded = @ptrCast(@alignCast(userdata));
1792 const socket_fd = openSocketPosix(t, posix.AF.UNIX, .{ .mode = .stream }) catch |err| switch (err) {
17931793 error.ProtocolUnsupportedBySystem => return error.AddressFamilyUnsupported,
17941794 error.ProtocolUnsupportedByAddressFamily => return error.AddressFamilyUnsupported,
17951795 error.SocketModeUnsupported => return error.AddressFamilyUnsupported,
......@@ -1799,10 +1799,10 @@ fn netListenUnix(
17991799
18001800 var storage: UnixAddress = undefined;
18011801 const addr_len = addressUnixToPosix(address, &storage);
1802 try posixBindUnix(pool, socket_fd, &storage.any, addr_len);
1802 try posixBindUnix(t, socket_fd, &storage.any, addr_len);
18031803
18041804 while (true) {
1805 try pool.checkCancel();
1805 try t.checkCancel();
18061806 switch (posix.errno(posix.system.listen(socket_fd, options.kernel_backlog))) {
18071807 .SUCCESS => break,
18081808 .ADDRINUSE => return error.AddressInUse,
......@@ -1814,9 +1814,9 @@ fn netListenUnix(
18141814 return socket_fd;
18151815}
18161816
1817fn posixBindUnix(pool: *Pool, fd: posix.socket_t, addr: *const posix.sockaddr, addr_len: posix.socklen_t) !void {
1817fn posixBindUnix(t: *Threaded, fd: posix.socket_t, addr: *const posix.sockaddr, addr_len: posix.socklen_t) !void {
18181818 while (true) {
1819 try pool.checkCancel();
1819 try t.checkCancel();
18201820 switch (posix.errno(posix.system.bind(fd, addr, addr_len))) {
18211821 .SUCCESS => break,
18221822 .INTR => continue,
......@@ -1842,9 +1842,9 @@ fn posixBindUnix(pool: *Pool, fd: posix.socket_t, addr: *const posix.sockaddr, a
18421842 }
18431843}
18441844
1845fn posixBind(pool: *Pool, socket_fd: posix.socket_t, addr: *const posix.sockaddr, addr_len: posix.socklen_t) !void {
1845fn posixBind(t: *Threaded, socket_fd: posix.socket_t, addr: *const posix.sockaddr, addr_len: posix.socklen_t) !void {
18461846 while (true) {
1847 try pool.checkCancel();
1847 try t.checkCancel();
18481848 switch (posix.errno(posix.system.bind(socket_fd, addr, addr_len))) {
18491849 .SUCCESS => break,
18501850 .INTR => continue,
......@@ -1861,9 +1861,9 @@ fn posixBind(pool: *Pool, socket_fd: posix.socket_t, addr: *const posix.sockaddr
18611861 }
18621862}
18631863
1864fn posixConnect(pool: *Pool, socket_fd: posix.socket_t, addr: *const posix.sockaddr, addr_len: posix.socklen_t) !void {
1864fn posixConnect(t: *Threaded, socket_fd: posix.socket_t, addr: *const posix.sockaddr, addr_len: posix.socklen_t) !void {
18651865 while (true) {
1866 try pool.checkCancel();
1866 try t.checkCancel();
18671867 switch (posix.errno(posix.system.connect(socket_fd, addr, addr_len))) {
18681868 .SUCCESS => return,
18691869 .INTR => continue,
......@@ -1890,9 +1890,9 @@ fn posixConnect(pool: *Pool, socket_fd: posix.socket_t, addr: *const posix.socka
18901890 }
18911891}
18921892
1893fn posixConnectUnix(pool: *Pool, fd: posix.socket_t, addr: *const posix.sockaddr, addr_len: posix.socklen_t) !void {
1893fn posixConnectUnix(t: *Threaded, fd: posix.socket_t, addr: *const posix.sockaddr, addr_len: posix.socklen_t) !void {
18941894 while (true) {
1895 try pool.checkCancel();
1895 try t.checkCancel();
18961896 switch (posix.errno(posix.system.connect(fd, addr, addr_len))) {
18971897 .SUCCESS => return,
18981898 .INTR => continue,
......@@ -1919,9 +1919,9 @@ fn posixConnectUnix(pool: *Pool, fd: posix.socket_t, addr: *const posix.sockaddr
19191919 }
19201920}
19211921
1922fn posixGetSockName(pool: *Pool, socket_fd: posix.fd_t, addr: *posix.sockaddr, addr_len: *posix.socklen_t) !void {
1922fn posixGetSockName(t: *Threaded, socket_fd: posix.fd_t, addr: *posix.sockaddr, addr_len: *posix.socklen_t) !void {
19231923 while (true) {
1924 try pool.checkCancel();
1924 try t.checkCancel();
19251925 switch (posix.errno(posix.system.getsockname(socket_fd, addr, addr_len))) {
19261926 .SUCCESS => break,
19271927 .INTR => continue,
......@@ -1935,10 +1935,10 @@ fn posixGetSockName(pool: *Pool, socket_fd: posix.fd_t, addr: *posix.sockaddr, a
19351935 }
19361936}
19371937
1938fn setSocketOption(pool: *Pool, fd: posix.fd_t, level: i32, opt_name: u32, option: u32) !void {
1938fn setSocketOption(t: *Threaded, fd: posix.fd_t, level: i32, opt_name: u32, option: u32) !void {
19391939 const o: []const u8 = @ptrCast(&option);
19401940 while (true) {
1941 try pool.checkCancel();
1941 try t.checkCancel();
19421942 switch (posix.errno(posix.system.setsockopt(fd, level, opt_name, o.ptr, @intCast(o.len)))) {
19431943 .SUCCESS => return,
19441944 .INTR => continue,
......@@ -1957,17 +1957,17 @@ fn netConnectIpPosix(
19571957 options: IpAddress.ConnectOptions,
19581958) IpAddress.ConnectError!net.Stream {
19591959 if (options.timeout != .none) @panic("TODO");
1960 const pool: *Pool = @ptrCast(@alignCast(userdata));
1960 const t: *Threaded = @ptrCast(@alignCast(userdata));
19611961 const family = posixAddressFamily(address);
1962 const socket_fd = try openSocketPosix(pool, family, .{
1962 const socket_fd = try openSocketPosix(t, family, .{
19631963 .mode = options.mode,
19641964 .protocol = options.protocol,
19651965 });
19661966 errdefer posix.close(socket_fd);
19671967 var storage: PosixAddress = undefined;
19681968 var addr_len = addressToPosix(address, &storage);
1969 try posixConnect(pool, socket_fd, &storage.any, addr_len);
1970 try posixGetSockName(pool, socket_fd, &storage.any, &addr_len);
1969 try posixConnect(t, socket_fd, &storage.any, addr_len);
1970 try posixGetSockName(t, socket_fd, &storage.any, &addr_len);
19711971 return .{ .socket = .{
19721972 .handle = socket_fd,
19731973 .address = addressFromPosix(&storage),
......@@ -1979,12 +1979,12 @@ fn netConnectUnix(
19791979 address: *const net.UnixAddress,
19801980) net.UnixAddress.ConnectError!net.Socket.Handle {
19811981 if (!net.has_unix_sockets) return error.AddressFamilyUnsupported;
1982 const pool: *Pool = @ptrCast(@alignCast(userdata));
1983 const socket_fd = try openSocketPosix(pool, posix.AF.UNIX, .{ .mode = .stream });
1982 const t: *Threaded = @ptrCast(@alignCast(userdata));
1983 const socket_fd = try openSocketPosix(t, posix.AF.UNIX, .{ .mode = .stream });
19841984 errdefer posix.close(socket_fd);
19851985 var storage: UnixAddress = undefined;
19861986 const addr_len = addressUnixToPosix(address, &storage);
1987 try posixConnectUnix(pool, socket_fd, &storage.any, addr_len);
1987 try posixConnectUnix(t, socket_fd, &storage.any, addr_len);
19881988 return socket_fd;
19891989}
19901990
......@@ -1993,25 +1993,25 @@ fn netBindIpPosix(
19931993 address: *const IpAddress,
19941994 options: IpAddress.BindOptions,
19951995) IpAddress.BindError!net.Socket {
1996 const pool: *Pool = @ptrCast(@alignCast(userdata));
1996 const t: *Threaded = @ptrCast(@alignCast(userdata));
19971997 const family = posixAddressFamily(address);
1998 const socket_fd = try openSocketPosix(pool, family, options);
1998 const socket_fd = try openSocketPosix(t, family, options);
19991999 errdefer posix.close(socket_fd);
20002000 var storage: PosixAddress = undefined;
20012001 var addr_len = addressToPosix(address, &storage);
2002 try posixBind(pool, socket_fd, &storage.any, addr_len);
2003 try posixGetSockName(pool, socket_fd, &storage.any, &addr_len);
2002 try posixBind(t, socket_fd, &storage.any, addr_len);
2003 try posixGetSockName(t, socket_fd, &storage.any, &addr_len);
20042004 return .{
20052005 .handle = socket_fd,
20062006 .address = addressFromPosix(&storage),
20072007 };
20082008}
20092009
2010fn openSocketPosix(pool: *Pool, family: posix.sa_family_t, options: IpAddress.BindOptions) !posix.socket_t {
2010fn openSocketPosix(t: *Threaded, family: posix.sa_family_t, options: IpAddress.BindOptions) !posix.socket_t {
20112011 const mode = posixSocketMode(options.mode);
20122012 const protocol = posixProtocol(options.protocol);
20132013 const socket_fd = while (true) {
2014 try pool.checkCancel();
2014 try t.checkCancel();
20152015 const flags: u32 = mode | if (socket_flags_unsupported) 0 else posix.SOCK.CLOEXEC;
20162016 const socket_rc = posix.system.socket(family, flags, protocol);
20172017 switch (posix.errno(socket_rc)) {
......@@ -2019,7 +2019,7 @@ fn openSocketPosix(pool: *Pool, family: posix.sa_family_t, options: IpAddress.Bi
20192019 const fd: posix.fd_t = @intCast(socket_rc);
20202020 errdefer posix.close(fd);
20212021 if (socket_flags_unsupported) while (true) {
2022 try pool.checkCancel();
2022 try t.checkCancel();
20232023 switch (posix.errno(posix.system.fcntl(fd, posix.F.SETFD, @as(usize, posix.FD_CLOEXEC)))) {
20242024 .SUCCESS => break,
20252025 .INTR => continue,
......@@ -2044,7 +2044,7 @@ fn openSocketPosix(pool: *Pool, family: posix.sa_family_t, options: IpAddress.Bi
20442044
20452045 if (options.ip6_only) {
20462046 if (posix.IPV6 == void) return error.OptionUnsupported;
2047 try setSocketOption(pool, socket_fd, posix.IPPROTO.IPV6, posix.IPV6.V6ONLY, 0);
2047 try setSocketOption(t, socket_fd, posix.IPPROTO.IPV6, posix.IPV6.V6ONLY, 0);
20482048 }
20492049
20502050 return socket_fd;
......@@ -2054,11 +2054,11 @@ const socket_flags_unsupported = builtin.os.tag.isDarwin() or native_os == .haik
20542054const have_accept4 = !socket_flags_unsupported;
20552055
20562056fn netAcceptPosix(userdata: ?*anyopaque, listen_fd: net.Socket.Handle) net.Server.AcceptError!net.Stream {
2057 const pool: *Pool = @ptrCast(@alignCast(userdata));
2057 const t: *Threaded = @ptrCast(@alignCast(userdata));
20582058 var storage: PosixAddress = undefined;
20592059 var addr_len: posix.socklen_t = @sizeOf(PosixAddress);
20602060 const fd = while (true) {
2061 try pool.checkCancel();
2061 try t.checkCancel();
20622062 const rc = if (have_accept4)
20632063 posix.system.accept4(listen_fd, &storage.any, &addr_len, posix.SOCK.CLOEXEC)
20642064 else
......@@ -2068,7 +2068,7 @@ fn netAcceptPosix(userdata: ?*anyopaque, listen_fd: net.Socket.Handle) net.Serve
20682068 const fd: posix.fd_t = @intCast(rc);
20692069 errdefer posix.close(fd);
20702070 if (!have_accept4) while (true) {
2071 try pool.checkCancel();
2071 try t.checkCancel();
20722072 switch (posix.errno(posix.system.fcntl(fd, posix.F.SETFD, @as(usize, posix.FD_CLOEXEC)))) {
20732073 .SUCCESS => break,
20742074 .INTR => continue,
......@@ -2101,7 +2101,7 @@ fn netAcceptPosix(userdata: ?*anyopaque, listen_fd: net.Socket.Handle) net.Serve
21012101}
21022102
21032103fn netReadPosix(userdata: ?*anyopaque, fd: net.Socket.Handle, data: [][]u8) net.Stream.Reader.Error!usize {
2104 const pool: *Pool = @ptrCast(@alignCast(userdata));
2104 const t: *Threaded = @ptrCast(@alignCast(userdata));
21052105
21062106 var iovecs_buffer: [max_iovecs_len]posix.iovec = undefined;
21072107 var i: usize = 0;
......@@ -2116,7 +2116,7 @@ fn netReadPosix(userdata: ?*anyopaque, fd: net.Socket.Handle, data: [][]u8) net.
21162116 assert(dest[0].len > 0);
21172117
21182118 if (native_os == .wasi and !builtin.link_libc) while (true) {
2119 try pool.checkCancel();
2119 try t.checkCancel();
21202120 var n: usize = undefined;
21212121 switch (std.os.wasi.fd_read(fd, dest.ptr, dest.len, &n)) {
21222122 .SUCCESS => return n,
......@@ -2137,7 +2137,7 @@ fn netReadPosix(userdata: ?*anyopaque, fd: net.Socket.Handle, data: [][]u8) net.
21372137 };
21382138
21392139 while (true) {
2140 try pool.checkCancel();
2140 try t.checkCancel();
21412141 const rc = posix.system.readv(fd, dest.ptr, @intCast(dest.len));
21422142 switch (posix.errno(rc)) {
21432143 .SUCCESS => return @intCast(rc),
......@@ -2167,7 +2167,7 @@ fn netSend(
21672167 messages: []net.OutgoingMessage,
21682168 flags: net.SendFlags,
21692169) struct { ?net.Socket.SendError, usize } {
2170 const pool: *Pool = @ptrCast(@alignCast(userdata));
2170 const t: *Threaded = @ptrCast(@alignCast(userdata));
21712171
21722172 const posix_flags: u32 =
21732173 @as(u32, if (@hasDecl(posix.MSG, "CONFIRM") and flags.confirm) posix.MSG.CONFIRM else 0) |
......@@ -2180,17 +2180,17 @@ fn netSend(
21802180 var i: usize = 0;
21812181 while (messages.len - i != 0) {
21822182 if (have_sendmmsg) {
2183 i += netSendMany(pool, handle, messages[i..], posix_flags) catch |err| return .{ err, i };
2183 i += netSendMany(t, handle, messages[i..], posix_flags) catch |err| return .{ err, i };
21842184 continue;
21852185 }
2186 netSendOne(pool, handle, &messages[i], posix_flags) catch |err| return .{ err, i };
2186 netSendOne(t, handle, &messages[i], posix_flags) catch |err| return .{ err, i };
21872187 i += 1;
21882188 }
21892189 return .{ null, i };
21902190}
21912191
21922192fn netSendOne(
2193 pool: *Pool,
2193 t: *Threaded,
21942194 handle: net.Socket.Handle,
21952195 message: *net.OutgoingMessage,
21962196 flags: u32,
......@@ -2207,7 +2207,7 @@ fn netSendOne(
22072207 .flags = 0,
22082208 };
22092209 while (true) {
2210 try pool.checkCancel();
2210 try t.checkCancel();
22112211 const rc = posix.system.sendmsg(handle, msg, flags);
22122212 if (is_windows) {
22132213 if (rc == windows.ws2_32.SOCKET_ERROR) {
......@@ -2274,7 +2274,7 @@ fn netSendOne(
22742274}
22752275
22762276fn netSendMany(
2277 pool: *Pool,
2277 t: *Threaded,
22782278 handle: net.Socket.Handle,
22792279 messages: []net.OutgoingMessage,
22802280 flags: u32,
......@@ -2305,7 +2305,7 @@ fn netSendMany(
23052305 }
23062306
23072307 while (true) {
2308 try pool.checkCancel();
2308 try t.checkCancel();
23092309 const rc = posix.system.sendmmsg(handle, clamped_msgs.ptr, @intCast(clamped_msgs.len), flags);
23102310 switch (posix.errno(rc)) {
23112311 .SUCCESS => {
......@@ -2348,7 +2348,7 @@ fn netReceive(
23482348 flags: net.ReceiveFlags,
23492349 timeout: Io.Timeout,
23502350) struct { ?net.Socket.ReceiveTimeoutError, usize } {
2351 const pool: *Pool = @ptrCast(@alignCast(userdata));
2351 const t: *Threaded = @ptrCast(@alignCast(userdata));
23522352
23532353 // recvmmsg is useless, here's why:
23542354 // * [timeout bug](https://bugzilla.kernel.org/show_bug.cgi?id=75371)
......@@ -2375,10 +2375,10 @@ fn netReceive(
23752375 var message_i: usize = 0;
23762376 var data_i: usize = 0;
23772377
2378 const deadline = timeout.toDeadline(pool.io()) catch |err| return .{ err, message_i };
2378 const deadline = timeout.toDeadline(t.io()) catch |err| return .{ err, message_i };
23792379
23802380 recv: while (true) {
2381 pool.checkCancel() catch |err| return .{ err, message_i };
2381 t.checkCancel() catch |err| return .{ err, message_i };
23822382
23832383 if (message_buffer.len - message_i == 0) return .{ null, message_i };
23842384 const message = &message_buffer[message_i];
......@@ -2416,12 +2416,12 @@ fn netReceive(
24162416 continue;
24172417 },
24182418 .AGAIN => while (true) {
2419 pool.checkCancel() catch |err| return .{ err, message_i };
2419 t.checkCancel() catch |err| return .{ err, message_i };
24202420 if (message_i != 0) return .{ null, message_i };
24212421
24222422 const max_poll_ms = std.math.maxInt(u31);
24232423 const timeout_ms: u31 = if (deadline) |d| t: {
2424 const duration = d.durationFromNow(pool.io()) catch |err| return .{ err, message_i };
2424 const duration = d.durationFromNow(t.io()) catch |err| return .{ err, message_i };
24252425 if (duration.raw.nanoseconds <= 0) return .{ error.Timeout, message_i };
24262426 break :t @intCast(@min(max_poll_ms, duration.raw.toMilliseconds()));
24272427 } else max_poll_ms;
......@@ -2473,8 +2473,8 @@ fn netWritePosix(
24732473 data: []const []const u8,
24742474 splat: usize,
24752475) net.Stream.Writer.Error!usize {
2476 const pool: *Pool = @ptrCast(@alignCast(userdata));
2477 try pool.checkCancel();
2476 const t: *Threaded = @ptrCast(@alignCast(userdata));
2477 try t.checkCancel();
24782478
24792479 var iovecs: [max_iovecs_len]posix.iovec_const = undefined;
24802480 var msg: posix.msghdr_const = .{
......@@ -2527,8 +2527,8 @@ fn addBuf(v: []posix.iovec_const, i: *@FieldType(posix.msghdr_const, "iovlen"),
25272527}
25282528
25292529fn netClose(userdata: ?*anyopaque, handle: net.Socket.Handle) void {
2530 const pool: *Pool = @ptrCast(@alignCast(userdata));
2531 _ = pool;
2530 const t: *Threaded = @ptrCast(@alignCast(userdata));
2531 _ = t;
25322532 switch (native_os) {
25332533 .windows => windows.closesocket(handle) catch recoverableOsBugDetected(),
25342534 else => posix.close(handle),
......@@ -2539,10 +2539,10 @@ fn netInterfaceNameResolve(
25392539 userdata: ?*anyopaque,
25402540 name: *const net.Interface.Name,
25412541) net.Interface.Name.ResolveError!net.Interface {
2542 const pool: *Pool = @ptrCast(@alignCast(userdata));
2542 const t: *Threaded = @ptrCast(@alignCast(userdata));
25432543
25442544 if (native_os == .linux) {
2545 const sock_fd = openSocketPosix(pool, posix.AF.UNIX, .{ .mode = .dgram }) catch |err| switch (err) {
2545 const sock_fd = openSocketPosix(t, posix.AF.UNIX, .{ .mode = .dgram }) catch |err| switch (err) {
25462546 error.ProcessFdQuotaExceeded => return error.SystemResources,
25472547 error.SystemFdQuotaExceeded => return error.SystemResources,
25482548 error.AddressFamilyUnsupported => return error.Unexpected,
......@@ -2559,7 +2559,7 @@ fn netInterfaceNameResolve(
25592559 };
25602560
25612561 while (true) {
2562 try pool.checkCancel();
2562 try t.checkCancel();
25632563 switch (posix.errno(posix.system.ioctl(sock_fd, posix.SIOCGIFINDEX, @intFromPtr(&ifr)))) {
25642564 .SUCCESS => return .{ .index = @bitCast(ifr.ifru.ivalue) },
25652565 .INTR => continue,
......@@ -2576,14 +2576,14 @@ fn netInterfaceNameResolve(
25762576 }
25772577
25782578 if (native_os == .windows) {
2579 try pool.checkCancel();
2579 try t.checkCancel();
25802580 const index = std.os.windows.ws2_32.if_nametoindex(&name.bytes);
25812581 if (index == 0) return error.InterfaceNotFound;
25822582 return .{ .index = index };
25832583 }
25842584
25852585 if (builtin.link_libc) {
2586 try pool.checkCancel();
2586 try t.checkCancel();
25872587 const index = std.c.if_nametoindex(&name.bytes);
25882588 if (index == 0) return error.InterfaceNotFound;
25892589 return .{ .index = @bitCast(index) };
......@@ -2593,8 +2593,8 @@ fn netInterfaceNameResolve(
25932593}
25942594
25952595fn netInterfaceName(userdata: ?*anyopaque, interface: net.Interface) net.Interface.NameError!net.Interface.Name {
2596 const pool: *Pool = @ptrCast(@alignCast(userdata));
2597 try pool.checkCancel();
2596 const t: *Threaded = @ptrCast(@alignCast(userdata));
2597 try t.checkCancel();
25982598
25992599 if (native_os == .linux) {
26002600 _ = interface;
......@@ -2618,18 +2618,18 @@ fn netLookup(
26182618 resolved: *Io.Queue(HostName.LookupResult),
26192619 options: HostName.LookupOptions,
26202620) void {
2621 const pool: *Pool = @ptrCast(@alignCast(userdata));
2622 const pool_io = pool.io();
2623 resolved.putOneUncancelable(pool_io, .{ .end = netLookupFallible(pool, host_name, resolved, options) });
2621 const t: *Threaded = @ptrCast(@alignCast(userdata));
2622 const t_io = t.io();
2623 resolved.putOneUncancelable(t_io, .{ .end = netLookupFallible(t, host_name, resolved, options) });
26242624}
26252625
26262626fn netLookupFallible(
2627 pool: *Pool,
2627 t: *Threaded,
26282628 host_name: HostName,
26292629 resolved: *Io.Queue(HostName.LookupResult),
26302630 options: HostName.LookupOptions,
26312631) !void {
2632 const pool_io = pool.io();
2632 const t_io = t.io();
26332633 const name = host_name.bytes;
26342634 assert(name.len <= HostName.max_len);
26352635
......@@ -2648,7 +2648,7 @@ fn netLookupFallible(
26482648 if (native_os == .linux) {
26492649 if (options.family != .ip4) {
26502650 if (IpAddress.parseIp6(name, options.port)) |addr| {
2651 try resolved.putAll(pool_io, &.{
2651 try resolved.putAll(t_io, &.{
26522652 .{ .address = addr },
26532653 .{ .canonical_name = copyCanon(options.canonical_name_buffer, name) },
26542654 });
......@@ -2658,7 +2658,7 @@ fn netLookupFallible(
26582658
26592659 if (options.family != .ip6) {
26602660 if (IpAddress.parseIp4(name, options.port)) |addr| {
2661 try resolved.putAll(pool_io, &.{
2661 try resolved.putAll(t_io, &.{
26622662 .{ .address = addr },
26632663 .{ .canonical_name = copyCanon(options.canonical_name_buffer, name) },
26642664 });
......@@ -2666,7 +2666,7 @@ fn netLookupFallible(
26662666 } else |_| {}
26672667 }
26682668
2669 lookupHosts(pool, host_name, resolved, options) catch |err| switch (err) {
2669 lookupHosts(t, host_name, resolved, options) catch |err| switch (err) {
26702670 error.UnknownHostName => {},
26712671 else => |e| return e,
26722672 };
......@@ -2697,11 +2697,11 @@ fn netLookupFallible(
26972697 canon_name_dest.* = canon_name.*;
26982698 results_buffer[results_index] = .{ .canonical_name = .{ .bytes = canon_name_dest } };
26992699 results_index += 1;
2700 try resolved.putAll(pool_io, results_buffer[0..results_index]);
2700 try resolved.putAll(t_io, results_buffer[0..results_index]);
27012701 return;
27022702 }
27032703
2704 return lookupDnsSearch(pool, host_name, resolved, options);
2704 return lookupDnsSearch(t, host_name, resolved, options);
27052705 }
27062706
27072707 if (native_os == .openbsd) {
......@@ -2953,13 +2953,13 @@ fn pathToPosix(file_path: []const u8, buffer: *[posix.PATH_MAX]u8) Io.Dir.PathNa
29532953}
29542954
29552955fn lookupDnsSearch(
2956 pool: *Pool,
2956 t: *Threaded,
29572957 host_name: HostName,
29582958 resolved: *Io.Queue(HostName.LookupResult),
29592959 options: HostName.LookupOptions,
29602960) HostName.LookupError!void {
2961 const pool_io = pool.io();
2962 const rc = HostName.ResolvConf.init(pool_io) catch return error.ResolvConfParseFailed;
2961 const t_io = t.io();
2962 const rc = HostName.ResolvConf.init(t_io) catch return error.ResolvConfParseFailed;
29632963
29642964 // Count dots, suppress search when >=ndots or name ends in
29652965 // a dot, which is an explicit request for global scope.
......@@ -2983,7 +2983,7 @@ fn lookupDnsSearch(
29832983 while (it.next()) |token| {
29842984 @memcpy(options.canonical_name_buffer[canon_name.len + 1 ..][0..token.len], token);
29852985 const lookup_canon_name = options.canonical_name_buffer[0 .. canon_name.len + 1 + token.len];
2986 if (lookupDns(pool, lookup_canon_name, &rc, resolved, options)) |result| {
2986 if (lookupDns(t, lookup_canon_name, &rc, resolved, options)) |result| {
29872987 return result;
29882988 } else |err| switch (err) {
29892989 error.UnknownHostName => continue,
......@@ -2992,17 +2992,17 @@ fn lookupDnsSearch(
29922992 }
29932993
29942994 const lookup_canon_name = options.canonical_name_buffer[0..canon_name.len];
2995 return lookupDns(pool, lookup_canon_name, &rc, resolved, options);
2995 return lookupDns(t, lookup_canon_name, &rc, resolved, options);
29962996}
29972997
29982998fn lookupDns(
2999 pool: *Pool,
2999 t: *Threaded,
30003000 lookup_canon_name: []const u8,
30013001 rc: *const HostName.ResolvConf,
30023002 resolved: *Io.Queue(HostName.LookupResult),
30033003 options: HostName.LookupOptions,
30043004) HostName.LookupError!void {
3005 const pool_io = pool.io();
3005 const t_io = t.io();
30063006 const family_records: [2]struct { af: IpAddress.Family, rr: u8 } = .{
30073007 .{ .af = .ip6, .rr = std.posix.RR.A },
30083008 .{ .af = .ip4, .rr = std.posix.RR.AAAA },
......@@ -3032,7 +3032,7 @@ fn lookupDns(
30323032 var socket = s: {
30333033 if (any_ip6) ip6: {
30343034 const ip6_addr: IpAddress = .{ .ip6 = .unspecified(0) };
3035 const socket = ip6_addr.bind(pool_io, .{ .ip6_only = true, .mode = .dgram }) catch |err| switch (err) {
3035 const socket = ip6_addr.bind(t_io, .{ .ip6_only = true, .mode = .dgram }) catch |err| switch (err) {
30363036 error.AddressFamilyUnsupported => break :ip6,
30373037 else => |e| return e,
30383038 };
......@@ -3040,10 +3040,10 @@ fn lookupDns(
30403040 }
30413041 any_ip6 = false;
30423042 const ip4_addr: IpAddress = .{ .ip4 = .unspecified(0) };
3043 const socket = try ip4_addr.bind(pool_io, .{ .mode = .dgram });
3043 const socket = try ip4_addr.bind(t_io, .{ .mode = .dgram });
30443044 break :s socket;
30453045 };
3046 defer socket.close(pool_io);
3046 defer socket.close(t_io);
30473047
30483048 const mapped_nameservers = if (any_ip6) ip4_mapped[0..rc.nameservers_len] else rc.nameservers();
30493049 const queries = queries_buffer[0..nq];
......@@ -3054,13 +3054,13 @@ fn lookupDns(
30543054 // boot clock is chosen because time the computer is suspended should count
30553055 // against time spent waiting for external messages to arrive.
30563056 const clock: Io.Clock = .boot;
3057 var now_ts = try clock.now(pool_io);
3057 var now_ts = try clock.now(t_io);
30583058 const final_ts = now_ts.addDuration(.fromSeconds(rc.timeout_seconds));
30593059 const attempt_duration: Io.Duration = .{
30603060 .nanoseconds = std.time.ns_per_s * @as(usize, rc.timeout_seconds) / rc.attempts,
30613061 };
30623062
3063 send: while (now_ts.nanoseconds < final_ts.nanoseconds) : (now_ts = try clock.now(pool_io)) {
3063 send: while (now_ts.nanoseconds < final_ts.nanoseconds) : (now_ts = try clock.now(t_io)) {
30643064 const max_messages = queries_buffer.len * HostName.ResolvConf.max_nameservers;
30653065 {
30663066 var message_buffer: [max_messages]Io.net.OutgoingMessage = undefined;
......@@ -3076,7 +3076,7 @@ fn lookupDns(
30763076 message_i += 1;
30773077 }
30783078 }
3079 _ = netSend(pool, socket.handle, message_buffer[0..message_i], .{});
3079 _ = netSend(t, socket.handle, message_buffer[0..message_i], .{});
30803080 }
30813081
30823082 const timeout: Io.Timeout = .{ .deadline = .{
......@@ -3087,7 +3087,7 @@ fn lookupDns(
30873087 while (true) {
30883088 var message_buffer: [max_messages]Io.net.IncomingMessage = undefined;
30893089 const buf = answer_buffer[answer_buffer_i..];
3090 const recv_err, const recv_n = socket.receiveManyTimeout(pool_io, &message_buffer, buf, .{}, timeout);
3090 const recv_err, const recv_n = socket.receiveManyTimeout(t_io, &message_buffer, buf, .{}, timeout);
30913091 for (message_buffer[0..recv_n]) |*received_message| {
30923092 const reply = received_message.data;
30933093 // Ignore non-identifiable packets.
......@@ -3124,7 +3124,7 @@ fn lookupDns(
31243124 .data_ptr = query.ptr,
31253125 .data_len = query.len,
31263126 };
3127 _ = netSend(pool, socket.handle, (&retry_message)[0..1], .{});
3127 _ = netSend(t, socket.handle, (&retry_message)[0..1], .{});
31283128 continue;
31293129 },
31303130 else => continue,
......@@ -3155,7 +3155,7 @@ fn lookupDns(
31553155 std.posix.RR.A => {
31563156 const data = record.packet[record.data_off..][0..record.data_len];
31573157 if (data.len != 4) return error.InvalidDnsARecord;
3158 try resolved.putOne(pool_io, .{ .address = .{ .ip4 = .{
3158 try resolved.putOne(t_io, .{ .address = .{ .ip4 = .{
31593159 .bytes = data[0..4].*,
31603160 .port = options.port,
31613161 } } });
......@@ -3164,7 +3164,7 @@ fn lookupDns(
31643164 std.posix.RR.AAAA => {
31653165 const data = record.packet[record.data_off..][0..record.data_len];
31663166 if (data.len != 16) return error.InvalidDnsAAAARecord;
3167 try resolved.putOne(pool_io, .{ .address = .{ .ip6 = .{
3167 try resolved.putOne(t_io, .{ .address = .{ .ip6 = .{
31683168 .bytes = data[0..16].*,
31693169 .port = options.port,
31703170 } } });
......@@ -3178,18 +3178,18 @@ fn lookupDns(
31783178 };
31793179 }
31803180
3181 try resolved.putOne(pool_io, .{ .canonical_name = canonical_name orelse .{ .bytes = lookup_canon_name } });
3181 try resolved.putOne(t_io, .{ .canonical_name = canonical_name orelse .{ .bytes = lookup_canon_name } });
31823182 if (addresses_len == 0) return error.NameServerFailure;
31833183}
31843184
31853185fn lookupHosts(
3186 pool: *Pool,
3186 t: *Threaded,
31873187 host_name: HostName,
31883188 resolved: *Io.Queue(HostName.LookupResult),
31893189 options: HostName.LookupOptions,
31903190) !void {
3191 const pool_io = pool.io();
3192 const file = Io.File.openAbsolute(pool_io, "/etc/hosts", .{}) catch |err| switch (err) {
3191 const t_io = t.io();
3192 const file = Io.File.openAbsolute(t_io, "/etc/hosts", .{}) catch |err| switch (err) {
31933193 error.FileNotFound,
31943194 error.NotDir,
31953195 error.AccessDenied,
......@@ -3202,11 +3202,11 @@ fn lookupHosts(
32023202 return error.DetectingNetworkConfigurationFailed;
32033203 },
32043204 };
3205 defer file.close(pool_io);
3205 defer file.close(t_io);
32063206
32073207 var line_buf: [512]u8 = undefined;
3208 var file_reader = file.reader(pool_io, &line_buf);
3209 return lookupHostsReader(pool, host_name, resolved, options, &file_reader.interface) catch |err| switch (err) {
3208 var file_reader = file.reader(t_io, &line_buf);
3209 return lookupHostsReader(t, host_name, resolved, options, &file_reader.interface) catch |err| switch (err) {
32103210 error.ReadFailed => switch (file_reader.err.?) {
32113211 error.Canceled => |e| return e,
32123212 else => {
......@@ -3220,13 +3220,13 @@ fn lookupHosts(
32203220}
32213221
32223222fn lookupHostsReader(
3223 pool: *Pool,
3223 t: *Threaded,
32243224 host_name: HostName,
32253225 resolved: *Io.Queue(HostName.LookupResult),
32263226 options: HostName.LookupOptions,
32273227 reader: *Io.Reader,
32283228) error{ ReadFailed, Canceled, UnknownHostName }!void {
3229 const pool_io = pool.io();
3229 const t_io = t.io();
32303230 var addresses_len: usize = 0;
32313231 var canonical_name: ?HostName = null;
32323232 while (true) {
......@@ -3268,19 +3268,19 @@ fn lookupHostsReader(
32683268
32693269 if (options.family != .ip6) {
32703270 if (IpAddress.parseIp4(ip_text, options.port)) |addr| {
3271 try resolved.putOne(pool_io, .{ .address = addr });
3271 try resolved.putOne(t_io, .{ .address = addr });
32723272 addresses_len += 1;
32733273 } else |_| {}
32743274 }
32753275 if (options.family != .ip4) {
32763276 if (IpAddress.parseIp6(ip_text, options.port)) |addr| {
3277 try resolved.putOne(pool_io, .{ .address = addr });
3277 try resolved.putOne(t_io, .{ .address = addr });
32783278 addresses_len += 1;
32793279 } else |_| {}
32803280 }
32813281 }
32823282
3283 if (canonical_name) |canon_name| try resolved.putOne(pool_io, .{ .canonical_name = canon_name });
3283 if (canonical_name) |canon_name| try resolved.putOne(t_io, .{ .canonical_name = canon_name });
32843284 if (addresses_len == 0) return error.UnknownHostName;
32853285}
32863286