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  				if GOOS == "darwin" {
   109  					sigNoteWakeup(&sig.note)
   110  					break Send
   111  				}
   112  				notewakeup(&sig.note)
   113  				break Send
   114  			}
   115  		}
   116  	}
   117  
   118  	atomic.Xadd(&sig.delivering, -1)
   119  	return true
   120  }
   121  
   122  // Called to receive the next queued signal.
   123  // Must only be called from a single goroutine at a time.
   124  //go:linkname signal_recv os/signal.signal_recv
   125  func signal_recv() uint32 {
   126  	for {
   127  		// Serve any signals from local copy.
   128  		for i := uint32(0); i < _NSIG; i++ {
   129  			if sig.recv[i/32]&(1<<(i&31)) != 0 {
   130  				sig.recv[i/32] &^= 1 << (i & 31)
   131  				return i
   132  			}
   133  		}
   134  
   135  		// Wait for updates to be available from signal sender.
   136  	Receive:
   137  		for {
   138  			switch atomic.Load(&sig.state) {
   139  			default:
   140  				throw("signal_recv: inconsistent state")
   141  			case sigIdle:
   142  				if atomic.Cas(&sig.state, sigIdle, sigReceiving) {
   143  					if GOOS == "darwin" {
   144  						sigNoteSleep(&sig.note)
   145  						break Receive
   146  					}
   147  					notetsleepg(&sig.note, -1)
   148  					noteclear(&sig.note)
   149  					break Receive
   150  				}
   151  			case sigSending:
   152  				if atomic.Cas(&sig.state, sigSending, sigIdle) {
   153  					break Receive
   154  				}
   155  			}
   156  		}
   157  
   158  		// Incorporate updates from sender into local copy.
   159  		for i := range sig.mask {
   160  			sig.recv[i] = atomic.Xchg(&sig.mask[i], 0)
   161  		}
   162  	}
   163  }
   164  
   165  // signalWaitUntilIdle waits until the signal delivery mechanism is idle.
   166  // This is used to ensure that we do not drop a signal notification due
   167  // to a race between disabling a signal and receiving a signal.
   168  // This assumes that signal delivery has already been disabled for
   169  // the signal(s) in question, and here we are just waiting to make sure
   170  // that all the signals have been delivered to the user channels
   171  // by the os/signal package.
   172  //go:linkname signalWaitUntilIdle os/signal.signalWaitUntilIdle
   173  func signalWaitUntilIdle() {
   174  	// Although the signals we care about have been removed from
   175  	// sig.wanted, it is possible that another thread has received
   176  	// a signal, has read from sig.wanted, is now updating sig.mask,
   177  	// and has not yet woken up the processor thread. We need to wait
   178  	// until all current signal deliveries have completed.
   179  	for atomic.Load(&sig.delivering) != 0 {
   180  		Gosched()
   181  	}
   182  
   183  	// Although WaitUntilIdle seems like the right name for this
   184  	// function, the state we are looking for is sigReceiving, not
   185  	// sigIdle.  The sigIdle state is really more like sigProcessing.
   186  	for atomic.Load(&sig.state) != sigReceiving {
   187  		Gosched()
   188  	}
   189  }
   190  
   191  // Must only be called from a single goroutine at a time.
   192  //go:linkname signal_enable os/signal.signal_enable
   193  func signal_enable(s uint32) {
   194  	if !sig.inuse {
   195  		// The first call to signal_enable is for us
   196  		// to use for initialization. It does not pass
   197  		// signal information in m.
   198  		sig.inuse = true // enable reception of signals; cannot disable
   199  		if GOOS == "darwin" {
   200  			sigNoteSetup(&sig.note)
   201  			return
   202  		}
   203  		noteclear(&sig.note)
   204  		return
   205  	}
   206  
   207  	if s >= uint32(len(sig.wanted)*32) {
   208  		return
   209  	}
   210  
   211  	w := sig.wanted[s/32]
   212  	w |= 1 << (s & 31)
   213  	atomic.Store(&sig.wanted[s/32], w)
   214  
   215  	i := sig.ignored[s/32]
   216  	i &^= 1 << (s & 31)
   217  	atomic.Store(&sig.ignored[s/32], i)
   218  
   219  	sigenable(s)
   220  }
   221  
   222  // Must only be called from a single goroutine at a time.
   223  //go:linkname signal_disable os/signal.signal_disable
   224  func signal_disable(s uint32) {
   225  	if s >= uint32(len(sig.wanted)*32) {
   226  		return
   227  	}
   228  	sigdisable(s)
   229  
   230  	w := sig.wanted[s/32]
   231  	w &^= 1 << (s & 31)
   232  	atomic.Store(&sig.wanted[s/32], w)
   233  }
   234  
   235  // Must only be called from a single goroutine at a time.
   236  //go:linkname signal_ignore os/signal.signal_ignore
   237  func signal_ignore(s uint32) {
   238  	if s >= uint32(len(sig.wanted)*32) {
   239  		return
   240  	}
   241  	sigignore(s)
   242  
   243  	w := sig.wanted[s/32]
   244  	w &^= 1 << (s & 31)
   245  	atomic.Store(&sig.wanted[s/32], w)
   246  
   247  	i := sig.ignored[s/32]
   248  	i |= 1 << (s & 31)
   249  	atomic.Store(&sig.ignored[s/32], i)
   250  }
   251  
   252  // sigInitIgnored marks the signal as already ignored. This is called at
   253  // program start by initsig. In a shared library initsig is called by
   254  // libpreinit, so the runtime may not be initialized yet.
   255  //go:nosplit
   256  func sigInitIgnored(s uint32) {
   257  	i := sig.ignored[s/32]
   258  	i |= 1 << (s & 31)
   259  	atomic.Store(&sig.ignored[s/32], i)
   260  }
   261  
   262  // Checked by signal handlers.
   263  //go:linkname signal_ignored os/signal.signal_ignored
   264  func signal_ignored(s uint32) bool {
   265  	i := atomic.Load(&sig.ignored[s/32])
   266  	return i&(1<<(s&31)) != 0
   267  }
   268  

View as plain text