1 /*
2 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 */
5
6 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
7 /* All Rights Reserved */
8
9 /*
10 * Copyright (c) 1980 Regents of the University of California.
11 * All rights reserved. The Berkeley Software License Agreement
12 * specifies the terms and conditions for redistribution.
13 */
14
15 #pragma ident "%Z%%M% %I% %E% SMI"
16
17 /*
18 * 4.3BSD signal compatibility functions
19 *
20 * the implementation interprets signal masks equal to -1 as "all of the
21 * signals in the signal set", thereby allowing signals with numbers
22 * above 32 to be blocked when referenced in code such as:
23 *
24 * for (i = 0; i < NSIG; i++)
25 * mask |= sigmask(i)
26 */
27
28 #include <sys/types.h>
29 #include <sys/siginfo.h>
30 #include <sys/ucontext.h>
31 #include <signal.h>
32 #include "signal.h"
33 #include <errno.h>
34 #include <stdio.h>
35
36 #define set2mask(setp) ((setp)->__sigbits[0])
37 #define mask2set(mask, setp) \
38 ((mask) == -1 ? sigfillset(setp) : sigemptyset(setp), (((setp)->__sigbits[0]) = (mask)))
39
40 void (*_siguhandler[NSIG])() = { 0 };
41
42 /*
43 * sigstack is emulated with sigaltstack by guessing an appropriate
44 * value for the stack size - on machines that have stacks that grow
45 * upwards, the ss_sp arguments for both functions mean the same thing,
46 * (the initial stack pointer sigstack() is also the stack base
47 * sigaltstack()), so a "very large" value should be chosen for the
48 * stack size - on machines that have stacks that grow downwards, the
49 * ss_sp arguments mean opposite things, so 0 should be used (hopefully
50 * these machines don't have hardware stack bounds registers that pay
51 * attention to sigaltstack()'s size argument.
52 */
53
54 #ifdef sun
55 #define SIGSTACKSIZE 0
56 #endif
57
58
59 /*
60 * sigvechandler is the real signal handler installed for all
61 * signals handled in the 4.3BSD compatibility interface - it translates
62 * SVR4 signal hander arguments into 4.3BSD signal handler arguments
63 * and then calls the real handler
64 */
65
66 static void
sigvechandler(int sig,siginfo_t * sip,ucontext_t * ucp)67 sigvechandler(int sig, siginfo_t *sip, ucontext_t *ucp)
68 {
69 struct sigcontext sc;
70 int code;
71 char *addr;
72 int i, j;
73 int gwinswitch = 0;
74
75 sc.sc_onstack = ((ucp->uc_stack.ss_flags & SS_ONSTACK) != 0);
76 sc.sc_mask = set2mask(&ucp->uc_sigmask);
77
78 /*
79 * Machine dependent code begins
80 */
81 sc.sc_sp = (int) ucp->uc_mcontext.gregs[UESP];
82 sc.sc_pc = (int) ucp->uc_mcontext.gregs[EIP];
83 sc.sc_ps = (int) ucp->uc_mcontext.gregs[EFL];
84 sc.sc_eax = (int) ucp->uc_mcontext.gregs[EAX];
85 sc.sc_edx = (int) ucp->uc_mcontext.gregs[EDX];
86
87 /*
88 * Machine dependent code ends
89 */
90
91 if (sip != NULL)
92 if ((code = sip->si_code) == BUS_OBJERR)
93 code = SEGV_MAKE_ERR(sip->si_errno);
94
95 if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || sig == SIGBUS)
96 if (sip != NULL)
97 addr = (char *)sip->si_addr;
98 else
99 addr = SIG_NOADDR;
100
101 (*_siguhandler[sig])(sig, code, &sc, addr);
102
103 if (sc.sc_onstack)
104 ucp->uc_stack.ss_flags |= SS_ONSTACK;
105 else
106 ucp->uc_stack.ss_flags &= ~SS_ONSTACK;
107 mask2set(sc.sc_mask, &ucp->uc_sigmask);
108
109 /*
110 * Machine dependent code begins
111 */
112 ucp->uc_mcontext.gregs[UESP] = (int) sc.sc_sp;
113 ucp->uc_mcontext.gregs[EIP] = (int) sc.sc_pc;
114 ucp->uc_mcontext.gregs[EFL] = (int) sc.sc_ps;
115 ucp->uc_mcontext.gregs[EAX] = (int) sc.sc_eax;
116 ucp->uc_mcontext.gregs[EDX] = (int) sc.sc_edx;
117 /*
118 * Machine dependent code ends
119 */
120
121 setcontext (ucp);
122 }
123
124 int
sigsetmask(int mask)125 sigsetmask(int mask)
126 {
127 sigset_t oset;
128 sigset_t nset;
129
130 (void) sigprocmask(0, (sigset_t *)0, &nset);
131 mask2set(mask, &nset);
132 (void) sigprocmask(SIG_SETMASK, &nset, &oset);
133 return set2mask(&oset);
134 }
135
136 int
sigblock(int mask)137 sigblock(int mask)
138 {
139 sigset_t oset;
140 sigset_t nset;
141
142 (void) sigprocmask(0, (sigset_t *)0, &nset);
143 mask2set(mask, &nset);
144 (void) sigprocmask(SIG_BLOCK, &nset, &oset);
145 return set2mask(&oset);
146 }
147
148 int
sigpause(int mask)149 sigpause(int mask)
150 {
151 sigset_t set;
152
153 (void) sigprocmask(0, (sigset_t *)0, &set);
154 mask2set(mask, &set);
155 return (sigsuspend(&set));
156 }
157
158 int
sigvec(int sig,struct sigvec * nvec,struct sigvec * ovec)159 sigvec(int sig, struct sigvec *nvec, struct sigvec *ovec)
160 {
161 struct sigaction nact;
162 struct sigaction oact;
163 struct sigaction *nactp;
164 void (*ohandler)(), (*nhandler)();
165
166 if (sig <= 0 || sig >= NSIG) {
167 errno = EINVAL;
168 return -1;
169 }
170
171 ohandler = _siguhandler[sig];
172
173 if (nvec) {
174 _sigaction(sig, (struct sigaction *)0, &nact);
175 nhandler = nvec->sv_handler;
176 _siguhandler[sig] = nhandler;
177 if (nhandler != SIG_DFL && nhandler != SIG_IGN)
178 nact.sa_handler = (void (*)())sigvechandler;
179 else
180 nact.sa_handler = nhandler;
181 mask2set(nvec->sv_mask, &nact.sa_mask);
182 /*
183 if ( sig == SIGTSTP || sig == SIGSTOP )
184 nact.sa_handler = SIG_DFL; */
185 nact.sa_flags = SA_SIGINFO;
186 if (!(nvec->sv_flags & SV_INTERRUPT))
187 nact.sa_flags |= SA_RESTART;
188 if (nvec->sv_flags & SV_RESETHAND)
189 nact.sa_flags |= SA_RESETHAND;
190 if (nvec->sv_flags & SV_ONSTACK)
191 nact.sa_flags |= SA_ONSTACK;
192 nactp = &nact;
193 } else
194 nactp = (struct sigaction *)0;
195
196 if (_sigaction(sig, nactp, &oact) < 0) {
197 _siguhandler[sig] = ohandler;
198 return -1;
199 }
200
201 if (ovec) {
202 if (oact.sa_handler == SIG_DFL || oact.sa_handler == SIG_IGN)
203 ovec->sv_handler = oact.sa_handler;
204 else
205 ovec->sv_handler = ohandler;
206 ovec->sv_mask = set2mask(&oact.sa_mask);
207 ovec->sv_flags = 0;
208 if (oact.sa_flags & SA_ONSTACK)
209 ovec->sv_flags |= SV_ONSTACK;
210 if (oact.sa_flags & SA_RESETHAND)
211 ovec->sv_flags |= SV_RESETHAND;
212 if (!(oact.sa_flags & SA_RESTART))
213 ovec->sv_flags |= SV_INTERRUPT;
214 }
215
216 return 0;
217 }
218
219
220 void (*
signal(int s,void (* a)())221 signal(int s, void (*a)()))()
222 {
223 struct sigvec osv;
224 struct sigvec nsv;
225 static int mask[NSIG];
226 static int flags[NSIG];
227
228 nsv.sv_handler = a;
229 nsv.sv_mask = mask[s];
230 nsv.sv_flags = flags[s];
231 if (sigvec(s, &nsv, &osv) < 0)
232 return (SIG_ERR);
233 if (nsv.sv_mask != osv.sv_mask || nsv.sv_flags != osv.sv_flags) {
234 mask[s] = nsv.sv_mask = osv.sv_mask;
235 flags[s] = nsv.sv_flags = osv.sv_flags & ~SV_RESETHAND;
236 if (sigvec(s, &nsv, (struct sigvec *)0) < 0)
237 return (SIG_ERR);
238 }
239 return (osv.sv_handler);
240 }
241