Source file src/runtime/signal_unix.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 unix
     6  
     7  package runtime
     8  
     9  import (
    10  	"internal/abi"
    11  	"runtime/internal/atomic"
    12  	"runtime/internal/sys"
    13  	"unsafe"
    14  )
    15  
    16  // sigTabT is the type of an entry in the global sigtable array.
    17  // sigtable is inherently system dependent, and appears in OS-specific files,
    18  // but sigTabT is the same for all Unixy systems.
    19  // The sigtable array is indexed by a system signal number to get the flags
    20  // and printable name of each signal.
    21  type sigTabT struct {
    22  	flags int32
    23  	name  string
    24  }
    25  
    26  //go:linkname os_sigpipe os.sigpipe
    27  func os_sigpipe() {
    28  	systemstack(sigpipe)
    29  }
    30  
    31  func signame(sig uint32) string {
    32  	if sig >= uint32(len(sigtable)) {
    33  		return ""
    34  	}
    35  	return sigtable[sig].name
    36  }
    37  
    38  const (
    39  	_SIG_DFL uintptr = 0
    40  	_SIG_IGN uintptr = 1
    41  )
    42  
    43  // sigPreempt is the signal used for non-cooperative preemption.
    44  //
    45  // There's no good way to choose this signal, but there are some
    46  // heuristics:
    47  //
    48  // 1. It should be a signal that's passed-through by debuggers by
    49  // default. On Linux, this is SIGALRM, SIGURG, SIGCHLD, SIGIO,
    50  // SIGVTALRM, SIGPROF, and SIGWINCH, plus some glibc-internal signals.
    51  //
    52  // 2. It shouldn't be used internally by libc in mixed Go/C binaries
    53  // because libc may assume it's the only thing that can handle these
    54  // signals. For example SIGCANCEL or SIGSETXID.
    55  //
    56  // 3. It should be a signal that can happen spuriously without
    57  // consequences. For example, SIGALRM is a bad choice because the
    58  // signal handler can't tell if it was caused by the real process
    59  // alarm or not (arguably this means the signal is broken, but I
    60  // digress). SIGUSR1 and SIGUSR2 are also bad because those are often
    61  // used in meaningful ways by applications.
    62  //
    63  // 4. We need to deal with platforms without real-time signals (like
    64  // macOS), so those are out.
    65  //
    66  // We use SIGURG because it meets all of these criteria, is extremely
    67  // unlikely to be used by an application for its "real" meaning (both
    68  // because out-of-band data is basically unused and because SIGURG
    69  // doesn't report which socket has the condition, making it pretty
    70  // useless), and even if it is, the application has to be ready for
    71  // spurious SIGURG. SIGIO wouldn't be a bad choice either, but is more
    72  // likely to be used for real.
    73  const sigPreempt = _SIGURG
    74  
    75  // Stores the signal handlers registered before Go installed its own.
    76  // These signal handlers will be invoked in cases where Go doesn't want to
    77  // handle a particular signal (e.g., signal occurred on a non-Go thread).
    78  // See sigfwdgo for more information on when the signals are forwarded.
    79  //
    80  // This is read by the signal handler; accesses should use
    81  // atomic.Loaduintptr and atomic.Storeuintptr.
    82  var fwdSig [_NSIG]uintptr
    83  
    84  // handlingSig is indexed by signal number and is non-zero if we are
    85  // currently handling the signal. Or, to put it another way, whether
    86  // the signal handler is currently set to the Go signal handler or not.
    87  // This is uint32 rather than bool so that we can use atomic instructions.
    88  var handlingSig [_NSIG]uint32
    89  
    90  // channels for synchronizing signal mask updates with the signal mask
    91  // thread
    92  var (
    93  	disableSigChan  chan uint32
    94  	enableSigChan   chan uint32
    95  	maskUpdatedChan chan struct{}
    96  )
    97  
    98  func init() {
    99  	// _NSIG is the number of signals on this operating system.
   100  	// sigtable should describe what to do for all the possible signals.
   101  	if len(sigtable) != _NSIG {
   102  		print("runtime: len(sigtable)=", len(sigtable), " _NSIG=", _NSIG, "\n")
   103  		throw("bad sigtable len")
   104  	}
   105  }
   106  
   107  var signalsOK bool
   108  
   109  // Initialize signals.
   110  // Called by libpreinit so runtime may not be initialized.
   111  //
   112  //go:nosplit
   113  //go:nowritebarrierrec
   114  func initsig(preinit bool) {
   115  	if !preinit {
   116  		// It's now OK for signal handlers to run.
   117  		signalsOK = true
   118  	}
   119  
   120  	// For c-archive/c-shared this is called by libpreinit with
   121  	// preinit == true.
   122  	if (isarchive || islibrary) && !preinit {
   123  		return
   124  	}
   125  
   126  	for i := uint32(0); i < _NSIG; i++ {
   127  		t := &sigtable[i]
   128  		if t.flags == 0 || t.flags&_SigDefault != 0 {
   129  			continue
   130  		}
   131  
   132  		// We don't need to use atomic operations here because
   133  		// there shouldn't be any other goroutines running yet.
   134  		fwdSig[i] = getsig(i)
   135  
   136  		if !sigInstallGoHandler(i) {
   137  			// Even if we are not installing a signal handler,
   138  			// set SA_ONSTACK if necessary.
   139  			if fwdSig[i] != _SIG_DFL && fwdSig[i] != _SIG_IGN {
   140  				setsigstack(i)
   141  			} else if fwdSig[i] == _SIG_IGN {
   142  				sigInitIgnored(i)
   143  			}
   144  			continue
   145  		}
   146  
   147  		handlingSig[i] = 1
   148  		setsig(i, abi.FuncPCABIInternal(sighandler))
   149  	}
   150  }
   151  
   152  //go:nosplit
   153  //go:nowritebarrierrec
   154  func sigInstallGoHandler(sig uint32) bool {
   155  	// For some signals, we respect an inherited SIG_IGN handler
   156  	// rather than insist on installing our own default handler.
   157  	// Even these signals can be fetched using the os/signal package.
   158  	switch sig {
   159  	case _SIGHUP, _SIGINT:
   160  		if atomic.Loaduintptr(&fwdSig[sig]) == _SIG_IGN {
   161  			return false
   162  		}
   163  	}
   164  
   165  	if (GOOS == "linux" || GOOS == "android") && !iscgo && sig == sigPerThreadSyscall {
   166  		// sigPerThreadSyscall is the same signal used by glibc for
   167  		// per-thread syscalls on Linux. We use it for the same purpose
   168  		// in non-cgo binaries.
   169  		return true
   170  	}
   171  
   172  	t := &sigtable[sig]
   173  	if t.flags&_SigSetStack != 0 {
   174  		return false
   175  	}
   176  
   177  	// When built using c-archive or c-shared, only install signal
   178  	// handlers for synchronous signals and SIGPIPE and sigPreempt.
   179  	if (isarchive || islibrary) && t.flags&_SigPanic == 0 && sig != _SIGPIPE && sig != sigPreempt {
   180  		return false
   181  	}
   182  
   183  	return true
   184  }
   185  
   186  // sigenable enables the Go signal handler to catch the signal sig.
   187  // It is only called while holding the os/signal.handlers lock,
   188  // via os/signal.enableSignal and signal_enable.
   189  func sigenable(sig uint32) {
   190  	if sig >= uint32(len(sigtable)) {
   191  		return
   192  	}
   193  
   194  	// SIGPROF is handled specially for profiling.
   195  	if sig == _SIGPROF {
   196  		return
   197  	}
   198  
   199  	t := &sigtable[sig]
   200  	if t.flags&_SigNotify != 0 {
   201  		ensureSigM()
   202  		enableSigChan <- sig
   203  		<-maskUpdatedChan
   204  		if atomic.Cas(&handlingSig[sig], 0, 1) {
   205  			atomic.Storeuintptr(&fwdSig[sig], getsig(sig))
   206  			setsig(sig, abi.FuncPCABIInternal(sighandler))
   207  		}
   208  	}
   209  }
   210  
   211  // sigdisable disables the Go signal handler for the signal sig.
   212  // It is only called while holding the os/signal.handlers lock,
   213  // via os/signal.disableSignal and signal_disable.
   214  func sigdisable(sig uint32) {
   215  	if sig >= uint32(len(sigtable)) {
   216  		return
   217  	}
   218  
   219  	// SIGPROF is handled specially for profiling.
   220  	if sig == _SIGPROF {
   221  		return
   222  	}
   223  
   224  	t := &sigtable[sig]
   225  	if t.flags&_SigNotify != 0 {
   226  		ensureSigM()
   227  		disableSigChan <- sig
   228  		<-maskUpdatedChan
   229  
   230  		// If initsig does not install a signal handler for a
   231  		// signal, then to go back to the state before Notify
   232  		// we should remove the one we installed.
   233  		if !sigInstallGoHandler(sig) {
   234  			atomic.Store(&handlingSig[sig], 0)
   235  			setsig(sig, atomic.Loaduintptr(&fwdSig[sig]))
   236  		}
   237  	}
   238  }
   239  
   240  // sigignore ignores the signal sig.
   241  // It is only called while holding the os/signal.handlers lock,
   242  // via os/signal.ignoreSignal and signal_ignore.
   243  func sigignore(sig uint32) {
   244  	if sig >= uint32(len(sigtable)) {
   245  		return
   246  	}
   247  
   248  	// SIGPROF is handled specially for profiling.
   249  	if sig == _SIGPROF {
   250  		return
   251  	}
   252  
   253  	t := &sigtable[sig]
   254  	if t.flags&_SigNotify != 0 {
   255  		atomic.Store(&handlingSig[sig], 0)
   256  		setsig(sig, _SIG_IGN)
   257  	}
   258  }
   259  
   260  // clearSignalHandlers clears all signal handlers that are not ignored
   261  // back to the default. This is called by the child after a fork, so that
   262  // we can enable the signal mask for the exec without worrying about
   263  // running a signal handler in the child.
   264  //
   265  //go:nosplit
   266  //go:nowritebarrierrec
   267  func clearSignalHandlers() {
   268  	for i := uint32(0); i < _NSIG; i++ {
   269  		if atomic.Load(&handlingSig[i]) != 0 {
   270  			setsig(i, _SIG_DFL)
   271  		}
   272  	}
   273  }
   274  
   275  // setProcessCPUProfilerTimer is called when the profiling timer changes.
   276  // It is called with prof.signalLock held. hz is the new timer, and is 0 if
   277  // profiling is being disabled. Enable or disable the signal as
   278  // required for -buildmode=c-archive.
   279  func setProcessCPUProfilerTimer(hz int32) {
   280  	if hz != 0 {
   281  		// Enable the Go signal handler if not enabled.
   282  		if atomic.Cas(&handlingSig[_SIGPROF], 0, 1) {
   283  			h := getsig(_SIGPROF)
   284  			// If no signal handler was installed before, then we record
   285  			// _SIG_IGN here. When we turn off profiling (below) we'll start
   286  			// ignoring SIGPROF signals. We do this, rather than change
   287  			// to SIG_DFL, because there may be a pending SIGPROF
   288  			// signal that has not yet been delivered to some other thread.
   289  			// If we change to SIG_DFL when turning off profiling, the
   290  			// program will crash when that SIGPROF is delivered. We assume
   291  			// that programs that use profiling don't want to crash on a
   292  			// stray SIGPROF. See issue 19320.
   293  			// We do the change here instead of when turning off profiling,
   294  			// because there we may race with a signal handler running
   295  			// concurrently, in particular, sigfwdgo may observe _SIG_DFL and
   296  			// die. See issue 43828.
   297  			if h == _SIG_DFL {
   298  				h = _SIG_IGN
   299  			}
   300  			atomic.Storeuintptr(&fwdSig[_SIGPROF], h)
   301  			setsig(_SIGPROF, abi.FuncPCABIInternal(sighandler))
   302  		}
   303  
   304  		var it itimerval
   305  		it.it_interval.tv_sec = 0
   306  		it.it_interval.set_usec(1000000 / hz)
   307  		it.it_value = it.it_interval
   308  		setitimer(_ITIMER_PROF, &it, nil)
   309  	} else {
   310  		setitimer(_ITIMER_PROF, &itimerval{}, nil)
   311  
   312  		// If the Go signal handler should be disabled by default,
   313  		// switch back to the signal handler that was installed
   314  		// when we enabled profiling. We don't try to handle the case
   315  		// of a program that changes the SIGPROF handler while Go
   316  		// profiling is enabled.
   317  		if !sigInstallGoHandler(_SIGPROF) {
   318  			if atomic.Cas(&handlingSig[_SIGPROF], 1, 0) {
   319  				h := atomic.Loaduintptr(&fwdSig[_SIGPROF])
   320  				setsig(_SIGPROF, h)
   321  			}
   322  		}
   323  	}
   324  }
   325  
   326  // setThreadCPUProfilerHz makes any thread-specific changes required to
   327  // implement profiling at a rate of hz.
   328  // No changes required on Unix systems when using setitimer.
   329  func setThreadCPUProfilerHz(hz int32) {
   330  	getg().m.profilehz = hz
   331  }
   332  
   333  func sigpipe() {
   334  	if signal_ignored(_SIGPIPE) || sigsend(_SIGPIPE) {
   335  		return
   336  	}
   337  	dieFromSignal(_SIGPIPE)
   338  }
   339  
   340  // doSigPreempt handles a preemption signal on gp.
   341  func doSigPreempt(gp *g, ctxt *sigctxt) {
   342  	// Check if this G wants to be preempted and is safe to
   343  	// preempt.
   344  	if wantAsyncPreempt(gp) {
   345  		if ok, newpc := isAsyncSafePoint(gp, ctxt.sigpc(), ctxt.sigsp(), ctxt.siglr()); ok {
   346  			// Adjust the PC and inject a call to asyncPreempt.
   347  			ctxt.pushCall(abi.FuncPCABI0(asyncPreempt), newpc)
   348  		}
   349  	}
   350  
   351  	// Acknowledge the preemption.
   352  	gp.m.preemptGen.Add(1)
   353  	gp.m.signalPending.Store(0)
   354  
   355  	if GOOS == "darwin" || GOOS == "ios" {
   356  		pendingPreemptSignals.Add(-1)
   357  	}
   358  }
   359  
   360  const preemptMSupported = true
   361  
   362  // preemptM sends a preemption request to mp. This request may be
   363  // handled asynchronously and may be coalesced with other requests to
   364  // the M. When the request is received, if the running G or P are
   365  // marked for preemption and the goroutine is at an asynchronous
   366  // safe-point, it will preempt the goroutine. It always atomically
   367  // increments mp.preemptGen after handling a preemption request.
   368  func preemptM(mp *m) {
   369  	// On Darwin, don't try to preempt threads during exec.
   370  	// Issue #41702.
   371  	if GOOS == "darwin" || GOOS == "ios" {
   372  		execLock.rlock()
   373  	}
   374  
   375  	if mp.signalPending.CompareAndSwap(0, 1) {
   376  		if GOOS == "darwin" || GOOS == "ios" {
   377  			pendingPreemptSignals.Add(1)
   378  		}
   379  
   380  		// If multiple threads are preempting the same M, it may send many
   381  		// signals to the same M such that it hardly make progress, causing
   382  		// live-lock problem. Apparently this could happen on darwin. See
   383  		// issue #37741.
   384  		// Only send a signal if there isn't already one pending.
   385  		signalM(mp, sigPreempt)
   386  	}
   387  
   388  	if GOOS == "darwin" || GOOS == "ios" {
   389  		execLock.runlock()
   390  	}
   391  }
   392  
   393  // sigFetchG fetches the value of G safely when running in a signal handler.
   394  // On some architectures, the g value may be clobbered when running in a VDSO.
   395  // See issue #32912.
   396  //
   397  //go:nosplit
   398  func sigFetchG(c *sigctxt) *g {
   399  	switch GOARCH {
   400  	case "arm", "arm64", "loong64", "ppc64", "ppc64le", "riscv64", "s390x":
   401  		if !iscgo && inVDSOPage(c.sigpc()) {
   402  			// When using cgo, we save the g on TLS and load it from there
   403  			// in sigtramp. Just use that.
   404  			// Otherwise, before making a VDSO call we save the g to the
   405  			// bottom of the signal stack. Fetch from there.
   406  			// TODO: in efence mode, stack is sysAlloc'd, so this wouldn't
   407  			// work.
   408  			sp := getcallersp()
   409  			s := spanOf(sp)
   410  			if s != nil && s.state.get() == mSpanManual && s.base() < sp && sp < s.limit {
   411  				gp := *(**g)(unsafe.Pointer(s.base()))
   412  				return gp
   413  			}
   414  			return nil
   415  		}
   416  	}
   417  	return getg()
   418  }
   419  
   420  // sigtrampgo is called from the signal handler function, sigtramp,
   421  // written in assembly code.
   422  // This is called by the signal handler, and the world may be stopped.
   423  //
   424  // It must be nosplit because getg() is still the G that was running
   425  // (if any) when the signal was delivered, but it's (usually) called
   426  // on the gsignal stack. Until this switches the G to gsignal, the
   427  // stack bounds check won't work.
   428  //
   429  //go:nosplit
   430  //go:nowritebarrierrec
   431  func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
   432  	if sigfwdgo(sig, info, ctx) {
   433  		return
   434  	}
   435  	c := &sigctxt{info, ctx}
   436  	gp := sigFetchG(c)
   437  	setg(gp)
   438  	if gp == nil || (gp.m != nil && gp.m.isExtraInC) {
   439  		if sig == _SIGPROF {
   440  			// Some platforms (Linux) have per-thread timers, which we use in
   441  			// combination with the process-wide timer. Avoid double-counting.
   442  			if validSIGPROF(nil, c) {
   443  				sigprofNonGoPC(c.sigpc())
   444  			}
   445  			return
   446  		}
   447  		if sig == sigPreempt && preemptMSupported && debug.asyncpreemptoff == 0 {
   448  			// This is probably a signal from preemptM sent
   449  			// while executing Go code but received while
   450  			// executing non-Go code.
   451  			// We got past sigfwdgo, so we know that there is
   452  			// no non-Go signal handler for sigPreempt.
   453  			// The default behavior for sigPreempt is to ignore
   454  			// the signal, so badsignal will be a no-op anyway.
   455  			if GOOS == "darwin" || GOOS == "ios" {
   456  				pendingPreemptSignals.Add(-1)
   457  			}
   458  			return
   459  		}
   460  		c.fixsigcode(sig)
   461  		// Set g to nil here and badsignal will use g0 by needm.
   462  		// TODO: reuse the current m here by using the gsignal and adjustSignalStack,
   463  		// since the current g maybe a normal goroutine and actually running on the signal stack,
   464  		// it may hit stack split that is not expected here.
   465  		if gp != nil {
   466  			setg(nil)
   467  		}
   468  		badsignal(uintptr(sig), c)
   469  		// Restore g
   470  		if gp != nil {
   471  			setg(gp)
   472  		}
   473  		return
   474  	}
   475  
   476  	setg(gp.m.gsignal)
   477  
   478  	// If some non-Go code called sigaltstack, adjust.
   479  	var gsignalStack gsignalStack
   480  	setStack := adjustSignalStack(sig, gp.m, &gsignalStack)
   481  	if setStack {
   482  		gp.m.gsignal.stktopsp = getcallersp()
   483  	}
   484  
   485  	if gp.stackguard0 == stackFork {
   486  		signalDuringFork(sig)
   487  	}
   488  
   489  	c.fixsigcode(sig)
   490  	sighandler(sig, info, ctx, gp)
   491  	setg(gp)
   492  	if setStack {
   493  		restoreGsignalStack(&gsignalStack)
   494  	}
   495  }
   496  
   497  // If the signal handler receives a SIGPROF signal on a non-Go thread,
   498  // it tries to collect a traceback into sigprofCallers.
   499  // sigprofCallersUse is set to non-zero while sigprofCallers holds a traceback.
   500  var sigprofCallers cgoCallers
   501  var sigprofCallersUse uint32
   502  
   503  // sigprofNonGo is called if we receive a SIGPROF signal on a non-Go thread,
   504  // and the signal handler collected a stack trace in sigprofCallers.
   505  // When this is called, sigprofCallersUse will be non-zero.
   506  // g is nil, and what we can do is very limited.
   507  //
   508  // It is called from the signal handling functions written in assembly code that
   509  // are active for cgo programs, cgoSigtramp and sigprofNonGoWrapper, which have
   510  // not verified that the SIGPROF delivery corresponds to the best available
   511  // profiling source for this thread.
   512  //
   513  //go:nosplit
   514  //go:nowritebarrierrec
   515  func sigprofNonGo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
   516  	if prof.hz.Load() != 0 {
   517  		c := &sigctxt{info, ctx}
   518  		// Some platforms (Linux) have per-thread timers, which we use in
   519  		// combination with the process-wide timer. Avoid double-counting.
   520  		if validSIGPROF(nil, c) {
   521  			n := 0
   522  			for n < len(sigprofCallers) && sigprofCallers[n] != 0 {
   523  				n++
   524  			}
   525  			cpuprof.addNonGo(sigprofCallers[:n])
   526  		}
   527  	}
   528  
   529  	atomic.Store(&sigprofCallersUse, 0)
   530  }
   531  
   532  // sigprofNonGoPC is called when a profiling signal arrived on a
   533  // non-Go thread and we have a single PC value, not a stack trace.
   534  // g is nil, and what we can do is very limited.
   535  //
   536  //go:nosplit
   537  //go:nowritebarrierrec
   538  func sigprofNonGoPC(pc uintptr) {
   539  	if prof.hz.Load() != 0 {
   540  		stk := []uintptr{
   541  			pc,
   542  			abi.FuncPCABIInternal(_ExternalCode) + sys.PCQuantum,
   543  		}
   544  		cpuprof.addNonGo(stk)
   545  	}
   546  }
   547  
   548  // adjustSignalStack adjusts the current stack guard based on the
   549  // stack pointer that is actually in use while handling a signal.
   550  // We do this in case some non-Go code called sigaltstack.
   551  // This reports whether the stack was adjusted, and if so stores the old
   552  // signal stack in *gsigstack.
   553  //
   554  //go:nosplit
   555  func adjustSignalStack(sig uint32, mp *m, gsigStack *gsignalStack) bool {
   556  	sp := uintptr(unsafe.Pointer(&sig))
   557  	if sp >= mp.gsignal.stack.lo && sp < mp.gsignal.stack.hi {
   558  		return false
   559  	}
   560  
   561  	var st stackt
   562  	sigaltstack(nil, &st)
   563  	stsp := uintptr(unsafe.Pointer(st.ss_sp))
   564  	if st.ss_flags&_SS_DISABLE == 0 && sp >= stsp && sp < stsp+st.ss_size {
   565  		setGsignalStack(&st, gsigStack)
   566  		return true
   567  	}
   568  
   569  	if sp >= mp.g0.stack.lo && sp < mp.g0.stack.hi {
   570  		// The signal was delivered on the g0 stack.
   571  		// This can happen when linked with C code
   572  		// using the thread sanitizer, which collects
   573  		// signals then delivers them itself by calling
   574  		// the signal handler directly when C code,
   575  		// including C code called via cgo, calls a
   576  		// TSAN-intercepted function such as malloc.
   577  		//
   578  		// We check this condition last as g0.stack.lo
   579  		// may be not very accurate (see mstart).
   580  		st := stackt{ss_size: mp.g0.stack.hi - mp.g0.stack.lo}
   581  		setSignalstackSP(&st, mp.g0.stack.lo)
   582  		setGsignalStack(&st, gsigStack)
   583  		return true
   584  	}
   585  
   586  	// sp is not within gsignal stack, g0 stack, or sigaltstack. Bad.
   587  	setg(nil)
   588  	needm(true)
   589  	if st.ss_flags&_SS_DISABLE != 0 {
   590  		noSignalStack(sig)
   591  	} else {
   592  		sigNotOnStack(sig, sp, mp)
   593  	}
   594  	dropm()
   595  	return false
   596  }
   597  
   598  // crashing is the number of m's we have waited for when implementing
   599  // GOTRACEBACK=crash when a signal is received.
   600  var crashing atomic.Int32
   601  
   602  // testSigtrap and testSigusr1 are used by the runtime tests. If
   603  // non-nil, it is called on SIGTRAP/SIGUSR1. If it returns true, the
   604  // normal behavior on this signal is suppressed.
   605  var testSigtrap func(info *siginfo, ctxt *sigctxt, gp *g) bool
   606  var testSigusr1 func(gp *g) bool
   607  
   608  // sighandler is invoked when a signal occurs. The global g will be
   609  // set to a gsignal goroutine and we will be running on the alternate
   610  // signal stack. The parameter gp will be the value of the global g
   611  // when the signal occurred. The sig, info, and ctxt parameters are
   612  // from the system signal handler: they are the parameters passed when
   613  // the SA is passed to the sigaction system call.
   614  //
   615  // The garbage collector may have stopped the world, so write barriers
   616  // are not allowed.
   617  //
   618  //go:nowritebarrierrec
   619  func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
   620  	// The g executing the signal handler. This is almost always
   621  	// mp.gsignal. See delayedSignal for an exception.
   622  	gsignal := getg()
   623  	mp := gsignal.m
   624  	c := &sigctxt{info, ctxt}
   625  
   626  	// Cgo TSAN (not the Go race detector) intercepts signals and calls the
   627  	// signal handler at a later time. When the signal handler is called, the
   628  	// memory may have changed, but the signal context remains old. The
   629  	// unmatched signal context and memory makes it unsafe to unwind or inspect
   630  	// the stack. So we ignore delayed non-fatal signals that will cause a stack
   631  	// inspection (profiling signal and preemption signal).
   632  	// cgo_yield is only non-nil for TSAN, and is specifically used to trigger
   633  	// signal delivery. We use that as an indicator of delayed signals.
   634  	// For delayed signals, the handler is called on the g0 stack (see
   635  	// adjustSignalStack).
   636  	delayedSignal := *cgo_yield != nil && mp != nil && gsignal.stack == mp.g0.stack
   637  
   638  	if sig == _SIGPROF {
   639  		// Some platforms (Linux) have per-thread timers, which we use in
   640  		// combination with the process-wide timer. Avoid double-counting.
   641  		if !delayedSignal && validSIGPROF(mp, c) {
   642  			sigprof(c.sigpc(), c.sigsp(), c.siglr(), gp, mp)
   643  		}
   644  		return
   645  	}
   646  
   647  	if sig == _SIGTRAP && testSigtrap != nil && testSigtrap(info, (*sigctxt)(noescape(unsafe.Pointer(c))), gp) {
   648  		return
   649  	}
   650  
   651  	if sig == _SIGUSR1 && testSigusr1 != nil && testSigusr1(gp) {
   652  		return
   653  	}
   654  
   655  	if (GOOS == "linux" || GOOS == "android") && sig == sigPerThreadSyscall {
   656  		// sigPerThreadSyscall is the same signal used by glibc for
   657  		// per-thread syscalls on Linux. We use it for the same purpose
   658  		// in non-cgo binaries. Since this signal is not _SigNotify,
   659  		// there is nothing more to do once we run the syscall.
   660  		runPerThreadSyscall()
   661  		return
   662  	}
   663  
   664  	if sig == sigPreempt && debug.asyncpreemptoff == 0 && !delayedSignal {
   665  		// Might be a preemption signal.
   666  		doSigPreempt(gp, c)
   667  		// Even if this was definitely a preemption signal, it
   668  		// may have been coalesced with another signal, so we
   669  		// still let it through to the application.
   670  	}
   671  
   672  	flags := int32(_SigThrow)
   673  	if sig < uint32(len(sigtable)) {
   674  		flags = sigtable[sig].flags
   675  	}
   676  	if !c.sigFromUser() && flags&_SigPanic != 0 && (gp.throwsplit || gp != mp.curg) {
   677  		// We can't safely sigpanic because it may grow the
   678  		// stack. Abort in the signal handler instead.
   679  		//
   680  		// Also don't inject a sigpanic if we are not on a
   681  		// user G stack. Either we're in the runtime, or we're
   682  		// running C code. Either way we cannot recover.
   683  		flags = _SigThrow
   684  	}
   685  	if isAbortPC(c.sigpc()) {
   686  		// On many architectures, the abort function just
   687  		// causes a memory fault. Don't turn that into a panic.
   688  		flags = _SigThrow
   689  	}
   690  	if !c.sigFromUser() && flags&_SigPanic != 0 {
   691  		// The signal is going to cause a panic.
   692  		// Arrange the stack so that it looks like the point
   693  		// where the signal occurred made a call to the
   694  		// function sigpanic. Then set the PC to sigpanic.
   695  
   696  		// Have to pass arguments out of band since
   697  		// augmenting the stack frame would break
   698  		// the unwinding code.
   699  		gp.sig = sig
   700  		gp.sigcode0 = uintptr(c.sigcode())
   701  		gp.sigcode1 = c.fault()
   702  		gp.sigpc = c.sigpc()
   703  
   704  		c.preparePanic(sig, gp)
   705  		return
   706  	}
   707  
   708  	if c.sigFromUser() || flags&_SigNotify != 0 {
   709  		if sigsend(sig) {
   710  			return
   711  		}
   712  	}
   713  
   714  	if c.sigFromUser() && signal_ignored(sig) {
   715  		return
   716  	}
   717  
   718  	if flags&_SigKill != 0 {
   719  		dieFromSignal(sig)
   720  	}
   721  
   722  	// _SigThrow means that we should exit now.
   723  	// If we get here with _SigPanic, it means that the signal
   724  	// was sent to us by a program (c.sigFromUser() is true);
   725  	// in that case, if we didn't handle it in sigsend, we exit now.
   726  	if flags&(_SigThrow|_SigPanic) == 0 {
   727  		return
   728  	}
   729  
   730  	mp.throwing = throwTypeRuntime
   731  	mp.caughtsig.set(gp)
   732  
   733  	if crashing.Load() == 0 {
   734  		startpanic_m()
   735  	}
   736  
   737  	gp = fatalsignal(sig, c, gp, mp)
   738  
   739  	level, _, docrash := gotraceback()
   740  	if level > 0 {
   741  		goroutineheader(gp)
   742  		tracebacktrap(c.sigpc(), c.sigsp(), c.siglr(), gp)
   743  		if crashing.Load() > 0 && gp != mp.curg && mp.curg != nil && readgstatus(mp.curg)&^_Gscan == _Grunning {
   744  			// tracebackothers on original m skipped this one; trace it now.
   745  			goroutineheader(mp.curg)
   746  			traceback(^uintptr(0), ^uintptr(0), 0, mp.curg)
   747  		} else if crashing.Load() == 0 {
   748  			tracebackothers(gp)
   749  			print("\n")
   750  		}
   751  		dumpregs(c)
   752  	}
   753  
   754  	if docrash {
   755  		isCrashThread := false
   756  		if crashing.CompareAndSwap(0, 1) {
   757  			isCrashThread = true
   758  		} else {
   759  			crashing.Add(1)
   760  		}
   761  		if crashing.Load() < mcount()-int32(extraMLength.Load()) {
   762  			// There are other m's that need to dump their stacks.
   763  			// Relay SIGQUIT to the next m by sending it to the current process.
   764  			// All m's that have already received SIGQUIT have signal masks blocking
   765  			// receipt of any signals, so the SIGQUIT will go to an m that hasn't seen it yet.
   766  			// The first m will wait until all ms received the SIGQUIT, then crash/exit.
   767  			// Just in case the relaying gets botched, each m involved in
   768  			// the relay sleeps for 5 seconds and then does the crash/exit itself.
   769  			// The faulting m is crashing first so it is the faulting thread in the core dump (see issue #63277):
   770  			// in expected operation, the first m will wait until the last m has received the SIGQUIT,
   771  			// and then run crash/exit and the process is gone.
   772  			// However, if it spends more than 5 seconds to send SIGQUIT to all ms,
   773  			// any of ms may crash/exit the process after waiting for 5 seconds.
   774  			print("\n-----\n\n")
   775  			raiseproc(_SIGQUIT)
   776  		}
   777  		if isCrashThread {
   778  			i := 0
   779  			for (crashing.Load() < mcount()-int32(extraMLength.Load())) && i < 10 {
   780  				i++
   781  				usleep(500 * 1000)
   782  			}
   783  		} else {
   784  			usleep(5 * 1000 * 1000)
   785  		}
   786  		printDebugLog()
   787  		crash()
   788  	}
   789  
   790  	printDebugLog()
   791  
   792  	exit(2)
   793  }
   794  
   795  func fatalsignal(sig uint32, c *sigctxt, gp *g, mp *m) *g {
   796  	if sig < uint32(len(sigtable)) {
   797  		print(sigtable[sig].name, "\n")
   798  	} else {
   799  		print("Signal ", sig, "\n")
   800  	}
   801  
   802  	if isSecureMode() {
   803  		exit(2)
   804  	}
   805  
   806  	print("PC=", hex(c.sigpc()), " m=", mp.id, " sigcode=", c.sigcode())
   807  	if sig == _SIGSEGV || sig == _SIGBUS {
   808  		print(" addr=", hex(c.fault()))
   809  	}
   810  	print("\n")
   811  	if mp.incgo && gp == mp.g0 && mp.curg != nil {
   812  		print("signal arrived during cgo execution\n")
   813  		// Switch to curg so that we get a traceback of the Go code
   814  		// leading up to the cgocall, which switched from curg to g0.
   815  		gp = mp.curg
   816  	}
   817  	if sig == _SIGILL || sig == _SIGFPE {
   818  		// It would be nice to know how long the instruction is.
   819  		// Unfortunately, that's complicated to do in general (mostly for x86
   820  		// and s930x, but other archs have non-standard instruction lengths also).
   821  		// Opt to print 16 bytes, which covers most instructions.
   822  		const maxN = 16
   823  		n := uintptr(maxN)
   824  		// We have to be careful, though. If we're near the end of
   825  		// a page and the following page isn't mapped, we could
   826  		// segfault. So make sure we don't straddle a page (even though
   827  		// that could lead to printing an incomplete instruction).
   828  		// We're assuming here we can read at least the page containing the PC.
   829  		// I suppose it is possible that the page is mapped executable but not readable?
   830  		pc := c.sigpc()
   831  		if n > physPageSize-pc%physPageSize {
   832  			n = physPageSize - pc%physPageSize
   833  		}
   834  		print("instruction bytes:")
   835  		b := (*[maxN]byte)(unsafe.Pointer(pc))
   836  		for i := uintptr(0); i < n; i++ {
   837  			print(" ", hex(b[i]))
   838  		}
   839  		println()
   840  	}
   841  	print("\n")
   842  	return gp
   843  }
   844  
   845  // sigpanic turns a synchronous signal into a run-time panic.
   846  // If the signal handler sees a synchronous panic, it arranges the
   847  // stack to look like the function where the signal occurred called
   848  // sigpanic, sets the signal's PC value to sigpanic, and returns from
   849  // the signal handler. The effect is that the program will act as
   850  // though the function that got the signal simply called sigpanic
   851  // instead.
   852  //
   853  // This must NOT be nosplit because the linker doesn't know where
   854  // sigpanic calls can be injected.
   855  //
   856  // The signal handler must not inject a call to sigpanic if
   857  // getg().throwsplit, since sigpanic may need to grow the stack.
   858  //
   859  // This is exported via linkname to assembly in runtime/cgo.
   860  //
   861  //go:linkname sigpanic
   862  func sigpanic() {
   863  	gp := getg()
   864  	if !canpanic() {
   865  		throw("unexpected signal during runtime execution")
   866  	}
   867  
   868  	switch gp.sig {
   869  	case _SIGBUS:
   870  		if gp.sigcode0 == _BUS_ADRERR && gp.sigcode1 < 0x1000 {
   871  			panicmem()
   872  		}
   873  		// Support runtime/debug.SetPanicOnFault.
   874  		if gp.paniconfault {
   875  			panicmemAddr(gp.sigcode1)
   876  		}
   877  		print("unexpected fault address ", hex(gp.sigcode1), "\n")
   878  		throw("fault")
   879  	case _SIGSEGV:
   880  		if (gp.sigcode0 == 0 || gp.sigcode0 == _SEGV_MAPERR || gp.sigcode0 == _SEGV_ACCERR) && gp.sigcode1 < 0x1000 {
   881  			panicmem()
   882  		}
   883  		// Support runtime/debug.SetPanicOnFault.
   884  		if gp.paniconfault {
   885  			panicmemAddr(gp.sigcode1)
   886  		}
   887  		if inUserArenaChunk(gp.sigcode1) {
   888  			// We could check that the arena chunk is explicitly set to fault,
   889  			// but the fact that we faulted on accessing it is enough to prove
   890  			// that it is.
   891  			print("accessed data from freed user arena ", hex(gp.sigcode1), "\n")
   892  		} else {
   893  			print("unexpected fault address ", hex(gp.sigcode1), "\n")
   894  		}
   895  		throw("fault")
   896  	case _SIGFPE:
   897  		switch gp.sigcode0 {
   898  		case _FPE_INTDIV:
   899  			panicdivide()
   900  		case _FPE_INTOVF:
   901  			panicoverflow()
   902  		}
   903  		panicfloat()
   904  	}
   905  
   906  	if gp.sig >= uint32(len(sigtable)) {
   907  		// can't happen: we looked up gp.sig in sigtable to decide to call sigpanic
   908  		throw("unexpected signal value")
   909  	}
   910  	panic(errorString(sigtable[gp.sig].name))
   911  }
   912  
   913  // dieFromSignal kills the program with a signal.
   914  // This provides the expected exit status for the shell.
   915  // This is only called with fatal signals expected to kill the process.
   916  //
   917  //go:nosplit
   918  //go:nowritebarrierrec
   919  func dieFromSignal(sig uint32) {
   920  	unblocksig(sig)
   921  	// Mark the signal as unhandled to ensure it is forwarded.
   922  	atomic.Store(&handlingSig[sig], 0)
   923  	raise(sig)
   924  
   925  	// That should have killed us. On some systems, though, raise
   926  	// sends the signal to the whole process rather than to just
   927  	// the current thread, which means that the signal may not yet
   928  	// have been delivered. Give other threads a chance to run and
   929  	// pick up the signal.
   930  	osyield()
   931  	osyield()
   932  	osyield()
   933  
   934  	// If that didn't work, try _SIG_DFL.
   935  	setsig(sig, _SIG_DFL)
   936  	raise(sig)
   937  
   938  	osyield()
   939  	osyield()
   940  	osyield()
   941  
   942  	// If we are still somehow running, just exit with the wrong status.
   943  	exit(2)
   944  }
   945  
   946  // raisebadsignal is called when a signal is received on a non-Go
   947  // thread, and the Go program does not want to handle it (that is, the
   948  // program has not called os/signal.Notify for the signal).
   949  func raisebadsignal(sig uint32, c *sigctxt) {
   950  	if sig == _SIGPROF {
   951  		// Ignore profiling signals that arrive on non-Go threads.
   952  		return
   953  	}
   954  
   955  	var handler uintptr
   956  	if sig >= _NSIG {
   957  		handler = _SIG_DFL
   958  	} else {
   959  		handler = atomic.Loaduintptr(&fwdSig[sig])
   960  	}
   961  
   962  	// Reset the signal handler and raise the signal.
   963  	// We are currently running inside a signal handler, so the
   964  	// signal is blocked. We need to unblock it before raising the
   965  	// signal, or the signal we raise will be ignored until we return
   966  	// from the signal handler. We know that the signal was unblocked
   967  	// before entering the handler, or else we would not have received
   968  	// it. That means that we don't have to worry about blocking it
   969  	// again.
   970  	unblocksig(sig)
   971  	setsig(sig, handler)
   972  
   973  	// If we're linked into a non-Go program we want to try to
   974  	// avoid modifying the original context in which the signal
   975  	// was raised. If the handler is the default, we know it
   976  	// is non-recoverable, so we don't have to worry about
   977  	// re-installing sighandler. At this point we can just
   978  	// return and the signal will be re-raised and caught by
   979  	// the default handler with the correct context.
   980  	//
   981  	// On FreeBSD, the libthr sigaction code prevents
   982  	// this from working so we fall through to raise.
   983  	if GOOS != "freebsd" && (isarchive || islibrary) && handler == _SIG_DFL && !c.sigFromUser() {
   984  		return
   985  	}
   986  
   987  	raise(sig)
   988  
   989  	// Give the signal a chance to be delivered.
   990  	// In almost all real cases the program is about to crash,
   991  	// so sleeping here is not a waste of time.
   992  	usleep(1000)
   993  
   994  	// If the signal didn't cause the program to exit, restore the
   995  	// Go signal handler and carry on.
   996  	//
   997  	// We may receive another instance of the signal before we
   998  	// restore the Go handler, but that is not so bad: we know
   999  	// that the Go program has been ignoring the signal.
  1000  	setsig(sig, abi.FuncPCABIInternal(sighandler))
  1001  }
  1002  
  1003  //go:nosplit
  1004  func crash() {
  1005  	dieFromSignal(_SIGABRT)
  1006  }
  1007  
  1008  // ensureSigM starts one global, sleeping thread to make sure at least one thread
  1009  // is available to catch signals enabled for os/signal.
  1010  func ensureSigM() {
  1011  	if maskUpdatedChan != nil {
  1012  		return
  1013  	}
  1014  	maskUpdatedChan = make(chan struct{})
  1015  	disableSigChan = make(chan uint32)
  1016  	enableSigChan = make(chan uint32)
  1017  	go func() {
  1018  		// Signal masks are per-thread, so make sure this goroutine stays on one
  1019  		// thread.
  1020  		LockOSThread()
  1021  		defer UnlockOSThread()
  1022  		// The sigBlocked mask contains the signals not active for os/signal,
  1023  		// initially all signals except the essential. When signal.Notify()/Stop is called,
  1024  		// sigenable/sigdisable in turn notify this thread to update its signal
  1025  		// mask accordingly.
  1026  		sigBlocked := sigset_all
  1027  		for i := range sigtable {
  1028  			if !blockableSig(uint32(i)) {
  1029  				sigdelset(&sigBlocked, i)
  1030  			}
  1031  		}
  1032  		sigprocmask(_SIG_SETMASK, &sigBlocked, nil)
  1033  		for {
  1034  			select {
  1035  			case sig := <-enableSigChan:
  1036  				if sig > 0 {
  1037  					sigdelset(&sigBlocked, int(sig))
  1038  				}
  1039  			case sig := <-disableSigChan:
  1040  				if sig > 0 && blockableSig(sig) {
  1041  					sigaddset(&sigBlocked, int(sig))
  1042  				}
  1043  			}
  1044  			sigprocmask(_SIG_SETMASK, &sigBlocked, nil)
  1045  			maskUpdatedChan <- struct{}{}
  1046  		}
  1047  	}()
  1048  }
  1049  
  1050  // This is called when we receive a signal when there is no signal stack.
  1051  // This can only happen if non-Go code calls sigaltstack to disable the
  1052  // signal stack.
  1053  func noSignalStack(sig uint32) {
  1054  	println("signal", sig, "received on thread with no signal stack")
  1055  	throw("non-Go code disabled sigaltstack")
  1056  }
  1057  
  1058  // This is called if we receive a signal when there is a signal stack
  1059  // but we are not on it. This can only happen if non-Go code called
  1060  // sigaction without setting the SS_ONSTACK flag.
  1061  func sigNotOnStack(sig uint32, sp uintptr, mp *m) {
  1062  	println("signal", sig, "received but handler not on signal stack")
  1063  	print("mp.gsignal stack [", hex(mp.gsignal.stack.lo), " ", hex(mp.gsignal.stack.hi), "], ")
  1064  	print("mp.g0 stack [", hex(mp.g0.stack.lo), " ", hex(mp.g0.stack.hi), "], sp=", hex(sp), "\n")
  1065  	throw("non-Go code set up signal handler without SA_ONSTACK flag")
  1066  }
  1067  
  1068  // signalDuringFork is called if we receive a signal while doing a fork.
  1069  // We do not want signals at that time, as a signal sent to the process
  1070  // group may be delivered to the child process, causing confusion.
  1071  // This should never be called, because we block signals across the fork;
  1072  // this function is just a safety check. See issue 18600 for background.
  1073  func signalDuringFork(sig uint32) {
  1074  	println("signal", sig, "received during fork")
  1075  	throw("signal received during fork")
  1076  }
  1077  
  1078  // This runs on a foreign stack, without an m or a g. No stack split.
  1079  //
  1080  //go:nosplit
  1081  //go:norace
  1082  //go:nowritebarrierrec
  1083  func badsignal(sig uintptr, c *sigctxt) {
  1084  	if !iscgo && !cgoHasExtraM {
  1085  		// There is no extra M. needm will not be able to grab
  1086  		// an M. Instead of hanging, just crash.
  1087  		// Cannot call split-stack function as there is no G.
  1088  		writeErrStr("fatal: bad g in signal handler\n")
  1089  		exit(2)
  1090  		*(*uintptr)(unsafe.Pointer(uintptr(123))) = 2
  1091  	}
  1092  	needm(true)
  1093  	if !sigsend(uint32(sig)) {
  1094  		// A foreign thread received the signal sig, and the
  1095  		// Go code does not want to handle it.
  1096  		raisebadsignal(uint32(sig), c)
  1097  	}
  1098  	dropm()
  1099  }
  1100  
  1101  //go:noescape
  1102  func sigfwd(fn uintptr, sig uint32, info *siginfo, ctx unsafe.Pointer)
  1103  
  1104  // Determines if the signal should be handled by Go and if not, forwards the
  1105  // signal to the handler that was installed before Go's. Returns whether the
  1106  // signal was forwarded.
  1107  // This is called by the signal handler, and the world may be stopped.
  1108  //
  1109  //go:nosplit
  1110  //go:nowritebarrierrec
  1111  func sigfwdgo(sig uint32, info *siginfo, ctx unsafe.Pointer) bool {
  1112  	if sig >= uint32(len(sigtable)) {
  1113  		return false
  1114  	}
  1115  	fwdFn := atomic.Loaduintptr(&fwdSig[sig])
  1116  	flags := sigtable[sig].flags
  1117  
  1118  	// If we aren't handling the signal, forward it.
  1119  	if atomic.Load(&handlingSig[sig]) == 0 || !signalsOK {
  1120  		// If the signal is ignored, doing nothing is the same as forwarding.
  1121  		if fwdFn == _SIG_IGN || (fwdFn == _SIG_DFL && flags&_SigIgn != 0) {
  1122  			return true
  1123  		}
  1124  		// We are not handling the signal and there is no other handler to forward to.
  1125  		// Crash with the default behavior.
  1126  		if fwdFn == _SIG_DFL {
  1127  			setsig(sig, _SIG_DFL)
  1128  			dieFromSignal(sig)
  1129  			return false
  1130  		}
  1131  
  1132  		sigfwd(fwdFn, sig, info, ctx)
  1133  		return true
  1134  	}
  1135  
  1136  	// This function and its caller sigtrampgo assumes SIGPIPE is delivered on the
  1137  	// originating thread. This property does not hold on macOS (golang.org/issue/33384),
  1138  	// so we have no choice but to ignore SIGPIPE.
  1139  	if (GOOS == "darwin" || GOOS == "ios") && sig == _SIGPIPE {
  1140  		return true
  1141  	}
  1142  
  1143  	// If there is no handler to forward to, no need to forward.
  1144  	if fwdFn == _SIG_DFL {
  1145  		return false
  1146  	}
  1147  
  1148  	c := &sigctxt{info, ctx}
  1149  	// Only forward synchronous signals and SIGPIPE.
  1150  	// Unfortunately, user generated SIGPIPEs will also be forwarded, because si_code
  1151  	// is set to _SI_USER even for a SIGPIPE raised from a write to a closed socket
  1152  	// or pipe.
  1153  	if (c.sigFromUser() || flags&_SigPanic == 0) && sig != _SIGPIPE {
  1154  		return false
  1155  	}
  1156  	// Determine if the signal occurred inside Go code. We test that:
  1157  	//   (1) we weren't in VDSO page,
  1158  	//   (2) we were in a goroutine (i.e., m.curg != nil), and
  1159  	//   (3) we weren't in CGO.
  1160  	//   (4) we weren't in dropped extra m.
  1161  	gp := sigFetchG(c)
  1162  	if gp != nil && gp.m != nil && gp.m.curg != nil && !gp.m.isExtraInC && !gp.m.incgo {
  1163  		return false
  1164  	}
  1165  
  1166  	// Signal not handled by Go, forward it.
  1167  	if fwdFn != _SIG_IGN {
  1168  		sigfwd(fwdFn, sig, info, ctx)
  1169  	}
  1170  
  1171  	return true
  1172  }
  1173  
  1174  // sigsave saves the current thread's signal mask into *p.
  1175  // This is used to preserve the non-Go signal mask when a non-Go
  1176  // thread calls a Go function.
  1177  // This is nosplit and nowritebarrierrec because it is called by needm
  1178  // which may be called on a non-Go thread with no g available.
  1179  //
  1180  //go:nosplit
  1181  //go:nowritebarrierrec
  1182  func sigsave(p *sigset) {
  1183  	sigprocmask(_SIG_SETMASK, nil, p)
  1184  }
  1185  
  1186  // msigrestore sets the current thread's signal mask to sigmask.
  1187  // This is used to restore the non-Go signal mask when a non-Go thread
  1188  // calls a Go function.
  1189  // This is nosplit and nowritebarrierrec because it is called by dropm
  1190  // after g has been cleared.
  1191  //
  1192  //go:nosplit
  1193  //go:nowritebarrierrec
  1194  func msigrestore(sigmask sigset) {
  1195  	sigprocmask(_SIG_SETMASK, &sigmask, nil)
  1196  }
  1197  
  1198  // sigsetAllExiting is used by sigblock(true) when a thread is
  1199  // exiting.
  1200  var sigsetAllExiting = func() sigset {
  1201  	res := sigset_all
  1202  
  1203  	// Apply GOOS-specific overrides here, rather than in osinit,
  1204  	// because osinit may be called before sigsetAllExiting is
  1205  	// initialized (#51913).
  1206  	if GOOS == "linux" && iscgo {
  1207  		// #42494 glibc and musl reserve some signals for
  1208  		// internal use and require they not be blocked by
  1209  		// the rest of a normal C runtime. When the go runtime
  1210  		// blocks...unblocks signals, temporarily, the blocked
  1211  		// interval of time is generally very short. As such,
  1212  		// these expectations of *libc code are mostly met by
  1213  		// the combined go+cgo system of threads. However,
  1214  		// when go causes a thread to exit, via a return from
  1215  		// mstart(), the combined runtime can deadlock if
  1216  		// these signals are blocked. Thus, don't block these
  1217  		// signals when exiting threads.
  1218  		// - glibc: SIGCANCEL (32), SIGSETXID (33)
  1219  		// - musl: SIGTIMER (32), SIGCANCEL (33), SIGSYNCCALL (34)
  1220  		sigdelset(&res, 32)
  1221  		sigdelset(&res, 33)
  1222  		sigdelset(&res, 34)
  1223  	}
  1224  
  1225  	return res
  1226  }()
  1227  
  1228  // sigblock blocks signals in the current thread's signal mask.
  1229  // This is used to block signals while setting up and tearing down g
  1230  // when a non-Go thread calls a Go function. When a thread is exiting
  1231  // we use the sigsetAllExiting value, otherwise the OS specific
  1232  // definition of sigset_all is used.
  1233  // This is nosplit and nowritebarrierrec because it is called by needm
  1234  // which may be called on a non-Go thread with no g available.
  1235  //
  1236  //go:nosplit
  1237  //go:nowritebarrierrec
  1238  func sigblock(exiting bool) {
  1239  	if exiting {
  1240  		sigprocmask(_SIG_SETMASK, &sigsetAllExiting, nil)
  1241  		return
  1242  	}
  1243  	sigprocmask(_SIG_SETMASK, &sigset_all, nil)
  1244  }
  1245  
  1246  // unblocksig removes sig from the current thread's signal mask.
  1247  // This is nosplit and nowritebarrierrec because it is called from
  1248  // dieFromSignal, which can be called by sigfwdgo while running in the
  1249  // signal handler, on the signal stack, with no g available.
  1250  //
  1251  //go:nosplit
  1252  //go:nowritebarrierrec
  1253  func unblocksig(sig uint32) {
  1254  	var set sigset
  1255  	sigaddset(&set, int(sig))
  1256  	sigprocmask(_SIG_UNBLOCK, &set, nil)
  1257  }
  1258  
  1259  // minitSignals is called when initializing a new m to set the
  1260  // thread's alternate signal stack and signal mask.
  1261  func minitSignals() {
  1262  	minitSignalStack()
  1263  	minitSignalMask()
  1264  }
  1265  
  1266  // minitSignalStack is called when initializing a new m to set the
  1267  // alternate signal stack. If the alternate signal stack is not set
  1268  // for the thread (the normal case) then set the alternate signal
  1269  // stack to the gsignal stack. If the alternate signal stack is set
  1270  // for the thread (the case when a non-Go thread sets the alternate
  1271  // signal stack and then calls a Go function) then set the gsignal
  1272  // stack to the alternate signal stack. We also set the alternate
  1273  // signal stack to the gsignal stack if cgo is not used (regardless
  1274  // of whether it is already set). Record which choice was made in
  1275  // newSigstack, so that it can be undone in unminit.
  1276  func minitSignalStack() {
  1277  	mp := getg().m
  1278  	var st stackt
  1279  	sigaltstack(nil, &st)
  1280  	if st.ss_flags&_SS_DISABLE != 0 || !iscgo {
  1281  		signalstack(&mp.gsignal.stack)
  1282  		mp.newSigstack = true
  1283  	} else {
  1284  		setGsignalStack(&st, &mp.goSigStack)
  1285  		mp.newSigstack = false
  1286  	}
  1287  }
  1288  
  1289  // minitSignalMask is called when initializing a new m to set the
  1290  // thread's signal mask. When this is called all signals have been
  1291  // blocked for the thread.  This starts with m.sigmask, which was set
  1292  // either from initSigmask for a newly created thread or by calling
  1293  // sigsave if this is a non-Go thread calling a Go function. It
  1294  // removes all essential signals from the mask, thus causing those
  1295  // signals to not be blocked. Then it sets the thread's signal mask.
  1296  // After this is called the thread can receive signals.
  1297  func minitSignalMask() {
  1298  	nmask := getg().m.sigmask
  1299  	for i := range sigtable {
  1300  		if !blockableSig(uint32(i)) {
  1301  			sigdelset(&nmask, i)
  1302  		}
  1303  	}
  1304  	sigprocmask(_SIG_SETMASK, &nmask, nil)
  1305  }
  1306  
  1307  // unminitSignals is called from dropm, via unminit, to undo the
  1308  // effect of calling minit on a non-Go thread.
  1309  //
  1310  //go:nosplit
  1311  func unminitSignals() {
  1312  	if getg().m.newSigstack {
  1313  		st := stackt{ss_flags: _SS_DISABLE}
  1314  		sigaltstack(&st, nil)
  1315  	} else {
  1316  		// We got the signal stack from someone else. Restore
  1317  		// the Go-allocated stack in case this M gets reused
  1318  		// for another thread (e.g., it's an extram). Also, on
  1319  		// Android, libc allocates a signal stack for all
  1320  		// threads, so it's important to restore the Go stack
  1321  		// even on Go-created threads so we can free it.
  1322  		restoreGsignalStack(&getg().m.goSigStack)
  1323  	}
  1324  }
  1325  
  1326  // blockableSig reports whether sig may be blocked by the signal mask.
  1327  // We never want to block the signals marked _SigUnblock;
  1328  // these are the synchronous signals that turn into a Go panic.
  1329  // We never want to block the preemption signal if it is being used.
  1330  // In a Go program--not a c-archive/c-shared--we never want to block
  1331  // the signals marked _SigKill or _SigThrow, as otherwise it's possible
  1332  // for all running threads to block them and delay their delivery until
  1333  // we start a new thread. When linked into a C program we let the C code
  1334  // decide on the disposition of those signals.
  1335  func blockableSig(sig uint32) bool {
  1336  	flags := sigtable[sig].flags
  1337  	if flags&_SigUnblock != 0 {
  1338  		return false
  1339  	}
  1340  	if sig == sigPreempt && preemptMSupported && debug.asyncpreemptoff == 0 {
  1341  		return false
  1342  	}
  1343  	if isarchive || islibrary {
  1344  		return true
  1345  	}
  1346  	return flags&(_SigKill|_SigThrow) == 0
  1347  }
  1348  
  1349  // gsignalStack saves the fields of the gsignal stack changed by
  1350  // setGsignalStack.
  1351  type gsignalStack struct {
  1352  	stack       stack
  1353  	stackguard0 uintptr
  1354  	stackguard1 uintptr
  1355  	stktopsp    uintptr
  1356  }
  1357  
  1358  // setGsignalStack sets the gsignal stack of the current m to an
  1359  // alternate signal stack returned from the sigaltstack system call.
  1360  // It saves the old values in *old for use by restoreGsignalStack.
  1361  // This is used when handling a signal if non-Go code has set the
  1362  // alternate signal stack.
  1363  //
  1364  //go:nosplit
  1365  //go:nowritebarrierrec
  1366  func setGsignalStack(st *stackt, old *gsignalStack) {
  1367  	gp := getg()
  1368  	if old != nil {
  1369  		old.stack = gp.m.gsignal.stack
  1370  		old.stackguard0 = gp.m.gsignal.stackguard0
  1371  		old.stackguard1 = gp.m.gsignal.stackguard1
  1372  		old.stktopsp = gp.m.gsignal.stktopsp
  1373  	}
  1374  	stsp := uintptr(unsafe.Pointer(st.ss_sp))
  1375  	gp.m.gsignal.stack.lo = stsp
  1376  	gp.m.gsignal.stack.hi = stsp + st.ss_size
  1377  	gp.m.gsignal.stackguard0 = stsp + stackGuard
  1378  	gp.m.gsignal.stackguard1 = stsp + stackGuard
  1379  }
  1380  
  1381  // restoreGsignalStack restores the gsignal stack to the value it had
  1382  // before entering the signal handler.
  1383  //
  1384  //go:nosplit
  1385  //go:nowritebarrierrec
  1386  func restoreGsignalStack(st *gsignalStack) {
  1387  	gp := getg().m.gsignal
  1388  	gp.stack = st.stack
  1389  	gp.stackguard0 = st.stackguard0
  1390  	gp.stackguard1 = st.stackguard1
  1391  	gp.stktopsp = st.stktopsp
  1392  }
  1393  
  1394  // signalstack sets the current thread's alternate signal stack to s.
  1395  //
  1396  //go:nosplit
  1397  func signalstack(s *stack) {
  1398  	st := stackt{ss_size: s.hi - s.lo}
  1399  	setSignalstackSP(&st, s.lo)
  1400  	sigaltstack(&st, nil)
  1401  }
  1402  
  1403  // setsigsegv is used on darwin/arm64 to fake a segmentation fault.
  1404  //
  1405  // This is exported via linkname to assembly in runtime/cgo.
  1406  //
  1407  //go:nosplit
  1408  //go:linkname setsigsegv
  1409  func setsigsegv(pc uintptr) {
  1410  	gp := getg()
  1411  	gp.sig = _SIGSEGV
  1412  	gp.sigpc = pc
  1413  	gp.sigcode0 = _SEGV_MAPERR
  1414  	gp.sigcode1 = 0 // TODO: emulate si_addr
  1415  }
  1416  

View as plain text