signal_sighandler.go

Documentation: runtime

     1  // Copyright 2013 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  // +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
     6  
     7  package runtime
     8  
     9  import (
    10  	"unsafe"
    11  )
    12  
    13  // crashing is the number of m's we have waited for when implementing
    14  // GOTRACEBACK=crash when a signal is received.
    15  var crashing int32
    16  
    17  // sighandler is invoked when a signal occurs. The global g will be
    18  // set to a gsignal goroutine and we will be running on the alternate
    19  // signal stack. The parameter g will be the value of the global g
    20  // when the signal occurred. The sig, info, and ctxt parameters are
    21  // from the system signal handler: they are the parameters passed when
    22  // the SA is passed to the sigaction system call.
    23  //
    24  // The garbage collector may have stopped the world, so write barriers
    25  // are not allowed.
    26  //
    27  //go:nowritebarrierrec
    28  func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
    29  	_g_ := getg()
    30  	c := &sigctxt{info, ctxt}
    31  
    32  	if sig == _SIGPROF {
    33  		sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, _g_.m)
    34  		return
    35  	}
    36  
    37  	flags := int32(_SigThrow)
    38  	if sig < uint32(len(sigtable)) {
    39  		flags = sigtable[sig].flags
    40  	}
    41  	if flags&_SigPanic != 0 && gp.throwsplit {
    42  		// We can't safely sigpanic because it may grow the
    43  		// stack. Abort in the signal handler instead.
    44  		flags = (flags &^ _SigPanic) | _SigThrow
    45  	}
    46  	if c.sigcode() != _SI_USER && flags&_SigPanic != 0 {
    47  		// The signal is going to cause a panic.
    48  		// Arrange the stack so that it looks like the point
    49  		// where the signal occurred made a call to the
    50  		// function sigpanic. Then set the PC to sigpanic.
    51  
    52  		// Have to pass arguments out of band since
    53  		// augmenting the stack frame would break
    54  		// the unwinding code.
    55  		gp.sig = sig
    56  		gp.sigcode0 = uintptr(c.sigcode())
    57  		gp.sigcode1 = uintptr(c.fault())
    58  		gp.sigpc = c.sigpc()
    59  
    60  		c.preparePanic(sig, gp)
    61  		return
    62  	}
    63  
    64  	if c.sigcode() == _SI_USER || flags&_SigNotify != 0 {
    65  		if sigsend(sig) {
    66  			return
    67  		}
    68  	}
    69  
    70  	if c.sigcode() == _SI_USER && signal_ignored(sig) {
    71  		return
    72  	}
    73  
    74  	if flags&_SigKill != 0 {
    75  		dieFromSignal(sig)
    76  	}
    77  
    78  	if flags&_SigThrow == 0 {
    79  		return
    80  	}
    81  
    82  	_g_.m.throwing = 1
    83  	_g_.m.caughtsig.set(gp)
    84  
    85  	if crashing == 0 {
    86  		startpanic()
    87  	}
    88  
    89  	if sig < uint32(len(sigtable)) {
    90  		print(sigtable[sig].name, "\n")
    91  	} else {
    92  		print("Signal ", sig, "\n")
    93  	}
    94  
    95  	print("PC=", hex(c.sigpc()), " m=", _g_.m.id, " sigcode=", c.sigcode(), "\n")
    96  	if _g_.m.lockedg != 0 && _g_.m.ncgo > 0 && gp == _g_.m.g0 {
    97  		print("signal arrived during cgo execution\n")
    98  		gp = _g_.m.lockedg.ptr()
    99  	}
   100  	print("\n")
   101  
   102  	level, _, docrash := gotraceback()
   103  	if level > 0 {
   104  		goroutineheader(gp)
   105  		tracebacktrap(c.sigpc(), c.sigsp(), c.siglr(), gp)
   106  		if crashing > 0 && gp != _g_.m.curg && _g_.m.curg != nil && readgstatus(_g_.m.curg)&^_Gscan == _Grunning {
   107  			// tracebackothers on original m skipped this one; trace it now.
   108  			goroutineheader(_g_.m.curg)
   109  			traceback(^uintptr(0), ^uintptr(0), 0, _g_.m.curg)
   110  		} else if crashing == 0 {
   111  			tracebackothers(gp)
   112  			print("\n")
   113  		}
   114  		dumpregs(c)
   115  	}
   116  
   117  	if docrash {
   118  		crashing++
   119  		if crashing < mcount()-int32(extraMCount) {
   120  			// There are other m's that need to dump their stacks.
   121  			// Relay SIGQUIT to the next m by sending it to the current process.
   122  			// All m's that have already received SIGQUIT have signal masks blocking
   123  			// receipt of any signals, so the SIGQUIT will go to an m that hasn't seen it yet.
   124  			// When the last m receives the SIGQUIT, it will fall through to the call to
   125  			// crash below. Just in case the relaying gets botched, each m involved in
   126  			// the relay sleeps for 5 seconds and then does the crash/exit itself.
   127  			// In expected operation, the last m has received the SIGQUIT and run
   128  			// crash/exit and the process is gone, all long before any of the
   129  			// 5-second sleeps have finished.
   130  			print("\n-----\n\n")
   131  			raiseproc(_SIGQUIT)
   132  			usleep(5 * 1000 * 1000)
   133  		}
   134  		crash()
   135  	}
   136  
   137  	exit(2)
   138  }
   139
View as plain text