mirror of
https://github.com/golang/go
synced 2024-10-02 04:18:33 -06:00
b1d1ec9183
CL 93658 moved stack trace printing inside a systemstack call to sidestep complexity in case the runtime is in a inconsistent state. Unfortunately, debuggers generating backtraces for a Go panic will be confused and come up with a technical correct but useless stack. This CL moves just the crash performing - typically a SIGABRT signal - outside the systemstack call to improve backtraces. Unfortunately, the crash function now needs to be marked nosplit and that triggers the no split stackoverflow check. To work around that, split fatalpanic in two: fatalthrow for runtime.throw and fatalpanic for runtime.gopanic. Only Go panics really needs crashes on the right stack and there is enough stack for gopanic. Example program: package main import "runtime/debug" func main() { debug.SetTraceback("crash") crash() } func crash() { panic("panic!") } Before: (lldb) bt * thread #1, name = 'simple', stop reason = signal SIGABRT * frame #0: 0x000000000044ffe4 simple`runtime.raise at <autogenerated>:1 frame #1: 0x0000000000438cfb simple`runtime.dieFromSignal(sig=<unavailable>) at signal_unix.go:424 frame #2: 0x0000000000438ec9 simple`runtime.crash at signal_unix.go:525 frame #3: 0x00000000004268f5 simple`runtime.dopanic_m(gp=<unavailable>, pc=<unavailable>, sp=<unavailable>) at panic.go:758 frame #4: 0x000000000044bead simple`runtime.fatalpanic.func1 at panic.go:657 frame #5: 0x000000000044d066 simple`runtime.systemstack at <autogenerated>:1 frame #6: 0x000000000042a980 simple at proc.go:1094 frame #7: 0x0000000000438ec9 simple`runtime.crash at signal_unix.go:525 frame #8: 0x00000000004268f5 simple`runtime.dopanic_m(gp=<unavailable>, pc=<unavailable>, sp=<unavailable>) at panic.go:758 frame #9: 0x000000000044bead simple`runtime.fatalpanic.func1 at panic.go:657 frame #10: 0x000000000044d066 simple`runtime.systemstack at <autogenerated>:1 frame #11: 0x000000000042a980 simple at proc.go:1094 frame #12: 0x00000000004268f5 simple`runtime.dopanic_m(gp=<unavailable>, pc=<unavailable>, sp=<unavailable>) at panic.go:758 frame #13: 0x000000000044bead simple`runtime.fatalpanic.func1 at panic.go:657 frame #14: 0x000000000044d066 simple`runtime.systemstack at <autogenerated>:1 frame #15: 0x000000000042a980 simple at proc.go:1094 frame #16: 0x000000000044bead simple`runtime.fatalpanic.func1 at panic.go:657 frame #17: 0x000000000044d066 simple`runtime.systemstack at <autogenerated>:1 After: (lldb) bt * thread #7, stop reason = signal SIGABRT * frame #0: 0x0000000000450024 simple`runtime.raise at <autogenerated>:1 frame #1: 0x0000000000438d1b simple`runtime.dieFromSignal(sig=<unavailable>) at signal_unix.go:424 frame #2: 0x0000000000438ee9 simple`runtime.crash at signal_unix.go:525 frame #3: 0x00000000004264e3 simple`runtime.fatalpanic(msgs=<unavailable>) at panic.go:664 frame #4: 0x0000000000425f1b simple`runtime.gopanic(e=<unavailable>) at panic.go:537 frame #5: 0x0000000000470c62 simple`main.crash at simple.go:11 frame #6: 0x0000000000470c00 simple`main.main at simple.go:6 frame #7: 0x0000000000427be7 simple`runtime.main at proc.go:198 frame #8: 0x000000000044ef91 simple`runtime.goexit at <autogenerated>:1 Updates #22716 Change-Id: Ib5fa35c13662c1dac2f1eac8b59c4a5824b98d92 Reviewed-on: https://go-review.googlesource.com/110065 Run-TryBot: Elias Naur <elias.naur@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com>
498 lines
9.3 KiB
Go
498 lines
9.3 KiB
Go
// Copyright 2010 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.
|
|
|
|
package runtime
|
|
|
|
import (
|
|
"runtime/internal/atomic"
|
|
"unsafe"
|
|
)
|
|
|
|
type mOS struct {
|
|
waitsemacount uint32
|
|
notesig *int8
|
|
errstr *byte
|
|
ignoreHangup bool
|
|
}
|
|
|
|
func closefd(fd int32) int32
|
|
|
|
//go:noescape
|
|
func open(name *byte, mode, perm int32) int32
|
|
|
|
//go:noescape
|
|
func pread(fd int32, buf unsafe.Pointer, nbytes int32, offset int64) int32
|
|
|
|
//go:noescape
|
|
func pwrite(fd int32, buf unsafe.Pointer, nbytes int32, offset int64) int32
|
|
|
|
func seek(fd int32, offset int64, whence int32) int64
|
|
|
|
//go:noescape
|
|
func exits(msg *byte)
|
|
|
|
//go:noescape
|
|
func brk_(addr unsafe.Pointer) int32
|
|
|
|
func sleep(ms int32) int32
|
|
|
|
func rfork(flags int32) int32
|
|
|
|
//go:noescape
|
|
func plan9_semacquire(addr *uint32, block int32) int32
|
|
|
|
//go:noescape
|
|
func plan9_tsemacquire(addr *uint32, ms int32) int32
|
|
|
|
//go:noescape
|
|
func plan9_semrelease(addr *uint32, count int32) int32
|
|
|
|
//go:noescape
|
|
func notify(fn unsafe.Pointer) int32
|
|
|
|
func noted(mode int32) int32
|
|
|
|
//go:noescape
|
|
func nsec(*int64) int64
|
|
|
|
//go:noescape
|
|
func sigtramp(ureg, note unsafe.Pointer)
|
|
|
|
func setfpmasks()
|
|
|
|
//go:noescape
|
|
func tstart_plan9(newm *m)
|
|
|
|
func errstr() string
|
|
|
|
type _Plink uintptr
|
|
|
|
//go:linkname os_sigpipe os.sigpipe
|
|
func os_sigpipe() {
|
|
throw("too many writes on closed pipe")
|
|
}
|
|
|
|
func sigpanic() {
|
|
g := getg()
|
|
if !canpanic(g) {
|
|
throw("unexpected signal during runtime execution")
|
|
}
|
|
|
|
note := gostringnocopy((*byte)(unsafe.Pointer(g.m.notesig)))
|
|
switch g.sig {
|
|
case _SIGRFAULT, _SIGWFAULT:
|
|
i := index(note, "addr=")
|
|
if i >= 0 {
|
|
i += 5
|
|
} else if i = index(note, "va="); i >= 0 {
|
|
i += 3
|
|
} else {
|
|
panicmem()
|
|
}
|
|
addr := note[i:]
|
|
g.sigcode1 = uintptr(atolwhex(addr))
|
|
if g.sigcode1 < 0x1000 || g.paniconfault {
|
|
panicmem()
|
|
}
|
|
print("unexpected fault address ", hex(g.sigcode1), "\n")
|
|
throw("fault")
|
|
case _SIGTRAP:
|
|
if g.paniconfault {
|
|
panicmem()
|
|
}
|
|
throw(note)
|
|
case _SIGINTDIV:
|
|
panicdivide()
|
|
case _SIGFLOAT:
|
|
panicfloat()
|
|
default:
|
|
panic(errorString(note))
|
|
}
|
|
}
|
|
|
|
func atolwhex(p string) int64 {
|
|
for hasprefix(p, " ") || hasprefix(p, "\t") {
|
|
p = p[1:]
|
|
}
|
|
neg := false
|
|
if hasprefix(p, "-") || hasprefix(p, "+") {
|
|
neg = p[0] == '-'
|
|
p = p[1:]
|
|
for hasprefix(p, " ") || hasprefix(p, "\t") {
|
|
p = p[1:]
|
|
}
|
|
}
|
|
var n int64
|
|
switch {
|
|
case hasprefix(p, "0x"), hasprefix(p, "0X"):
|
|
p = p[2:]
|
|
for ; len(p) > 0; p = p[1:] {
|
|
if '0' <= p[0] && p[0] <= '9' {
|
|
n = n*16 + int64(p[0]-'0')
|
|
} else if 'a' <= p[0] && p[0] <= 'f' {
|
|
n = n*16 + int64(p[0]-'a'+10)
|
|
} else if 'A' <= p[0] && p[0] <= 'F' {
|
|
n = n*16 + int64(p[0]-'A'+10)
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
case hasprefix(p, "0"):
|
|
for ; len(p) > 0 && '0' <= p[0] && p[0] <= '7'; p = p[1:] {
|
|
n = n*8 + int64(p[0]-'0')
|
|
}
|
|
default:
|
|
for ; len(p) > 0 && '0' <= p[0] && p[0] <= '9'; p = p[1:] {
|
|
n = n*10 + int64(p[0]-'0')
|
|
}
|
|
}
|
|
if neg {
|
|
n = -n
|
|
}
|
|
return n
|
|
}
|
|
|
|
type sigset struct{}
|
|
|
|
// Called to initialize a new m (including the bootstrap m).
|
|
// Called on the parent thread (main thread in case of bootstrap), can allocate memory.
|
|
func mpreinit(mp *m) {
|
|
// Initialize stack and goroutine for note handling.
|
|
mp.gsignal = malg(32 * 1024)
|
|
mp.gsignal.m = mp
|
|
mp.notesig = (*int8)(mallocgc(_ERRMAX, nil, true))
|
|
// Initialize stack for handling strings from the
|
|
// errstr system call, as used in package syscall.
|
|
mp.errstr = (*byte)(mallocgc(_ERRMAX, nil, true))
|
|
}
|
|
|
|
func msigsave(mp *m) {
|
|
}
|
|
|
|
func msigrestore(sigmask sigset) {
|
|
}
|
|
|
|
//go:nosplit
|
|
//go:nowritebarrierrec
|
|
func clearSignalHandlers() {
|
|
}
|
|
|
|
func sigblock() {
|
|
}
|
|
|
|
// Called to initialize a new m (including the bootstrap m).
|
|
// Called on the new thread, cannot allocate memory.
|
|
func minit() {
|
|
if atomic.Load(&exiting) != 0 {
|
|
exits(&emptystatus[0])
|
|
}
|
|
// Mask all SSE floating-point exceptions
|
|
// when running on the 64-bit kernel.
|
|
setfpmasks()
|
|
}
|
|
|
|
// Called from dropm to undo the effect of an minit.
|
|
func unminit() {
|
|
}
|
|
|
|
var sysstat = []byte("/dev/sysstat\x00")
|
|
|
|
func getproccount() int32 {
|
|
var buf [2048]byte
|
|
fd := open(&sysstat[0], _OREAD, 0)
|
|
if fd < 0 {
|
|
return 1
|
|
}
|
|
ncpu := int32(0)
|
|
for {
|
|
n := read(fd, unsafe.Pointer(&buf), int32(len(buf)))
|
|
if n <= 0 {
|
|
break
|
|
}
|
|
for i := int32(0); i < n; i++ {
|
|
if buf[i] == '\n' {
|
|
ncpu++
|
|
}
|
|
}
|
|
}
|
|
closefd(fd)
|
|
if ncpu == 0 {
|
|
ncpu = 1
|
|
}
|
|
return ncpu
|
|
}
|
|
|
|
var devswap = []byte("/dev/swap\x00")
|
|
var pagesize = []byte(" pagesize\n")
|
|
|
|
func getPageSize() uintptr {
|
|
var buf [2048]byte
|
|
var pos int
|
|
fd := open(&devswap[0], _OREAD, 0)
|
|
if fd < 0 {
|
|
// There's not much we can do if /dev/swap doesn't
|
|
// exist. However, nothing in the memory manager uses
|
|
// this on Plan 9, so it also doesn't really matter.
|
|
return minPhysPageSize
|
|
}
|
|
for pos < len(buf) {
|
|
n := read(fd, unsafe.Pointer(&buf[pos]), int32(len(buf)-pos))
|
|
if n <= 0 {
|
|
break
|
|
}
|
|
pos += int(n)
|
|
}
|
|
closefd(fd)
|
|
text := buf[:pos]
|
|
// Find "<n> pagesize" line.
|
|
bol := 0
|
|
for i, c := range text {
|
|
if c == '\n' {
|
|
bol = i + 1
|
|
}
|
|
if bytesHasPrefix(text[i:], pagesize) {
|
|
// Parse number at the beginning of this line.
|
|
return uintptr(_atoi(text[bol:]))
|
|
}
|
|
}
|
|
// Again, the page size doesn't really matter, so use a fallback.
|
|
return minPhysPageSize
|
|
}
|
|
|
|
func bytesHasPrefix(s, prefix []byte) bool {
|
|
if len(s) < len(prefix) {
|
|
return false
|
|
}
|
|
for i, p := range prefix {
|
|
if s[i] != p {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
var pid = []byte("#c/pid\x00")
|
|
|
|
func getpid() uint64 {
|
|
var b [20]byte
|
|
fd := open(&pid[0], 0, 0)
|
|
if fd >= 0 {
|
|
read(fd, unsafe.Pointer(&b), int32(len(b)))
|
|
closefd(fd)
|
|
}
|
|
c := b[:]
|
|
for c[0] == ' ' || c[0] == '\t' {
|
|
c = c[1:]
|
|
}
|
|
return uint64(_atoi(c))
|
|
}
|
|
|
|
func osinit() {
|
|
initBloc()
|
|
ncpu = getproccount()
|
|
physPageSize = getPageSize()
|
|
getg().m.procid = getpid()
|
|
notify(unsafe.Pointer(funcPC(sigtramp)))
|
|
}
|
|
|
|
//go:nosplit
|
|
func crash() {
|
|
notify(nil)
|
|
*(*int)(nil) = 0
|
|
}
|
|
|
|
//go:nosplit
|
|
func getRandomData(r []byte) {
|
|
extendRandom(r, 0)
|
|
}
|
|
|
|
func goenvs() {
|
|
}
|
|
|
|
func initsig(preinit bool) {
|
|
}
|
|
|
|
//go:nosplit
|
|
func osyield() {
|
|
sleep(0)
|
|
}
|
|
|
|
//go:nosplit
|
|
func usleep(µs uint32) {
|
|
ms := int32(µs / 1000)
|
|
if ms == 0 {
|
|
ms = 1
|
|
}
|
|
sleep(ms)
|
|
}
|
|
|
|
//go:nosplit
|
|
func nanotime() int64 {
|
|
var scratch int64
|
|
ns := nsec(&scratch)
|
|
// TODO(aram): remove hack after I fix _nsec in the pc64 kernel.
|
|
if ns == 0 {
|
|
return scratch
|
|
}
|
|
return ns
|
|
}
|
|
|
|
//go:nosplit
|
|
func itoa(buf []byte, val uint64) []byte {
|
|
i := len(buf) - 1
|
|
for val >= 10 {
|
|
buf[i] = byte(val%10 + '0')
|
|
i--
|
|
val /= 10
|
|
}
|
|
buf[i] = byte(val + '0')
|
|
return buf[i:]
|
|
}
|
|
|
|
var goexits = []byte("go: exit ")
|
|
var emptystatus = []byte("\x00")
|
|
var exiting uint32
|
|
|
|
func goexitsall(status *byte) {
|
|
var buf [_ERRMAX]byte
|
|
if !atomic.Cas(&exiting, 0, 1) {
|
|
return
|
|
}
|
|
getg().m.locks++
|
|
n := copy(buf[:], goexits)
|
|
n = copy(buf[n:], gostringnocopy(status))
|
|
pid := getpid()
|
|
for mp := (*m)(atomic.Loadp(unsafe.Pointer(&allm))); mp != nil; mp = mp.alllink {
|
|
if mp.procid != 0 && mp.procid != pid {
|
|
postnote(mp.procid, buf[:])
|
|
}
|
|
}
|
|
getg().m.locks--
|
|
}
|
|
|
|
var procdir = []byte("/proc/")
|
|
var notefile = []byte("/note\x00")
|
|
|
|
func postnote(pid uint64, msg []byte) int {
|
|
var buf [128]byte
|
|
var tmp [32]byte
|
|
n := copy(buf[:], procdir)
|
|
n += copy(buf[n:], itoa(tmp[:], pid))
|
|
copy(buf[n:], notefile)
|
|
fd := open(&buf[0], _OWRITE, 0)
|
|
if fd < 0 {
|
|
return -1
|
|
}
|
|
len := findnull(&msg[0])
|
|
if write(uintptr(fd), unsafe.Pointer(&msg[0]), int32(len)) != int64(len) {
|
|
closefd(fd)
|
|
return -1
|
|
}
|
|
closefd(fd)
|
|
return 0
|
|
}
|
|
|
|
//go:nosplit
|
|
func exit(e int32) {
|
|
var status []byte
|
|
if e == 0 {
|
|
status = emptystatus
|
|
} else {
|
|
// build error string
|
|
var tmp [32]byte
|
|
status = append(itoa(tmp[:len(tmp)-1], uint64(e)), 0)
|
|
}
|
|
goexitsall(&status[0])
|
|
exits(&status[0])
|
|
}
|
|
|
|
// May run with m.p==nil, so write barriers are not allowed.
|
|
//go:nowritebarrier
|
|
func newosproc(mp *m) {
|
|
if false {
|
|
print("newosproc mp=", mp, " ostk=", &mp, "\n")
|
|
}
|
|
pid := rfork(_RFPROC | _RFMEM | _RFNOWAIT)
|
|
if pid < 0 {
|
|
throw("newosproc: rfork failed")
|
|
}
|
|
if pid == 0 {
|
|
tstart_plan9(mp)
|
|
}
|
|
}
|
|
|
|
func exitThread(wait *uint32) {
|
|
// We should never reach exitThread on Plan 9 because we let
|
|
// the OS clean up threads.
|
|
throw("exitThread")
|
|
}
|
|
|
|
//go:nosplit
|
|
func semacreate(mp *m) {
|
|
}
|
|
|
|
//go:nosplit
|
|
func semasleep(ns int64) int {
|
|
_g_ := getg()
|
|
if ns >= 0 {
|
|
ms := timediv(ns, 1000000, nil)
|
|
if ms == 0 {
|
|
ms = 1
|
|
}
|
|
ret := plan9_tsemacquire(&_g_.m.waitsemacount, ms)
|
|
if ret == 1 {
|
|
return 0 // success
|
|
}
|
|
return -1 // timeout or interrupted
|
|
}
|
|
for plan9_semacquire(&_g_.m.waitsemacount, 1) < 0 {
|
|
// interrupted; try again (c.f. lock_sema.go)
|
|
}
|
|
return 0 // success
|
|
}
|
|
|
|
//go:nosplit
|
|
func semawakeup(mp *m) {
|
|
plan9_semrelease(&mp.waitsemacount, 1)
|
|
}
|
|
|
|
//go:nosplit
|
|
func read(fd int32, buf unsafe.Pointer, n int32) int32 {
|
|
return pread(fd, buf, n, -1)
|
|
}
|
|
|
|
//go:nosplit
|
|
func write(fd uintptr, buf unsafe.Pointer, n int32) int64 {
|
|
return int64(pwrite(int32(fd), buf, n, -1))
|
|
}
|
|
|
|
var _badsignal = []byte("runtime: signal received on thread not created by Go.\n")
|
|
|
|
// This runs on a foreign stack, without an m or a g. No stack split.
|
|
//go:nosplit
|
|
func badsignal2() {
|
|
pwrite(2, unsafe.Pointer(&_badsignal[0]), int32(len(_badsignal)), -1)
|
|
exits(&_badsignal[0])
|
|
}
|
|
|
|
func raisebadsignal(sig uint32) {
|
|
badsignal2()
|
|
}
|
|
|
|
func _atoi(b []byte) int {
|
|
n := 0
|
|
for len(b) > 0 && '0' <= b[0] && b[0] <= '9' {
|
|
n = n*10 + int(b[0]) - '0'
|
|
b = b[1:]
|
|
}
|
|
return n
|
|
}
|
|
|
|
func signame(sig uint32) string {
|
|
if sig >= uint32(len(sigtable)) {
|
|
return ""
|
|
}
|
|
return sigtable[sig].name
|
|
}
|