libgo/runtime/go-signal.c

   1 /* go-signal.c -- signal handling for Go.
   2
   3    Copyright 2009 The Go Authors. All rights reserved.
   4    Use of this source code is governed by a BSD-style
   5    license that can be found in the LICENSE file.  */
   6
   7 #include <signal.h>
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <sys/time.h>
  11
  12 #include "runtime.h"
  13 #include "go-assert.h"
  14 #include "go-panic.h"
  15
  16 #ifndef SA_RESTART
  17   #define SA_RESTART 0
  18 #endif
  19
  20 #ifdef USING_SPLIT_STACK
  21
  22 extern void __splitstack_getcontext(void *context[10]);
  23
  24 extern void __splitstack_setcontext(void *context[10]);
  25
  26 #endif
  27
  28 #define N SigNotify
  29 #define K SigKill
  30 #define T SigThrow
  31 #define P SigPanic
  32 #define D SigDefault
  33
  34 /* Signal actions.  This collects the sigtab tables for several
  35    different targets from the master library.  SIGKILL, SIGCONT, and
  36    SIGSTOP are not listed, as we don't want to set signal handlers for
  37    them.  */
  38
  39 SigTab runtime_sigtab[] = {
  40 #ifdef SIGHUP
  41   { SIGHUP,     N + K },
  42 #endif
  43 #ifdef SIGINT
  44   { SIGINT,     N + K },
  45 #endif
  46 #ifdef SIGQUIT
  47   { SIGQUIT,    N + T },
  48 #endif
  49 #ifdef SIGILL
  50   { SIGILL,     T },
  51 #endif
  52 #ifdef SIGTRAP
  53   { SIGTRAP,    T },
  54 #endif
  55 #ifdef SIGABRT
  56   { SIGABRT,    N + T },
  57 #endif
  58 #ifdef SIGBUS
  59   { SIGBUS,     P },
  60 #endif
  61 #ifdef SIGFPE
  62   { SIGFPE,     P },
  63 #endif
  64 #ifdef SIGUSR1
  65   { SIGUSR1,    N },
  66 #endif
  67 #ifdef SIGSEGV
  68   { SIGSEGV,    P },
  69 #endif
  70 #ifdef SIGUSR2
  71   { SIGUSR2,    N },
  72 #endif
  73 #ifdef SIGPIPE
  74   { SIGPIPE,    N },
  75 #endif
  76 #ifdef SIGALRM
  77   { SIGALRM,    N },
  78 #endif
  79 #ifdef SIGTERM
  80   { SIGTERM,    N + K },
  81 #endif
  82 #ifdef SIGSTKFLT
  83   { SIGSTKFLT,  T },
  84 #endif
  85 #ifdef SIGCHLD
  86   { SIGCHLD,    N },
  87 #endif
  88 #ifdef SIGTSTP
  89   { SIGTSTP,    N + D },
  90 #endif
  91 #ifdef SIGTTIN
  92   { SIGTTIN,    N + D },
  93 #endif
  94 #ifdef SIGTTOU
  95   { SIGTTOU,    N + D },
  96 #endif
  97 #ifdef SIGURG
  98   { SIGURG,     N },
  99 #endif
 100 #ifdef SIGXCPU
 101   { SIGXCPU,    N },
 102 #endif
 103 #ifdef SIGXFSZ
 104   { SIGXFSZ,    N },
 105 #endif
 106 #ifdef SIGVTALRM
 107   { SIGVTALRM,  N },
 108 #endif
 109 #ifdef SIGPROF
 110   { SIGPROF,    N },
 111 #endif
 112 #ifdef SIGWINCH
 113   { SIGWINCH,   N },
 114 #endif
 115 #ifdef SIGIO
 116   { SIGIO,      N },
 117 #endif
 118 #ifdef SIGPWR
 119   { SIGPWR,     N },
 120 #endif
 121 #ifdef SIGSYS
 122   { SIGSYS,     N },
 123 #endif
 124 #ifdef SIGEMT
 125   { SIGEMT,     T },
 126 #endif
 127 #ifdef SIGINFO
 128   { SIGINFO,    N },
 129 #endif
 130 #ifdef SIGTHR
 131   { SIGTHR,     N },
 132 #endif
 133   { -1,         0 }
 134 };
 135 #undef N
 136 #undef K
 137 #undef T
 138 #undef P
 139 #undef D
 140
 141
 142 static int8 badsignal[] = "runtime: signal received on thread not created by Go.\n";
 143
 144 static void
 145 runtime_badsignal(int32 sig)
 146 {
 147         if (sig == SIGPROF) {
 148                 return;  // Ignore SIGPROFs intended for a non-Go thread.
 149         }
 150         runtime_write(2, badsignal, sizeof badsignal - 1);
 151         runtime_exit(1);
 152 }
 153
 154 /* Handle a signal, for cases where we don't panic.  We can split the
 155    stack here.  */
 156
 157 static void
 158 sig_handler (int sig)
 159 {
 160   int i;
 161
 162   if (runtime_m () == NULL)
 163     {
 164       runtime_badsignal (sig);
 165       return;
 166     }
 167
 168 #ifdef SIGPROF
 169   if (sig == SIGPROF)
 170     {
 171       runtime_sigprof ();
 172       return;
 173     }
 174 #endif
 175
 176   for (i = 0; runtime_sigtab[i].sig != -1; ++i)
 177     {
 178       SigTab *t;
 179
 180       t = &runtime_sigtab[i];
 181
 182       if (t->sig != sig)
 183         continue;
 184
 185       if ((t->flags & SigNotify) != 0)
 186         {
 187           if (__go_sigsend (sig))
 188             return;
 189         }
 190       if ((t->flags & SigKill) != 0)
 191         runtime_exit (2);
 192       if ((t->flags & SigThrow) == 0)
 193         return;
 194
 195       runtime_startpanic ();
 196
 197       {
 198         const char *name = NULL;
 199
 200 #ifdef HAVE_STRSIGNAL
 201         name = strsignal (sig);
 202 #endif
 203
 204         if (name == NULL)
 205           runtime_printf ("Signal %d\n", sig);
 206         else
 207           runtime_printf ("%s\n", name);
 208       }
 209
 210       runtime_printf ("\n");
 211
 212       if (runtime_gotraceback ())
 213         {
 214           G *g;
 215
 216           g = runtime_g ();
 217           runtime_traceback (g);
 218           runtime_tracebackothers (g);
 219
 220           /* The gc library calls runtime_dumpregs here, and provides
 221              a function that prints the registers saved in context in
 222              a readable form.  */
 223         }
 224
 225       runtime_exit (2);
 226     }
 227
 228   __builtin_unreachable ();
 229 }
 230
 231 /* The start of handling a signal which panics.  */
 232
 233 static void
 234 sig_panic_leadin (int sig)
 235 {
 236   int i;
 237   sigset_t clear;
 238
 239   if (runtime_m ()->mallocing)
 240     {
 241       runtime_printf ("caught signal while mallocing: %d\n", sig);
 242       runtime_throw ("caught signal while mallocing");
 243     }
 244
 245   /* The signal handler blocked signals; unblock them.  */
 246   i = sigfillset (&clear);
 247   __go_assert (i == 0);
 248   i = sigprocmask (SIG_UNBLOCK, &clear, NULL);
 249   __go_assert (i == 0);
 250 }
 251
 252 #ifdef SA_SIGINFO
 253
 254 /* Signal dispatch for signals which panic, on systems which support
 255    SA_SIGINFO.  This is called on the thread stack, and as such it is
 256    permitted to split the stack.  */
 257
 258 static void
 259 sig_panic_info_handler (int sig, siginfo_t *info,
 260                         void *context __attribute__ ((unused)))
 261 {
 262   G *g;
 263
 264   g = runtime_g ();
 265   if (g == NULL || info->si_code == SI_USER)
 266     {
 267       sig_handler (sig);
 268       return;
 269     }
 270
 271   g->sig = sig;
 272   g->sigcode0 = info->si_code;
 273   g->sigcode1 = (uintptr_t) info->si_addr;
 274
 275   /* It would be nice to set g->sigpc here as the gc library does, but
 276      I don't know how to get it portably.  */
 277
 278   sig_panic_leadin (sig);
 279
 280   switch (sig)
 281     {
 282 #ifdef SIGBUS
 283     case SIGBUS:
 284       if (info->si_code == BUS_ADRERR && (uintptr_t) info->si_addr < 0x1000)
 285         runtime_panicstring ("invalid memory address or "
 286                              "nil pointer dereference");
 287       runtime_printf ("unexpected fault address %p\n", info->si_addr);
 288       runtime_throw ("fault");
 289 #endif
 290
 291 #ifdef SIGSEGV
 292     case SIGSEGV:
 293       if ((info->si_code == 0
 294            || info->si_code == SEGV_MAPERR
 295            || info->si_code == SEGV_ACCERR)
 296           && (uintptr_t) info->si_addr < 0x1000)
 297         runtime_panicstring ("invalid memory address or "
 298                              "nil pointer dereference");
 299       runtime_printf ("unexpected fault address %p\n", info->si_addr);
 300       runtime_throw ("fault");
 301 #endif
 302
 303 #ifdef SIGFPE
 304     case SIGFPE:
 305       switch (info->si_code)
 306         {
 307         case FPE_INTDIV:
 308           runtime_panicstring ("integer divide by zero");
 309         case FPE_INTOVF:
 310           runtime_panicstring ("integer overflow");
 311         }
 312       runtime_panicstring ("floating point error");
 313 #endif
 314     }
 315
 316   /* All signals with SigPanic should be in cases above, and this
 317      handler should only be invoked for those signals.  */
 318   __builtin_unreachable ();
 319 }
 320
 321 #else /* !defined (SA_SIGINFO) */
 322
 323 static void
 324 sig_panic_handler (int sig)
 325 {
 326   G *g;
 327
 328   g = runtime_g ();
 329   if (g == NULL)
 330     {
 331       sig_handler (sig);
 332       return;
 333     }
 334
 335   g->sig = sig;
 336   g->sigcode0 = 0;
 337   g->sigcode1 = 0;
 338
 339   sig_panic_leadin (sig);
 340
 341   switch (sig)
 342     {
 343 #ifdef SIGBUS
 344     case SIGBUS:
 345       runtime_panicstring ("invalid memory address or "
 346                            "nil pointer dereference");
 347 #endif
 348
 349 #ifdef SIGSEGV
 350     case SIGSEGV:
 351       runtime_panicstring ("invalid memory address or "
 352                            "nil pointer dereference");
 353 #endif
 354
 355 #ifdef SIGFPE
 356     case SIGFPE:
 357       runtime_panicstring ("integer divide by zero or floating point error");
 358 #endif
 359     }
 360
 361   /* All signals with SigPanic should be in cases above, and this
 362      handler should only be invoked for those signals.  */
 363   __builtin_unreachable ();
 364 }
 365
 366 #endif /* !defined (SA_SIGINFO) */
 367
 368 /* A signal handler used for signals which are not going to panic.
 369    This is called on the alternate signal stack so it may not split
 370    the stack.  */
 371
 372 static void
 373 sig_tramp (int) __attribute__ ((no_split_stack));
 374
 375 static void
 376 sig_tramp (int sig)
 377 {
 378   G *gp;
 379   M *mp;
 380
 381   /* We are now running on the stack registered via sigaltstack.
 382      (Actually there is a small span of time between runtime_siginit
 383      and sigaltstack when the program starts.)  */
 384   gp = runtime_g ();
 385   mp = runtime_m ();
 386
 387   if (gp != NULL)
 388     {
 389 #ifdef USING_SPLIT_STACK
 390       __splitstack_getcontext (&gp->stack_context[0]);
 391 #endif
 392     }
 393
 394   if (gp != NULL && mp->gsignal != NULL)
 395     {
 396       /* We are running on the signal stack.  Set the split stack
 397          context so that the stack guards are checked correctly.  */
 398 #ifdef USING_SPLIT_STACK
 399       __splitstack_setcontext (&mp->gsignal->stack_context[0]);
 400 #endif
 401     }
 402
 403   sig_handler (sig);
 404
 405   /* We are going to return back to the signal trampoline and then to
 406      whatever we were doing before we got the signal.  Restore the
 407      split stack context so that stack guards are checked
 408      correctly.  */
 409
 410   if (gp != NULL)
 411     {
 412 #ifdef USING_SPLIT_STACK
 413       __splitstack_setcontext (&gp->stack_context[0]);
 414 #endif
 415     }
 416 }
 417
 418 void
 419 runtime_setsig (int32 i, bool def __attribute__ ((unused)), bool restart)
 420 {
 421   struct sigaction sa;
 422   int r;
 423   SigTab *t;
 424
 425   memset (&sa, 0, sizeof sa);
 426
 427   r = sigfillset (&sa.sa_mask);
 428   __go_assert (r == 0);
 429
 430   t = &runtime_sigtab[i];
 431
 432   if ((t->flags & SigPanic) == 0)
 433     {
 434       sa.sa_flags = SA_ONSTACK;
 435       sa.sa_handler = sig_tramp;
 436     }
 437   else
 438     {
 439 #ifdef SA_SIGINFO
 440       sa.sa_flags = SA_SIGINFO;
 441       sa.sa_sigaction = sig_panic_info_handler;
 442 #else
 443       sa.sa_flags = 0;
 444       sa.sa_handler = sig_panic_handler;
 445 #endif
 446     }
 447
 448   if (restart)
 449     sa.sa_flags |= SA_RESTART;
 450
 451   if (sigaction (t->sig, &sa, NULL) != 0)
 452     __go_assert (0);
 453 }
 454
 455 /* Used by the os package to raise SIGPIPE.  */
 456
 457 void os_sigpipe (void) __asm__ ("os.sigpipe");
 458
 459 void
 460 os_sigpipe (void)
 461 {
 462   struct sigaction sa;
 463   int i;
 464
 465   memset (&sa, 0, sizeof sa);
 466
 467   sa.sa_handler = SIG_DFL;
 468
 469   i = sigemptyset (&sa.sa_mask);
 470   __go_assert (i == 0);
 471
 472   if (sigaction (SIGPIPE, &sa, NULL) != 0)
 473     abort ();
 474
 475   raise (SIGPIPE);
 476 }
 477
 478 void
 479 runtime_setprof(bool on)
 480 {
 481         USED(on);
 482 }