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
runtime_initsig(bool preinit)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
runtime_sigenable(uint32 sig)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
runtime_sigdisable(uint32 sig)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
runtime_sigignore(uint32 sig)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
runtime_resetcpuprofiler(int32 hz)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
runtime_unblocksignals(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
runtime_crash(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
runtime_raise(int32 sig)173 runtime_raise(int32 sig)
174 {
175 raise(sig);
176 }
177