...
Run Format

Source file src/runtime/sigqueue.go

Documentation: runtime

     1  // Copyright 2009 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  // This file implements runtime support for signal handling.
     6  //
     7  // Most synchronization primitives are not available from
     8  // the signal handler (it cannot block, allocate memory, or use locks)
     9  // so the handler communicates with a processing goroutine
    10  // via struct sig, below.
    11  //
    12  // sigsend is called by the signal handler to queue a new signal.
    13  // signal_recv is called by the Go program to receive a newly queued signal.
    14  // Synchronization between sigsend and signal_recv is based on the sig.state
    15  // variable. It can be in 3 states: sigIdle, sigReceiving and sigSending.
    16  // sigReceiving means that signal_recv is blocked on sig.Note and there are no
    17  // new pending signals.
    18  // sigSending means that sig.mask *may* contain new pending signals,
    19  // signal_recv can't be blocked in this state.
    20  // sigIdle means that there are no new pending signals and signal_recv is not blocked.
    21  // Transitions between states are done atomically with CAS.
    22  // When signal_recv is unblocked, it resets sig.Note and rechecks sig.mask.
    23  // If several sigsends and signal_recv execute concurrently, it can lead to
    24  // unnecessary rechecks of sig.mask, but it cannot lead to missed signals
    25  // nor deadlocks.
    26  
    27  // +build !plan9
    28  
    29  package runtime
    30  
    31  import (
    32  	"runtime/internal/atomic"
    33  	_ "unsafe" // for go:linkname
    34  )
    35  
    36  // sig handles communication between the signal handler and os/signal.
    37  // Other than the inuse and recv fields, the fields are accessed atomically.
    38  //
    39  // The wanted and ignored fields are only written by one goroutine at
    40  // a time; access is controlled by the handlers Mutex in os/signal.
    41  // The fields are only read by that one goroutine and by the signal handler.
    42  // We access them atomically to minimize the race between setting them
    43  // in the goroutine calling os/signal and the signal handler,
    44  // which may be running in a different thread. That race is unavoidable,
    45  // as there is no connection between handling a signal and receiving one,
    46  // but atomic instructions should minimize it.
    47  var sig struct {
    48  	note       note
    49  	mask       [(_NSIG + 31) / 32]uint32
    50  	wanted     [(_NSIG + 31) / 32]uint32
    51  	ignored    [(_NSIG + 31) / 32]uint32
    52  	recv       [(_NSIG + 31) / 32]uint32
    53  	state      uint32
    54  	delivering uint32
    55  	inuse      bool
    56  }
    57  
    58  const (
    59  	sigIdle = iota
    60  	sigReceiving
    61  	sigSending
    62  )
    63  
    64  // sigsend delivers a signal from sighandler to the internal signal delivery queue.
    65  // It reports whether the signal was sent. If not, the caller typically crashes the program.
    66  // It runs from the signal handler, so it's limited in what it can do.
    67  func sigsend(s uint32) bool {
    68  	bit := uint32(1) << uint(s&31)
    69  	if !sig.inuse || s >= uint32(32*len(sig.wanted)) {
    70  		return false
    71  	}
    72  
    73  	atomic.Xadd(&sig.delivering, 1)
    74  	// We are running in the signal handler; defer is not available.
    75  
    76  	if w := atomic.Load(&sig.wanted[s/32]); w&bit == 0 {
    77  		atomic.Xadd(&sig.delivering, -1)
    78  		return false
    79  	}
    80  
    81  	// Add signal to outgoing queue.
    82  	for {
    83  		mask := sig.mask[s/32]
    84  		if mask&bit != 0 {
    85  			atomic.Xadd(&sig.delivering, -1)
    86  			return true // signal already in queue
    87  		}
    88  		if atomic.Cas(&sig.mask[s/32], mask, mask|bit) {
    89  			break
    90  		}
    91  	}
    92  
    93  	// Notify receiver that queue has new bit.
    94  Send:
    95  	for {
    96  		switch atomic.Load(&sig.state) {
    97  		default:
    98  			throw("sigsend: inconsistent state")
    99  		case sigIdle:
   100  			if atomic.Cas(&sig.state, sigIdle, sigSending) {
   101  				break Send
   102  			}
   103  		case sigSending:
   104  			// notification already pending
   105  			break Send
   106  		case sigReceiving:
   107  			if atomic.Cas(&sig.state, sigReceiving, sigIdle) {
   108  				notewakeup(&sig.note)
   109  				break Send
   110  			}
   111  		}
   112  	}
   113  
   114  	atomic.Xadd(&sig.delivering, -1)
   115  	return true
   116  }
   117  
   118  // Called to receive the next queued signal.
   119  // Must only be called from a single goroutine at a time.
   120  //go:linkname signal_recv os/signal.signal_recv
   121  func signal_recv() uint32 {
   122  	for {
   123  		// Serve any signals from local copy.
   124  		for i := uint32(0); i < _NSIG; i++ {
   125  			if sig.recv[i/32]&(1<<(i&31)) != 0 {
   126  				sig.recv[i/32] &^= 1 << (i & 31)
   127  				return i
   128  			}
   129  		}
   130  
   131  		// Wait for updates to be available from signal sender.
   132  	Receive:
   133  		for {
   134  			switch atomic.Load(&sig.state) {
   135  			default:
   136  				throw("signal_recv: inconsistent state")
   137  			case sigIdle:
   138  				if atomic.Cas(&sig.state, sigIdle, sigReceiving) {
   139  					notetsleepg(&sig.note, -1)
   140  					noteclear(&sig.note)
   141  					break Receive
   142  				}
   143  			case sigSending:
   144  				if atomic.Cas(&sig.state, sigSending, sigIdle) {
   145  					break Receive
   146  				}
   147  			}
   148  		}
   149  
   150  		// Incorporate updates from sender into local copy.
   151  		for i := range sig.mask {
   152  			sig.recv[i] = atomic.Xchg(&sig.mask[i], 0)
   153  		}
   154  	}
   155  }
   156  
   157  // signalWaitUntilIdle waits until the signal delivery mechanism is idle.
   158  // This is used to ensure that we do not drop a signal notification due
   159  // to a race between disabling a signal and receiving a signal.
   160  // This assumes that signal delivery has already been disabled for
   161  // the signal(s) in question, and here we are just waiting to make sure
   162  // that all the signals have been delivered to the user channels
   163  // by the os/signal package.
   164  //go:linkname signalWaitUntilIdle os/signal.signalWaitUntilIdle
   165  func signalWaitUntilIdle() {
   166  	// Although the signals we care about have been removed from
   167  	// sig.wanted, it is possible that another thread has received
   168  	// a signal, has read from sig.wanted, is now updating sig.mask,
   169  	// and has not yet woken up the processor thread. We need to wait
   170  	// until all current signal deliveries have completed.
   171  	for atomic.Load(&sig.delivering) != 0 {
   172  		Gosched()
   173  	}
   174  
   175  	// Although WaitUntilIdle seems like the right name for this
   176  	// function, the state we are looking for is sigReceiving, not
   177  	// sigIdle.  The sigIdle state is really more like sigProcessing.
   178  	for atomic.Load(&sig.state) != sigReceiving {
   179  		Gosched()
   180  	}
   181  }
   182  
   183  // Must only be called from a single goroutine at a time.
   184  //go:linkname signal_enable os/signal.signal_enable
   185  func signal_enable(s uint32) {
   186  	if !sig.inuse {
   187  		// The first call to signal_enable is for us
   188  		// to use for initialization. It does not pass
   189  		// signal information in m.
   190  		sig.inuse = true // enable reception of signals; cannot disable
   191  		noteclear(&sig.note)
   192  		return
   193  	}
   194  
   195  	if s >= uint32(len(sig.wanted)*32) {
   196  		return
   197  	}
   198  
   199  	w := sig.wanted[s/32]
   200  	w |= 1 << (s & 31)
   201  	atomic.Store(&sig.wanted[s/32], w)
   202  
   203  	i := sig.ignored[s/32]
   204  	i &^= 1 << (s & 31)
   205  	atomic.Store(&sig.ignored[s/32], i)
   206  
   207  	sigenable(s)
   208  }
   209  
   210  // Must only be called from a single goroutine at a time.
   211  //go:linkname signal_disable os/signal.signal_disable
   212  func signal_disable(s uint32) {
   213  	if s >= uint32(len(sig.wanted)*32) {
   214  		return
   215  	}
   216  	sigdisable(s)
   217  
   218  	w := sig.wanted[s/32]
   219  	w &^= 1 << (s & 31)
   220  	atomic.Store(&sig.wanted[s/32], w)
   221  }
   222  
   223  // Must only be called from a single goroutine at a time.
   224  //go:linkname signal_ignore os/signal.signal_ignore
   225  func signal_ignore(s uint32) {
   226  	if s >= uint32(len(sig.wanted)*32) {
   227  		return
   228  	}
   229  	sigignore(s)
   230  
   231  	w := sig.wanted[s/32]
   232  	w &^= 1 << (s & 31)
   233  	atomic.Store(&sig.wanted[s/32], w)
   234  
   235  	i := sig.ignored[s/32]
   236  	i |= 1 << (s & 31)
   237  	atomic.Store(&sig.ignored[s/32], i)
   238  }
   239  
   240  // sigInitIgnored marks the signal as already ignored. This is called at
   241  // program start by initsig. In a shared library initsig is called by
   242  // libpreinit, so the runtime may not be initialized yet.
   243  //go:nosplit
   244  func sigInitIgnored(s uint32) {
   245  	i := sig.ignored[s/32]
   246  	i |= 1 << (s & 31)
   247  	atomic.Store(&sig.ignored[s/32], i)
   248  }
   249  
   250  // Checked by signal handlers.
   251  //go:linkname signal_ignored os/signal.signal_ignored
   252  func signal_ignored(s uint32) bool {
   253  	i := atomic.Load(&sig.ignored[s/32])
   254  	return i&(1<<(s&31)) != 0
   255  }
   256  

View as plain text