github.com/epfl-dcsl/gotee@v0.0.0-20200909122901-014b35f5e5e9/src/runtime/os3_plan9.go (about) 1 // Copyright 2010 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 package runtime 6 7 import ( 8 "runtime/internal/sys" 9 "unsafe" 10 ) 11 12 // May run during STW, so write barriers are not allowed. 13 // 14 //go:nowritebarrierrec 15 func sighandler(_ureg *ureg, note *byte, gp *g) int { 16 _g_ := getg() 17 var t sigTabT 18 var docrash bool 19 var sig int 20 var flags int 21 var level int32 22 23 c := &sigctxt{_ureg} 24 notestr := gostringnocopy(note) 25 26 // The kernel will never pass us a nil note or ureg so we probably 27 // made a mistake somewhere in sigtramp. 28 if _ureg == nil || note == nil { 29 print("sighandler: ureg ", _ureg, " note ", note, "\n") 30 goto Throw 31 } 32 // Check that the note is no more than ERRMAX bytes (including 33 // the trailing NUL). We should never receive a longer note. 34 if len(notestr) > _ERRMAX-1 { 35 print("sighandler: note is longer than ERRMAX\n") 36 goto Throw 37 } 38 // See if the note matches one of the patterns in sigtab. 39 // Notes that do not match any pattern can be handled at a higher 40 // level by the program but will otherwise be ignored. 41 flags = _SigNotify 42 for sig, t = range sigtable { 43 if hasprefix(notestr, t.name) { 44 flags = t.flags 45 break 46 } 47 } 48 if flags&_SigPanic != 0 && gp.throwsplit { 49 // We can't safely sigpanic because it may grow the 50 // stack. Abort in the signal handler instead. 51 flags = (flags &^ _SigPanic) | _SigThrow 52 } 53 if flags&_SigGoExit != 0 { 54 exits((*byte)(add(unsafe.Pointer(note), 9))) // Strip "go: exit " prefix. 55 } 56 if flags&_SigPanic != 0 { 57 // Copy the error string from sigtramp's stack into m->notesig so 58 // we can reliably access it from the panic routines. 59 memmove(unsafe.Pointer(_g_.m.notesig), unsafe.Pointer(note), uintptr(len(notestr)+1)) 60 gp.sig = uint32(sig) 61 gp.sigpc = c.pc() 62 63 pc := c.pc() 64 sp := c.sp() 65 66 // If we don't recognize the PC as code 67 // but we do recognize the top pointer on the stack as code, 68 // then assume this was a call to non-code and treat like 69 // pc == 0, to make unwinding show the context. 70 if pc != 0 && !findfunc(pc).valid() && findfunc(*(*uintptr)(unsafe.Pointer(sp))).valid() { 71 pc = 0 72 } 73 74 // IF LR exists, sigpanictramp must save it to the stack 75 // before entry to sigpanic so that panics in leaf 76 // functions are correctly handled. This will smash 77 // the stack frame but we're not going back there 78 // anyway. 79 if usesLR { 80 c.savelr(c.lr()) 81 } 82 83 // If PC == 0, probably panicked because of a call to a nil func. 84 // Not faking that as the return address will make the trace look like a call 85 // to sigpanic instead. (Otherwise the trace will end at 86 // sigpanic and we won't get to see who faulted). 87 if pc != 0 { 88 if usesLR { 89 c.setlr(pc) 90 } else { 91 if sys.RegSize > sys.PtrSize { 92 sp -= sys.PtrSize 93 *(*uintptr)(unsafe.Pointer(sp)) = 0 94 } 95 sp -= sys.PtrSize 96 *(*uintptr)(unsafe.Pointer(sp)) = pc 97 c.setsp(sp) 98 } 99 } 100 if usesLR { 101 c.setpc(funcPC(sigpanictramp)) 102 } else { 103 c.setpc(funcPC(sigpanic)) 104 } 105 return _NCONT 106 } 107 if flags&_SigNotify != 0 { 108 if ignoredNote(note) { 109 return _NCONT 110 } 111 if sendNote(note) { 112 return _NCONT 113 } 114 } 115 if flags&_SigKill != 0 { 116 goto Exit 117 } 118 if flags&_SigThrow == 0 { 119 return _NCONT 120 } 121 Throw: 122 _g_.m.throwing = 1 123 _g_.m.caughtsig.set(gp) 124 startpanic() 125 print(notestr, "\n") 126 print("PC=", hex(c.pc()), "\n") 127 print("\n") 128 level, _, docrash = gotraceback() 129 if level > 0 { 130 goroutineheader(gp) 131 tracebacktrap(c.pc(), c.sp(), c.lr(), gp) 132 tracebackothers(gp) 133 print("\n") 134 dumpregs(_ureg) 135 } 136 if docrash { 137 crash() 138 } 139 Exit: 140 goexitsall(note) 141 exits(note) 142 return _NDFLT // not reached 143 } 144 145 func sigenable(sig uint32) { 146 } 147 148 func sigdisable(sig uint32) { 149 } 150 151 func sigignore(sig uint32) { 152 } 153 154 func setProcessCPUProfiler(hz int32) { 155 } 156 157 func setThreadCPUProfiler(hz int32) { 158 // TODO: Enable profiling interrupts. 159 getg().m.profilehz = hz 160 } 161 162 // gsignalStack is unused on Plan 9. 163 type gsignalStack struct{}