Commit f0aefa625b5b0d0b3612cfba9bd25c825a71818f | zig

author	Pat Tullmann <pat.github@tullmann.org> 2025-04-22 09:31:14-07:00
committer	Pat Tullmann <pat.github@tullmann.org> 2025-04-30 20:32:04-07:00
log	f0aefa625b5b0d0b3612cfba9bd25c825a71818f
tree	b4b4d660ed9d2795a7bacf454ba4d803b49d8450
parent	d16079d79a6b7963db05253b6a3fe57a7e19d813

posix: remove empty_sigset

When linking a libc, Zig should defer to the C library for sigset
operations.  The pre-filled constants signal sets (empty_sigset,
filled_sigset) are not compatible with C library initialization, so remove
them and use the runtime `sigemptyset` and `sigfillset` methods to
initialize any sigset.

7 files changed, 26 insertions(+), 19 deletions(-)

lib
- std
  - Progress.zig
  - debug.zig
  - posix.zig
  - posix
    test.zig
  - start.zig
src
- crash_report.zig
test
- standalone
  - sigpipe
    build.zig

lib/std/Progress.zig+2-1

 @@ -412,9 +412,10 @@ pub fn start(options: Options) Node {
             if (have_sigwinch) {
                 var act: posix.Sigaction = .{
                     .handler = .{ .sigaction = handleSigWinch },
-                    .mask = posix.empty_sigset,
+                    .mask = undefined,
                     .flags = (posix.SA.SIGINFO | posix.SA.RESTART),
                 };
+                posix.sigemptyset(&act.mask);
                 posix.sigaction(posix.SIG.WINCH, &act, null);
             }

lib/std/debug.zig+4-2

 @@ -1389,9 +1389,10 @@ pub fn attachSegfaultHandler() void {
     }
     var act = posix.Sigaction{
         .handler = .{ .sigaction = handleSegfaultPosix },
-        .mask = posix.empty_sigset,
+        .mask = undefined,
         .flags = (posix.SA.SIGINFO | posix.SA.RESTART | posix.SA.RESETHAND),
     };
+    posix.sigemptyset(&act.mask);
     updateSegfaultHandler(&act);
 }
 @@ -1406,9 +1407,10 @@ fn resetSegfaultHandler() void {
     }
     var act = posix.Sigaction{
         .handler = .{ .handler = posix.SIG.DFL },
-        .mask = posix.empty_sigset,
+        .mask = undefined,
         .flags = 0,
     };
+    posix.sigemptyset(&act.mask);
     updateSegfaultHandler(&act);
 }

lib/std/posix.zig+3-4

 @@ -127,7 +127,6 @@ pub const timerfd_clockid_t = system.timerfd_clockid_t;
 pub const cpu_set_t = system.cpu_set_t;
 pub const dev_t = system.dev_t;
 pub const dl_phdr_info = system.dl_phdr_info;
-pub const empty_sigset = system.empty_sigset;
 pub const fd_t = system.fd_t;
 pub const file_obj = system.file_obj;
 pub const gid_t = system.gid_t;
 @@ -691,14 +690,14 @@ pub fn abort() noreturn {
         // Install default handler so that the tkill below will terminate.
         const sigact = Sigaction{
             .handler = .{ .handler = SIG.DFL },
-            .mask = empty_sigset,
+            .mask = linux.empty_sigset,
             .flags = 0,
         };
         sigaction(SIG.ABRT, &sigact, null);
         _ = linux.tkill(linux.gettid(), SIG.ABRT);
-        var sigabrtmask = empty_sigset;
+        var sigabrtmask = linux.empty_sigset;
         sigaddset(&sigabrtmask, SIG.ABRT);
         sigprocmask(SIG.UNBLOCK, &sigabrtmask, null);
 @@ -5831,7 +5830,7 @@ pub fn sigemptyset(set: *sigset_t) void {
             else => unreachable,
         }
     }
