Go1.12 is no longer supported. Does this happen in Go1.15?

Go1.12 is no longer supported. Does this happen in Go1.15?

It's hard to reproduce and I can't reproduce deadlock one more time either in 1.12 or 1.15.

needm code is the same in 1.15 and 1.12 and I suppose it's also relevant for Go1.15.
cgocallback doesn't block signals for current thread and what if signal will be raised between lockextra and unlockextra:

func needm(x byte) {
	if (iscgo || GOOS == "windows") && !cgoHasExtraM {
		// Can happen if C/C++ code calls Go from a global ctor.
		// Can also happen on Windows if a global ctor uses a
		// callback created by syscall.NewCallback. See issue #6751
		// for details.
		//
		// Can not throw, because scheduler is not initialized yet.
		write(2, unsafe.Pointer(&earlycgocallback[0]), int32(len(earlycgocallback)))
		exit(1)
	}

	// Lock extra list, take head, unlock popped list.
	// nilokay=false is safe here because of the invariant above,
	// that the extra list always contains or will soon contain
	// at least one m.
	mp := lockextra(false)

	// Set needextram when we've just emptied the list,
	// so that the eventual call into cgocallbackg will
	// allocate a new m for the extra list. We delay the
	// allocation until then so that it can be done
	// after exitsyscall makes sure it is okay to be
	// running at all (that is, there's no garbage collection
	// running right now).
	mp.needextram = mp.schedlink == 0
	extraMCount--
	unlockextra(mp.schedlink.ptr()) // <--- signal raised before unlockextra
...

sigtrampgo will call badsignal since g==nil in cgocallback. badsignal will call needm and we get deadlock:

func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
	if sigfwdgo(sig, info, ctx) {
		return
	}
	c := &sigctxt{info, ctx}
	g := sigFetchG(c)
	setg(g)
	if g == nil {
		if sig == _SIGPROF {
			sigprofNonGoPC(c.sigpc())
			return
		}
		if sig == sigPreempt && preemptMSupported && debug.asyncpreemptoff == 0 {
			// This is probably a signal from preemptM sent
			// while executing Go code but received while
			// executing non-Go code.
			// We got past sigfwdgo, so we know that there is
			// no non-Go signal handler for sigPreempt.
			// The default behavior for sigPreempt is to ignore
			// the signal, so badsignal will be a no-op anyway.
			return
		}
		c.fixsigcode(sig)
		badsignal(uintptr(sig), c) // <--- here we will get deadlock
		return
	}
...

P.S. it's code from Go1.15 runtime

UPD

I've written a simple cgo program that reproduces this bug in Go1.15.3

$ go version
go version go1.15.3 linux/amd64

$ go env
GO111MODULE="on"
GOARCH="amd64"
GOBIN=""
GOCACHE="/root/.cache/go-build"
GOENV="/root/.config/go/env"
GOEXE=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOINSECURE=""
GOMODCACHE="/root/go/pkg/mod"
GONOPROXY="git.acronis.com"
GONOSUMDB="git.acronis.com"
GOOS="linux"
GOPATH="/root/go"
GOPRIVATE="git.acronis.com"
GOPROXY="https://proxy.golang.org,direct"
GOROOT="/usr/local/go"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/usr/local/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
AR="ar"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD="/dev/null"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build195996747=/tmp/go-build -gno-record-gcc-switches"

Program consists of 3 files: main.go, thread.h, thread.c.

main.go

package main

/*
#cgo CFLAGS: -g -Wall
#include <stdlib.h>
#include "thread.h"
*/
import "C"
import (
	"fmt"
	"os"
	"os/signal"
	"syscall"
)

//export goCallbackHandler
func goCallbackHandler(s *C.char) {
	fmt.Println(C.GoString(s))
}

func main() {

	for i := 0; i < 5; i++ {
		C.start_pthread()
	}

	sigsch := make(chan os.Signal, 1)
	donech := make(chan bool, 1)
	signal.Notify(sigsch, syscall.SIGINT, syscall.SIGTERM)

	go func() {
		<-sigsch
		donech <- true
	}()

	<-donech
}

thread.h

#ifndef _THREAD_H
#define _TREAD_H

extern void goCallbackHandler(char*);
int start_pthread(void);

#endif

thread.c

#include "thread.h"
#include <unistd.h>
#include <stdio.h>
#include <pthread.h>

static pthread_t thr;

static void dump_to_golog(FILE *fp)
{
    char buf[256];
    while (fgets(buf, sizeof(buf) - 1, fp))
    {
        buf[sizeof(buf) - 1] = 0;
        goCallbackHandler(buf);
    }
}

static void *watchdog_thread(void *arg)
{
    while (1)
    {
        FILE *fp = popen("ps axv", "re");
        if (fp)
        {
            dump_to_golog(fp);
            pclose(fp);
        }
        usleep(1000);
    }
    return 0;
}

int start_pthread(void)
{
    pthread_create(&thr, NULL, watchdog_thread, NULL);
    return 0;
}

Deadlock can be reproduced almost immediately:

(gdb) bt
#0  runtime.osyield () at /usr/local/go/src/runtime/sys_linux_amd64.s:677
#1  0x0000000000439445 in runtime.lockextra (nilokay=false, ~r1=) at /usr/local/go/src/runtime/proc.go:1721
#2  0x0000000000438e8f in runtime.needm (x=) at /usr/local/go/src/runtime/proc.go:1535
#3  0x0000000000448fa5 in runtime.badsignal (sig=17, c=0x7f6d95ffa688) at /usr/local/go/src/runtime/signal_unix.go:933
#4  0x00000000004477b9 in runtime.sigtrampgo (sig=17, info=0x7f6d95ffa830, ctx=0x7f6d95ffa700) at /usr/local/go/src/runtime/signal_unix.go:431
#5  0x0000000000467dc3 in runtime.sigtramp () at /usr/local/go/src/runtime/sys_linux_amd64.s:409
#6  
#7  0x0000000000438ea1 in runtime.needm (x=) at /usr/local/go/src/runtime/proc.go:1544
#8  0x0000000000465f17 in runtime.cgocallback_gofunc () at /usr/local/go/src/runtime/asm_amd64.s:733
#9  0x0000000000465ebe in runtime.cgocallback () at /usr/local/go/src/runtime/asm_amd64.s:705
#10 0x000000000049cea7 in _cgoexp_a037f58797fa_goCallbackHandler (a=0x7f6d95ffadd8, n=8, ctxt=0) at _cgo_gotypes.go:72
#11 0x000000000046a077 in crosscall2 () at /usr/local/go/src/runtime/cgo/asm_amd64.s:59
#12 0x000000000049cfaf in goCallbackHandler (s=0x7f6d95fface0 "", s@entry=0x7f6d95ffae00 "   84 ?        S<     0:00      0     0     0     0  0.0 [kpsmoused]\n") at _cgo_export.c:32
#13 0x000000000049d038 in dump_to_golog (fp=) at thread.c:13
#14 watchdog_thread (arg=) at thread.c:22
#15 0x00007f6dc4737e65 in start_thread () from /lib64/libpthread.so.0
#16 0x00007f6dc446088d in clone () from /lib64/libc.so.6

Thanks for the reproducer.

cc @ianlancetaylor

Thanks for the test case. I can't reproduce the problem on my system, but I think I see the problem.

Change https://golang.org/cl/265759 mentions this issue: runtime: block signals in needm before allocating M

Change https://golang.org/cl/265778 mentions this issue: runtime: move TestNeedmDeadlock to crash_cgo_test.go

Thanks for quick fix!
What about merging this fix into minor release go1.15.X?

@gopherbot Please open backport issues.

This bug can cause a deadlock for programs that create threads in C code such that those threads call into Go code, if a signal is received at the wrong time. There is no workaround.

Note that CL 265759 had a bug in the test, and that CL 265778 (a test-only change) is also required.

Backport issue(s) opened: #42635 (for 1.14), #42636 (for 1.15).

Remember to create the cherry-pick CL(s) as soon as the patch is submitted to master, according to https://golang.org/wiki/MinorReleases.

Change https://golang.org/cl/271847 mentions this issue: [release-branch.go1.15] runtime: block signals in needm before allocating M

Change https://golang.org/cl/271848 mentions this issue: [release-branch.go1.14] runtime: block signals in needm before allocating M