Commit 120c4789c31c066f15fe414a5b32cdc7e80a065c | zig

author	Pat Tullmann <pat.github@tullmann.org> 2025-04-22 14:19:06-07:00
committer	Pat Tullmann <pat.github@tullmann.org> 2025-04-30 20:32:04-07:00
log	120c4789c31c066f15fe414a5b32cdc7e80a065c
tree	e45c5a1dd84791676bb8f516fc0c2c0200cfe0c0
parent	f0aefa625b5b0d0b3612cfba9bd25c825a71818f

sigset_t: sigemptyset() and sigfillset() are functions that return sigset_t

By returning an initialized sigset (instead of taking the set as an output
parameter), these functions can be used to directly initialize the `mask`
parameter of a `Sigaction` instance.

11 files changed, 65 insertions(+), 63 deletions(-)

lib
- std
  - Progress.zig
  - debug.zig
  - os
    emscripten.zig
    linux.zig
    linux
    test.zig
    plan9.zig
  - posix.zig
  - posix
    test.zig
  - start.zig
src
- crash_report.zig
test
- standalone
  - sigpipe
    build.zig

lib/std/Progress.zig+2-3

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

lib/std/debug.zig+4-7

 @@ -1387,13 +1387,11 @@ pub fn attachSegfaultHandler() void {
         windows_segfault_handle = windows.kernel32.AddVectoredExceptionHandler(0, handleSegfaultWindows);
         return;
     }
-    var act = posix.Sigaction{
+    const act = posix.Sigaction{
         .handler = .{ .sigaction = handleSegfaultPosix },
-        .mask = undefined,
+        .mask = posix.sigemptyset(),
         .flags = (posix.SA.SIGINFO | posix.SA.RESTART | posix.SA.RESETHAND),
     };
-    posix.sigemptyset(&act.mask);
     updateSegfaultHandler(&act);
 }
 @@ -1405,12 +1403,11 @@ fn resetSegfaultHandler() void {
         }
         return;
     }
-    var act = posix.Sigaction{
+    const act = posix.Sigaction{
         .handler = .{ .handler = posix.SIG.DFL },
-        .mask = undefined,
+        .mask = posix.sigemptyset(),
         .flags = 0,
     };
-    posix.sigemptyset(&act.mask);
     updateSegfaultHandler(&act);
 }

lib/std/os/emscripten.zig+3-1

 @@ -560,7 +560,9 @@ pub const Sigaction = extern struct {
 };
 pub const sigset_t = [1024 / 32]u32;
