uint32 runtime·sighandler(ExceptionRecord *info, Context *r, G *gp) { uintptr *sp; switch(info->ExceptionCode) { case EXCEPTION_BREAKPOINT: r->Eip--; // because 8l generates 2 bytes for INT3 return 1; } if(gp != nil && runtime·issigpanic(info->ExceptionCode)) { // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = info->ExceptionCode; gp->sigcode0 = info->ExceptionInformation[0]; gp->sigcode1 = info->ExceptionInformation[1]; gp->sigpc = r->Eip; // Only push runtime·sigpanic if r->eip != 0. // If r->eip == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to runtime·sigpanic instead. // (Otherwise the trace will end at runtime·sigpanic and we // won't get to see who faulted.) if(r->Eip != 0) { sp = (uintptr*)r->Esp; *--sp = r->Eip; r->Esp = (uintptr)sp; } r->Eip = (uintptr)runtime·sigpanic; return 0; } if(runtime·panicking) // traceback already printed runtime·exit(2); runtime·panicking = 1; runtime·printf("Exception %x %p %p\n", info->ExceptionCode, info->ExceptionInformation[0], info->ExceptionInformation[1]); runtime·printf("PC=%x\n", r->Eip); if(m->lockedg != nil && m->ncgo > 0 && gp == m->g0) { runtime·printf("signal arrived during cgo execution\n"); gp = m->lockedg; } runtime·printf("\n"); if(runtime·gotraceback()){ runtime·traceback((void*)r->Eip, (void*)r->Esp, 0, gp); runtime·tracebackothers(gp); runtime·dumpregs(r); } runtime·exit(2); return 0; }
bool runtime·showframe(Func *f) { static int32 traceback = -1; if(traceback < 0) traceback = runtime·gotraceback(); return traceback > 1 || contains(f->name, ".") && !hasprefix(f->name, "runtime."); }
bool runtime·showframe(Func *f, bool current) { static int32 traceback = -1; if(current && m->throwing > 0) return 1; if(traceback < 0) traceback = runtime·gotraceback(); return traceback > 1 || f != nil && contains(f->name, ".") && !hasprefix(f->name, "runtime."); }
void runtime·tracebackothers(G *me) { G *gp; int32 traceback; traceback = runtime·gotraceback(); for(gp = runtime·allg; gp != nil; gp = gp->alllink) { if(gp == me || gp->status == Gdead) continue; if(gp->issystem && traceback < 2) continue; runtime·printf("\n"); runtime·goroutineheader(gp); runtime·traceback(gp->sched.pc, (byte*)gp->sched.sp, 0, gp); } }
void runtime·dopanic(int32 unused) { static bool didothers; bool crash; int32 t; if(g->sig != 0) runtime·printf("[signal %x code=%p addr=%p pc=%p]\n", g->sig, g->sigcode0, g->sigcode1, g->sigpc); if((t = runtime·gotraceback(&crash)) > 0){ if(g != m->g0) { runtime·printf("\n"); runtime·goroutineheader(g); runtime·traceback((uintptr)runtime·getcallerpc(&unused), (uintptr)runtime·getcallersp(&unused), 0, g); } else if(t >= 2 || m->throwing > 0) { runtime·printf("\nruntime stack:\n"); runtime·traceback((uintptr)runtime·getcallerpc(&unused), (uintptr)runtime·getcallersp(&unused), 0, g); } if(!didothers) { didothers = true; runtime·tracebackothers(g); } } runtime·unlock(&paniclk); if(runtime·xadd(&runtime·panicking, -1) != 0) { // Some other m is panicking too. // Let it print what it needs to print. // Wait forever without chewing up cpu. // It will exit when it's done. static Lock deadlock; runtime·lock(&deadlock); runtime·lock(&deadlock); } if(crash) runtime·crash(); runtime·exit(2); }
void sighandler(int32 sig, Siginfo *info, void *context) { Ucontext *uc; Mcontext *mc; Regs *r; if(sigtab[sig].flags & SigQueue) { if(sigsend(sig) || (sigtab[sig].flags & SigIgnore)) return; exit(2); // SIGINT, SIGTERM, etc } if(panicking) // traceback already printed exit(2); panicking = 1; if(sig < 0 || sig >= NSIG){ printf("Signal %d\n", sig); }else{ printf("%s\n", sigtab[sig].name); } uc = context; mc = uc->uc_mcontext; r = &mc->ss; printf("Faulting address: %p\n", info->si_addr); printf("pc: %X\n", r->rip); printf("\n"); if(gotraceback()){ traceback((void*)r->rip, (void*)r->rsp, (void*)r->r15); tracebackothers((void*)r->r15); dumpregs(r); } breakpoint(); exit(2); }
void sighandler(int32 sig, Siginfo* info, void* context) { Ucontext *uc; Mcontext *mc; if(sigtab[sig].flags & SigQueue) { if(sigsend(sig) || (sigtab[sig].flags & SigIgnore)) return; exit(2); // SIGINT, SIGTERM, etc } if(panicking) // traceback already printed exit(2); panicking = 1; uc = context; mc = &uc->uc_mcontext; if(sig < 0 || sig >= NSIG) printf("Signal %d\n", sig); else printf("%s\n", sigtab[sig].name); printf("Faulting address: %p\n", info->si_addr); printf("PC=%X\n", mc->mc_eip); printf("\n"); if(gotraceback()){ traceback((void*)mc->mc_eip, (void*)mc->mc_esp, m->curg); tracebackothers(m->curg); dumpregs(mc); } breakpoint(); exit(2); }
void sighandler(int32 sig, Siginfo *info, void *context) { Ucontext *uc; Mcontext *mc; Regs *r; G *gp; uintptr *sp; byte *pc; uc = context; mc = uc->uc_mcontext; r = &mc->ss; if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) { // Work around Leopard bug that doesn't set FPE_INTDIV. // Look at instruction to see if it is a divide. // Not necessary in Snow Leopard (si_code will be != 0). if(sig == SIGFPE && info->si_code == 0) { pc = (byte*)r->rip; if((pc[0]&0xF0) == 0x40) // 64-bit REX prefix pc++; if(pc[0] == 0xF7) info->si_code = FPE_INTDIV; } // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = sig; gp->sigcode0 = info->si_code; gp->sigcode1 = (uintptr)info->si_addr; // Only push sigpanic if r->rip != 0. // If r->rip == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to sigpanic instead. // (Otherwise the trace will end at sigpanic and we // won't get to see who faulted.) if(r->rip != 0) { sp = (uintptr*)r->rsp; *--sp = r->rip; r->rsp = (uintptr)sp; } r->rip = (uintptr)sigpanic; return; } if(sigtab[sig].flags & SigQueue) { if(sigsend(sig) || (sigtab[sig].flags & SigIgnore)) return; exit(2); // SIGINT, SIGTERM, etc } if(panicking) // traceback already printed exit(2); panicking = 1; if(sig < 0 || sig >= NSIG){ printf("Signal %d\n", sig); }else{ printf("%s\n", sigtab[sig].name); } printf("pc: %X\n", r->rip); printf("\n"); if(gotraceback()){ traceback((void*)r->rip, (void*)r->rsp, 0, (void*)r->r15); tracebackothers((void*)r->r15); dumpregs(r); } breakpoint(); exit(2); }
void runtime·sighandler(int32 sig, Siginfo *info, void *context, G *gp) { Ucontext *uc; Sigcontext *r; SigTab *t; uc = context; r = &uc->uc_mcontext; if(sig == SIGPROF) { runtime·sigprof((uint8*)r->arm_pc, (uint8*)r->arm_sp, (uint8*)r->arm_lr, gp); return; } t = &runtime·sigtab[sig]; if(info->si_code != SI_USER && (t->flags & SigPanic)) { if(gp == nil) goto Throw; // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = sig; gp->sigcode0 = info->si_code; gp->sigcode1 = r->fault_address; gp->sigpc = r->arm_pc; // If this is a leaf function, we do smash LR, // but we're not going back there anyway. // Don't bother smashing if r->arm_pc is 0, // which is probably a call to a nil func: the // old link register is more useful in the stack trace. if(r->arm_pc != 0) r->arm_lr = r->arm_pc; // In case we are panicking from external C code r->arm_r10 = (uintptr)gp; r->arm_r9 = (uintptr)m; r->arm_pc = (uintptr)runtime·sigpanic; return; } if(info->si_code == SI_USER || (t->flags & SigNotify)) if(runtime·sigsend(sig)) return; if(t->flags & SigKill) runtime·exit(2); if(!(t->flags & SigThrow)) return; Throw: if(runtime·panicking) // traceback already printed runtime·exit(2); runtime·panicking = 1; if(sig < 0 || sig >= NSIG) runtime·printf("Signal %d\n", sig); else runtime·printf("%s\n", runtime·sigtab[sig].name); runtime·printf("PC=%x\n", r->arm_pc); runtime·printf("\n"); if(runtime·gotraceback()){ runtime·traceback((void*)r->arm_pc, (void*)r->arm_sp, (void*)r->arm_lr, gp); runtime·tracebackothers(gp); runtime·printf("\n"); runtime·dumpregs(r); } // breakpoint(); runtime·exit(2); }
int32 runtime·sighandler(void *v, int8 *note, G *gp) { uintptr *sp; SigTab *t; bool crash; Ureg *ureg; intgo len, n; int32 sig, flags; ureg = (Ureg*)v; // The kernel will never pass us a nil note or ureg so we probably // made a mistake somewhere in runtime·sigtramp. if(ureg == nil || note == nil) { runtime·printf("sighandler: ureg %p note %p\n", ureg, note); goto Throw; } // Check that the note is no more than ERRMAX bytes (including // the trailing NUL). We should never receive a longer note. len = runtime·findnull((byte*)note); if(len > ERRMAX-1) { runtime·printf("sighandler: note is longer than ERRMAX\n"); goto Throw; } // See if the note matches one of the patterns in runtime·sigtab. // Notes that do not match any pattern can be handled at a higher // level by the program but will otherwise be ignored. flags = SigNotify; for(sig = 0; sig < nelem(runtime·sigtab); sig++) { t = &runtime·sigtab[sig]; n = runtime·findnull((byte*)t->name); if(len < n) continue; if(runtime·strncmp((byte*)note, (byte*)t->name, n) == 0) { flags = t->flags; break; } } if(flags & SigGoExit) runtime·exits(note+9); // Strip "go: exit " prefix. if(flags & SigPanic) { // Copy the error string from sigtramp's stack into m->notesig so // we can reliably access it from the panic routines. runtime·memmove(g->m->notesig, note, len+1); gp->sig = sig; gp->sigpc = ureg->ip; // Only push runtime·sigpanic if PC != 0. // // If PC == 0, probably panicked because of a call to a nil func. // Not pushing that onto SP will make the trace look like a call // to runtime·sigpanic instead. (Otherwise the trace will end at // runtime·sigpanic and we won't get to see who faulted). if(ureg->ip != 0) { sp = (uintptr*)ureg->sp; *--sp = ureg->ip; ureg->sp = (uint64)sp; } ureg->ip = (uintptr)runtime·sigpanic; return NCONT; } if(flags & SigNotify) { // TODO(ality): See if os/signal wants it. //if(runtime·sigsend(...)) // return NCONT; } if(flags & SigKill) goto Exit; if(!(flags & SigThrow)) return NCONT; Throw: g->m->throwing = 1; g->m->caughtsig = gp; runtime·startpanic(); runtime·printf("%s\n", note); runtime·printf("PC=%X\n", ureg->ip); runtime·printf("\n"); if(runtime·gotraceback(&crash)) { runtime·goroutineheader(gp); runtime·traceback(ureg->ip, ureg->sp, 0, gp); runtime·tracebackothers(gp); runtime·printf("\n"); runtime·dumpregs(ureg); } if(crash) runtime·crash(); Exit: runtime·goexitsall(note); runtime·exits(note); return NDFLT; // not reached }
void runtime·sighandler(int32 sig, Siginfo *info, void *context, G *gp) { Ucontext *uc; Sigcontext *r; uintptr *sp; SigTab *t; uc = context; r = &uc->uc_mcontext; if(sig == SIGPROF) { runtime·sigprof((uint8*)r->eip, (uint8*)r->esp, nil, gp); return; } t = &runtime·sigtab[sig]; if(info->si_code != SI_USER && (t->flags & SigPanic)) { if(gp == nil) goto Throw; // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = sig; gp->sigcode0 = info->si_code; gp->sigcode1 = ((uintptr*)info)[3]; gp->sigpc = r->eip; // Only push runtime·sigpanic if r->eip != 0. // If r->eip == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to runtime·sigpanic instead. // (Otherwise the trace will end at runtime·sigpanic and we // won't get to see who faulted.) if(r->eip != 0) { sp = (uintptr*)r->esp; *--sp = r->eip; r->esp = (uintptr)sp; } r->eip = (uintptr)runtime·sigpanic; return; } if(info->si_code == SI_USER || (t->flags & SigNotify)) if(runtime·sigsend(sig)) return; if(t->flags & SigKill) runtime·exit(2); if(!(t->flags & SigThrow)) return; Throw: runtime·startpanic(); if(sig < 0 || sig >= NSIG) runtime·printf("Signal %d\n", sig); else runtime·printf("%s\n", runtime·sigtab[sig].name); runtime·printf("PC=%X\n", r->eip); runtime·printf("\n"); if(runtime·gotraceback()){ runtime·traceback((void*)r->eip, (void*)r->esp, 0, gp); runtime·tracebackothers(gp); runtime·dumpregs(r); } runtime·exit(2); }
int32 runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip, uintptr *pcbuf, int32 max, bool (*callback)(Stkframe*, void*), void *v, bool printall) { int32 i, n, nprint, line, gotraceback; uintptr x, tracepc, sparg; bool waspanic, wasnewproc, printing; Func *f, *flr; Stkframe frame; Stktop *stk; String file; Panic *panic; Defer *defer; gotraceback = runtime·gotraceback(nil); if(pc0 == ~(uintptr)0 && sp0 == ~(uintptr)0) { // Signal to fetch saved values from gp. if(gp->syscallstack != (uintptr)nil) { pc0 = gp->syscallpc; sp0 = gp->syscallsp; lr0 = 0; } else { pc0 = gp->sched.pc; sp0 = gp->sched.sp; lr0 = gp->sched.lr; } } nprint = 0; runtime·memclr((byte*)&frame, sizeof frame); frame.pc = pc0; frame.lr = lr0; frame.sp = sp0; waspanic = false; wasnewproc = false; printing = pcbuf==nil && callback==nil; panic = gp->panic; defer = gp->defer; while(defer != nil && defer->argp == NoArgs) defer = defer->link; while(panic != nil && panic->defer == nil) panic = panic->link; // If the PC is zero, it's likely a nil function call. // Start in the caller's frame. if(frame.pc == 0) { frame.pc = frame.lr; frame.lr = 0; } f = runtime·findfunc(frame.pc); if(f == nil) { if(callback != nil) { runtime·printf("runtime: unknown pc %p\n", frame.pc); runtime·throw("unknown pc"); } return 0; } frame.fn = f; n = 0; stk = (Stktop*)gp->stackbase; while(n < max) { // Typically: // pc is the PC of the running function. // sp is the stack pointer at that program counter. // fp is the frame pointer (caller's stack pointer) at that program counter, or nil if unknown. // stk is the stack containing sp. // The caller's program counter is lr, unless lr is zero, in which case it is *(uintptr*)sp. if(frame.pc == (uintptr)runtime·lessstack) { // Hit top of stack segment. Unwind to next segment. frame.pc = stk->gobuf.pc; frame.sp = stk->gobuf.sp; frame.lr = 0; frame.fp = 0; if(printing && runtime·showframe(nil, gp)) runtime·printf("----- stack segment boundary -----\n"); stk = (Stktop*)stk->stackbase; f = runtime·findfunc(frame.pc); if(f == nil) { runtime·printf("runtime: unknown pc %p after stack split\n", frame.pc); if(callback != nil) runtime·throw("unknown pc"); } frame.fn = f; continue; } f = frame.fn; // Found an actual function. // Derive frame pointer and link register. if(frame.fp == 0) frame.fp = frame.sp + runtime·funcspdelta(f, frame.pc); if(runtime·topofstack(f)) { frame.lr = 0; flr = nil; } else if(f->entry == (uintptr)runtime·jmpdefer) { // jmpdefer modifies SP/LR/PC non-atomically. // If a profiling interrupt arrives during jmpdefer, // the stack unwind may see a mismatched register set // and get confused. Stop if we see PC within jmpdefer // to avoid that confusion. // See golang.org/issue/8153. // This check can be deleted if jmpdefer is changed // to restore all three atomically using pop. if(callback != nil) runtime·throw("traceback_arm: found jmpdefer when tracing with callback"); frame.lr = 0; flr = nil; } else { if((n == 0 && frame.sp < frame.fp) || frame.lr == 0) frame.lr = *(uintptr*)frame.sp; flr = runtime·findfunc(frame.lr); if(flr == nil) { runtime·printf("runtime: unexpected return pc for %s called from %p\n", runtime·funcname(f), frame.lr); if(callback != nil) runtime·throw("unknown caller pc"); } } frame.varp = (byte*)frame.fp; // Derive size of arguments. // Most functions have a fixed-size argument block, // so we can use metadata about the function f. // Not all, though: there are some variadic functions // in package runtime and reflect, and for those we use call-specific // metadata recorded by f's caller. if(callback != nil || printing) { frame.argp = (byte*)frame.fp + sizeof(uintptr); if(f->args != ArgsSizeUnknown) frame.arglen = f->args; else if(flr == nil) frame.arglen = 0; else if(frame.lr == (uintptr)runtime·lessstack) frame.arglen = stk->argsize; else if((i = runtime·funcarglen(flr, frame.lr)) >= 0) frame.arglen = i; else { runtime·printf("runtime: unknown argument frame size for %s called from %p [%s]\n", runtime·funcname(f), frame.lr, flr ? runtime·funcname(flr) : "?"); if(callback != nil) runtime·throw("invalid stack"); frame.arglen = 0; } } // Determine function SP where deferproc would find its arguments. // On ARM that's just the standard bottom-of-stack plus 1 word for // the saved LR. If the previous frame was a direct call to newproc/deferproc, // however, the SP is three words lower than normal. // If the function has no frame at all - perhaps it just started, or perhaps // it is a leaf with no local variables - then we cannot possibly find its // SP in a defer, and we might confuse its SP for its caller's SP, so // set sparg=0 in that case. sparg = 0; if(frame.fp != frame.sp) { sparg = frame.sp + sizeof(uintreg); if(wasnewproc) sparg += 3*sizeof(uintreg); } // Determine frame's 'continuation PC', where it can continue. // Normally this is the return address on the stack, but if sigpanic // is immediately below this function on the stack, then the frame // stopped executing due to a trap, and frame.pc is probably not // a safe point for looking up liveness information. In this panicking case, // the function either doesn't return at all (if it has no defers or if the // defers do not recover) or it returns from one of the calls to // deferproc a second time (if the corresponding deferred func recovers). // It suffices to assume that the most recent deferproc is the one that // returns; everything live at earlier deferprocs is still live at that one. frame.continpc = frame.pc; if(waspanic) { if(panic != nil && panic->defer->argp == (byte*)sparg) frame.continpc = (uintptr)panic->defer->pc; else if(defer != nil && defer->argp == (byte*)sparg) frame.continpc = (uintptr)defer->pc; else frame.continpc = 0; } // Unwind our local panic & defer stacks past this frame. while(panic != nil && (panic->defer == nil || panic->defer->argp == (byte*)sparg || panic->defer->argp == NoArgs)) panic = panic->link; while(defer != nil && (defer->argp == (byte*)sparg || defer->argp == NoArgs)) defer = defer->link; if(skip > 0) { skip--; goto skipped; } if(pcbuf != nil) pcbuf[n] = frame.pc; if(callback != nil) { if(!callback(&frame, v)) return n; } if(printing) { if(printall || runtime·showframe(f, gp)) { // Print during crash. // main(0x1, 0x2, 0x3) // /home/rsc/go/src/runtime/x.go:23 +0xf tracepc = frame.pc; // back up to CALL instruction for funcline. if(n > 0 && frame.pc > f->entry && !waspanic) tracepc -= sizeof(uintptr); runtime·printf("%s(", runtime·funcname(f)); for(i = 0; i < frame.arglen/sizeof(uintptr); i++) { if(i >= 10) { runtime·prints(", ..."); break; } if(i != 0) runtime·prints(", "); runtime·printhex(((uintptr*)frame.argp)[i]); } runtime·prints(")\n"); line = runtime·funcline(f, tracepc, &file); runtime·printf("\t%S:%d", file, line); if(frame.pc > f->entry) runtime·printf(" +%p", (uintptr)(frame.pc - f->entry)); if(m->throwing > 0 && gp == m->curg || gotraceback >= 2) runtime·printf(" fp=%p sp=%p", frame.fp, frame.sp); runtime·printf("\n"); nprint++; } } n++; skipped: waspanic = f->entry == (uintptr)runtime·sigpanic; wasnewproc = f->entry == (uintptr)runtime·newproc || f->entry == (uintptr)runtime·deferproc; // Do not unwind past the bottom of the stack. if(flr == nil) break; // Unwind to next frame. frame.pc = frame.lr; frame.fn = flr; frame.lr = 0; frame.sp = frame.fp; frame.fp = 0; // sighandler saves the lr on stack before faking a call to sigpanic if(waspanic) { x = *(uintptr*)frame.sp; frame.sp += 4; frame.fn = f = runtime·findfunc(frame.pc); if(f == nil) frame.pc = x; else if(f->frame == 0) frame.lr = x; } } if(pcbuf == nil && callback == nil) n = nprint; // For rationale, see long comment in traceback_x86.c. if(callback != nil && n < max && defer != nil) { if(defer != nil) runtime·printf("runtime: g%D: leftover defer argp=%p pc=%p\n", gp->goid, defer->argp, defer->pc); if(panic != nil) runtime·printf("runtime: g%D: leftover panic argp=%p pc=%p\n", gp->goid, panic->defer->argp, panic->defer->pc); for(defer = gp->defer; defer != nil; defer = defer->link) runtime·printf("\tdefer %p argp=%p pc=%p\n", defer, defer->argp, defer->pc); for(panic = gp->panic; panic != nil; panic = panic->link) { runtime·printf("\tpanic %p defer %p", panic, panic->defer); if(panic->defer != nil) runtime·printf(" argp=%p pc=%p", panic->defer->argp, panic->defer->pc); runtime·printf("\n"); } runtime·throw("traceback has leftover defers or panics"); } return n; }
void runtime·sighandler(int32 sig, Siginfo *info, void *context, G *gp) { Ucontext *uc; Mcontext32 *mc; Regs32 *r; uintptr *sp; byte *pc; SigTab *t; uc = context; mc = uc->uc_mcontext; r = &mc->ss; if(sig == SIGPROF) { if(gp != m->g0 && gp != m->gsignal) runtime·sigprof((uint8*)r->eip, (uint8*)r->esp, nil, gp); return; } t = &runtime·sigtab[sig]; if(info->si_code != SI_USER && (t->flags & SigPanic)) { if(gp == nil || gp == m->g0) goto Throw; // Work around Leopard bug that doesn't set FPE_INTDIV. // Look at instruction to see if it is a divide. // Not necessary in Snow Leopard (si_code will be != 0). if(sig == SIGFPE && info->si_code == 0) { pc = (byte*)r->eip; if(pc[0] == 0x66) // 16-bit instruction prefix pc++; if(pc[0] == 0xF6 || pc[0] == 0xF7) info->si_code = FPE_INTDIV; } // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = sig; gp->sigcode0 = info->si_code; gp->sigcode1 = (uintptr)info->si_addr; gp->sigpc = r->eip; // Only push runtime·sigpanic if r->eip != 0. // If r->eip == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to runtime·sigpanic instead. // (Otherwise the trace will end at runtime·sigpanic and we // won't get to see who faulted.) if(r->eip != 0) { sp = (uintptr*)r->esp; *--sp = r->eip; r->esp = (uintptr)sp; } r->eip = (uintptr)runtime·sigpanic; return; } if(info->si_code == SI_USER || (t->flags & SigNotify)) if(runtime·sigsend(sig)) return; if(t->flags & SigKill) runtime·exit(2); if(!(t->flags & SigThrow)) return; Throw: runtime·startpanic(); if(sig < 0 || sig >= NSIG){ runtime·printf("Signal %d\n", sig); }else{ runtime·printf("%s\n", runtime·sigtab[sig].name); } runtime·printf("PC=%x\n", r->eip); if(m->lockedg != nil && m->ncgo > 0 && gp == m->g0) { runtime·printf("signal arrived during cgo execution\n"); gp = m->lockedg; } runtime·printf("\n"); if(runtime·gotraceback()){ runtime·traceback((void*)r->eip, (void*)r->esp, 0, gp); runtime·tracebackothers(gp); runtime·dumpregs(r); } runtime·exit(2); }
void runtime·sighandler(int32 sig, Siginfo *info, void *context, G *gp) { Ucontext *uc; Sigcontext *r; SigTab *t; uc = context; r = &uc->uc_mcontext; if(sig == SIGPROF) { runtime·sigprof((uint8*)r->arm_pc, (uint8*)r->arm_sp, (uint8*)r->arm_lr, gp); return; } t = &runtime·sigtab[sig]; if(info->si_code != SI_USER && (t->flags & SigPanic)) { if(gp == nil || gp == m->g0) goto Throw; // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = sig; gp->sigcode0 = info->si_code; gp->sigcode1 = r->fault_address; gp->sigpc = r->arm_pc; // We arrange lr, and pc to pretend the panicking // function calls sigpanic directly. // Always save LR to stack so that panics in leaf // functions are correctly handled. This smashes // the stack frame but we're not going back there // anyway. r->arm_sp -= 4; *(uint32 *)r->arm_sp = r->arm_lr; // Don't bother saving PC if it's zero, which is // probably a call to a nil func: the old link register // is more useful in the stack trace. if(r->arm_pc != 0) r->arm_lr = r->arm_pc; // In case we are panicking from external C code r->arm_r10 = (uintptr)gp; r->arm_r9 = (uintptr)m; r->arm_pc = (uintptr)runtime·sigpanic; return; } if(info->si_code == SI_USER || (t->flags & SigNotify)) if(runtime·sigsend(sig)) return; if(t->flags & SigKill) runtime·exit(2); if(!(t->flags & SigThrow)) return; Throw: if(runtime·panicking) // traceback already printed runtime·exit(2); runtime·panicking = 1; if(sig < 0 || sig >= NSIG) runtime·printf("Signal %d\n", sig); else runtime·printf("%s\n", runtime·sigtab[sig].name); runtime·printf("PC=%x\n", r->arm_pc); if(m->lockedg != nil && m->ncgo > 0 && gp == m->g0) { runtime·printf("signal arrived during cgo execution\n"); gp = m->lockedg; } runtime·printf("\n"); if(runtime·gotraceback()) { runtime·traceback((void*)r->arm_pc, (void*)r->arm_sp, (void*)r->arm_lr, gp); runtime·tracebackothers(gp); runtime·printf("\n"); runtime·dumpregs(r); } // breakpoint(); runtime·exit(2); }
void runtime·sighandler(int32 sig, Siginfo *info, void *ctxt, G *gp) { uintptr *sp; SigTab *t; bool crash; if(sig == SIGPROF) { if(gp != m->g0 && gp != m->gsignal) runtime·sigprof((byte*)SIG_RIP(info, ctxt), (byte*)SIG_RSP(info, ctxt), nil, gp); return; } t = &runtime·sigtab[sig]; if(SIG_CODE0(info, ctxt) != SI_USER && (t->flags & SigPanic)) { if(gp == nil || gp == m->g0) goto Throw; // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = sig; gp->sigcode0 = SIG_CODE0(info, ctxt); gp->sigcode1 = SIG_CODE1(info, ctxt); gp->sigpc = SIG_RIP(info, ctxt); #ifdef GOOS_darwin // Work around Leopard bug that doesn't set FPE_INTDIV. // Look at instruction to see if it is a divide. // Not necessary in Snow Leopard (si_code will be != 0). if(sig == SIGFPE && gp->sigcode0 == 0) { byte *pc; pc = (byte*)gp->sigpc; if((pc[0]&0xF0) == 0x40) // 64-bit REX prefix pc++; else if(pc[0] == 0x66) // 16-bit instruction prefix pc++; if(pc[0] == 0xF6 || pc[0] == 0xF7) gp->sigcode0 = FPE_INTDIV; } #endif // Only push runtime·sigpanic if rip != 0. // If rip == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to runtime·sigpanic instead. // (Otherwise the trace will end at runtime·sigpanic and we // won't get to see who faulted.) if(SIG_RIP(info, ctxt) != 0) { sp = (uintptr*)SIG_RSP(info, ctxt); *--sp = SIG_RIP(info, ctxt); SIG_RSP(info, ctxt) = (uintptr)sp; } SIG_RIP(info, ctxt) = (uintptr)runtime·sigpanic; return; } if(SIG_CODE0(info, ctxt) == SI_USER || (t->flags & SigNotify)) if(runtime·sigsend(sig)) return; if(t->flags & SigKill) runtime·exit(2); if(!(t->flags & SigThrow)) return; Throw: m->throwing = 1; m->caughtsig = gp; runtime·startpanic(); if(sig < 0 || sig >= NSIG) runtime·printf("Signal %d\n", sig); else runtime·printf("%s\n", runtime·sigtab[sig].name); runtime·printf("PC=%X\n", SIG_RIP(info, ctxt)); if(m->lockedg != nil && m->ncgo > 0 && gp == m->g0) { runtime·printf("signal arrived during cgo execution\n"); gp = m->lockedg; } runtime·printf("\n"); if(runtime·gotraceback(&crash)){ runtime·traceback(SIG_RIP(info, ctxt), SIG_RSP(info, ctxt), 0, gp); runtime·tracebackothers(gp); runtime·printf("\n"); runtime·dumpregs(info, ctxt); } if(crash) runtime·crash(); runtime·exit(2); }
void runtime·sighandler(int32 sig, Siginfo *info, void *context, G *gp) { UcontextT *uc = context; McontextT *mc = &uc->uc_mcontext; uintptr *sp; SigTab *t; if(sig == SIGPROF) { runtime·sigprof((uint8*)mc->__gregs[REG_EIP], (uint8*)mc->__gregs[REG_UESP], nil, gp); return; } t = &runtime·sigtab[sig]; if(info->_code != SI_USER && (t->flags & SigPanic)) { if(gp == nil || gp == m->g0) goto Throw; // Make it look like a call to the signal func. // We need to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = sig; gp->sigcode0 = info->_code; gp->sigcode1 = *(uintptr*)&info->_reason[0]; /* _addr */ gp->sigpc = mc->__gregs[REG_EIP]; // Only push runtime·sigpanic if __gregs[REG_EIP] != 0. // If __gregs[REG_EIP] == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will make the // trace look like a call to runtime·sigpanic instead. // (Otherwise the trace will end at runtime·sigpanic // and we won't get to see who faulted.) if(mc->__gregs[REG_EIP] != 0) { sp = (uintptr*)mc->__gregs[REG_UESP]; *--sp = mc->__gregs[REG_EIP]; mc->__gregs[REG_UESP] = (uintptr)sp; } mc->__gregs[REG_EIP] = (uintptr)runtime·sigpanic; return; } if(info->_code == SI_USER || (t->flags & SigNotify)) if(runtime·sigsend(sig)) return; if(t->flags & SigKill) runtime·exit(2); if(!(t->flags & SigThrow)) return; Throw: runtime·startpanic(); if(sig < 0 || sig >= NSIG) runtime·printf("Signal %d\n", sig); else runtime·printf("%s\n", runtime·sigtab[sig].name); runtime·printf("PC=%X\n", mc->__gregs[REG_EIP]); if(m->lockedg != nil && m->ncgo > 0 && gp == m->g0) { runtime·printf("signal arrived during cgo execution\n"); gp = m->lockedg; } runtime·printf("\n"); if(runtime·gotraceback()){ runtime·traceback((void*)mc->__gregs[REG_EIP], (void*)mc->__gregs[REG_UESP], 0, gp); runtime·tracebackothers(gp); runtime·dumpregs(mc); } runtime·exit(2); }
int32 runtime·sighandler(void *v, int8 *s, G *gp) { Ureg *ureg; uintptr *sp; SigTab *sig, *nsig; int32 len, i; if(!s) return NCONT; len = runtime·findnull((byte*)s); if(len <= 4 || runtime·mcmp((byte*)s, (byte*)"sys:", 4) != 0) return NDFLT; nsig = nil; sig = runtime·sigtab; for(i=0; i < NSIG; i++) { if(runtime·strstr((byte*)s, (byte*)sig->name)) { nsig = sig; break; } sig++; } if(nsig == nil) return NDFLT; ureg = v; if(nsig->flags & SigPanic) { if(gp == nil || m->notesig == 0) goto Throw; // Save error string from sigtramp's stack, // into gsignal->sigcode0, so we can reliably // access it from the panic routines. if(len > ERRMAX) len = ERRMAX; runtime·memmove((void*)m->notesig, (void*)s, len); gp->sig = i; gp->sigpc = ureg->pc; // Only push runtime·sigpanic if ureg->pc != 0. // If ureg->pc == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to runtime·sigpanic instead. // (Otherwise the trace will end at runtime·sigpanic and we // won't get to see who faulted.) if(ureg->pc != 0) { sp = (uintptr*)ureg->sp; *--sp = ureg->pc; ureg->sp = (uint32)sp; } ureg->pc = (uintptr)runtime·sigpanic; return NCONT; } if(!(nsig->flags & SigThrow)) return NDFLT; Throw: runtime·startpanic(); runtime·printf("%s\n", s); runtime·printf("PC=%X\n", ureg->pc); runtime·printf("\n"); if(runtime·gotraceback()) { runtime·traceback((void*)ureg->pc, (void*)ureg->sp, 0, gp); runtime·tracebackothers(gp); runtime·dumpregs(ureg); } runtime·goexitsall(""); runtime·exits(s); return 0; }
// Generic traceback. Handles runtime stack prints (pcbuf == nil), // the runtime.Callers function (pcbuf != nil), as well as the garbage // collector (callback != nil). A little clunky to merge these, but avoids // duplicating the code and all its subtlety. int32 runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip, uintptr *pcbuf, int32 max, bool (*callback)(Stkframe*, void*), void *v, bool printall) { int32 i, n, nprint, line, gotraceback; uintptr tracepc, sparg; bool waspanic, wasnewproc, printing; Func *f, *flr; Stkframe frame; Stktop *stk; String file; Panic *panic; Defer *defer; USED(lr0); gotraceback = runtime·gotraceback(nil); if(pc0 == ~(uintptr)0 && sp0 == ~(uintptr)0) { // Signal to fetch saved values from gp. if(gp->syscallstack != (uintptr)nil) { pc0 = gp->syscallpc; sp0 = gp->syscallsp; } else { pc0 = gp->sched.pc; sp0 = gp->sched.sp; } } nprint = 0; runtime·memclr((byte*)&frame, sizeof frame); frame.pc = pc0; frame.sp = sp0; waspanic = false; wasnewproc = false; printing = pcbuf==nil && callback==nil; panic = gp->panic; defer = gp->defer; while(defer != nil && defer->argp == NoArgs) defer = defer->link; while(panic != nil && panic->defer == nil) panic = panic->link; // If the PC is zero, it's likely a nil function call. // Start in the caller's frame. if(frame.pc == 0) { frame.pc = *(uintptr*)frame.sp; frame.sp += sizeof(uintreg); } f = runtime·findfunc(frame.pc); if(f == nil) { if(callback != nil) { runtime·printf("runtime: unknown pc %p\n", frame.pc); runtime·throw("unknown pc"); } return 0; } frame.fn = f; n = 0; stk = (Stktop*)gp->stackbase; while(n < max) { // Typically: // pc is the PC of the running function. // sp is the stack pointer at that program counter. // fp is the frame pointer (caller's stack pointer) at that program counter, or nil if unknown. // stk is the stack containing sp. // The caller's program counter is lr, unless lr is zero, in which case it is *(uintptr*)sp. if(frame.pc == (uintptr)runtime·lessstack) { // Hit top of stack segment. Unwind to next segment. frame.pc = stk->gobuf.pc; frame.sp = stk->gobuf.sp; frame.lr = 0; frame.fp = 0; frame.fn = nil; if(printing && runtime·showframe(nil, gp)) runtime·printf("----- stack segment boundary -----\n"); stk = (Stktop*)stk->stackbase; f = runtime·findfunc(frame.pc); if(f == nil) { runtime·printf("runtime: unknown pc %p after stack split\n", frame.pc); if(callback != nil) runtime·throw("unknown pc"); } frame.fn = f; continue; } f = frame.fn; #ifdef GOOS_windows // Windows exception handlers run on the actual g stack (there is room // dedicated to this below the usual "bottom of stack"), not on a separate // stack. As a result, we have to be able to unwind past the exception // handler when called to unwind during stack growth inside the handler. // Recognize the frame at the call to sighandler in sigtramp and unwind // using the context argument passed to the call. This is awful. if(f != nil && f->entry == (uintptr)runtime·sigtramp && frame.pc > f->entry) { Context *r; // Invoke callback so that stack copier sees an uncopyable frame. if(callback != nil) { frame.continpc = frame.pc; frame.argp = nil; frame.arglen = 0; if(!callback(&frame, v)) return n; } r = (Context*)((uintptr*)frame.sp)[1]; #ifdef GOARCH_amd64 frame.pc = r->Rip; frame.sp = r->Rsp; #else frame.pc = r->Eip; frame.sp = r->Esp; #endif frame.lr = 0; frame.fp = 0; frame.fn = nil; if(printing && runtime·showframe(nil, gp)) runtime·printf("----- exception handler -----\n"); f = runtime·findfunc(frame.pc); if(f == nil) { runtime·printf("runtime: unknown pc %p after exception handler\n", frame.pc); if(callback != nil) runtime·throw("unknown pc"); } frame.fn = f; continue; } #endif // Found an actual function. // Derive frame pointer and link register. if(frame.fp == 0) { frame.fp = frame.sp + runtime·funcspdelta(f, frame.pc); frame.fp += sizeof(uintreg); // caller PC } if(runtime·topofstack(f)) { frame.lr = 0; flr = nil; } else { if(frame.lr == 0) frame.lr = ((uintreg*)frame.fp)[-1]; flr = runtime·findfunc(frame.lr); if(flr == nil) { runtime·printf("runtime: unexpected return pc for %s called from %p\n", runtime·funcname(f), frame.lr); if(callback != nil) runtime·throw("unknown caller pc"); } } frame.varp = (byte*)frame.fp - sizeof(uintreg); // Derive size of arguments. // Most functions have a fixed-size argument block, // so we can use metadata about the function f. // Not all, though: there are some variadic functions // in package runtime and reflect, and for those we use call-specific // metadata recorded by f's caller. if(callback != nil || printing) { frame.argp = (byte*)frame.fp; if(f->args != ArgsSizeUnknown) frame.arglen = f->args; else if(flr == nil) frame.arglen = 0; else if(frame.lr == (uintptr)runtime·lessstack) frame.arglen = stk->argsize; else if((i = runtime·funcarglen(flr, frame.lr)) >= 0) frame.arglen = i; else { runtime·printf("runtime: unknown argument frame size for %s called from %p [%s]\n", runtime·funcname(f), frame.lr, flr ? runtime·funcname(flr) : "?"); if(callback != nil) runtime·throw("invalid stack"); frame.arglen = 0; } } // Determine function SP where deferproc would find its arguments. // On x86 that's just the standard bottom-of-stack, so SP exactly. // If the previous frame was a direct call to newproc/deferproc, however, // the SP is two words lower than normal. sparg = frame.sp; if(wasnewproc) sparg += 2*sizeof(uintptr); // Determine frame's 'continuation PC', where it can continue. // Normally this is the return address on the stack, but if sigpanic // is immediately below this function on the stack, then the frame // stopped executing due to a trap, and frame.pc is probably not // a safe point for looking up liveness information. In this panicking case, // the function either doesn't return at all (if it has no defers or if the // defers do not recover) or it returns from one of the calls to // deferproc a second time (if the corresponding deferred func recovers). // It suffices to assume that the most recent deferproc is the one that // returns; everything live at earlier deferprocs is still live at that one. frame.continpc = frame.pc; if(waspanic) { if(panic != nil && panic->defer->argp == (byte*)sparg) frame.continpc = (uintptr)panic->defer->pc; else if(defer != nil && defer->argp == (byte*)sparg) frame.continpc = (uintptr)defer->pc; else frame.continpc = 0; } // Unwind our local panic & defer stacks past this frame. while(panic != nil && (panic->defer == nil || panic->defer->argp == (byte*)sparg || panic->defer->argp == NoArgs)) panic = panic->link; while(defer != nil && (defer->argp == (byte*)sparg || defer->argp == NoArgs)) defer = defer->link; if(skip > 0) { skip--; goto skipped; } if(pcbuf != nil) pcbuf[n] = frame.pc; if(callback != nil) { if(!callback(&frame, v)) return n; } if(printing) { if(printall || runtime·showframe(f, gp)) { // Print during crash. // main(0x1, 0x2, 0x3) // /home/rsc/go/src/runtime/x.go:23 +0xf // tracepc = frame.pc; // back up to CALL instruction for funcline. if(n > 0 && frame.pc > f->entry && !waspanic) tracepc--; runtime·printf("%s(", runtime·funcname(f)); for(i = 0; i < frame.arglen/sizeof(uintptr); i++) { if(i >= 10) { runtime·prints(", ..."); break; } if(i != 0) runtime·prints(", "); runtime·printhex_c(((uintptr*)frame.argp)[i]); } runtime·prints(")\n"); line = runtime·funcline(f, tracepc, &file); runtime·printf("\t%S:%d", file, line); if(frame.pc > f->entry) runtime·printf(" +%p", (uintptr)(frame.pc - f->entry)); if(g->m->throwing > 0 && gp == g->m->curg || gotraceback >= 2) runtime·printf(" fp=%p sp=%p", frame.fp, frame.sp); runtime·printf("\n"); nprint++; } } n++; skipped: waspanic = f->entry == (uintptr)runtime·sigpanic; wasnewproc = f->entry == (uintptr)runtime·newproc || f->entry == (uintptr)runtime·deferproc; // Do not unwind past the bottom of the stack. if(flr == nil) break; // Unwind to next frame. frame.fn = flr; frame.pc = frame.lr; frame.lr = 0; frame.sp = frame.fp; frame.fp = 0; } if(pcbuf == nil && callback == nil) n = nprint; // If callback != nil, we're being called to gather stack information during // garbage collection or stack growth. In that context, require that we used // up the entire defer stack. If not, then there is a bug somewhere and the // garbage collection or stack growth may not have seen the correct picture // of the stack. Crash now instead of silently executing the garbage collection // or stack copy incorrectly and setting up for a mysterious crash later. // // Note that panic != nil is okay here: there can be leftover panics, // because the defers on the panic stack do not nest in frame order as // they do on the defer stack. If you have: // // frame 1 defers d1 // frame 2 defers d2 // frame 3 defers d3 // frame 4 panics // frame 4's panic starts running defers // frame 5, running d3, defers d4 // frame 5 panics // frame 5's panic starts running defers // frame 6, running d4, garbage collects // frame 6, running d2, garbage collects // // During the execution of d4, the panic stack is d4 -> d3, which // is nested properly, and we'll treat frame 3 as resumable, because we // can find d3. (And in fact frame 3 is resumable. If d4 recovers // and frame 5 continues running, d3, d3 can recover and we'll // resume execution in (returning from) frame 3.) // // During the execution of d2, however, the panic stack is d2 -> d3, // which is inverted. The scan will match d2 to frame 2 but having // d2 on the stack until then means it will not match d3 to frame 3. // This is okay: if we're running d2, then all the defers after d2 have // completed and their corresponding frames are dead. Not finding d3 // for frame 3 means we'll set frame 3's continpc == 0, which is correct // (frame 3 is dead). At the end of the walk the panic stack can thus // contain defers (d3 in this case) for dead frames. The inversion here // always indicates a dead frame, and the effect of the inversion on the // scan is to hide those dead frames, so the scan is still okay: // what's left on the panic stack are exactly (and only) the dead frames. // // We require callback != nil here because only when callback != nil // do we know that gentraceback is being called in a "must be correct" // context as opposed to a "best effort" context. The tracebacks with // callbacks only happen when everything is stopped nicely. // At other times, such as when gathering a stack for a profiling signal // or when printing a traceback during a crash, everything may not be // stopped nicely, and the stack walk may not be able to complete. // It's okay in those situations not to use up the entire defer stack: // incomplete information then is still better than nothing. if(callback != nil && n < max && defer != nil) { if(defer != nil) runtime·printf("runtime: g%D: leftover defer argp=%p pc=%p\n", gp->goid, defer->argp, defer->pc); if(panic != nil) runtime·printf("runtime: g%D: leftover panic argp=%p pc=%p\n", gp->goid, panic->defer->argp, panic->defer->pc); for(defer = gp->defer; defer != nil; defer = defer->link) runtime·printf("\tdefer %p argp=%p pc=%p\n", defer, defer->argp, defer->pc); for(panic = gp->panic; panic != nil; panic = panic->link) { runtime·printf("\tpanic %p defer %p", panic, panic->defer); if(panic->defer != nil) runtime·printf(" argp=%p pc=%p", panic->defer->argp, panic->defer->pc); runtime·printf("\n"); } runtime·throw("traceback has leftover defers or panics"); } return n; }
// Called by sigtramp from Windows VEH handler. // Return value signals whether the exception has been handled (-1) // or should be made available to other handlers in the chain (0). uint32 runtime·sighandler(ExceptionRecord *info, Context *r, G *gp) { bool crash; uintptr *sp; extern byte text[], etext[]; if(info->ExceptionCode == DBG_PRINTEXCEPTION_C) { // This exception is intended to be caught by debuggers. // There is a not-very-informational message like // "Invalid parameter passed to C runtime function" // sitting at info->ExceptionInformation[0] (a wchar_t*), // with length info->ExceptionInformation[1]. // The default behavior is to ignore this exception, // but somehow returning 0 here (meaning keep going) // makes the program crash instead. Maybe Windows has no // other handler registered? In any event, ignore it. return -1; } // Only handle exception if executing instructions in Go binary // (not Windows library code). if(r->Rip < (uint64)text || (uint64)etext < r->Rip) return 0; switch(info->ExceptionCode) { case EXCEPTION_BREAKPOINT: // It is unclear whether this is needed, unclear whether it // would work, and unclear how to test it. Leave out for now. // This only handles breakpoint instructions written in the // assembly sources, not breakpoints set by a debugger, and // there are very few of the former. break; } if(gp != nil && runtime·issigpanic(info->ExceptionCode)) { // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = info->ExceptionCode; gp->sigcode0 = info->ExceptionInformation[0]; gp->sigcode1 = info->ExceptionInformation[1]; gp->sigpc = r->Rip; // Only push runtime·sigpanic if r->rip != 0. // If r->rip == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to runtime·sigpanic instead. // (Otherwise the trace will end at runtime·sigpanic and we // won't get to see who faulted.) if(r->Rip != 0) { sp = (uintptr*)r->Rsp; *--sp = r->Rip; r->Rsp = (uintptr)sp; } r->Rip = (uintptr)runtime·sigpanic; return -1; } if(runtime·panicking) // traceback already printed runtime·exit(2); runtime·panicking = 1; runtime·printf("Exception %x %p %p %p\n", info->ExceptionCode, info->ExceptionInformation[0], info->ExceptionInformation[1], r->Rip); runtime·printf("PC=%X\n", r->Rip); if(m->lockedg != nil && m->ncgo > 0 && gp == m->g0) { runtime·printf("signal arrived during cgo execution\n"); gp = m->lockedg; } runtime·printf("\n"); if(runtime·gotraceback(&crash)){ runtime·traceback(r->Rip, r->Rsp, 0, gp); runtime·tracebackothers(gp); runtime·dumpregs(r); } if(crash) runtime·crash(); runtime·exit(2); return -1; // not reached }
void runtime·sighandler(int32 sig, Siginfo *info, void *context, G *gp) { Ucontext *uc; Mcontext *mc; Sigcontext *r; uintptr *sp; uc = context; mc = &uc->uc_mcontext; r = (Sigcontext*)mc; // same layout, more conveient names if(sig == SIGPROF) { runtime·sigprof((uint8*)r->rip, (uint8*)r->rsp, nil, gp); return; } if(gp != nil && (runtime·sigtab[sig].flags & SigPanic)) { // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = sig; gp->sigcode0 = info->si_code; gp->sigcode1 = ((uintptr*)info)[2]; gp->sigpc = r->rip; // Only push runtime·sigpanic if r->rip != 0. // If r->rip == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to runtime·sigpanic instead. // (Otherwise the trace will end at runtime·sigpanic and we // won't get to see who faulted.) if(r->rip != 0) { sp = (uintptr*)r->rsp; *--sp = r->rip; r->rsp = (uintptr)sp; } r->rip = (uintptr)runtime·sigpanic; return; } if(runtime·sigtab[sig].flags & SigQueue) { if(runtime·sigsend(sig) || (runtime·sigtab[sig].flags & SigIgnore)) return; runtime·exit(2); // SIGINT, SIGTERM, etc } if(runtime·panicking) // traceback already printed runtime·exit(2); runtime·panicking = 1; if(sig < 0 || sig >= NSIG) runtime·printf("Signal %d\n", sig); else runtime·printf("%s\n", runtime·sigtab[sig].name); runtime·printf("PC=%X\n", r->rip); runtime·printf("\n"); if(runtime·gotraceback()){ runtime·traceback((void*)r->rip, (void*)r->rsp, 0, gp); runtime·tracebackothers(gp); runtime·dumpregs(r); } runtime·exit(2); }
void runtime·sighandler(int32 sig, Siginfo *info, void *ctxt, G *gp) { uintptr *sp; SigTab *t; bool crash; if(sig == SIGPROF) { runtime·sigprof((byte*)SIG_RIP(info, ctxt), (byte*)SIG_RSP(info, ctxt), nil, gp, g->m); return; } #ifdef GOOS_darwin // x86-64 has 48-bit virtual addresses. The top 16 bits must echo bit 47. // The hardware delivers a different kind of fault for a malformed address // than it does for an attempt to access a valid but unmapped address. // OS X 10.9.2 mishandles the malformed address case, making it look like // a user-generated signal (like someone ran kill -SEGV ourpid). // We pass user-generated signals to os/signal, or else ignore them. // Doing that here - and returning to the faulting code - results in an // infinite loop. It appears the best we can do is rewrite what the kernel // delivers into something more like the truth. The address used below // has very little chance of being the one that caused the fault, but it is // malformed, it is clearly not a real pointer, and if it does get printed // in real life, people will probably search for it and find this code. // There are no Google hits for b01dfacedebac1e or 0xb01dfacedebac1e // as I type this comment. if(sig == SIGSEGV && SIG_CODE0(info, ctxt) == SI_USER) { SIG_CODE0(info, ctxt) = SI_USER+1; info->si_addr = (void*)(uintptr)0xb01dfacedebac1eULL; } #endif t = &runtime·sigtab[sig]; if(SIG_CODE0(info, ctxt) != SI_USER && (t->flags & SigPanic)) { // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = sig; gp->sigcode0 = SIG_CODE0(info, ctxt); gp->sigcode1 = SIG_CODE1(info, ctxt); gp->sigpc = SIG_RIP(info, ctxt); #ifdef GOOS_darwin // Work around Leopard bug that doesn't set FPE_INTDIV. // Look at instruction to see if it is a divide. // Not necessary in Snow Leopard (si_code will be != 0). if(sig == SIGFPE && gp->sigcode0 == 0) { byte *pc; pc = (byte*)gp->sigpc; if((pc[0]&0xF0) == 0x40) // 64-bit REX prefix pc++; else if(pc[0] == 0x66) // 16-bit instruction prefix pc++; if(pc[0] == 0xF6 || pc[0] == 0xF7) gp->sigcode0 = FPE_INTDIV; } #endif // Only push runtime·sigpanic if rip != 0. // If rip == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to runtime·sigpanic instead. // (Otherwise the trace will end at runtime·sigpanic and we // won't get to see who faulted.) if(SIG_RIP(info, ctxt) != 0) { sp = (uintptr*)SIG_RSP(info, ctxt); if(sizeof(uintreg) > sizeof(uintptr)) *--sp = 0; *--sp = SIG_RIP(info, ctxt); SIG_RSP(info, ctxt) = (uintptr)sp; } SIG_RIP(info, ctxt) = (uintptr)runtime·sigpanic; return; } if(SIG_CODE0(info, ctxt) == SI_USER || (t->flags & SigNotify)) if(runtime·sigsend(sig)) return; if(t->flags & SigKill) runtime·exit(2); if(!(t->flags & SigThrow)) return; g->m->throwing = 1; g->m->caughtsig = gp; runtime·startpanic(); if(sig < 0 || sig >= NSIG) runtime·printf("Signal %d\n", sig); else runtime·printf("%s\n", runtime·sigtab[sig].name); runtime·printf("PC=%X\n", SIG_RIP(info, ctxt)); if(g->m->lockedg != nil && g->m->ncgo > 0 && gp == g->m->g0) { runtime·printf("signal arrived during cgo execution\n"); gp = g->m->lockedg; } runtime·printf("\n"); if(runtime·gotraceback(&crash)){ runtime·goroutineheader(gp); runtime·traceback(SIG_RIP(info, ctxt), SIG_RSP(info, ctxt), 0, gp); runtime·tracebackothers(gp); runtime·printf("\n"); runtime·dumpregs(info, ctxt); } if(crash) runtime·crash(); runtime·exit(2); }
int32 runtime·sighandler(void *v, int8 *s, G *gp) { bool crash; Ureg *ureg; uintptr *sp; SigTab *sig, *nsig; intgo len, i; if(!s) return NCONT; len = runtime·findnull((byte*)s); if(len <= 4 || runtime·mcmp((byte*)s, (byte*)"sys:", 4) != 0) return NDFLT; nsig = nil; sig = runtime·sigtab; for(i=0; i < NSIG; i++) { if(runtime·strstr((byte*)s, (byte*)sig->name)) { nsig = sig; break; } sig++; } if(nsig == nil) return NDFLT; ureg = v; if(nsig->flags & SigPanic) { if(gp == nil || m->notesig == 0) goto Throw; // Copy the error string from sigtramp's stack into m->notesig so // we can reliably access it from the panic routines. We can't use // runtime·memmove here since it will use SSE instructions for big // copies. The Plan 9 kernel doesn't allow floating point in note // handlers. // // TODO(ality): revert back to memmove when the kernel is fixed. if(len >= ERRMAX) len = ERRMAX-1; for(i = 0; i < len; i++) m->notesig[i] = s[i]; m->notesig[i] = '\0'; gp->sig = i; gp->sigpc = ureg->pc; // Only push runtime·sigpanic if ureg->pc != 0. // If ureg->pc == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to runtime·sigpanic instead. // (Otherwise the trace will end at runtime·sigpanic and we // won't get to see who faulted.) if(ureg->pc != 0) { sp = (uintptr*)ureg->sp; *--sp = ureg->pc; ureg->sp = (uint32)sp; } ureg->pc = (uintptr)runtime·sigpanic; return NCONT; } if(!(nsig->flags & SigThrow)) return NDFLT; Throw: m->throwing = 1; m->caughtsig = gp; runtime·startpanic(); runtime·printf("%s\n", s); runtime·printf("PC=%X\n", ureg->pc); runtime·printf("\n"); if(runtime·gotraceback(&crash)) { runtime·traceback(ureg->pc, ureg->sp, 0, gp); runtime·tracebackothers(gp); runtime·dumpregs(ureg); } if(crash) runtime·crash(); runtime·goexitsall(""); runtime·exits(s); return 0; }
void sighandler(int32 sig, Siginfo* info, void* context) { Ucontext *uc; Mcontext *r; G *gp; uintptr *sp; uc = context; r = &uc->uc_mcontext; if((gp = m->curg) != nil && (sigtab[sig].flags & SigPanic)) { // Make it look like a call to the signal func. // Have to pass arguments out of band since // augmenting the stack frame would break // the unwinding code. gp->sig = sig; gp->sigcode0 = info->si_code; gp->sigcode1 = (uintptr)info->si_addr; // Only push sigpanic if r->mc_rip != 0. // If r->mc_rip == 0, probably panicked because of a // call to a nil func. Not pushing that onto sp will // make the trace look like a call to sigpanic instead. // (Otherwise the trace will end at sigpanic and we // won't get to see who faulted.) if(r->mc_rip != 0) { sp = (uintptr*)r->mc_rsp; *--sp = r->mc_rip; r->mc_rsp = (uintptr)sp; } r->mc_rip = (uintptr)sigpanic; return; } if(sigtab[sig].flags & SigQueue) { if(sigsend(sig) || (sigtab[sig].flags & SigIgnore)) return; exit(2); // SIGINT, SIGTERM, etc } if(panicking) // traceback already printed exit(2); panicking = 1; if(sig < 0 || sig >= NSIG) printf("Signal %d\n", sig); else printf("%s\n", sigtab[sig].name); printf("PC=%X\n", r->mc_rip); printf("\n"); if(gotraceback()){ traceback((void*)r->mc_rip, (void*)r->mc_rsp, 0, (void*)r->mc_r15); tracebackothers((void*)r->mc_r15); dumpregs(r); } breakpoint(); exit(2); }