547 lines
10 KiB
C
547 lines
10 KiB
C
/* go-signal.c -- signal handling for 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. */
|
|
|
|
#include <signal.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <sys/time.h>
|
|
|
|
#include "runtime.h"
|
|
#include "go-assert.h"
|
|
#include "go-panic.h"
|
|
#include "signal_unix.h"
|
|
|
|
#ifndef SA_RESTART
|
|
#define SA_RESTART 0
|
|
#endif
|
|
|
|
#ifdef USING_SPLIT_STACK
|
|
|
|
extern void __splitstack_getcontext(void *context[10]);
|
|
|
|
extern void __splitstack_setcontext(void *context[10]);
|
|
|
|
#endif
|
|
|
|
#define N SigNotify
|
|
#define K SigKill
|
|
#define T SigThrow
|
|
#define P SigPanic
|
|
#define D SigDefault
|
|
|
|
/* Signal actions. This collects the sigtab tables for several
|
|
different targets from the master library. SIGKILL, SIGCONT, and
|
|
SIGSTOP are not listed, as we don't want to set signal handlers for
|
|
them. */
|
|
|
|
SigTab runtime_sigtab[] = {
|
|
#ifdef SIGHUP
|
|
{ SIGHUP, N + K },
|
|
#endif
|
|
#ifdef SIGINT
|
|
{ SIGINT, N + K },
|
|
#endif
|
|
#ifdef SIGQUIT
|
|
{ SIGQUIT, N + T },
|
|
#endif
|
|
#ifdef SIGILL
|
|
{ SIGILL, T },
|
|
#endif
|
|
#ifdef SIGTRAP
|
|
{ SIGTRAP, T },
|
|
#endif
|
|
#ifdef SIGABRT
|
|
{ SIGABRT, N + T },
|
|
#endif
|
|
#ifdef SIGBUS
|
|
{ SIGBUS, P },
|
|
#endif
|
|
#ifdef SIGFPE
|
|
{ SIGFPE, P },
|
|
#endif
|
|
#ifdef SIGUSR1
|
|
{ SIGUSR1, N },
|
|
#endif
|
|
#ifdef SIGSEGV
|
|
{ SIGSEGV, P },
|
|
#endif
|
|
#ifdef SIGUSR2
|
|
{ SIGUSR2, N },
|
|
#endif
|
|
#ifdef SIGPIPE
|
|
{ SIGPIPE, N },
|
|
#endif
|
|
#ifdef SIGALRM
|
|
{ SIGALRM, N },
|
|
#endif
|
|
#ifdef SIGTERM
|
|
{ SIGTERM, N + K },
|
|
#endif
|
|
#ifdef SIGSTKFLT
|
|
{ SIGSTKFLT, T },
|
|
#endif
|
|
#ifdef SIGCHLD
|
|
{ SIGCHLD, N },
|
|
#endif
|
|
#ifdef SIGTSTP
|
|
{ SIGTSTP, N + D },
|
|
#endif
|
|
#ifdef SIGTTIN
|
|
{ SIGTTIN, N + D },
|
|
#endif
|
|
#ifdef SIGTTOU
|
|
{ SIGTTOU, N + D },
|
|
#endif
|
|
#ifdef SIGURG
|
|
{ SIGURG, N },
|
|
#endif
|
|
#ifdef SIGXCPU
|
|
{ SIGXCPU, N },
|
|
#endif
|
|
#ifdef SIGXFSZ
|
|
{ SIGXFSZ, N },
|
|
#endif
|
|
#ifdef SIGVTALRM
|
|
{ SIGVTALRM, N },
|
|
#endif
|
|
#ifdef SIGPROF
|
|
{ SIGPROF, N },
|
|
#endif
|
|
#ifdef SIGWINCH
|
|
{ SIGWINCH, N },
|
|
#endif
|
|
#ifdef SIGIO
|
|
{ SIGIO, N },
|
|
#endif
|
|
#ifdef SIGPWR
|
|
{ SIGPWR, N },
|
|
#endif
|
|
#ifdef SIGSYS
|
|
{ SIGSYS, N },
|
|
#endif
|
|
#ifdef SIGEMT
|
|
{ SIGEMT, T },
|
|
#endif
|
|
#ifdef SIGINFO
|
|
{ SIGINFO, N },
|
|
#endif
|
|
#ifdef SIGTHR
|
|
{ SIGTHR, N },
|
|
#endif
|
|
{ -1, 0 }
|
|
};
|
|
#undef N
|
|
#undef K
|
|
#undef T
|
|
#undef P
|
|
#undef D
|
|
|
|
/* Handle a signal, for cases where we don't panic. We can split the
|
|
stack here. */
|
|
|
|
void
|
|
runtime_sighandler (int sig, Siginfo *info,
|
|
void *context __attribute__ ((unused)), G *gp)
|
|
{
|
|
M *m;
|
|
int i;
|
|
|
|
m = runtime_m ();
|
|
|
|
#ifdef SIGPROF
|
|
if (sig == SIGPROF)
|
|
{
|
|
if (m != NULL && gp != m->g0 && gp != m->gsignal)
|
|
runtime_sigprof ();
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
if (m == NULL)
|
|
{
|
|
runtime_badsignal (sig);
|
|
return;
|
|
}
|
|
|
|
for (i = 0; runtime_sigtab[i].sig != -1; ++i)
|
|
{
|
|
SigTab *t;
|
|
bool notify, crash;
|
|
|
|
t = &runtime_sigtab[i];
|
|
|
|
if (t->sig != sig)
|
|
continue;
|
|
|
|
notify = false;
|
|
#ifdef SA_SIGINFO
|
|
notify = info != NULL && info->si_code == SI_USER;
|
|
#endif
|
|
if (notify || (t->flags & SigNotify) != 0)
|
|
{
|
|
if (__go_sigsend (sig))
|
|
return;
|
|
}
|
|
if ((t->flags & SigKill) != 0)
|
|
runtime_exit (2);
|
|
if ((t->flags & SigThrow) == 0)
|
|
return;
|
|
|
|
runtime_startpanic ();
|
|
|
|
{
|
|
const char *name = NULL;
|
|
|
|
#ifdef HAVE_STRSIGNAL
|
|
name = strsignal (sig);
|
|
#endif
|
|
|
|
if (name == NULL)
|
|
runtime_printf ("Signal %d\n", sig);
|
|
else
|
|
runtime_printf ("%s\n", name);
|
|
}
|
|
|
|
if (m->lockedg != NULL && m->ncgo > 0 && gp == m->g0)
|
|
{
|
|
runtime_printf("signal arrived during cgo execution\n");
|
|
gp = m->lockedg;
|
|
}
|
|
|
|
runtime_printf ("\n");
|
|
|
|
if (runtime_gotraceback (&crash))
|
|
{
|
|
G *g;
|
|
|
|
g = runtime_g ();
|
|
runtime_traceback ();
|
|
runtime_tracebackothers (g);
|
|
|
|
/* The gc library calls runtime_dumpregs here, and provides
|
|
a function that prints the registers saved in context in
|
|
a readable form. */
|
|
}
|
|
|
|
if (crash)
|
|
runtime_crash ();
|
|
|
|
runtime_exit (2);
|
|
}
|
|
|
|
__builtin_unreachable ();
|
|
}
|
|
|
|
/* The start of handling a signal which panics. */
|
|
|
|
static void
|
|
sig_panic_leadin (G *gp)
|
|
{
|
|
int i;
|
|
sigset_t clear;
|
|
|
|
if (!runtime_canpanic (gp))
|
|
runtime_throw ("unexpected signal during runtime execution");
|
|
|
|
/* The signal handler blocked signals; unblock them. */
|
|
i = sigfillset (&clear);
|
|
__go_assert (i == 0);
|
|
i = pthread_sigmask (SIG_UNBLOCK, &clear, NULL);
|
|
__go_assert (i == 0);
|
|
}
|
|
|
|
#ifdef SA_SIGINFO
|
|
|
|
/* Signal dispatch for signals which panic, on systems which support
|
|
SA_SIGINFO. This is called on the thread stack, and as such it is
|
|
permitted to split the stack. */
|
|
|
|
static void
|
|
sig_panic_info_handler (int sig, Siginfo *info, void *context)
|
|
{
|
|
G *g;
|
|
|
|
g = runtime_g ();
|
|
if (g == NULL || info->si_code == SI_USER)
|
|
{
|
|
runtime_sighandler (sig, info, context, g);
|
|
return;
|
|
}
|
|
|
|
g->sig = sig;
|
|
g->sigcode0 = info->si_code;
|
|
g->sigcode1 = (uintptr_t) info->si_addr;
|
|
|
|
/* It would be nice to set g->sigpc here as the gc library does, but
|
|
I don't know how to get it portably. */
|
|
|
|
sig_panic_leadin (g);
|
|
|
|
switch (sig)
|
|
{
|
|
#ifdef SIGBUS
|
|
case SIGBUS:
|
|
if ((info->si_code == BUS_ADRERR && (uintptr_t) info->si_addr < 0x1000)
|
|
|| g->paniconfault)
|
|
runtime_panicstring ("invalid memory address or "
|
|
"nil pointer dereference");
|
|
runtime_printf ("unexpected fault address %p\n", info->si_addr);
|
|
runtime_throw ("fault");
|
|
#endif
|
|
|
|
#ifdef SIGSEGV
|
|
case SIGSEGV:
|
|
if (((info->si_code == 0
|
|
|| info->si_code == SEGV_MAPERR
|
|
|| info->si_code == SEGV_ACCERR)
|
|
&& (uintptr_t) info->si_addr < 0x1000)
|
|
|| g->paniconfault)
|
|
runtime_panicstring ("invalid memory address or "
|
|
"nil pointer dereference");
|
|
runtime_printf ("unexpected fault address %p\n", info->si_addr);
|
|
runtime_throw ("fault");
|
|
#endif
|
|
|
|
#ifdef SIGFPE
|
|
case SIGFPE:
|
|
switch (info->si_code)
|
|
{
|
|
case FPE_INTDIV:
|
|
runtime_panicstring ("integer divide by zero");
|
|
case FPE_INTOVF:
|
|
runtime_panicstring ("integer overflow");
|
|
}
|
|
runtime_panicstring ("floating point error");
|
|
#endif
|
|
}
|
|
|
|
/* All signals with SigPanic should be in cases above, and this
|
|
handler should only be invoked for those signals. */
|
|
__builtin_unreachable ();
|
|
}
|
|
|
|
#else /* !defined (SA_SIGINFO) */
|
|
|
|
static void
|
|
sig_panic_handler (int sig)
|
|
{
|
|
G *g;
|
|
|
|
g = runtime_g ();
|
|
if (g == NULL)
|
|
{
|
|
runtime_sighandler (sig, NULL, NULL, g);
|
|
return;
|
|
}
|
|
|
|
g->sig = sig;
|
|
g->sigcode0 = 0;
|
|
g->sigcode1 = 0;
|
|
|
|
sig_panic_leadin (g);
|
|
|
|
switch (sig)
|
|
{
|
|
#ifdef SIGBUS
|
|
case SIGBUS:
|
|
runtime_panicstring ("invalid memory address or "
|
|
"nil pointer dereference");
|
|
#endif
|
|
|
|
#ifdef SIGSEGV
|
|
case SIGSEGV:
|
|
runtime_panicstring ("invalid memory address or "
|
|
"nil pointer dereference");
|
|
#endif
|
|
|
|
#ifdef SIGFPE
|
|
case SIGFPE:
|
|
runtime_panicstring ("integer divide by zero or floating point error");
|
|
#endif
|
|
}
|
|
|
|
/* All signals with SigPanic should be in cases above, and this
|
|
handler should only be invoked for those signals. */
|
|
__builtin_unreachable ();
|
|
}
|
|
|
|
#endif /* !defined (SA_SIGINFO) */
|
|
|
|
/* A signal handler used for signals which are not going to panic.
|
|
This is called on the alternate signal stack so it may not split
|
|
the stack. */
|
|
|
|
static void
|
|
sig_tramp_info (int, Siginfo *, void *) __attribute__ ((no_split_stack));
|
|
|
|
static void
|
|
sig_tramp_info (int sig, Siginfo *info, void *context)
|
|
{
|
|
G *gp;
|
|
M *mp;
|
|
#ifdef USING_SPLIT_STACK
|
|
void *stack_context[10];
|
|
#endif
|
|
|
|
/* We are now running on the stack registered via sigaltstack.
|
|
(Actually there is a small span of time between runtime_siginit
|
|
and sigaltstack when the program starts.) */
|
|
gp = runtime_g ();
|
|
mp = runtime_m ();
|
|
|
|
if (gp != NULL)
|
|
{
|
|
#ifdef USING_SPLIT_STACK
|
|
__splitstack_getcontext (&stack_context[0]);
|
|
#endif
|
|
}
|
|
|
|
if (gp != NULL && mp->gsignal != NULL)
|
|
{
|
|
/* We are running on the signal stack. Set the split stack
|
|
context so that the stack guards are checked correctly. */
|
|
#ifdef USING_SPLIT_STACK
|
|
__splitstack_setcontext (&mp->gsignal->stack_context[0]);
|
|
#endif
|
|
}
|
|
|
|
runtime_sighandler (sig, info, context, gp);
|
|
|
|
/* We are going to return back to the signal trampoline and then to
|
|
whatever we were doing before we got the signal. Restore the
|
|
split stack context so that stack guards are checked
|
|
correctly. */
|
|
|
|
if (gp != NULL)
|
|
{
|
|
#ifdef USING_SPLIT_STACK
|
|
__splitstack_setcontext (&stack_context[0]);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#ifndef SA_SIGINFO
|
|
|
|
static void sig_tramp (int sig) __attribute__ ((no_split_stack));
|
|
|
|
static void
|
|
sig_tramp (int sig)
|
|
{
|
|
sig_tramp_info (sig, NULL, NULL);
|
|
}
|
|
|
|
#endif
|
|
|
|
void
|
|
runtime_setsig (int32 i, GoSighandler *fn, bool restart)
|
|
{
|
|
struct sigaction sa;
|
|
int r;
|
|
SigTab *t;
|
|
|
|
memset (&sa, 0, sizeof sa);
|
|
|
|
r = sigfillset (&sa.sa_mask);
|
|
__go_assert (r == 0);
|
|
|
|
t = &runtime_sigtab[i];
|
|
|
|
if ((t->flags & SigPanic) == 0)
|
|
{
|
|
#ifdef SA_SIGINFO
|
|
sa.sa_flags = SA_ONSTACK | SA_SIGINFO;
|
|
if (fn == runtime_sighandler)
|
|
fn = (void *) sig_tramp_info;
|
|
sa.sa_sigaction = (void *) fn;
|
|
#else
|
|
sa.sa_flags = SA_ONSTACK;
|
|
if (fn == runtime_sighandler)
|
|
fn = (void *) sig_tramp;
|
|
sa.sa_handler = (void *) fn;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#ifdef SA_SIGINFO
|
|
sa.sa_flags = SA_SIGINFO;
|
|
if (fn == runtime_sighandler)
|
|
fn = (void *) sig_panic_info_handler;
|
|
sa.sa_sigaction = (void *) fn;
|
|
#else
|
|
sa.sa_flags = 0;
|
|
if (fn == runtime_sighandler)
|
|
fn = (void *) sig_panic_handler;
|
|
sa.sa_handler = (void *) fn;
|
|
#endif
|
|
}
|
|
|
|
if (restart)
|
|
sa.sa_flags |= SA_RESTART;
|
|
|
|
if (sigaction (t->sig, &sa, NULL) != 0)
|
|
__go_assert (0);
|
|
}
|
|
|
|
GoSighandler*
|
|
runtime_getsig (int32 i)
|
|
{
|
|
struct sigaction sa;
|
|
int r;
|
|
SigTab *t;
|
|
|
|
memset (&sa, 0, sizeof sa);
|
|
|
|
r = sigemptyset (&sa.sa_mask);
|
|
__go_assert (r == 0);
|
|
|
|
t = &runtime_sigtab[i];
|
|
|
|
if (sigaction (t->sig, NULL, &sa) != 0)
|
|
runtime_throw ("sigaction read failure");
|
|
|
|
if ((void *) sa.sa_handler == sig_tramp_info)
|
|
return runtime_sighandler;
|
|
#ifdef SA_SIGINFO
|
|
if ((void *) sa.sa_handler == sig_panic_info_handler)
|
|
return runtime_sighandler;
|
|
#else
|
|
if ((void *) sa.sa_handler == sig_tramp
|
|
|| (void *) sa.sa_handler == sig_panic_handler)
|
|
return runtime_sighandler;
|
|
#endif
|
|
|
|
return (void *) sa.sa_handler;
|
|
}
|
|
|
|
/* Used by the os package to raise SIGPIPE. */
|
|
|
|
void os_sigpipe (void) __asm__ (GOSYM_PREFIX "os.sigpipe");
|
|
|
|
void
|
|
os_sigpipe (void)
|
|
{
|
|
struct sigaction sa;
|
|
int i;
|
|
|
|
memset (&sa, 0, sizeof sa);
|
|
|
|
sa.sa_handler = SIG_DFL;
|
|
|
|
i = sigemptyset (&sa.sa_mask);
|
|
__go_assert (i == 0);
|
|
|
|
if (sigaction (SIGPIPE, &sa, NULL) != 0)
|
|
abort ();
|
|
|
|
raise (SIGPIPE);
|
|
}
|
|
|
|
void
|
|
runtime_setprof(bool on)
|
|
{
|
|
USED(on);
|
|
}
|