crash_cgo_test.go

     1  // Copyright 2012 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  //go:build cgo
     6  
     7  package runtime_test
     8  
     9  import (
    10  	"fmt"
    11  	"internal/goos"
    12  	"internal/platform"
    13  	"internal/testenv"
    14  	"os"
    15  	"os/exec"
    16  	"runtime"
    17  	"strconv"
    18  	"strings"
    19  	"testing"
    20  	"time"
    21  )
    22  
    23  func TestCgoCrashHandler(t *testing.T) {
    24  	t.Parallel()
    25  	testCrashHandler(t, true)
    26  }
    27  
    28  func TestCgoSignalDeadlock(t *testing.T) {
    29  	// Don't call t.Parallel, since too much work going on at the
    30  	// same time can cause the testprogcgo code to overrun its
    31  	// timeouts (issue #18598).
    32  
    33  	if testing.Short() && runtime.GOOS == "windows" {
    34  		t.Skip("Skipping in short mode") // takes up to 64 seconds
    35  	}
    36  	got := runTestProg(t, "testprogcgo", "CgoSignalDeadlock")
    37  	want := "OK\n"
    38  	if got != want {
    39  		t.Fatalf("expected %q, but got:\n%s", want, got)
    40  	}
    41  }
    42  
    43  func TestCgoTraceback(t *testing.T) {
    44  	t.Parallel()
    45  	got := runTestProg(t, "testprogcgo", "CgoTraceback")
    46  	want := "OK\n"
    47  	if got != want {
    48  		t.Fatalf("expected %q, but got:\n%s", want, got)
    49  	}
    50  }
    51  
    52  func TestCgoCallbackGC(t *testing.T) {
    53  	t.Parallel()
    54  	switch runtime.GOOS {
    55  	case "plan9", "windows":
    56  		t.Skipf("no pthreads on %s", runtime.GOOS)
    57  	}
    58  	if testing.Short() {
    59  		switch {
    60  		case runtime.GOOS == "dragonfly":
    61  			t.Skip("see golang.org/issue/11990")
    62  		case runtime.GOOS == "linux" && runtime.GOARCH == "arm":
    63  			t.Skip("too slow for arm builders")
    64  		case runtime.GOOS == "linux" && (runtime.GOARCH == "mips64" || runtime.GOARCH == "mips64le"):
    65  			t.Skip("too slow for mips64x builders")
    66  		}
    67  	}
    68  	got := runTestProg(t, "testprogcgo", "CgoCallbackGC")
    69  	want := "OK\n"
    70  	if got != want {
    71  		t.Fatalf("expected %q, but got:\n%s", want, got)
    72  	}
    73  }
    74  
    75  func TestCgoCallbackPprof(t *testing.T) {
    76  	t.Parallel()
    77  	switch runtime.GOOS {
    78  	case "plan9", "windows":
    79  		t.Skipf("no pthreads on %s", runtime.GOOS)
    80  	}
    81  	if testenv.CPUProfilingBroken() {
    82  		t.Skip("skipping on platform with broken profiling")
    83  	}
    84  
    85  	got := runTestProg(t, "testprogcgo", "CgoCallbackPprof")
    86  	if want := "OK\n"; got != want {
    87  		t.Fatalf("expected %q, but got:\n%s", want, got)
    88  	}
    89  }
    90  
    91  func TestCgoExternalThreadPanic(t *testing.T) {
    92  	t.Parallel()
    93  	if runtime.GOOS == "plan9" {
    94  		t.Skipf("no pthreads on %s", runtime.GOOS)
    95  	}
    96  	got := runTestProg(t, "testprogcgo", "CgoExternalThreadPanic")
    97  	want := "panic: BOOM"
    98  	if !strings.Contains(got, want) {
    99  		t.Fatalf("want failure containing %q. output:\n%s\n", want, got)
   100  	}
   101  }
   102  
   103  func TestCgoExternalThreadSIGPROF(t *testing.T) {
   104  	t.Parallel()
   105  	// issue 9456.
   106  	switch runtime.GOOS {
   107  	case "plan9", "windows":
   108  		t.Skipf("no pthreads on %s", runtime.GOOS)
   109  	}
   110  
   111  	got := runTestProg(t, "testprogcgo", "CgoExternalThreadSIGPROF", "GO_START_SIGPROF_THREAD=1")
   112  	if want := "OK\n"; got != want {
   113  		t.Fatalf("expected %q, but got:\n%s", want, got)
   114  	}
   115  }
   116  
   117  func TestCgoExternalThreadSignal(t *testing.T) {
   118  	t.Parallel()
   119  	// issue 10139
   120  	switch runtime.GOOS {
   121  	case "plan9", "windows":
   122  		t.Skipf("no pthreads on %s", runtime.GOOS)
   123  	}
   124  
   125  	got := runTestProg(t, "testprogcgo", "CgoExternalThreadSignal")
   126  	if want := "OK\n"; got != want {
   127  		if runtime.GOOS == "ios" && strings.Contains(got, "C signal did not crash as expected") {
   128  			testenv.SkipFlaky(t, 59913)
   129  		}
   130  		t.Fatalf("expected %q, but got:\n%s", want, got)
   131  	}
   132  }
   133  
   134  func TestCgoDLLImports(t *testing.T) {
   135  	// test issue 9356
   136  	if runtime.GOOS != "windows" {
   137  		t.Skip("skipping windows specific test")
   138  	}
   139  	got := runTestProg(t, "testprogcgo", "CgoDLLImportsMain")
   140  	want := "OK\n"
   141  	if got != want {
   142  		t.Fatalf("expected %q, but got %v", want, got)
   143  	}
   144  }
   145  
   146  func TestCgoExecSignalMask(t *testing.T) {
   147  	t.Parallel()
   148  	// Test issue 13164.
   149  	switch runtime.GOOS {
   150  	case "windows", "plan9":
   151  		t.Skipf("skipping signal mask test on %s", runtime.GOOS)
   152  	}
   153  	got := runTestProg(t, "testprogcgo", "CgoExecSignalMask", "GOTRACEBACK=system")
   154  	want := "OK\n"
   155  	if got != want {
   156  		t.Errorf("expected %q, got %v", want, got)
   157  	}
   158  }
   159  
   160  func TestEnsureDropM(t *testing.T) {
   161  	t.Parallel()
   162  	// Test for issue 13881.
   163  	switch runtime.GOOS {
   164  	case "windows", "plan9":
   165  		t.Skipf("skipping dropm test on %s", runtime.GOOS)
   166  	}
   167  	got := runTestProg(t, "testprogcgo", "EnsureDropM")
   168  	want := "OK\n"
   169  	if got != want {
   170  		t.Errorf("expected %q, got %v", want, got)
   171  	}
   172  }
   173  
   174  // Test for issue 14387.
   175  // Test that the program that doesn't need any cgo pointer checking
   176  // takes about the same amount of time with it as without it.
   177  func TestCgoCheckBytes(t *testing.T) {
   178  	t.Parallel()
   179  	// Make sure we don't count the build time as part of the run time.
   180  	testenv.MustHaveGoBuild(t)
   181  	exe, err := buildTestProg(t, "testprogcgo")
   182  	if err != nil {
   183  		t.Fatal(err)
   184  	}
   185  
   186  	// Try it 10 times to avoid flakiness.
   187  	const tries = 10
   188  	var tot1, tot2 time.Duration
   189  	for i := 0; i < tries; i++ {
   190  		cmd := testenv.CleanCmdEnv(exec.Command(exe, "CgoCheckBytes"))
   191  		cmd.Env = append(cmd.Env, "GODEBUG=cgocheck=0", fmt.Sprintf("GO_CGOCHECKBYTES_TRY=%d", i))
   192  
   193  		start := time.Now()
   194  		cmd.Run()
   195  		d1 := time.Since(start)
   196  
   197  		cmd = testenv.CleanCmdEnv(exec.Command(exe, "CgoCheckBytes"))
   198  		cmd.Env = append(cmd.Env, fmt.Sprintf("GO_CGOCHECKBYTES_TRY=%d", i))
   199  
   200  		start = time.Now()
   201  		cmd.Run()
   202  		d2 := time.Since(start)
   203  
   204  		if d1*20 > d2 {
   205  			// The slow version (d2) was less than 20 times
   206  			// slower than the fast version (d1), so OK.
   207  			return
   208  		}
   209  
   210  		tot1 += d1
   211  		tot2 += d2
   212  	}
   213  
   214  	t.Errorf("cgo check too slow: got %v, expected at most %v", tot2/tries, (tot1/tries)*20)
   215  }
   216  
   217  func TestCgoPanicDeadlock(t *testing.T) {
   218  	t.Parallel()
   219  	// test issue 14432
   220  	got := runTestProg(t, "testprogcgo", "CgoPanicDeadlock")
   221  	want := "panic: cgo error\n\n"
   222  	if !strings.HasPrefix(got, want) {
   223  		t.Fatalf("output does not start with %q:\n%s", want, got)
   224  	}
   225  }
   226  
   227  func TestCgoCCodeSIGPROF(t *testing.T) {
   228  	t.Parallel()
   229  	got := runTestProg(t, "testprogcgo", "CgoCCodeSIGPROF")
   230  	want := "OK\n"
   231  	if got != want {
   232  		t.Errorf("expected %q got %v", want, got)
   233  	}
   234  }
   235  
   236  func TestCgoPprofCallback(t *testing.T) {
   237  	if testing.Short() {
   238  		t.Skip("skipping in short mode") // takes a full second
   239  	}
   240  	switch runtime.GOOS {
   241  	case "windows", "plan9":
   242  		t.Skipf("skipping cgo pprof callback test on %s", runtime.GOOS)
   243  	}
   244  	got := runTestProg(t, "testprogcgo", "CgoPprofCallback")
   245  	want := "OK\n"
   246  	if got != want {
   247  		t.Errorf("expected %q got %v", want, got)
   248  	}
   249  }
   250  
   251  func TestCgoCrashTraceback(t *testing.T) {
   252  	t.Parallel()
   253  	switch platform := runtime.GOOS + "/" + runtime.GOARCH; platform {
   254  	case "darwin/amd64":
   255  	case "linux/amd64":
   256  	case "linux/arm64":
   257  	case "linux/loong64":
   258  	case "linux/ppc64le":
   259  	default:
   260  		t.Skipf("not yet supported on %s", platform)
   261  	}
   262  	got := runTestProg(t, "testprogcgo", "CrashTraceback")
   263  	for i := 1; i <= 3; i++ {
   264  		if !strings.Contains(got, fmt.Sprintf("cgo symbolizer:%d", i)) {
   265  			t.Errorf("missing cgo symbolizer:%d", i)
   266  		}
   267  	}
   268  }
   269  
   270  func TestCgoCrashTracebackGo(t *testing.T) {
   271  	t.Parallel()
   272  	switch platform := runtime.GOOS + "/" + runtime.GOARCH; platform {
   273  	case "darwin/amd64":
   274  	case "linux/amd64":
   275  	case "linux/arm64":
   276  	case "linux/loong64":
   277  	case "linux/ppc64le":
   278  	default:
   279  		t.Skipf("not yet supported on %s", platform)
   280  	}
   281  	got := runTestProg(t, "testprogcgo", "CrashTracebackGo")
   282  	for i := 1; i <= 3; i++ {
   283  		want := fmt.Sprintf("main.h%d", i)
   284  		if !strings.Contains(got, want) {
   285  			t.Errorf("missing %s", want)
   286  		}
   287  	}
   288  }
   289  
   290  func TestCgoTracebackContext(t *testing.T) {
   291  	t.Parallel()
   292  	got := runTestProg(t, "testprogcgo", "TracebackContext")
   293  	want := "OK\n"
   294  	if got != want {
   295  		t.Errorf("expected %q got %v", want, got)
   296  	}
   297  }
   298  
   299  func TestCgoTracebackContextPreemption(t *testing.T) {
   300  	t.Parallel()
   301  	got := runTestProg(t, "testprogcgo", "TracebackContextPreemption")
   302  	want := "OK\n"
   303  	if got != want {
   304  		t.Errorf("expected %q got %v", want, got)
   305  	}
   306  }
   307  
   308  func testCgoPprof(t *testing.T, buildArg, runArg, top, bottom string) {
   309  	t.Parallel()
   310  	if runtime.GOOS != "linux" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "ppc64le" && runtime.GOARCH != "arm64" && runtime.GOARCH != "loong64") {
   311  		t.Skipf("not yet supported on %s/%s", runtime.GOOS, runtime.GOARCH)
   312  	}
   313  	testenv.MustHaveGoRun(t)
   314  
   315  	exe, err := buildTestProg(t, "testprogcgo", buildArg)
   316  	if err != nil {
   317  		t.Fatal(err)
   318  	}
   319  
   320  	cmd := testenv.CleanCmdEnv(exec.Command(exe, runArg))
   321  	got, err := cmd.CombinedOutput()
   322  	if err != nil {
   323  		if testenv.Builder() == "linux-amd64-alpine" {
   324  			// See Issue 18243 and Issue 19938.
   325  			t.Skipf("Skipping failing test on Alpine (golang.org/issue/18243). Ignoring error: %v", err)
   326  		}
   327  		t.Fatalf("%s\n\n%v", got, err)
   328  	}
   329  	fn := strings.TrimSpace(string(got))
   330  	defer os.Remove(fn)
   331  
   332  	for try := 0; try < 2; try++ {
   333  		cmd := testenv.CleanCmdEnv(exec.Command(testenv.GoToolPath(t), "tool", "pprof", "-tagignore=ignore", "-traces"))
   334  		// Check that pprof works both with and without explicit executable on command line.
   335  		if try == 0 {
   336  			cmd.Args = append(cmd.Args, exe, fn)
   337  		} else {
   338  			cmd.Args = append(cmd.Args, fn)
   339  		}
   340  
   341  		found := false
   342  		for i, e := range cmd.Env {
   343  			if strings.HasPrefix(e, "PPROF_TMPDIR=") {
   344  				cmd.Env[i] = "PPROF_TMPDIR=" + os.TempDir()
   345  				found = true
   346  				break
   347  			}
   348  		}
   349  		if !found {
   350  			cmd.Env = append(cmd.Env, "PPROF_TMPDIR="+os.TempDir())
   351  		}
   352  
   353  		out, err := cmd.CombinedOutput()
   354  		t.Logf("%s:\n%s", cmd.Args, out)
   355  		if err != nil {
   356  			t.Error(err)
   357  			continue
   358  		}
   359  
   360  		trace := findTrace(string(out), top)
   361  		if len(trace) == 0 {
   362  			t.Errorf("%s traceback missing.", top)
   363  			continue
   364  		}
   365  		if trace[len(trace)-1] != bottom {
   366  			t.Errorf("invalid traceback origin: got=%v; want=[%s ... %s]", trace, top, bottom)
   367  		}
   368  	}
   369  }
   370  
   371  func TestCgoPprof(t *testing.T) {
   372  	testCgoPprof(t, "", "CgoPprof", "cpuHog", "runtime.main")
   373  }
   374  
   375  func TestCgoPprofPIE(t *testing.T) {
   376  	testCgoPprof(t, "-buildmode=pie", "CgoPprof", "cpuHog", "runtime.main")
   377  }
   378  
   379  func TestCgoPprofThread(t *testing.T) {
   380  	testCgoPprof(t, "", "CgoPprofThread", "cpuHogThread", "cpuHogThread2")
   381  }
   382  
   383  func TestCgoPprofThreadNoTraceback(t *testing.T) {
   384  	testCgoPprof(t, "", "CgoPprofThreadNoTraceback", "cpuHogThread", "runtime._ExternalCode")
   385  }
   386  
   387  func TestRaceProf(t *testing.T) {
   388  	if !platform.RaceDetectorSupported(runtime.GOOS, runtime.GOARCH) {
   389  		t.Skipf("skipping on %s/%s because race detector not supported", runtime.GOOS, runtime.GOARCH)
   390  	}
   391  	if runtime.GOOS == "windows" {
   392  		t.Skipf("skipping: test requires pthread support")
   393  		// TODO: Can this test be rewritten to use the C11 thread API instead?
   394  	}
   395  
   396  	testenv.MustHaveGoRun(t)
   397  
   398  	// This test requires building various packages with -race, so
   399  	// it's somewhat slow.
   400  	if testing.Short() {
   401  		t.Skip("skipping test in -short mode")
   402  	}
   403  
   404  	exe, err := buildTestProg(t, "testprogcgo", "-race")
   405  	if err != nil {
   406  		t.Fatal(err)
   407  	}
   408  
   409  	got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoRaceprof")).CombinedOutput()
   410  	if err != nil {
   411  		t.Fatal(err)
   412  	}
   413  	want := "OK\n"
   414  	if string(got) != want {
   415  		t.Errorf("expected %q got %s", want, got)
   416  	}
   417  }
   418  
   419  func TestRaceSignal(t *testing.T) {
   420  	if !platform.RaceDetectorSupported(runtime.GOOS, runtime.GOARCH) {
   421  		t.Skipf("skipping on %s/%s because race detector not supported", runtime.GOOS, runtime.GOARCH)
   422  	}
   423  	if runtime.GOOS == "windows" {
   424  		t.Skipf("skipping: test requires pthread support")
   425  		// TODO: Can this test be rewritten to use the C11 thread API instead?
   426  	}
   427  	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
   428  		testenv.SkipFlaky(t, 60316)
   429  	}
   430  
   431  	t.Parallel()
   432  
   433  	testenv.MustHaveGoRun(t)
   434  
   435  	// This test requires building various packages with -race, so
   436  	// it's somewhat slow.
   437  	if testing.Short() {
   438  		t.Skip("skipping test in -short mode")
   439  	}
   440  
   441  	exe, err := buildTestProg(t, "testprogcgo", "-race")
   442  	if err != nil {
   443  		t.Fatal(err)
   444  	}
   445  
   446  	got, err := testenv.CleanCmdEnv(testenv.Command(t, exe, "CgoRaceSignal")).CombinedOutput()
   447  	if err != nil {
   448  		t.Logf("%s\n", got)
   449  		t.Fatal(err)
   450  	}
   451  	want := "OK\n"
   452  	if string(got) != want {
   453  		t.Errorf("expected %q got %s", want, got)
   454  	}
   455  }
   456  
   457  func TestCgoNumGoroutine(t *testing.T) {
   458  	switch runtime.GOOS {
   459  	case "windows", "plan9":
   460  		t.Skipf("skipping numgoroutine test on %s", runtime.GOOS)
   461  	}
   462  	t.Parallel()
   463  	got := runTestProg(t, "testprogcgo", "NumGoroutine")
   464  	want := "OK\n"
   465  	if got != want {
   466  		t.Errorf("expected %q got %v", want, got)
   467  	}
   468  }
   469  
   470  func TestCatchPanic(t *testing.T) {
   471  	t.Parallel()
   472  	switch runtime.GOOS {
   473  	case "plan9", "windows":
   474  		t.Skipf("no signals on %s", runtime.GOOS)
   475  	case "darwin":
   476  		if runtime.GOARCH == "amd64" {
   477  			t.Skipf("crash() on darwin/amd64 doesn't raise SIGABRT")
   478  		}
   479  	}
   480  
   481  	testenv.MustHaveGoRun(t)
   482  
   483  	exe, err := buildTestProg(t, "testprogcgo")
   484  	if err != nil {
   485  		t.Fatal(err)
   486  	}
   487  
   488  	for _, early := range []bool{true, false} {
   489  		cmd := testenv.CleanCmdEnv(exec.Command(exe, "CgoCatchPanic"))
   490  		// Make sure a panic results in a crash.
   491  		cmd.Env = append(cmd.Env, "GOTRACEBACK=crash")
   492  		if early {
   493  			// Tell testprogcgo to install an early signal handler for SIGABRT
   494  			cmd.Env = append(cmd.Env, "CGOCATCHPANIC_EARLY_HANDLER=1")
   495  		}
   496  		if out, err := cmd.CombinedOutput(); err != nil {
   497  			t.Errorf("testprogcgo CgoCatchPanic failed: %v\n%s", err, out)
   498  		}
   499  	}
   500  }
   501  
   502  func TestCgoLockOSThreadExit(t *testing.T) {
   503  	switch runtime.GOOS {
   504  	case "plan9", "windows":
   505  		t.Skipf("no pthreads on %s", runtime.GOOS)
   506  	}
   507  	t.Parallel()
   508  	testLockOSThreadExit(t, "testprogcgo")
   509  }
   510  
   511  func TestWindowsStackMemoryCgo(t *testing.T) {
   512  	if runtime.GOOS != "windows" {
   513  		t.Skip("skipping windows specific test")
   514  	}
   515  	testenv.SkipFlaky(t, 22575)
   516  	o := runTestProg(t, "testprogcgo", "StackMemory")
   517  	stackUsage, err := strconv.Atoi(o)
   518  	if err != nil {
   519  		t.Fatalf("Failed to read stack usage: %v", err)
   520  	}
   521  	if expected, got := 100<<10, stackUsage; got > expected {
   522  		t.Fatalf("expected < %d bytes of memory per thread, got %d", expected, got)
   523  	}
   524  }
   525  
   526  func TestSigStackSwapping(t *testing.T) {
   527  	switch runtime.GOOS {
   528  	case "plan9", "windows":
   529  		t.Skipf("no sigaltstack on %s", runtime.GOOS)
   530  	}
   531  	t.Parallel()
   532  	got := runTestProg(t, "testprogcgo", "SigStack")
   533  	want := "OK\n"
   534  	if got != want {
   535  		t.Errorf("expected %q got %v", want, got)
   536  	}
   537  }
   538  
   539  func TestCgoTracebackSigpanic(t *testing.T) {
   540  	// Test unwinding over a sigpanic in C code without a C
   541  	// symbolizer. See issue #23576.
   542  	if runtime.GOOS == "windows" {
   543  		// On Windows if we get an exception in C code, we let
   544  		// the Windows exception handler unwind it, rather
   545  		// than injecting a sigpanic.
   546  		t.Skip("no sigpanic in C on windows")
   547  	}
   548  	if runtime.GOOS == "ios" {
   549  		testenv.SkipFlaky(t, 59912)
   550  	}
   551  	t.Parallel()
   552  	got := runTestProg(t, "testprogcgo", "TracebackSigpanic")
   553  	t.Log(got)
   554  	// We should see the function that calls the C function.
   555  	want := "main.TracebackSigpanic"
   556  	if !strings.Contains(got, want) {
   557  		if runtime.GOOS == "android" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64") {
   558  			testenv.SkipFlaky(t, 58794)
   559  		}
   560  		t.Errorf("did not see %q in output", want)
   561  	}
   562  	// We shouldn't inject a sigpanic call. (see issue 57698)
   563  	nowant := "runtime.sigpanic"
   564  	if strings.Contains(got, nowant) {
   565  		t.Errorf("unexpectedly saw %q in output", nowant)
   566  	}
   567  	// No runtime errors like "runtime: unexpected return pc".
   568  	nowant = "runtime: "
   569  	if strings.Contains(got, nowant) {
   570  		t.Errorf("unexpectedly saw %q in output", nowant)
   571  	}
   572  }
   573  
   574  func TestCgoPanicCallback(t *testing.T) {
   575  	t.Parallel()
   576  	got := runTestProg(t, "testprogcgo", "PanicCallback")
   577  	t.Log(got)
   578  	want := "panic: runtime error: invalid memory address or nil pointer dereference"
   579  	if !strings.Contains(got, want) {
   580  		t.Errorf("did not see %q in output", want)
   581  	}
   582  	want = "panic_callback"
   583  	if !strings.Contains(got, want) {
   584  		t.Errorf("did not see %q in output", want)
   585  	}
   586  	want = "PanicCallback"
   587  	if !strings.Contains(got, want) {
   588  		t.Errorf("did not see %q in output", want)
   589  	}
   590  	// No runtime errors like "runtime: unexpected return pc".
   591  	nowant := "runtime: "
   592  	if strings.Contains(got, nowant) {
   593  		t.Errorf("did not see %q in output", want)
   594  	}
   595  }
   596  
   597  // Test that C code called via cgo can use large Windows thread stacks
   598  // and call back in to Go without crashing. See issue #20975.
   599  //
   600  // See also TestBigStackCallbackSyscall.
   601  func TestBigStackCallbackCgo(t *testing.T) {
   602  	if runtime.GOOS != "windows" {
   603  		t.Skip("skipping windows specific test")
   604  	}
   605  	t.Parallel()
   606  	got := runTestProg(t, "testprogcgo", "BigStack")
   607  	want := "OK\n"
   608  	if got != want {
   609  		t.Errorf("expected %q got %v", want, got)
   610  	}
   611  }
   612  
   613  func nextTrace(lines []string) ([]string, []string) {
   614  	var trace []string
   615  	for n, line := range lines {
   616  		if strings.HasPrefix(line, "---") {
   617  			return trace, lines[n+1:]
   618  		}
   619  		fields := strings.Fields(strings.TrimSpace(line))
   620  		if len(fields) == 0 {
   621  			continue
   622  		}
   623  		// Last field contains the function name.
   624  		trace = append(trace, fields[len(fields)-1])
   625  	}
   626  	return nil, nil
   627  }
   628  
   629  func findTrace(text, top string) []string {
   630  	lines := strings.Split(text, "\n")
   631  	_, lines = nextTrace(lines) // Skip the header.
   632  	for len(lines) > 0 {
   633  		var t []string
   634  		t, lines = nextTrace(lines)
   635  		if len(t) == 0 {
   636  			continue
   637  		}
   638  		if t[0] == top {
   639  			return t
   640  		}
   641  	}
   642  	return nil
   643  }
   644  
   645  func TestSegv(t *testing.T) {
   646  	switch runtime.GOOS {
   647  	case "plan9", "windows":
   648  		t.Skipf("no signals on %s", runtime.GOOS)
   649  	}
   650  
   651  	for _, test := range []string{"Segv", "SegvInCgo", "TgkillSegv", "TgkillSegvInCgo"} {
   652  		test := test
   653  
   654  		// The tgkill variants only run on Linux.
   655  		if runtime.GOOS != "linux" && strings.HasPrefix(test, "Tgkill") {
   656  			continue
   657  		}
   658  
   659  		t.Run(test, func(t *testing.T) {
   660  			if test == "SegvInCgo" && runtime.GOOS == "ios" {
   661  				testenv.SkipFlaky(t, 59947) // Don't even try, in case it times out.
   662  			}
   663  
   664  			t.Parallel()
   665  			prog := "testprog"
   666  			if strings.HasSuffix(test, "InCgo") {
   667  				prog = "testprogcgo"
   668  			}
   669  			got := runTestProg(t, prog, test)
   670  			t.Log(got)
   671  			want := "SIGSEGV"
   672  			if !strings.Contains(got, want) {
   673  				if runtime.GOOS == "darwin" && runtime.GOARCH == "amd64" && strings.Contains(got, "fatal: morestack on g0") {
   674  					testenv.SkipFlaky(t, 39457)
   675  				}
   676  				t.Errorf("did not see %q in output", want)
   677  			}
   678  
   679  			// No runtime errors like "runtime: unknown pc".
   680  			switch runtime.GOOS {
   681  			case "darwin", "ios", "illumos", "solaris":
   682  				// Runtime sometimes throws when generating the traceback.
   683  				testenv.SkipFlaky(t, 49182)
   684  			case "linux":
   685  				if runtime.GOARCH == "386" {
   686  					// Runtime throws when generating a traceback from
   687  					// a VDSO call via asmcgocall.
   688  					testenv.SkipFlaky(t, 50504)
   689  				}
   690  			}
   691  			if test == "SegvInCgo" && strings.Contains(got, "unknown pc") {
   692  				testenv.SkipFlaky(t, 50979)
   693  			}
   694  
   695  			for _, nowant := range []string{"fatal error: ", "runtime: "} {
   696  				if strings.Contains(got, nowant) {
   697  					if runtime.GOOS == "darwin" && strings.Contains(got, "0xb01dfacedebac1e") {
   698  						// See the comment in signal_darwin_amd64.go.
   699  						t.Skip("skipping due to Darwin handling of malformed addresses")
   700  					}
   701  					t.Errorf("unexpectedly saw %q in output", nowant)
   702  				}
   703  			}
   704  		})
   705  	}
   706  }
   707  
   708  func TestAbortInCgo(t *testing.T) {
   709  	switch runtime.GOOS {
   710  	case "plan9", "windows":
   711  		// N.B. On Windows, C abort() causes the program to exit
   712  		// without going through the runtime at all.
   713  		t.Skipf("no signals on %s", runtime.GOOS)
   714  	}
   715  
   716  	t.Parallel()
   717  	got := runTestProg(t, "testprogcgo", "Abort")
   718  	t.Log(got)
   719  	want := "SIGABRT"
   720  	if !strings.Contains(got, want) {
   721  		t.Errorf("did not see %q in output", want)
   722  	}
   723  	// No runtime errors like "runtime: unknown pc".
   724  	nowant := "runtime: "
   725  	if strings.Contains(got, nowant) {
   726  		t.Errorf("did not see %q in output", want)
   727  	}
   728  }
   729  
   730  // TestEINTR tests that we handle EINTR correctly.
   731  // See issue #20400 and friends.
   732  func TestEINTR(t *testing.T) {
   733  	switch runtime.GOOS {
   734  	case "plan9", "windows":
   735  		t.Skipf("no EINTR on %s", runtime.GOOS)
   736  	case "linux":
   737  		if runtime.GOARCH == "386" {
   738  			// On linux-386 the Go signal handler sets
   739  			// a restorer function that is not preserved
   740  			// by the C sigaction call in the test,
   741  			// causing the signal handler to crash when
   742  			// returning the normal code. The test is not
   743  			// architecture-specific, so just skip on 386
   744  			// rather than doing a complicated workaround.
   745  			t.Skip("skipping on linux-386; C sigaction does not preserve Go restorer")
   746  		}
   747  	}
   748  
   749  	t.Parallel()
   750  	output := runTestProg(t, "testprogcgo", "EINTR")
   751  	want := "OK\n"
   752  	if output != want {
   753  		t.Fatalf("want %s, got %s\n", want, output)
   754  	}
   755  }
   756  
   757  // Issue #42207.
   758  func TestNeedmDeadlock(t *testing.T) {
   759  	switch runtime.GOOS {
   760  	case "plan9", "windows":
   761  		t.Skipf("no signals on %s", runtime.GOOS)
   762  	}
   763  	output := runTestProg(t, "testprogcgo", "NeedmDeadlock")
   764  	want := "OK\n"
   765  	if output != want {
   766  		t.Fatalf("want %s, got %s\n", want, output)
   767  	}
   768  }
   769  
   770  func TestCgoNoCallback(t *testing.T) {
   771  	got := runTestProg(t, "testprogcgo", "CgoNoCallback")
   772  	want := "function marked with #cgo nocallback called back into Go"
   773  	if !strings.Contains(got, want) {
   774  		t.Fatalf("did not see %q in output:\n%s", want, got)
   775  	}
   776  }
   777  
   778  func TestCgoNoEscape(t *testing.T) {
   779  	got := runTestProg(t, "testprogcgo", "CgoNoEscape")
   780  	want := "OK\n"
   781  	if got != want {
   782  		t.Fatalf("want %s, got %s\n", want, got)
   783  	}
   784  }
   785  
   786  // Issue #63739.
   787  func TestCgoEscapeWithMultiplePointers(t *testing.T) {
   788  	got := runTestProg(t, "testprogcgo", "CgoEscapeWithMultiplePointers")
   789  	want := "OK\n"
   790  	if got != want {
   791  		t.Fatalf("output is %s; want %s", got, want)
   792  	}
   793  }
   794  
   795  func TestCgoTracebackGoroutineProfile(t *testing.T) {
   796  	output := runTestProg(t, "testprogcgo", "GoroutineProfile")
   797  	want := "OK\n"
   798  	if output != want {
   799  		t.Fatalf("want %s, got %s\n", want, output)
   800  	}
   801  }
   802  
   803  func TestCgoSigfwd(t *testing.T) {
   804  	t.Parallel()
   805  	if !goos.IsUnix {
   806  		t.Skipf("no signals on %s", runtime.GOOS)
   807  	}
   808  
   809  	got := runTestProg(t, "testprogcgo", "CgoSigfwd", "GO_TEST_CGOSIGFWD=1")
   810  	if want := "OK\n"; got != want {
   811  		t.Fatalf("expected %q, but got:\n%s", want, got)
   812  	}
   813  }
   814  
   815  func TestDestructorCallback(t *testing.T) {
   816  	t.Parallel()
   817  	got := runTestProg(t, "testprogcgo", "DestructorCallback")
   818  	if want := "OK\n"; got != want {
   819  		t.Errorf("expected %q, but got:\n%s", want, got)
   820  	}
   821  }
   822  
   823  func TestDestructorCallbackRace(t *testing.T) {
   824  	// This test requires building with -race,
   825  	// so it's somewhat slow.
   826  	if testing.Short() {
   827  		t.Skip("skipping test in -short mode")
   828  	}
   829  
   830  	if !platform.RaceDetectorSupported(runtime.GOOS, runtime.GOARCH) {
   831  		t.Skipf("skipping on %s/%s because race detector not supported", runtime.GOOS, runtime.GOARCH)
   832  	}
   833  
   834  	t.Parallel()
   835  
   836  	exe, err := buildTestProg(t, "testprogcgo", "-race")
   837  	if err != nil {
   838  		t.Fatal(err)
   839  	}
   840  
   841  	got, err := testenv.CleanCmdEnv(exec.Command(exe, "DestructorCallback")).CombinedOutput()
   842  	if err != nil {
   843  		t.Fatal(err)
   844  	}
   845  
   846  	if want := "OK\n"; string(got) != want {
   847  		t.Errorf("expected %q, but got:\n%s", want, got)
   848  	}
   849  }
   850  
   851  func TestEnsureBindM(t *testing.T) {
   852  	t.Parallel()
   853  	switch runtime.GOOS {
   854  	case "windows", "plan9":
   855  		t.Skipf("skipping bindm test on %s", runtime.GOOS)
   856  	}
   857  	got := runTestProg(t, "testprogcgo", "EnsureBindM")
   858  	want := "OK\n"
   859  	if got != want {
   860  		t.Errorf("expected %q, got %v", want, got)
   861  	}
   862  }
   863  
   864  func TestStackSwitchCallback(t *testing.T) {
   865  	t.Parallel()
   866  	switch runtime.GOOS {
   867  	case "windows", "plan9", "android", "ios", "openbsd": // no getcontext
   868  		t.Skipf("skipping test on %s", runtime.GOOS)
   869  	}
   870  	got := runTestProg(t, "testprogcgo", "StackSwitchCallback")
   871  	skip := "SKIP\n"
   872  	if got == skip {
   873  		t.Skip("skipping on musl/bionic libc")
   874  	}
   875  	want := "OK\n"
   876  	if got != want {
   877  		t.Errorf("expected %q, got %v", want, got)
   878  	}
   879  }
   880  
   881  func TestCgoToGoCallGoexit(t *testing.T) {
   882  	if runtime.GOOS == "plan9" || runtime.GOOS == "windows" {
   883  		t.Skipf("no pthreads on %s", runtime.GOOS)
   884  	}
   885  	output := runTestProg(t, "testprogcgo", "CgoToGoCallGoexit")
   886  	if !strings.Contains(output, "runtime.Goexit called in a thread that was not created by the Go runtime") {
   887  		t.Fatalf("output should contain %s, got %s", "runtime.Goexit called in a thread that was not created by the Go runtime", output)
   888  	}
   889  }
   890
View as plain text