-    set.* = system.empty_sigset;
+    set.* = mem.zeroes(sigset_t);
 }
 pub fn sigaddset(set: *sigset_t, sig: u8) void {

lib/std/posix/test.zig+9-6

 @@ -887,7 +887,8 @@ test "sigset add/del" {
     if (native_os == .wasi or native_os == .windows)
         return error.SkipZigTest;
-    var sigset = posix.empty_sigset;
+    var sigset: posix.sigset_t = undefined;
+    posix.sigemptyset(&sigset);
     // See that none are set, then set each one, see that they're all set, then
     // remove them all, and then see that none are set.
 @@ -903,7 +904,6 @@ test "sigset add/del" {
         if (!reserved_signo(i)) {
             try expectEqual(true, posix.sigismember(&sigset, @truncate(i)));
         }
-        try expectEqual(false, posix.sigismember(&posix.empty_sigset, @truncate(i)));
     }
     for (1..posix.NSIG) |i| {
         if (!reserved_signo(i)) {
 @@ -944,9 +944,10 @@ test "sigaction" {
     var sa: posix.Sigaction = .{
         .handler = .{ .sigaction = &S.handler },
-        .mask = posix.empty_sigset,
+        .mask = undefined,
         .flags = posix.SA.SIGINFO | posix.SA.RESETHAND,
     };
+    posix.sigemptyset(&sa.mask);
     var old_sa: posix.Sigaction = undefined;
     // Install the new signal handler.
 @@ -1019,17 +1020,19 @@ test "sigset_t bits" {
         var sa: posix.Sigaction = .{
             .handler = .{ .sigaction = &S.handler },
-            .mask = posix.empty_sigset,
+            .mask = undefined,
             .flags = posix.SA.SIGINFO | posix.SA.RESETHAND,
         };
+        posix.sigemptyset(&sa.mask);
         var old_sa: posix.Sigaction = undefined;
         // Install the new signal handler.
         posix.sigaction(test_signo, &sa, &old_sa);
         // block the signal and see that its delayed until unblocked
-        var block_one = posix.empty_sigset;
+        var block_one: posix.sigset_t = undefined;
-        _ = posix.sigaddset(&block_one, test_signo);
+        posix.sigemptyset(&block_one);
+        posix.sigaddset(&block_one, test_signo);
         posix.sigprocmask(posix.SIG.BLOCK, &block_one, null);
         // qemu maps target signals to host signals 1-to-1, so targets

lib/std/start.zig+3-2

 @@ -745,13 +745,14 @@ fn maybeIgnoreSigpipe() void {
     if (have_sigpipe_support and !std.options.keep_sigpipe) {
         const posix = std.posix;
-        const act: posix.Sigaction = .{
+        var act: posix.Sigaction = .{
             // Set handler to a noop function instead of `SIG.IGN` to prevent
             // leaking signal disposition to a child process.
             .handler = .{ .handler = noopSigHandler },
-            .mask = posix.empty_sigset,
+            .mask = undefined,
             .flags = 0,
         };
+        posix.sigemptyset(&act.mask);
         posix.sigaction(posix.SIG.PIPE, &act, null);
     }
 }

src/crash_report.zig+2-2

...	@@ -177,10 +177,10 @@ pub fn attachSegfaultHandler() void {	...	@@ -177,10 +177,10 @@ pub fn attachSegfaultHandler() void {
177	}	177	}
178	var act: posix.Sigaction = .{	178	var act: posix.Sigaction = .{
179	.handler = .{ .sigaction = handleSegfaultPosix },	179	.handler = .{ .sigaction = handleSegfaultPosix },
180	.mask = posix.empty_sigset,	180	.mask = undefined,
181	.flags = (posix.SA.SIGINFO \| posix.SA.RESTART \| posix.SA.RESETHAND),	181	.flags = (posix.SA.SIGINFO \| posix.SA.RESTART \| posix.SA.RESETHAND),
182	};	182	};
183		183	posix.sigemptyset(&act.mask);
184	debug.updateSegfaultHandler(&act);	184	debug.updateSegfaultHandler(&act);
185	}	185	}
186		186

test/standalone/sigpipe/build.zig+3-2

 @@ -16,11 +16,12 @@ pub fn build(b: *std.build.Builder) !void {
     // This test runs "breakpipe" as a child process and that process
     // depends on inheriting a SIGPIPE disposition of "default".
     {
-        const act = posix.Sigaction{
+        var act = posix.Sigaction{
             .handler = .{ .handler = posix.SIG.DFL },
-            .mask = posix.empty_sigset,
+            .mask = undefined,
             .flags = 0,
         };
+        posix.sigemptyset(&act.mask);
         try posix.sigaction(posix.SIG.PIPE, &act, null);
     }