-pub const empty_sigset = [_]u32{0} ** @typeInfo(sigset_t).array.len;
+pub fn sigemptyset() sigset_t {
+    return [_]u32{0} ** @typeInfo(sigset_t).array.len;
+}
 pub const siginfo_t = extern struct {
     signo: i32,
     errno: i32,

lib/std/os/linux.zig+8-4

 @@ -1800,11 +1800,15 @@ const SigsetElement = c_ulong;
 const sigset_len = @typeInfo(sigset_t).array.len;
-/// Empty set to initialize sigset_t instances from.  No need for `sigemptyset`.
+/// Zig's version of sigemptyset.  Returns initialized sigset_t.
-pub const empty_sigset: sigset_t = [_]SigsetElement{0} ** sigset_len;
+pub fn sigemptyset() sigset_t {
+    return [_]SigsetElement{0} ** sigset_len;
+}
-/// Filled set to initialize sigset_t instances from.  No need for `sigfillset`.
+/// Zig's version of sigfillset.  Returns initalized sigset_t.
-pub const filled_sigset: sigset_t = [_]SigsetElement{~@as(SigsetElement, 0)} ** sigset_len;
+pub fn sigfillset() sigset_t {
+    return [_]SigsetElement{~@as(SigsetElement, 0)} ** sigset_len;
+}
 fn sigset_bit_index(sig: usize) struct { word: usize, mask: SigsetElement } {
     assert(sig > 0);

lib/std/os/linux/test.zig+5-7

 @@ -128,7 +128,7 @@ test "fadvise" {
 test "sigset_t" {
     std.debug.assert(@sizeOf(linux.sigset_t) == (linux.NSIG / 8));
-    var sigset = linux.empty_sigset;
+    var sigset = linux.sigemptyset();
     // 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.
 @@ -140,8 +140,6 @@ test "sigset_t" {
     }
     for (1..linux.NSIG) |i| {
         try expectEqual(linux.sigismember(&sigset, @truncate(i)), true);
-        try expectEqual(linux.sigismember(&linux.filled_sigset, @truncate(i)), true);
-        try expectEqual(linux.sigismember(&linux.empty_sigset, @truncate(i)), false);
     }
     for (1..linux.NSIG) |i| {
         linux.sigdelset(&sigset, @truncate(i));
 @@ -183,16 +181,16 @@ test "sigset_t" {
     }
 }
-test "filled_sigset" {
+test "sigfillset" {
     // unlike the C library, all the signals are set in the kernel-level fillset
-    const sigset = linux.filled_sigset;
+    const sigset = linux.sigfillset();
     for (1..linux.NSIG) |i| {
         try expectEqual(linux.sigismember(&sigset, @truncate(i)), true);
     }
 }
-test "empty_sigset" {
+test "sigemptyset" {
-    const sigset = linux.empty_sigset;
+    const sigset = linux.sigemptyset();
     for (1..linux.NSIG) |i| {
         try expectEqual(linux.sigismember(&sigset, @truncate(i)), false);
     }

lib/std/os/plan9.zig+4-1

...	@@ -182,7 +182,6 @@ pub const SIG = struct {	...	@@ -182,7 +182,6 @@ pub const SIG = struct {
182	pub const TTOU = 20;	182	pub const TTOU = 20;
183	};	183	};
184	pub const sigset_t = c_long;	184	pub const sigset_t = c_long;
185	pub const empty_sigset = 0;
186	pub const siginfo_t = c_long;	185	pub const siginfo_t = c_long;
187	// TODO plan9 doesn't have sigaction_fn. Sigaction is not a union, but we include it here to be compatible.	186	// TODO plan9 doesn't have sigaction_fn. Sigaction is not a union, but we include it here to be compatible.
188	pub const Sigaction = extern struct {	187	pub const Sigaction = extern struct {
...	@@ -199,6 +198,10 @@ pub const Sigaction = extern struct {	...	@@ -199,6 +198,10 @@ pub const Sigaction = extern struct {
199	pub const AT = struct {	198	pub const AT = struct {
200	pub const FDCWD = -100; // we just make up a constant; FDCWD and openat don't actually exist in plan9	199	pub const FDCWD = -100; // we just make up a constant; FDCWD and openat don't actually exist in plan9
201	};	200	};
		201	// Plan 9 doesn't do signals. This is just needed to get through start.zig.
		202	pub fn sigemptyset() sigset_t {
		203	return 0;
		204	}
202	// TODO implement sigaction	205	// TODO implement sigaction
203	// right now it is just a shim to allow using start.zig code	206	// right now it is just a shim to allow using start.zig code
204	pub fn sigaction(sig: u6, noalias act: ?const Sigaction, noalias oact: ?Sigaction) usize {	207	pub fn sigaction(sig: u6, noalias act: ?const Sigaction, noalias oact: ?Sigaction) usize {

lib/std/posix.zig+17-12

 @@ -677,7 +677,8 @@ pub fn abort() noreturn {
         raise(SIG.ABRT) catch {};
         // Disable all signal handlers.
-        sigprocmask(SIG.BLOCK, &linux.filled_sigset, null);
+        const filledset = linux.sigfillset();
+        sigprocmask(SIG.BLOCK, &filledset, null);
         // Only one thread may proceed to the rest of abort().
         if (!builtin.single_threaded) {
 @@ -690,14 +691,14 @@ pub fn abort() noreturn {
         // Install default handler so that the tkill below will terminate.
         const sigact = Sigaction{
             .handler = .{ .handler = SIG.DFL },
-            .mask = linux.empty_sigset,
+            .mask = sigemptyset(),
             .flags = 0,
         };
         sigaction(SIG.ABRT, &sigact, null);
         _ = linux.tkill(linux.gettid(), SIG.ABRT);
-        var sigabrtmask = linux.empty_sigset;
+        var sigabrtmask = sigemptyset();
         sigaddset(&sigabrtmask, SIG.ABRT);
         sigprocmask(SIG.UNBLOCK, &sigabrtmask, null);
 @@ -727,7 +728,7 @@ pub fn raise(sig: u8) RaiseError!void {
         // cannot trigger an extra, unexpected, inter-process signal.  Signal paranoia inherited from Musl.
         const filled = linux.sigfillset();
         var orig: sigset_t = undefined;
-        sigprocmask(SIG.BLOCK, &linux.filled_sigset, &orig);
+        sigprocmask(SIG.BLOCK, &filled, &orig);
         const rc = linux.tkill(linux.gettid(), sig);
         sigprocmask(SIG.SETMASK, &orig, null);
 @@ -5813,24 +5814,28 @@ pub fn sigaltstack(ss: ?*stack_t, old_ss: ?*stack_t) SigaltstackError!void {
     }
 }
-pub fn sigfillset(set: *sigset_t) void {
+/// Return a filled sigset_t.
+pub fn sigfillset() sigset_t {
     if (builtin.link_libc) {
-        switch (errno(system.sigfillset(set))) {
+        var set: sigset_t = undefined;
-            .SUCCESS => return,
+        switch (errno(system.sigfillset(&set))) {
+            .SUCCESS => return set,
             else => unreachable,
         }
     }
-    set.* = system.filled_sigset;
+    return system.sigfillset();
 }
-pub fn sigemptyset(set: *sigset_t) void {
+/// Return an empty sigset_t.
+pub fn sigemptyset() sigset_t {
     if (builtin.link_libc) {
-        switch (errno(system.sigemptyset(set))) {
+        var set: sigset_t = undefined;
-            .SUCCESS => return,
+        switch (errno(system.sigemptyset(&set))) {
+            .SUCCESS => return set,
             else => unreachable,
         }
     }
-    set.* = mem.zeroes(sigset_t);
+    return system.sigemptyset();
 }
 pub fn sigaddset(set: *sigset_t, sig: u8) void {

lib/std/posix/test.zig+16-19

...	@@ -863,17 +863,15 @@ test "sigset empty/full" {	...	@@ -863,17 +863,15 @@ test "sigset empty/full" {
863	if (native_os == .wasi or native_os == .windows)	863	if (native_os == .wasi or native_os == .windows)
864	return error.SkipZigTest;	864	return error.SkipZigTest;
865		865
866	var set: posix.sigset_t = undefined;	866	var set: posix.sigset_t = posix.sigemptyset();
867
868	posix.sigemptyset(&set);
869	for (1..posix.NSIG) \|i\| {	867	for (1..posix.NSIG) \|i\| {
870	try expectEqual(false, posix.sigismember(&set, @truncate(i)));	868	try expectEqual(false, posix.sigismember(&set, @truncate(i)));
871	}	869	}
872		870
873	// The C library can reserve some (unnamed) signals, so can't check the full	871	// The C library can reserve some (unnamed) signals, so can't check the full
874	// NSIG set is defined, but just test a couple:	872	// NSIG set is defined, but just test a couple:
875	posix.sigfillset(&set);	873	set = posix.sigfillset();
876	try expectEqual(true, posix.sigismember(&set, @truncate(posix.SIG.USR1)));	874	try expectEqual(true, posix.sigismember(&set, @truncate(posix.SIG.CHLD)));
877	try expectEqual(true, posix.sigismember(&set, @truncate(posix.SIG.INT)));	875	try expectEqual(true, posix.sigismember(&set, @truncate(posix.SIG.INT)));
878	}	876	}
879		877
...	@@ -887,8 +885,7 @@ test "sigset add/del" {	...	@@ -887,8 +885,7 @@ test "sigset add/del" {
887	if (native_os == .wasi or native_os == .windows)	885	if (native_os == .wasi or native_os == .windows)
888	return error.SkipZigTest;	886	return error.SkipZigTest;
889		887
890	var sigset: posix.sigset_t = undefined;	888	var sigset: posix.sigset_t = posix.sigemptyset();
891	posix.sigemptyset(&sigset);
892		889
893	// See that none are set, then set each one, see that they're all set, then	890	// See that none are set, then set each one, see that they're all set, then
894	// remove them all, and then see that none are set.	891	// remove them all, and then see that none are set.
...	@@ -924,7 +921,7 @@ test "sigaction" {	...	@@ -924,7 +921,7 @@ test "sigaction" {
924	return error.SkipZigTest;	921	return error.SkipZigTest;
925	}	922	}
926		923
927	const test_signo = posix.SIG.USR1;	924	const test_signo = posix.SIG.URG; // URG only because it is ignored by default in debuggers
928		925
929	const S = struct {	926	const S = struct {
930	var handler_called_count: u32 = 0;	927	var handler_called_count: u32 = 0;
...	@@ -944,10 +941,10 @@ test "sigaction" {	...	@@ -944,10 +941,10 @@ test "sigaction" {
944		941
945	var sa: posix.Sigaction = .{	942	var sa: posix.Sigaction = .{
946	.handler = .{ .sigaction = &S.handler },	943	.handler = .{ .sigaction = &S.handler },
947	.mask = undefined,	944	.mask = posix.sigemptyset(),
948	.flags = posix.SA.SIGINFO \| posix.SA.RESETHAND,	945	.flags = posix.SA.SIGINFO \| posix.SA.RESETHAND,
949	};	946	};
950	posix.sigemptyset(&sa.mask);	947
951	var old_sa: posix.Sigaction = undefined;	948	var old_sa: posix.Sigaction = undefined;
952		949
953	// Install the new signal handler.	950	// Install the new signal handler.
...	@@ -1009,29 +1006,29 @@ test "sigset_t bits" {	...	@@ -1009,29 +1006,29 @@ test "sigset_t bits" {
1009		1006
1010	const self_pid = posix.system.getpid();	1007	const self_pid = posix.system.getpid();
1011		1008
1012	// To check that sigset_t mapping matches kernel (think u32/u64	1009	// To check that sigset_t mapping matches kernel (think u32/u64 mismatches on
1013	// mismatches on big-endian), try sending a blocked signal to make	1010	// big-endian), try sending a blocked signal to make sure the mask matches the
1014	// sure the mask matches the signal.	1011	// signal. (Send URG and CHLD because they're ignored by default in the
1015	inline for ([_]usize{ posix.SIG.INT, posix.SIG.USR1, 62, 94, 126 }) \|test_signo\| {	1012	// debugger, vs. USR1 or other named signals)
		1013	inline for ([_]usize{ posix.SIG.URG, posix.SIG.CHLD, 62, 94, 126 }) \|test_signo\| {
1016	if (test_signo >= posix.NSIG) continue;	1014	if (test_signo >= posix.NSIG) continue;
1017		1015
1018	S.expected_sig = test_signo;	1016	S.expected_sig = test_signo;
1019	S.handler_called_count = 0;	1017	S.handler_called_count = 0;
1020		1018
1021	var sa: posix.Sigaction = .{	1019	const sa: posix.Sigaction = .{
1022	.handler = .{ .sigaction = &S.handler },	1020	.handler = .{ .sigaction = &S.handler },
1023	.mask = undefined,	1021	.mask = posix.sigemptyset(),
1024	.flags = posix.SA.SIGINFO \| posix.SA.RESETHAND,	1022	.flags = posix.SA.SIGINFO \| posix.SA.RESETHAND,
1025	};	1023	};
1026	posix.sigemptyset(&sa.mask);	1024
1027	var old_sa: posix.Sigaction = undefined;	1025	var old_sa: posix.Sigaction = undefined;
1028		1026
1029	// Install the new signal handler.	1027	// Install the new signal handler.
1030	posix.sigaction(test_signo, &sa, &old_sa);	1028	posix.sigaction(test_signo, &sa, &old_sa);
1031		1029
1032	// block the signal and see that its delayed until unblocked	1030	// block the signal and see that its delayed until unblocked
1033	var block_one: posix.sigset_t = undefined;	1031	var block_one: posix.sigset_t = posix.sigemptyset();
1034	posix.sigemptyset(&block_one);
1035	posix.sigaddset(&block_one, test_signo);	1032	posix.sigaddset(&block_one, test_signo);
1036	posix.sigprocmask(posix.SIG.BLOCK, &block_one, null);	1033	posix.sigprocmask(posix.SIG.BLOCK, &block_one, null);
1037		1034

lib/std/start.zig+2-3

 @@ -745,14 +745,13 @@ fn maybeIgnoreSigpipe() void {
     if (have_sigpipe_support and !std.options.keep_sigpipe) {
         const posix = std.posix;
-        var act: posix.Sigaction = .{
+        const 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 = undefined,
+            .mask = posix.sigemptyset(),
             .flags = 0,
         };
-        posix.sigemptyset(&act.mask);
         posix.sigaction(posix.SIG.PIPE, &act, null);
     }
 }

src/crash_report.zig+2-3

 @@ -175,12 +175,11 @@ pub fn attachSegfaultHandler() void {
         _ = windows.kernel32.AddVectoredExceptionHandler(0, handleSegfaultWindows);
         return;
     }
-    var act: posix.Sigaction = .{
+    const act: posix.Sigaction = .{
         .handler = .{ .sigaction = handleSegfaultPosix },
-        .mask = undefined,
+        .mask = posix.sigemptyset(),
         .flags = (posix.SA.SIGINFO | posix.SA.RESTART | posix.SA.RESETHAND),
     };
-    posix.sigemptyset(&act.mask);
     debug.updateSegfaultHandler(&act);
 }

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

 @@ -16,12 +16,11 @@ 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".
     {
-        var act = posix.Sigaction{
+        const act = posix.Sigaction{
             .handler = .{ .handler = posix.SIG.DFL },
-            .mask = undefined,
+            .mask = posix.sigemptyset(),
             .flags = 0,
         };
-        posix.sigemptyset(&act.mask);
         try posix.sigaction(posix.SIG.PIPE, &act, null);
     }