libgo/runtime/signal_unix.c

   1 // Copyright 2012 The Go Authors.  All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
   6
   7 #include <sys/time.h>
   8
   9 #include "runtime.h"
  10 #include "defs.h"
  11 #include "signal_unix.h"
  12
  13 extern SigTab runtime_sigtab[];
  14
  15 void
  16 runtime_initsig(bool preinit)
  17 {
  18         int32 i;
  19         SigTab *t;
  20
  21         // For c-archive/c-shared this is called by go-libmain.c with
  22         // preinit == true.
  23         if(runtime_isarchive && !preinit)
  24                 return;
  25
  26         // First call: basic setup.
  27         for(i = 0; runtime_sigtab[i].sig != -1; i++) {
  28                 t = &runtime_sigtab[i];
  29                 if((t->flags == 0) || (t->flags & SigDefault))
  30                         continue;
  31
  32                 t->fwdsig = runtime_getsig(i);
  33
  34                 // For some signals, we respect an inherited SIG_IGN handler
  35                 // rather than insist on installing our own default handler.
  36                 // Even these signals can be fetched using the os/signal package.
  37                 switch(t->sig) {
  38                 case SIGHUP:
  39                 case SIGINT:
  40                         if(t->fwdsig == GO_SIG_IGN) {
  41                                 continue;
  42                         }
  43                 }
  44
  45                 if(runtime_isarchive && (t->flags&SigPanic) == 0)
  46                         continue;
  47
  48                 t->flags |= SigHandling;
  49                 runtime_setsig(i, runtime_sighandler, true);
  50         }
  51 }
  52
  53 void
  54 runtime_sigenable(uint32 sig)
  55 {
  56         int32 i;
  57         SigTab *t;
  58
  59         t = nil;
  60         for(i = 0; runtime_sigtab[i].sig != -1; i++) {
  61                 if(runtime_sigtab[i].sig == (int32)sig) {
  62                         t = &runtime_sigtab[i];
  63                         break;
  64                 }
  65         }
  66
  67         if(t == nil)
  68                 return;
  69
  70         if((t->flags & SigNotify) && !(t->flags & SigHandling)) {
  71                 t->flags |= SigHandling;
  72                 t->fwdsig = runtime_getsig(i);
  73                 runtime_setsig(i, runtime_sighandler, true);
  74         }
  75 }
  76
  77 void
  78 runtime_sigdisable(uint32 sig)
  79 {
  80         int32 i;
  81         SigTab *t;
  82
  83         t = nil;
  84         for(i = 0; runtime_sigtab[i].sig != -1; i++) {
  85                 if(runtime_sigtab[i].sig == (int32)sig) {
  86                         t = &runtime_sigtab[i];
  87                         break;
  88                 }
  89         }
  90
  91         if(t == nil)
  92                 return;
  93
  94         if((sig == SIGHUP || sig == SIGINT) && t->fwdsig == GO_SIG_IGN) {
  95                 t->flags &= ~SigHandling;
  96                 runtime_setsig(i, t->fwdsig, true);
  97         }
  98 }
  99
 100 void
 101 runtime_sigignore(uint32 sig)
 102 {
 103         int32 i;
 104         SigTab *t;
 105
 106         t = nil;
 107         for(i = 0; runtime_sigtab[i].sig != -1; i++) {
 108                 if(runtime_sigtab[i].sig == (int32)sig) {
 109                         t = &runtime_sigtab[i];
 110                         break;
 111                 }
 112         }
 113
 114         if(t == nil)
 115                 return;
 116
 117         if((t->flags & SigNotify) != 0) {
 118                 t->flags &= ~SigHandling;
 119                 runtime_setsig(i, GO_SIG_IGN, true);
 120         }
 121 }
 122
 123 void
 124 runtime_resetcpuprofiler(int32 hz)
 125 {
 126         struct itimerval it;
 127
 128         runtime_memclr((byte*)&it, sizeof it);
 129         if(hz == 0) {
 130                 runtime_setitimer(ITIMER_PROF, &it, nil);
 131         } else {
 132                 it.it_interval.tv_sec = 0;
 133                 it.it_interval.tv_usec = 1000000 / hz;
 134                 it.it_value = it.it_interval;
 135                 runtime_setitimer(ITIMER_PROF, &it, nil);
 136         }
 137         runtime_m()->profilehz = hz;
 138 }
 139
 140 void
 141 runtime_unblocksignals(void)
 142 {
 143         sigset_t sigset_none;
 144         sigemptyset(&sigset_none);
 145         pthread_sigmask(SIG_SETMASK, &sigset_none, nil);
 146 }
 147
 148 void
 149 runtime_crash(void)
 150 {
 151         int32 i;
 152
 153 #ifdef GOOS_darwin
 154         // OS X core dumps are linear dumps of the mapped memory,
 155         // from the first virtual byte to the last, with zeros in the gaps.
 156         // Because of the way we arrange the address space on 64-bit systems,
 157         // this means the OS X core file will be >128 GB and even on a zippy
 158         // workstation can take OS X well over an hour to write (uninterruptible).
 159         // Save users from making that mistake.
 160         if(sizeof(void*) == 8)
 161                 return;
 162 #endif
 163
 164         runtime_unblocksignals();
 165         for(i = 0; runtime_sigtab[i].sig != -1; i++)
 166                 if(runtime_sigtab[i].sig == SIGABRT)
 167                         break;
 168         runtime_setsig(i, GO_SIG_DFL, false);
 169         runtime_raise(SIGABRT);
 170 }
 171
 172 void
 173 runtime_raise(int32 sig)
 174 {
 175         raise(sig);
 176 }