mirror of
https://github.com/golang/go
synced 2024-10-02 12:18:33 -06:00
5fea2ccc77
The tree's pretty inconsistent about single space vs double space after a period in documentation. Make it consistently a single space, per earlier decisions. This means contributors won't be confused by misleading precedence. This CL doesn't use go/doc to parse. It only addresses // comments. It was generated with: $ perl -i -npe 's,^(\s*// .+[a-z]\.) +([A-Z]),$1 $2,' $(git grep -l -E '^\s*//(.+\.) +([A-Z])') $ go test go/doc -update Change-Id: Iccdb99c37c797ef1f804a94b22ba5ee4b500c4f7 Reviewed-on: https://go-review.googlesource.com/20022 Reviewed-by: Rob Pike <r@golang.org> Reviewed-by: Dave Day <djd@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
135 lines
2.6 KiB
Go
135 lines
2.6 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// This file implements runtime support for signal handling.
|
|
|
|
package runtime
|
|
|
|
import _ "unsafe"
|
|
|
|
const qsize = 64
|
|
|
|
var sig struct {
|
|
q noteQueue
|
|
inuse bool
|
|
|
|
lock mutex
|
|
note note
|
|
sleeping bool
|
|
}
|
|
|
|
type noteData struct {
|
|
s [_ERRMAX]byte
|
|
n int // n bytes of s are valid
|
|
}
|
|
|
|
type noteQueue struct {
|
|
lock mutex
|
|
data [qsize]noteData
|
|
ri int
|
|
wi int
|
|
full bool
|
|
}
|
|
|
|
// It is not allowed to allocate memory in the signal handler.
|
|
func (q *noteQueue) push(item *byte) bool {
|
|
lock(&q.lock)
|
|
if q.full {
|
|
unlock(&q.lock)
|
|
return false
|
|
}
|
|
s := gostringnocopy(item)
|
|
copy(q.data[q.wi].s[:], s)
|
|
q.data[q.wi].n = len(s)
|
|
q.wi++
|
|
if q.wi == qsize {
|
|
q.wi = 0
|
|
}
|
|
if q.wi == q.ri {
|
|
q.full = true
|
|
}
|
|
unlock(&q.lock)
|
|
return true
|
|
}
|
|
|
|
func (q *noteQueue) pop() string {
|
|
lock(&q.lock)
|
|
q.full = false
|
|
if q.ri == q.wi {
|
|
unlock(&q.lock)
|
|
return ""
|
|
}
|
|
note := &q.data[q.ri]
|
|
item := string(note.s[:note.n])
|
|
q.ri++
|
|
if q.ri == qsize {
|
|
q.ri = 0
|
|
}
|
|
unlock(&q.lock)
|
|
return item
|
|
}
|
|
|
|
// Called from sighandler to send a signal back out of the signal handling thread.
|
|
// Reports whether the signal was sent. If not, the caller typically crashes the program.
|
|
func sendNote(s *byte) bool {
|
|
if !sig.inuse {
|
|
return false
|
|
}
|
|
|
|
// Add signal to outgoing queue.
|
|
if !sig.q.push(s) {
|
|
return false
|
|
}
|
|
|
|
lock(&sig.lock)
|
|
if sig.sleeping {
|
|
sig.sleeping = false
|
|
notewakeup(&sig.note)
|
|
}
|
|
unlock(&sig.lock)
|
|
|
|
return true
|
|
}
|
|
|
|
// Called to receive the next queued signal.
|
|
// Must only be called from a single goroutine at a time.
|
|
//go:linkname signal_recv os/signal.signal_recv
|
|
func signal_recv() string {
|
|
for {
|
|
note := sig.q.pop()
|
|
if note != "" {
|
|
return note
|
|
}
|
|
|
|
lock(&sig.lock)
|
|
sig.sleeping = true
|
|
noteclear(&sig.note)
|
|
unlock(&sig.lock)
|
|
notetsleepg(&sig.note, -1)
|
|
}
|
|
}
|
|
|
|
// Must only be called from a single goroutine at a time.
|
|
//go:linkname signal_enable os/signal.signal_enable
|
|
func signal_enable(s uint32) {
|
|
if !sig.inuse {
|
|
// The first call to signal_enable is for us
|
|
// to use for initialization. It does not pass
|
|
// signal information in m.
|
|
sig.inuse = true // enable reception of signals; cannot disable
|
|
noteclear(&sig.note)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Must only be called from a single goroutine at a time.
|
|
//go:linkname signal_disable os/signal.signal_disable
|
|
func signal_disable(s uint32) {
|
|
}
|
|
|
|
// Must only be called from a single goroutine at a time.
|
|
//go:linkname signal_ignore os/signal.signal_ignore
|
|
func signal_ignore(s uint32) {
|
|
}
|