debug_test.go

Documentation: runtime

     1  // Copyright 2018 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  // TODO: This test could be implemented on all (most?) UNIXes if we
     6  // added syscall.Tgkill more widely.
     7  
     8  // We skip all of these tests under race mode because our test thread
     9  // spends all of its time in the race runtime, which isn't a safe
    10  // point.
    11  
    12  //go:build (amd64 || arm64 || ppc64le) && linux && !race
    13  
    14  package runtime_test
    15  
    16  import (
    17  	"fmt"
    18  	"internal/abi"
    19  	"math"
    20  	"os"
    21  	"regexp"
    22  	"runtime"
    23  	"runtime/debug"
    24  	"sync/atomic"
    25  	"syscall"
    26  	"testing"
    27  )
    28  
    29  func startDebugCallWorker(t *testing.T) (g *runtime.G, after func()) {
    30  	// This can deadlock if run under a debugger because it
    31  	// depends on catching SIGTRAP, which is usually swallowed by
    32  	// a debugger.
    33  	skipUnderDebugger(t)
    34  
    35  	// This can deadlock if there aren't enough threads or if a GC
    36  	// tries to interrupt an atomic loop (see issue #10958). Execute
    37  	// an extra GC to ensure even the sweep phase is done (out of
    38  	// caution to prevent #49370 from happening).
    39  	// TODO(mknyszek): This extra GC cycle is likely unnecessary
    40  	// because preemption (which may happen during the sweep phase)
    41  	// isn't much of an issue anymore thanks to asynchronous preemption.
    42  	// The biggest risk is having a write barrier in the debug call
    43  	// injection test code fire, because it runs in a signal handler
    44  	// and may not have a P.
    45  	//
    46  	// We use 8 Ps so there's room for the debug call worker,
    47  	// something that's trying to preempt the call worker, and the
    48  	// goroutine that's trying to stop the call worker.
    49  	ogomaxprocs := runtime.GOMAXPROCS(8)
    50  	ogcpercent := debug.SetGCPercent(-1)
    51  	runtime.GC()
    52  
    53  	// ready is a buffered channel so debugCallWorker won't block
    54  	// on sending to it. This makes it less likely we'll catch
    55  	// debugCallWorker while it's in the runtime.
    56  	ready := make(chan *runtime.G, 1)
    57  	var stop uint32
    58  	done := make(chan error)
    59  	go debugCallWorker(ready, &stop, done)
    60  	g = <-ready
    61  	return g, func() {
    62  		atomic.StoreUint32(&stop, 1)
    63  		err := <-done
    64  		if err != nil {
    65  			t.Fatal(err)
    66  		}
    67  		runtime.GOMAXPROCS(ogomaxprocs)
    68  		debug.SetGCPercent(ogcpercent)
    69  	}
    70  }
    71  
    72  func debugCallWorker(ready chan<- *runtime.G, stop *uint32, done chan<- error) {
    73  	runtime.LockOSThread()
    74  	defer runtime.UnlockOSThread()
    75  
    76  	ready <- runtime.Getg()
    77  
    78  	x := 2
    79  	debugCallWorker2(stop, &x)
    80  	if x != 1 {
    81  		done <- fmt.Errorf("want x = 2, got %d; register pointer not adjusted?", x)
    82  	}
    83  	close(done)
    84  }
    85  
    86  // Don't inline this function, since we want to test adjusting
    87  // pointers in the arguments.
    88  //
    89  //go:noinline
    90  func debugCallWorker2(stop *uint32, x *int) {
    91  	for atomic.LoadUint32(stop) == 0 {
    92  		// Strongly encourage x to live in a register so we
    93  		// can test pointer register adjustment.
    94  		*x++
    95  	}
    96  	*x = 1
    97  }
    98  
    99  func debugCallTKill(tid int) error {
   100  	return syscall.Tgkill(syscall.Getpid(), tid, syscall.SIGTRAP)
   101  }
   102  
   103  // skipUnderDebugger skips the current test when running under a
   104  // debugger (specifically if this process has a tracer). This is
   105  // Linux-specific.
   106  func skipUnderDebugger(t *testing.T) {
   107  	pid := syscall.Getpid()
   108  	status, err := os.ReadFile(fmt.Sprintf("/proc/%d/status", pid))
   109  	if err != nil {
   110  		t.Logf("couldn't get proc tracer: %s", err)
   111  		return
   112  	}
   113  	re := regexp.MustCompile(`TracerPid:\s+([0-9]+)`)
   114  	sub := re.FindSubmatch(status)
   115  	if sub == nil {
   116  		t.Logf("couldn't find proc tracer PID")
   117  		return
   118  	}
   119  	if string(sub[1]) == "0" {
   120  		return
   121  	}
   122  	t.Skip("test will deadlock under a debugger")
   123  }
   124  
   125  func TestDebugCall(t *testing.T) {
   126  	g, after := startDebugCallWorker(t)
   127  	defer after()
   128  
   129  	type stackArgs struct {
   130  		x0    int
   131  		x1    float64
   132  		y0Ret int
   133  		y1Ret float64
   134  	}
   135  
   136  	// Inject a call into the debugCallWorker goroutine and test
   137  	// basic argument and result passing.
   138  	fn := func(x int, y float64) (y0Ret int, y1Ret float64) {
   139  		return x + 1, y + 1.0
   140  	}
   141  	var args *stackArgs
   142  	var regs abi.RegArgs
   143  	intRegs := regs.Ints[:]
   144  	floatRegs := regs.Floats[:]
   145  	fval := float64(42.0)
   146  	if len(intRegs) > 0 {
   147  		intRegs[0] = 42
   148  		floatRegs[0] = math.Float64bits(fval)
   149  	} else {
   150  		args = &stackArgs{
   151  			x0: 42,
   152  			x1: 42.0,
   153  		}
   154  	}
   155  
   156  	if _, err := runtime.InjectDebugCall(g, fn, &regs, args, debugCallTKill, false); err != nil {
   157  		t.Fatal(err)
   158  	}
   159  	var result0 int
   160  	var result1 float64
   161  	if len(intRegs) > 0 {
   162  		result0 = int(intRegs[0])
   163  		result1 = math.Float64frombits(floatRegs[0])
   164  	} else {
   165  		result0 = args.y0Ret
   166  		result1 = args.y1Ret
   167  	}
   168  	if result0 != 43 {
   169  		t.Errorf("want 43, got %d", result0)
   170  	}
   171  	if result1 != fval+1 {
   172  		t.Errorf("want 43, got %f", result1)
   173  	}
   174  }
   175  
   176  func TestDebugCallLarge(t *testing.T) {
   177  	g, after := startDebugCallWorker(t)
   178  	defer after()
   179  
   180  	// Inject a call with a large call frame.
   181  	const N = 128
   182  	var args struct {
   183  		in  [N]int
   184  		out [N]int
   185  	}
   186  	fn := func(in [N]int) (out [N]int) {
   187  		for i := range in {
   188  			out[i] = in[i] + 1
   189  		}
   190  		return
   191  	}
   192  	var want [N]int
   193  	for i := range args.in {
   194  		args.in[i] = i
   195  		want[i] = i + 1
   196  	}
   197  	if _, err := runtime.InjectDebugCall(g, fn, nil, &args, debugCallTKill, false); err != nil {
   198  		t.Fatal(err)
   199  	}
   200  	if want != args.out {
   201  		t.Fatalf("want %v, got %v", want, args.out)
   202  	}
   203  }
   204  
   205  func TestDebugCallGC(t *testing.T) {
   206  	g, after := startDebugCallWorker(t)
   207  	defer after()
   208  
   209  	// Inject a call that performs a GC.
   210  	if _, err := runtime.InjectDebugCall(g, runtime.GC, nil, nil, debugCallTKill, false); err != nil {
   211  		t.Fatal(err)
   212  	}
   213  }
   214  
   215  func TestDebugCallGrowStack(t *testing.T) {
   216  	g, after := startDebugCallWorker(t)
   217  	defer after()
   218  
   219  	// Inject a call that grows the stack. debugCallWorker checks
   220  	// for stack pointer breakage.
   221  	if _, err := runtime.InjectDebugCall(g, func() { growStack(nil) }, nil, nil, debugCallTKill, false); err != nil {
   222  		t.Fatal(err)
   223  	}
   224  }
   225  
   226  //go:nosplit
   227  func debugCallUnsafePointWorker(gpp **runtime.G, ready, stop *uint32) {
   228  	// The nosplit causes this function to not contain safe-points
   229  	// except at calls.
   230  	runtime.LockOSThread()
   231  	defer runtime.UnlockOSThread()
   232  
   233  	*gpp = runtime.Getg()
   234  
   235  	for atomic.LoadUint32(stop) == 0 {
   236  		atomic.StoreUint32(ready, 1)
   237  	}
   238  }
   239  
   240  func TestDebugCallUnsafePoint(t *testing.T) {
   241  	skipUnderDebugger(t)
   242  
   243  	// This can deadlock if there aren't enough threads or if a GC
   244  	// tries to interrupt an atomic loop (see issue #10958).
   245  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(8))
   246  
   247  	// InjectDebugCall cannot be executed while a GC is actively in
   248  	// progress. Wait until the current GC is done, and turn it off.
   249  	//
   250  	// See #49370.
   251  	runtime.GC()
   252  	defer debug.SetGCPercent(debug.SetGCPercent(-1))
   253  
   254  	// Test that the runtime refuses call injection at unsafe points.
   255  	var g *runtime.G
   256  	var ready, stop uint32
   257  	defer atomic.StoreUint32(&stop, 1)
   258  	go debugCallUnsafePointWorker(&g, &ready, &stop)
   259  	for atomic.LoadUint32(&ready) == 0 {
   260  		runtime.Gosched()
   261  	}
   262  
   263  	_, err := runtime.InjectDebugCall(g, func() {}, nil, nil, debugCallTKill, true)
   264  	if msg := "call not at safe point"; err == nil || err.Error() != msg {
   265  		t.Fatalf("want %q, got %s", msg, err)
   266  	}
   267  }
   268  
   269  func TestDebugCallPanic(t *testing.T) {
   270  	skipUnderDebugger(t)
   271  
   272  	// This can deadlock if there aren't enough threads.
   273  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(8))
   274  
   275  	// InjectDebugCall cannot be executed while a GC is actively in
   276  	// progress. Wait until the current GC is done, and turn it off.
   277  	//
   278  	// See #10958 and #49370.
   279  	defer debug.SetGCPercent(debug.SetGCPercent(-1))
   280  	// TODO(mknyszek): This extra GC cycle is likely unnecessary
   281  	// because preemption (which may happen during the sweep phase)
   282  	// isn't much of an issue anymore thanks to asynchronous preemption.
   283  	// The biggest risk is having a write barrier in the debug call
   284  	// injection test code fire, because it runs in a signal handler
   285  	// and may not have a P.
   286  	runtime.GC()
   287  
   288  	ready := make(chan *runtime.G)
   289  	var stop uint32
   290  	defer atomic.StoreUint32(&stop, 1)
   291  	go func() {
   292  		runtime.LockOSThread()
   293  		defer runtime.UnlockOSThread()
   294  		ready <- runtime.Getg()
   295  		for atomic.LoadUint32(&stop) == 0 {
   296  		}
   297  	}()
   298  	g := <-ready
   299  
   300  	p, err := runtime.InjectDebugCall(g, func() { panic("test") }, nil, nil, debugCallTKill, false)
   301  	if err != nil {
   302  		t.Fatal(err)
   303  	}
   304  	if ps, ok := p.(string); !ok || ps != "test" {
   305  		t.Fatalf("wanted panic %v, got %v", "test", p)
   306  	}
   307  }
   308
View as plain text