gcc/libgo/runtime/go-signal.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"

#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 C SigCatch
#define I SigIgnore
#define R SigRestart
#define Q SigQueue
#define P SigPanic

/* 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,	Q + R },
#endif
#ifdef SIGINT
  { SIGINT, 	Q + R },
#endif
#ifdef SIGQUIT
  { SIGQUIT, 	C },
#endif
#ifdef SIGILL
  { SIGILL, 	C },
#endif
#ifdef SIGTRAP
  { SIGTRAP, 	C },
#endif
#ifdef SIGABRT
  { SIGABRT, 	C },
#endif
#ifdef SIGBUS
  { SIGBUS, 	C + P },
#endif
#ifdef SIGFPE
  { SIGFPE, 	C + P },
#endif
#ifdef SIGUSR1
  { SIGUSR1, 	Q + I + R },
#endif
#ifdef SIGSEGV
  { SIGSEGV, 	C + P },
#endif
#ifdef SIGUSR2
  { SIGUSR2, 	Q + I + R },
#endif
#ifdef SIGPIPE
  { SIGPIPE, 	I },
#endif
#ifdef SIGALRM
  { SIGALRM, 	Q + I + R },
#endif
#ifdef SIGTERM
  { SIGTERM, 	Q + R },
#endif
#ifdef SIGSTKFLT
  { SIGSTKFLT, 	C },
#endif
#ifdef SIGCHLD
  { SIGCHLD, 	Q + I + R },
#endif
#ifdef SIGTSTP
  { SIGTSTP, 	Q + I + R },
#endif
#ifdef SIGTTIN
  { SIGTTIN, 	Q + I + R },
#endif
#ifdef SIGTTOU
  { SIGTTOU, 	Q + I + R },
#endif
#ifdef SIGURG
  { SIGURG, 	Q + I + R },
#endif
#ifdef SIGXCPU
  { SIGXCPU, 	Q + I + R },
#endif
#ifdef SIGXFSZ
  { SIGXFSZ, 	Q + I + R },
#endif
#ifdef SIGVTALRM
  { SIGVTALRM, 	Q + I + R },
#endif
#ifdef SIGPROF
  { SIGPROF, 	Q + I + R },
#endif
#ifdef SIGWINCH
  { SIGWINCH, 	Q + I + R },
#endif
#ifdef SIGIO
  { SIGIO, 	Q + I + R },
#endif
#ifdef SIGPWR
  { SIGPWR, 	Q + I + R },
#endif
#ifdef SIGSYS
  { SIGSYS, 	C },
#endif
#ifdef SIGEMT
  { SIGEMT,	C },
#endif
#ifdef SIGINFO
  { SIGINFO,	Q + I + R },
#endif
#ifdef SIGTHR
  { SIGTHR,	Q + I + R },
#endif
  { -1,		0 }
};
#undef C
#undef I
#undef R
#undef Q
#undef P

/* Handle a signal, for cases where we don't panic.  We can split the
   stack here.  */

static void
sig_handler (int sig)
{
  int i;

#ifdef SIGPROF
  if (sig == SIGPROF)
    {
      /* FIXME.  */
      runtime_sigprof (0, 0, nil, nil);
      return;
    }
#endif

  for (i = 0; runtime_sigtab[i].sig != -1; ++i)
    {
      struct sigaction sa;

      if (runtime_sigtab[i].sig != sig)
	continue;

      if ((runtime_sigtab[i].flags & SigQueue) != 0)
	{
	  if (__go_sigsend (sig)
	      || (runtime_sigtab[sig].flags & SigIgnore) != 0)
	    return;
	  runtime_exit (2);		// SIGINT, SIGTERM, etc
	}

      if (runtime_panicking)
	runtime_exit (2);
      runtime_panicking = 1;

      /* We should do a stack backtrace here.  Until we can do that,
	 we reraise the signal in order to get a slightly better
	 report from the shell.  */

      memset (&sa, 0, sizeof sa);

      sa.sa_handler = SIG_DFL;

      i = sigemptyset (&sa.sa_mask);
      __go_assert (i == 0);

      if (sigaction (sig, &sa, NULL) != 0)
	abort ();

      raise (sig);

      runtime_exit (2);
    }

  __builtin_unreachable ();
}

