@zigc/lib 0.16.0-dev.3061 → 0.16.0-dev.3070

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.16.0-dev.3061",
+  "version": "0.16.0-dev.3070",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/WebServer.zig

@@ -6,7 +6,7 @@ root_prog_node: std.Progress.Node,
 watch: bool,
 
 tcp_server: ?net.Server,
-serve_thread: ?std.Thread,
+serve_task: ?Io.Future(Io.Cancelable!void),
 
 /// Uses `Io.Clock.awake`.
 base_timestamp: Io.Timestamp,
@@ -103,7 +103,7 @@ pub fn init(opts: Options) WebServer {
         .watch = opts.watch,
 
         .tcp_server = null,
-        .serve_thread = null,
+        .serve_task = null,
 
         .base_timestamp = opts.base_timestamp.raw,
         .step_names_trailing = step_names_trailing,
@@ -136,9 +136,9 @@ pub fn deinit(ws: *WebServer) void {
     gpa.free(ws.time_report_msgs);
     gpa.free(ws.time_report_update_times);
 
-    if (ws.serve_thread) |t| {
+    if (ws.serve_task) |t| {
         if (ws.tcp_server) |*s| s.stream.close(io);
-        t.join();
+        t.await();
     }
     if (ws.tcp_server) |*s| s.deinit();
 
@@ -146,15 +146,15 @@ pub fn deinit(ws: *WebServer) void {
 }
 pub fn start(ws: *WebServer) error{AlreadyReported}!void {
     assert(ws.tcp_server == null);
-    assert(ws.serve_thread == null);
+    assert(ws.serve_task == null);
     const io = ws.graph.io;
 
     ws.tcp_server = ws.listen_address.listen(io, .{ .reuse_address = true }) catch |err| {
-        log.err("failed to listen to port {d}: {s}", .{ ws.listen_address.getPort(), @errorName(err) });
+        log.err("failed to listen to port {d}: {t}", .{ ws.listen_address.getPort(), err });
         return error.AlreadyReported;
     };
-    ws.serve_thread = std.Thread.spawn(.{}, serve, .{ws}) catch |err| {
-        log.err("unable to spawn web server thread: {s}", .{@errorName(err)});
+    ws.serve_task = io.concurrent(serve, .{ws}) catch |err| {
+        log.err("unable to spawn web server thread: {t}", .{err});
         ws.tcp_server.?.deinit(io);
         ws.tcp_server = null;
         return error.AlreadyReported;
@@ -165,15 +165,20 @@ pub fn start(ws: *WebServer) error{AlreadyReported}!void {
         log.info("hint: pass '--webui={f}' to use the same port next time", .{ws.tcp_server.?.socket.address});
     }
 }
-fn serve(ws: *WebServer) void {
+fn serve(ws: *WebServer) Io.Cancelable!void {
     const io = ws.graph.io;
+    var group: Io.Group = .init;
+    defer group.cancel(io);
     while (true) {
-        var stream = ws.tcp_server.?.accept(io) catch |err| {
-            log.err("failed to accept connection: {s}", .{@errorName(err)});
-            return;
+        var stream = ws.tcp_server.?.accept(io) catch |err| switch (err) {
+            error.Canceled => |e| return e,
+            else => |e| {
+                log.err("failed to accept connection: {t}", .{e});
+                return;
+            },
         };
-        _ = std.Thread.spawn(.{}, accept, .{ ws, stream }) catch |err| {
-            log.err("unable to spawn connection thread: {s}", .{@errorName(err)});
+        group.concurrent(io, accept, .{ ws, stream }) catch |err| {
+            log.err("unable to spawn connection thread: {t}", .{err});
             stream.close(io);
             continue;
         };
@@ -303,8 +308,8 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn {
         copy.* = @atomicLoad(u8, shared, .monotonic);
     }
 
-    const recv_thread = try std.Thread.spawn(.{}, recvWebSocketMessages, .{ ws, sock });
-    defer recv_thread.join();
+    var recv_thread = try io.concurrent(recvWebSocketMessages, .{ ws, sock });
+    defer recv_thread.cancel(io);
 
     {
         const hello_header: abi.Hello = .{

package/std/Thread.zig

@@ -1147,6 +1147,11 @@ const LinuxThreadImpl = struct {
         /// Ported over from musl libc's pthread detached implementation:
         /// https://github.com/ifduyue/musl/search?q=__unmapself
         fn freeAndExit(self: *ThreadCompletion) noreturn {
+            // If we do not reset the child_tidptr to null here, the kernel would later write the
+            // value zero to that address, which is inside the block we're unmapping below, after
+            // our thread exits.  This can sometimes corrupt memory in other mmap blocks from
+            // unrelated concurrent threads.
+            _ = linux.set_tid_address(null);
             // If a signal were delivered between SYS_munmap and SYS_exit, any installed signal
             // handler would immediately segfault due to the stack being unmapped. To avoid this,
             // we need to mask all signals before entering the inline asm.
@@ -1484,7 +1489,7 @@ const LinuxThreadImpl = struct {
         }
 
         // Prepare the TLS segment and prepare a user_desc struct when needed on x86
-        var tls_ptr = linux.tls.prepareArea(mapped[tls_offset..]);
+        var tls_ptr = linux.tls.prepareArea(mapped[tls_offset..][0..linux.tls.area_desc.size]);
         var user_desc: if (target.cpu.arch == .x86) linux.user_desc else void = undefined;
         if (target.cpu.arch == .x86) {
             defer tls_ptr = @intFromPtr(&user_desc);

package/std/os/linux.zig

@@ -1584,6 +1584,11 @@ pub fn clone2(flags: u32, child_stack_ptr: usize) usize {
     return syscall2(.clone, flags, child_stack_ptr);
 }
 
+/// This call cannot fail, and the return value is the caller's thread id
+pub fn set_tid_address(tidptr: ?*pid_t) pid_t {
+    return @intCast(@as(u32, @truncate(syscall1(.set_tid_address, @intFromPtr(tidptr)))));
+}
+
 pub fn close(fd: fd_t) usize {
     return syscall1(.close, @as(usize, @bitCast(@as(isize, fd))));
 }