From 3a3edb8fc045d7a7de9f0f212dd28938fb04dc53 Mon Sep 17 00:00:00 2001
From: leongross <leon.gross@9elements.com>
Date: Tue, 8 Oct 2024 15:47:33 +0200
Subject: [PATCH] signals: improve waitForEvents

Signed-off-by: leongross <leon.gross@9elements.com>
---
 src/runtime/runtime_unix.go | 54 ++++++++++++++++++++++++++++++++--
 src/runtime/signal.c        | 58 +++++++++++++++++++++++++++++++++----
 2 files changed, 104 insertions(+), 8 deletions(-)

diff --git a/src/runtime/runtime_unix.go b/src/runtime/runtime_unix.go
index 7b7a51f2ad..47e42a702f 100644
--- a/src/runtime/runtime_unix.go
+++ b/src/runtime/runtime_unix.go
@@ -17,6 +17,11 @@ func usleep(usec uint) int
 //export pause
 func pause() int32
 
+// int sigsuspend(const sigset_t *mask);
+//
+//export sigsuspend
+func sigsuspend(sigset_t unsafe.Pointer) int32
+
 // void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
 // Note: off_t is defined as int64 because:
 //   - musl (used on Linux) always defines it as int64
@@ -341,6 +346,12 @@ var hasSignals uint32
 // signals into this value.
 var receivedSignals uint32
 
+// Bitmap keeping track of enabled signals.
+var activeSignals uint32
+
+// Bitmap keeping track of masked/disabled signals.
+var maskedSignals uint32
+
 //go:linkname signal_enable os/signal.signal_enable
 func signal_enable(s uint32) {
 	if s >= 32 {
@@ -349,6 +360,10 @@ func signal_enable(s uint32) {
 		runtimePanicAt(returnAddress(0), "unsupported signal number")
 	}
 	atomic.StoreUint32(&hasSignals, 1)
+
+	// update the enabled signals bitmap
+	val := atomic.LoadUint32(&activeSignals)
+	atomic.CompareAndSwapUint32(&receivedSignals, val, val|(1<<s))
 	// It's easier to implement this function in C.
 	tinygo_signal_enable(s)
 }
@@ -396,6 +411,15 @@ func tinygo_signal_ignore(s uint32)
 //export tinygo_signal_disable
 func tinygo_signal_disable(s uint32)
 
+//export tinygo_mask_signals
+func tinygo_mask_signals(mask uint32)
+
+//export tinygo_unmask_signals
+func tinygo_unmask_signals(mask uint32)
+
+//export tinygo_sigsuspend
+func tinygo_sigsuspend(mask uint32)
+
 // void tinygo_signal_handler(int sig);
 //
 //export tinygo_signal_handler
@@ -424,7 +448,7 @@ func signal_recv() uint32 {
 	return val
 }
 
-// Atomically find a signal that previously occured and send it into the
+// Atomically find a signal that previously occurred and send it into the
 // signalChan channel. Return true if at least one signal was delivered this
 // way, false otherwise.
 func checkSignals() bool {
@@ -467,6 +491,24 @@ func checkSignals() bool {
 	}
 }
 
+func sigSuspend() {
+	signals := atomic.LoadUint32(&activeSignals)
+	tinygo_sigsuspend(signals)
+}
+
+// mask a set of signals defined by the activeSignals bitmap (32bit)
+// returns the C style sigset_t pointer.
+func maskActiveSignals() {
+	signals := atomic.LoadUint32(&activeSignals)
+	tinygo_mask_signals(signals)
+}
+
+// unmask a set of signals defined by the activeSignals bitmap (32bit)
+func unmaskActiveSignals() {
+	signals := atomic.LoadUint32(&activeSignals)
+	tinygo_unmask_signals(signals)
+}
+
 func waitForEvents() {
 	if atomic.LoadUint32(&hasSignals) != 0 {
 		// TODO: there is a race condition here. If a signal arrives between
@@ -479,9 +521,17 @@ func waitForEvents() {
 		//   - unmask all active signals
 		// For a longer explanation of the problem, see:
 		// https://www.cipht.net/2023/11/30/perils-of-pause.html
+
+		// When a signal arrives while masked by the process, it remains pending
+		// until the process unmasks it.
+		maskActiveSignals()
+
 		checkSignals()
-		pause()
+		sigSuspend()
+
 		checkSignals()
+		unmaskActiveSignals()
+
 	} else {
 		// The program doesn't use signals, so this is a deadlock.
 		runtimePanic("deadlocked: no event source")
diff --git a/src/runtime/signal.c b/src/runtime/signal.c
index bf1f452b1c..9015364ff7 100644
--- a/src/runtime/signal.c
+++ b/src/runtime/signal.c
@@ -11,20 +11,66 @@
 void tinygo_signal_handler(int sig);
 
 // Enable a signal from the runtime.
-void tinygo_signal_enable(uint32_t sig) {
-    struct sigaction act = { 0 };
+void tinygo_signal_enable(uint32_t sig)
+{
+    struct sigaction act = {0};
     act.sa_handler = &tinygo_signal_handler;
     sigaction(sig, &act, NULL);
 }
 
-void tinygo_signal_ignore(uint32_t sig) {
-    struct sigaction act = { 0 };
+void tinygo_signal_ignore(uint32_t sig)
+{
+    struct sigaction act = {0};
     act.sa_handler = SIG_IGN;
     sigaction(sig, &act, NULL);
 }
 
-void tinygo_signal_disable(uint32_t sig) {
-    struct sigaction act = { 0 };
+void tinygo_signal_disable(uint32_t sig)
+{
+    struct sigaction act = {0};
     act.sa_handler = SIG_DFL;
     sigaction(sig, &act, NULL);
 }
+
+// https://www.cipht.net/2023/11/30/perils-of-pause.html#text-3
+void tinygo_mask_signals(uint32_t mask)
+{
+    sigset_t set, prev;
+    sigemptyset(&set);
+    for (int i = 0; i < 32; i++)
+    {
+        if (mask & (1 << i))
+        {
+            sigaddset(&set, i);
+        }
+    }
+    sigprocmask(SIG_BLOCK, &set, &prev);
+}
+
+void tinygo_unmask_signals(uint32_t mask)
+{
+    sigset_t set, prev;
+    sigemptyset(&set);
+    for (int i = 0; i < 32; i++)
+    {
+        if (mask & (1 << i))
+        {
+            sigaddset(&set, i);
+        }
+    }
+    sigprocmask(SIG_UNBLOCK, &set, &prev);
+}
+
+void tinygo_sigsuspend(uint32_t mask)
+{
+    sigset_t set;
+    sigemptyset(&set);
+    for (int i = 0; i < 32; i++)
+    {
+        if (mask & (1 << i))
+        {
+            sigaddset(&set, i);
+        }
+    }
+    sigsuspend(&set);
+}