/* The start of handling a signal which panics.  */

static void
sig_panic_leadin (int sig)
{
  int i;
  sigset_t clear;

  if (runtime_m ()->mallocing)
    {
      runtime_printf ("caught signal while mallocing: %d\n", sig);
      runtime_throw ("caught signal while mallocing");
    }

  /* The signal handler blocked signals; unblock them.  */
  i = sigfillset (&clear);
  __go_assert (i == 0);
  i = sigprocmask (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_t *info,
			void *context __attribute__ ((unused)))
{
  if (runtime_g () == NULL)
    {
      sig_handler (sig);
      return;
    }

  sig_panic_leadin (sig);

  switch (sig)
    {
#ifdef SIGBUS
    case SIGBUS:
      if (info->si_code == BUS_ADRERR && (uintptr_t) info->si_addr < 0x1000)
	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)
	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)
{
  if (runtime_g () == NULL)
    {
      sig_handler (sig);
      return;
    }

  sig_panic_leadin (sig);

  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) */

/* Ignore a signal.  This is called on the alternate signal stack so
   it may not split the stack.  */

static void sig_ignore (int) __attribute__ ((no_split_stack));

static void
sig_ignore (int sig __attribute__ ((unused)))
{
}

/* 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 (int) __attribute__ ((no_split_stack));

static void
sig_tramp (int sig)
{
  G *gp;
  M *mp;

  /* 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 (&gp->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
    }

  sig_handler (sig);

  /* 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 (&gp->stack_context[0]);
#endif
    }
}

/* Initialize signal handling for Go.  This is called when the program
   starts.  */

void
runtime_initsig (int32 queue)
{
  struct sigaction sa;
  int i;

  siginit ();

  memset (&sa, 0, sizeof sa);

  i = sigfillset (&sa.sa_mask);
  __go_assert (i == 0);

  for (i = 0; runtime_sigtab[i].sig != -1; ++i)
    {
      if (runtime_sigtab[i].flags == 0)
	continue;
      if ((runtime_sigtab[i].flags & SigQueue) != queue)
	continue;

      if ((runtime_sigtab[i].flags & (SigCatch | SigQueue)) != 0)
	{
	  if ((runtime_sigtab[i].flags & SigPanic) == 0)
	    {
	      sa.sa_flags = SA_ONSTACK;
	      sa.sa_handler = sig_tramp;
	    }
	  else
	    {
#ifdef SA_SIGINFO
	      sa.sa_flags = SA_SIGINFO;
	      sa.sa_sigaction = sig_panic_info_handler;
#else
	      sa.sa_flags = 0;
	      sa.sa_handler = sig_panic_handler;
#endif
	    }
	}
      else
	{
	  sa.sa_flags = SA_ONSTACK;
	  sa.sa_handler = sig_ignore;
	}

      if ((runtime_sigtab[i].flags & SigRestart) != 0)
	sa.sa_flags |= SA_RESTART;

      if (sigaction (runtime_sigtab[i].sig, &sa, NULL) != 0)
	__go_assert (0);
    }
}

void
runtime_resetcpuprofiler(int32 hz)
{
#ifdef SIGPROF
  struct itimerval it;
  struct sigaction sa;
  int i;

  memset (&it, 0, sizeof it);

  memset (&sa, 0, sizeof sa);
  i = sigfillset (&sa.sa_mask);
  __go_assert (i == 0);

  if (hz == 0)
    {
      i = setitimer (ITIMER_PROF, &it, NULL);
      __go_assert (i == 0);

      sa.sa_handler = SIG_IGN;
      i = sigaction (SIGPROF, &sa, NULL);
      __go_assert (i == 0);
    }
  else
    {
      sa.sa_handler = sig_handler;
      sa.sa_flags = SA_RESTART;
      i = sigaction (SIGPROF, &sa, NULL);
      __go_assert (i == 0);

      it.it_interval.tv_sec = 0;
      it.it_interval.tv_usec = 1000000 / hz;
      it.it_value = it.it_interval;
      i = setitimer (ITIMER_PROF, &it, NULL);
      __go_assert (i == 0);
    }
#endif

  runtime_m()->profilehz = hz;
}

/* Used by the os package to raise SIGPIPE.  */

void os_sigpipe (void) __asm__ ("libgo_os.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);
}