add signal.Ignore, add signal.Ignored, update signal tests, add Exited()

Signed-off-by: leongross <leon.gross@9elements.com>

Author: leongross

src/os/exec.go

@@ -47,6 +47,10 @@ func (p *ProcessState) Sys() interface{} {
 	return nil // TODO
 }
 
+func (p *ProcessState) Exited() bool {
+	return false // TODO
+}
+
 // ExitCode returns the exit code of the exited process, or -1
 // if the process hasn't exited or was terminated by a signal.
 func (p *ProcessState) ExitCode() int {

src/os/signal/signal_linux.go

@@ -0,0 +1,39 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go: build linux
+
+package signal
+
+import (
+	"os"
+	"syscall"
+)
+
+// these functions are linked to the runtime at src/runtime/runtime_unix.go
+func signal_enable(sig uint32)
+func signal_disable(sig uint32)
+func signal_ignore(sig uint32)
+func signal_ignored() []bool
+
+func signum(s os.Signal) int {
+	return int(s.(syscall.Signal))
+}
+
+// Ignore causes the provided signals to be ignored.
+// If they are received by the program, nothing will happen
+func Ignore(sig ...os.Signal) {
+	for _, s := range sig {
+		signal_ignore(uint32(signum(s)))
+	}
+}
+
+// Return true if the provided signal is being ignored
+// The runtime keeps track of the ignored signals in the signalIgnored array
+func Ignored(sig os.Signal) bool {
+	return signal_ignored()[signum(sig)]
+}
+
+// TODO: reset all previously set masks
+func Reset(sig ...os.Signal) {}

src/runtime/runtime_unix.go

@@ -3,7 +3,6 @@
 package runtime
 
 import (
-	"syscall"
 	"unsafe"
 )
 
@@ -318,7 +317,17 @@ func init() {
 }
 
 var signalChan chan uint32
-var signalIgnored []bool // TODO: replace with more efficient bitmap?
+var signalIgnored []bool
+
+// SignalIgnored returns the signalIgnored array.
+// Do not expose signalIgnored directly, as it is mutable.
+//
+//export SignalIgnored
+func SignalIgnored() []bool {
+	sigs := make([]bool, len(signalIgnored))
+	copy(sigs, signalIgnored)
+	return sigs
+}
 
 //go:linkname signal_enable os/signal.signal_enable
 func signal_enable(sig uint32) {
@@ -329,6 +338,7 @@ func signal_enable(sig uint32) {
 //export tinygo_signal_enable
 func tinygo_signal_enable(s uint32)
 
+// go: link signal_disable os/signal.signal_disable
 func signal_disable(sig uint32) {
 	tinygo_signal_disable(sig)
 }
@@ -339,10 +349,22 @@ func tinygo_signal_disable(sig uint32)
 // Ignore the given signal by adding it into the signalIgnored array.
 // If the signal is received, it will be ignored in the tinygo_signal_handler.
 // The signals SIGKILL and SIGSTOP cannot be caught or ignored. man (2) signal
-func tinygo_signal_ignore(sig uint32) {
-	if syscall.Signal(sig) != syscall.SIGKILL && syscall.Signal(sig) != syscall.SIGSTOP {
-		signalIgnored[sig] = true
-	}
+//
+//	func tinygo_signal_ignore(sig uint32) {
+//		if syscall.Signal(sig) != syscall.SIGKILL && syscall.Signal(sig) != syscall.SIGSTOP {
+//			signalIgnored[sig] = true
+//		}
+//	}
+
+//export tinygo_signal_ignore
+func tinygo_signal_ignore(sig uint32)
+
+// go: link signal_ignore os/signal.signal_ignore
+func signal_ignore(sig uint32) {
+	// keep track of ignored signal for Ignore(sig os.Signal)
+	// the ignore logic itself is tracked by the kernel https://elixir.bootlin.com/linux/v6.10/source/kernel/signal.c#L4142
+	signalIgnored[sig] = true
+	tinygo_signal_ignore(sig)
 }
 
 // void tinygo_signal_handler(int sig);

src/runtime/signal.c

@@ -1,4 +1,4 @@
-// go:build none
+//go:build none
 
 // Ignore the //go:build above. This file is manually included on Linux and
 // MacOS to provide os/signal support.
@@ -31,3 +31,11 @@ void tinygo_signal_disable(uint32_t sig)
     act.sa_handler = SIG_DFL;
     sigaction(sig, &act, NULL);
 }
+
+// Ignore a signal from the runtime.
+void tinygo_signal_ignore(uint32_t sig)
+{
+    struct sigaction act = {0};
+    act.sa_handler = SIG_IGN;
+    sigaction(sig, &act, NULL);
+}

testdata/signal/signal.go

@@ -25,10 +25,23 @@ func main() {
 			}
 		}
 	}()
+	// test signal_enable
 
-	// Send the signal.
-	syscall.Kill(syscall.Getpid(), syscall.SIGUSR1)
+	// test signal_disable
+
+	// test signal_ignore
+	signal.Ignore(syscall.SIGUSR1)
+	if signal.Ignored(syscall.SIGUSR1) {
+		println("SIGUSR1 is ignored")
+	} else {
+		println("SIGUSR1 is not ignored")
+	}
 
+	// test signal_ignore SIGKILL and SIGSTOP that cannot be caught or ignored
+	signal.Ignore()
+
+	// send the signal.
+	syscall.Kill(syscall.Getpid(), syscall.SIGUSR1)
 	time.Sleep(time.Millisecond * 100)
 	println("exiting signal program")
 }