runtime: add support for os/signal

This adds support for enabling and listening to signals on Linux and
MacOS.

TODO: also support disabling signals.

Author: aykevl

builder/musl.go

@@ -124,6 +124,7 @@ var Musl = Library{
 			"malloc/mallocng/*.c",
 			"mman/*.c",
 			"math/*.c",
+			"signal/" + arch + "/*.s",
 			"signal/*.c",
 			"stdio/*.c",
 			"string/*.c",

compileopts/target.go

@@ -356,6 +356,7 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 			"-arch", arch,
 			"-platform_version", "macos", platformVersion, platformVersion,
 		)
+		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/signal.c")
 	} else if goos == "linux" {
 		spec.Linker = "ld.lld"
 		spec.RTLib = "compiler-rt"
@@ -375,6 +376,7 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 			// proper threading.
 			spec.CFlags = append(spec.CFlags, "-mno-outline-atomics")
 		}
+		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/signal.c")
 	} else if goos == "windows" {
 		spec.Linker = "ld.lld"
 		spec.Libc = "mingw-w64"

lib/macos-minimal-sdk

@@ -76,6 +76,7 @@ func TestBuild(t *testing.T) {
 		"oldgo/",
 		"print.go",
 		"reflect.go",
+		"signal/",
 		"slice.go",
 		"sort.go",
 		"stdlib.go",

main_test.go

@@ -256,3 +256,41 @@ func growHeap() bool {
 	setHeapEnd(heapStart + heapSize)
 	return true
 }
+
+func init() {
+	// Set up a channel to receive signals into.
+	// A channel size of 1 should be sufficient in most cases, but using 4 just
+	// to be sure.
+	signalChan = make(chan uint32, 4)
+}
+
+var signalChan chan uint32
+
+//go:linkname signal_enable os/signal.signal_enable
+func signal_enable(s uint32) {
+	// It's easier to implement this function in C.
+	tinygo_signal_enable(s)
+}
+
+//export tinygo_signal_enable
+func tinygo_signal_enable(s uint32)
+
+// void tinygo_signal_handler(int sig);
+//
+//export tinygo_signal_handler
+func tinygo_signal_handler(s int32) {
+	select {
+	case signalChan <- uint32(s):
+	default:
+		// TODO: we should handle this in a better way somehow.
+		// Maybe just ignore the signal, assuming that nothing is reading from
+		// the notify channel?
+		runtimePanic("could not deliver signal: runtime internal channel is full")
+	}
+}
+
+//go:linkname signal_recv os/signal.signal_recv
+func signal_recv() uint32 {
+	// Function called from os/signal to get the next received signal.
+	return <-signalChan
+}

src/runtime/runtime_unix.go

@@ -0,0 +1,19 @@
+//go:build none
+
+// Ignore the //go:build above. This file is manually included on Linux and
+// MacOS to provide os/signal support.
+
+#include <stdint.h>
+#include <signal.h>
+#include <unistd.h>
+
+// Signal handler in the runtime.
+void tinygo_signal_handler(int sig);
+
+// Enable a signal from the runtime.
+void tinygo_signal_enable(uint32_t sig) {
+    struct sigaction act = { 0 };
+    act.sa_flags = SA_SIGINFO;
+    act.sa_handler = &tinygo_signal_handler;
+    sigaction(sig, &act, NULL);
+}

src/runtime/signal.c

@@ -93,6 +93,8 @@ const (
 	SIGPIPE Signal = 13 /* write on a pipe with no one to read it */
 	SIGTERM Signal = 15 /* software termination signal from kill */
 	SIGCHLD Signal = 20 /* to parent on child stop or exit */
+	SIGUSR1 Signal = 30 /* user defined signal 1 */
+	SIGUSR2 Signal = 31 /* user defined signal 2 */
 )
 
 func (s Signal) Signal() {}

src/syscall/syscall_libc_darwin.go

@@ -0,0 +1,2 @@
+got signal: user defined signal 1
+exiting signal program

testdata/signal/out.txt

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+)
+
+func main() {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, syscall.SIGUSR1)
+
+	// Wait for signals to arrive.
+	go func() {
+		for sig := range c {
+			println("got signal:", sig.String())
+		}
+	}()
+
+	// Send the signal.
+	syscall.Kill(syscall.Getpid(), syscall.SIGUSR1)
+
+	time.Sleep(time.Millisecond * 100)
+	println("exiting signal program")
+}