runtime: ignore SIGPROF to foreign threads before cgocallback is fully initialized

Some libraries, for example, OpenBLAS, create work threads in a global constructor.
If we're doing cpu profiling, it's possible that SIGPROF might come to some of the
worker threads before we make our first cgo call. Cgocallback used to terminate the
process when that happens, but it's better to miss a couple profiling signals than
to abort in this case.

Fixes #9456.

Change-Id: I112b8e1a6e10e6cc8ac695a4b518c0f577309b6b
Reviewed-on: https://go-review.googlesource.com/2141
Reviewed-by: Ian Lance Taylor <iant@golang.org>

src/runtime/crash_cgo_test.go

@@ -50,6 +50,18 @@ func TestCgoExternalThreadPanic(t *testing.T) {
 	}
 }
 
+func TestCgoExternalThreadSIGPROF(t *testing.T) {
+	// issue 9456.
+	if runtime.GOOS == "plan9" || runtime.GOOS == "windows" {
+		t.Skipf("no pthreads on %s", runtime.GOOS)
+	}
+	got := executeTest(t, cgoExternalThreadSIGPROFSource, nil)
+	want := "OK\n"
+	if got != want {
+		t.Fatalf("expected %q, but got %q", want, got)
+	}
+}
+
 const cgoSignalDeadlockSource = `
 package main
 
@@ -194,3 +206,46 @@ start(void)
 		printf("_beginthreadex failed\n");
 }
 `
+
+const cgoExternalThreadSIGPROFSource = `
+package main
+
+/*
+#include <stdint.h>
+#include <signal.h>
+#include <pthread.h>
+
+volatile int32_t spinlock;
+
+static void *thread1(void *p) {
+	(void)p;
+	while (spinlock == 0)
+		;
+	pthread_kill(pthread_self(), SIGPROF);
+	spinlock = 0;
+	return NULL;
+}
+__attribute__((constructor)) void issue9456() {
+	pthread_t tid;
+	pthread_create(&tid, 0, thread1, NULL);
+}
+*/
+import "C"
+
+import (
+	"runtime"
+	"sync/atomic"
+	"unsafe"
+)
+
+func main() {
+	// This test intends to test that sending SIGPROF to foreign threads
+	// before we make any cgo call will not abort the whole process, so
+	// we cannot make any cgo call here. See http://golang.org/issue/9456.
+	atomic.StoreInt32((*int32)(unsafe.Pointer(&C.spinlock)), 1)
+	for atomic.LoadInt32((*int32)(unsafe.Pointer(&C.spinlock))) == 1 {
+		runtime.Gosched()
+	}
+	println("OK")
+}
+`

src/runtime/sigqueue.go

@@ -154,5 +154,14 @@ func signal_disable(s uint32) {
 // This runs on a foreign stack, without an m or a g.  No stack split.
 //go:nosplit
 func badsignal(sig uintptr) {
+	// Some external libraries, for example, OpenBLAS, create worker threads in
+	// a global constructor. If we're doing cpu profiling, and the SIGPROF signal
+	// comes to one of the foreign threads before we make our first cgo call, the
+	// call to cgocallback below will bring down the whole process.
+	// It's better to miss a few SIGPROF signals than to abort in this case.
+	// See http://golang.org/issue/9456.
+	if sig == _SIGPROF && needextram != 0 {
+		return
+	}
 	cgocallback(unsafe.Pointer(funcPC(sigsend)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
 }