authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-10-28 18:45:53-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-10-29 06:20:52-07:00
log05b28409e7204f78e3edb32ea9c46b10e4e97cef
tree4db0f476cbb8718941df6c07a375ee384f1b0d00
parentb863f2548b95cdc8b2e2818ac3a26e553be155dc

std.Io.Threaded: install and cleanup signal handlers

rather than in start code. delete std.options.keep_sig_io and std.options.keep_sig_pipe

4 files changed, 38 insertions(+), 37 deletions(-)

lib/std/Io/Threaded.zig+37-1
......@@ -26,8 +26,13 @@ threads: std.ArrayListUnmanaged(std.Thread),
2626stack_size: usize,
2727cpu_count: std.Thread.CpuCountError!usize,
2828concurrent_count: usize,
29
2930wsa: if (is_windows) Wsa else struct {} = .{},
3031
32have_signal_handler: bool,
33old_sig_io: if (have_sig_io) posix.Sigaction else void,
34old_sig_pipe: if (have_sig_pipe) posix.Sigaction else void,
35
3136threadlocal var current_closure: ?*Closure = null;
3237
3338const max_iovecs_len = 8;
......@@ -104,23 +109,46 @@ pub fn init(
104109 .stack_size = std.Thread.SpawnConfig.default_stack_size,
105110 .cpu_count = std.Thread.getCpuCount(),
106111 .concurrent_count = 0,
112 .old_sig_io = undefined,
113 .old_sig_pipe = undefined,
114 .have_signal_handler = false,
107115 };
116
108117 if (t.cpu_count) |n| {
109118 t.threads.ensureTotalCapacityPrecise(gpa, n - 1) catch {};
110119 } else |_| {}
120
121 if (posix.Sigaction != void) {
122 // This causes sending `posix.SIG.IO` to thread to interrupt blocking
123 // syscalls, returning `posix.E.INTR`.
124 const act: posix.Sigaction = .{
125 .handler = .{ .handler = doNothingSignalHandler },
126 .mask = posix.sigemptyset(),
127 .flags = 0,
128 };
129 if (have_sig_io) posix.sigaction(.IO, &act, &t.old_sig_io);
130 if (have_sig_pipe) posix.sigaction(.PIPE, &act, &t.old_sig_pipe);
131 t.have_signal_handler = true;
132 }
133
111134 return t;
112135}
113136
114137/// Statically initialize such that calls to `Io.VTable.concurrent` will fail
115138/// with `error.ConcurrencyUnavailable`.
116139///
117/// When initialized this way, `deinit` is safe, but unnecessary to call.
140/// When initialized this way:
141/// * cancel requests have no effect.
142/// * `deinit` is safe, but unnecessary to call.
118143pub const init_single_threaded: Threaded = .{
119144 .allocator = .failing,
120145 .threads = .empty,
121146 .stack_size = std.Thread.SpawnConfig.default_stack_size,
122147 .cpu_count = 1,
123148 .concurrent_count = 0,
149 .old_sig_io = undefined,
150 .old_sig_pipe = undefined,
151 .have_signal_handler = false,
124152};
125153
126154pub fn deinit(t: *Threaded) void {
......@@ -130,6 +158,10 @@ pub fn deinit(t: *Threaded) void {
130158 if (is_windows and t.wsa.status == .initialized) {
131159 if (ws2_32.WSACleanup() != 0) recoverableOsBugDetected();
132160 }
161 if (posix.Sigaction != void and t.have_signal_handler) {
162 if (have_sig_io) posix.sigaction(.IO, &t.old_sig_io, null);
163 if (have_sig_pipe) posix.sigaction(.PIPE, &t.old_sig_pipe, null);
164 }
133165 t.* = undefined;
134166}
135167
......@@ -338,6 +370,8 @@ const have_preadv = switch (native_os) {
338370 .windows, .haiku, .serenity => false, // 💩💩💩
339371 else => true,
340372};
373const have_sig_io = posix.SIG != void and @hasField(posix.SIG, "IO");
374const have_sig_pipe = posix.SIG != void and @hasField(posix.SIG, "PIPE");
341375
342376const openat_sym = if (posix.lfs64_abi) posix.system.openat64 else posix.system.openat;
343377const fstat_sym = if (posix.lfs64_abi) posix.system.fstat64 else posix.system.fstat;
......@@ -6115,6 +6149,8 @@ fn initializeWsa(t: *Threaded) error{NetworkDown}!void {
61156149 return error.NetworkDown;
61166150}
61176151
6152fn doNothingSignalHandler(_: posix.SIG) callconv(.c) void {}
6153
61186154test {
61196155 _ = @import("Threaded/test.zig");
61206156}
lib/std/posix.zig+1
......@@ -55,6 +55,7 @@ else switch (native_os) {
5555 pub const mode_t = u0;
5656 pub const ino_t = void;
5757 pub const IFNAMESIZE = {};
58 pub const SIG = void;
5859 },
5960};
6061
lib/std/start.zig-21
......@@ -651,7 +651,6 @@ inline fn callMainWithArgs(argc: usize, argv: [*][*:0]u8, envp: [][*:0]u8) u8 {
651651 std.os.argv = argv[0..argc];
652652 std.os.environ = envp;
653653
654 maybeIgnoreSignals();
655654 std.debug.maybeEnableSegfaultHandler();
656655
657656 return callMain();
......@@ -756,23 +755,3 @@ pub fn call_wWinMain() std.os.windows.INT {
756755 // second parameter hPrevInstance, MSDN: "This parameter is always NULL"
757756 return root.wWinMain(hInstance, null, lpCmdLine, nCmdShow);
758757}
759
760fn maybeIgnoreSignals() void {
761 const posix = std.posix;
762 if (posix.Sigaction == void) return;
763 const act: posix.Sigaction = .{
764 // Set handler to a noop function instead of `IGN` to prevent
765 // leaking signal disposition to a child process.
766 .handler = .{ .handler = noopSigHandler },
767 .mask = posix.sigemptyset(),
768 .flags = 0,
769 };
770
771 if (@hasField(posix.SIG, "IO") and !std.options.keep_sig_io)
772 posix.sigaction(.IO, &act, null);
773
774 if (@hasField(posix.SIG, "PIPE") and !std.options.keep_sig_pipe)
775 posix.sigaction(.PIPE, &act, null);
776}
777
778fn noopSigHandler(_: std.posix.SIG) callconv(.c) void {}
lib/std/std.zig-15
......@@ -144,21 +144,6 @@ pub const Options = struct {
144144
145145 crypto_fork_safety: bool = true,
146146
147 keep_sig_io: bool = false,
148
149 /// By default Zig disables SIGPIPE by setting a "no-op" handler for it. Set this option
150 /// to `true` to prevent that.
151 ///
152 /// Note that we use a "no-op" handler instead of SIG_IGN because it will not be inherited by
153 /// any child process.
154 ///
155 /// SIGPIPE is triggered when a process attempts to write to a broken pipe. By default, SIGPIPE
156 /// will terminate the process instead of exiting. It doesn't trigger the panic handler so in many
157 /// cases it's unclear why the process was terminated. By capturing SIGPIPE instead, functions that
158 /// write to broken pipes will return the EPIPE error (error.BrokenPipe) and the program can handle
159 /// it like any other error.
160 keep_sig_pipe: bool = false,
161
162147 /// By default, std.http.Client will support HTTPS connections. Set this option to `true` to
163148 /// disable TLS support.
164149 ///