blob: 80d711f33828b0fba0122ce29700318fd3b75a1e [file] [log] [blame]
// 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.
#include "runtime.h"
#include "defs_GOOS_GOARCH.h"
#include "os_GOOS.h"
#include "signals_GOOS.h"
void
runtime·dumpregs(Ureg *u)
{
runtime·printf("ax %x\n", u->ax);
runtime·printf("bx %x\n", u->bx);
runtime·printf("cx %x\n", u->cx);
runtime·printf("dx %x\n", u->dx);
runtime·printf("di %x\n", u->di);
runtime·printf("si %x\n", u->si);
runtime·printf("bp %x\n", u->bp);
runtime·printf("sp %x\n", u->sp);
runtime·printf("pc %x\n", u->pc);
runtime·printf("flags %x\n", u->flags);
runtime·printf("cs %x\n", u->cs);
runtime·printf("fs %x\n", u->fs);
runtime·printf("gs %x\n", u->gs);
}
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(m->notesig, note, len+1);
gp->sig = sig;
gp->sigpc = ureg->pc;
// 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->pc != 0) {
sp = (uintptr*)ureg->sp;
*--sp = ureg->pc;
ureg->sp = (uint32)sp;
}
ureg->pc = (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:
m->throwing = 1;
m->caughtsig = gp;
runtime·startpanic();
runtime·printf("%s\n", note);
runtime·printf("PC=%x\n", ureg->pc);
runtime·printf("\n");
if(runtime·gotraceback(&crash)) {
runtime·goroutineheader(gp);
runtime·traceback(ureg->pc, 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·sigenable(uint32 sig)
{
USED(sig);
}
void
runtime·sigdisable(uint32 sig)
{
USED(sig);
}
void
runtime·resetcpuprofiler(int32 hz)
{
// TODO: Enable profiling interrupts.
m->profilehz = hz;
}