1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 * Portions of this source code were derived from Berkeley 4.3 BSD
32 * under license from the Regents of the University of California.
33 */
34
35 /*
36 * 4.3BSD signal compatibility functions
37 *
38 * the implementation interprets signal masks equal to -1 as "all of the
39 * signals in the signal set", thereby allowing signals with numbers
40 * above 32 to be blocked when referenced in code such as:
41 *
42 * for (i = 0; i < NSIG; i++)
43 * mask |= sigmask(i)
44 */
45
46 #include <sys/types.h>
47 #include <ucontext.h>
48 #include <signal.h>
49 #include <errno.h>
50
51 #undef BUS_OBJERR /* namespace conflict */
52 #include <sys/siginfo.h>
53 #include "libc.h"
54
55 #pragma weak sigvechandler = _sigvechandler
56 #pragma weak sigsetmask = _sigsetmask
57 #pragma weak sigblock = _sigblock
58 #pragma weak sigpause = usigpause
59 #pragma weak sigvec = _sigvec
60 #pragma weak sigstack = _sigstack
61 #pragma weak signal = usignal
62 #pragma weak siginterrupt = _siginterrupt
63
64 /*
65 * DO NOT remove the _ from these 3 functions or the subsequent
66 * calls to them below. The non _ versions of these functions
67 * are the wrong functions to call. This is BCP. Extra
68 * care should be taken when modifying this code.
69 */
70 extern int _sigfillset(sigset_t *);
71 extern int _sigemptyset(sigset_t *);
72 extern int _sigprocmask(int, const sigset_t *, sigset_t *);
73
74 #define set2mask(setp) ((setp)->__sigbits[0])
75 #define mask2set(mask, setp) \
76 ((mask) == -1 ? _sigfillset(setp) : \
77 ((void) _sigemptyset(setp), (((setp)->__sigbits[0]) = (int)(mask))))
78
79 void (*_siguhandler[NSIG])() = { 0 };
80
81 /*
82 * forward declarations
83 */
84 int ucbsiginterrupt(int, int);
85 int ucbsigvec(int, struct sigvec *, struct sigvec *);
86 int ucbsigpause(int);
87 int ucbsigblock(int);
88 int ucbsigsetmask(int);
89 static void ucbsigvechandler(int, siginfo_t *, ucontext_t *);
90
91 /*
92 * sigvechandler is the real signal handler installed for all
93 * signals handled in the 4.3BSD compatibility interface - it translates
94 * SVR4 signal hander arguments into 4.3BSD signal handler arguments
95 * and then calls the real handler
96 */
97
98 int
_sigvechandler(int sig,siginfo_t * sip,ucontext_t * ucp)99 _sigvechandler(int sig, siginfo_t *sip, ucontext_t *ucp)
100 {
101 ucbsigvechandler(sig, sip, ucp);
102 return (0); /* keep the same as the original prototype */
103 }
104
105 static void
ucbsigvechandler(int sig,siginfo_t * sip,ucontext_t * ucp)106 ucbsigvechandler(int sig, siginfo_t *sip, ucontext_t *ucp)
107 {
108 struct sigcontext sc;
109 int code;
110 char *addr;
111 #ifdef NEVER
112 int gwinswitch = 0;
113 #endif
114
115 sc.sc_onstack = ((ucp->uc_stack.ss_flags & SS_ONSTACK) != 0);
116 sc.sc_mask = set2mask(&ucp->uc_sigmask);
117
118 #if defined(__sparc)
119 if (sig == SIGFPE && sip != NULL && SI_FROMKERNEL(sip) &&
120 (sip->si_code == FPE_INTDIV || sip->si_code == FPE_INTOVF)) {
121 /*
122 * Hack to emulate the 4.x kernel behavior of incrementing
123 * the PC on integer divide by zero and integer overflow
124 * on sparc machines. (5.x does not increment the PC.)
125 */
126 ucp->uc_mcontext.gregs[REG_PC] =
127 ucp->uc_mcontext.gregs[REG_nPC];
128 ucp->uc_mcontext.gregs[REG_nPC] += 4;
129 }
130 sc.sc_sp = ucp->uc_mcontext.gregs[REG_SP];
131 sc.sc_pc = ucp->uc_mcontext.gregs[REG_PC];
132 sc.sc_npc = ucp->uc_mcontext.gregs[REG_nPC];
133
134 /* XX64 There is no REG_PSR for sparcv9, we map in REG_CCR for now */
135 #if defined(__sparcv9)
136 sc.sc_psr = ucp->uc_mcontext.gregs[REG_CCR];
137 #else
138 sc.sc_psr = ucp->uc_mcontext.gregs[REG_PSR];
139 #endif
140
141 sc.sc_g1 = ucp->uc_mcontext.gregs[REG_G1];
142 sc.sc_o0 = ucp->uc_mcontext.gregs[REG_O0];
143
144 /*
145 * XXX - What a kludge!
146 * Store a pointer to the original ucontext_t in the sigcontext
147 * so that it's available to the sigcleanup call that needs to
148 * return from the signal handler. Otherwise, vital information
149 * (e.g., the "out" registers) that's only saved in the
150 * ucontext_t isn't available to sigcleanup.
151 */
152 sc.sc_wbcnt = (int)(sizeof (*ucp));
153 sc.sc_spbuf[0] = (char *)(uintptr_t)sig;
154 sc.sc_spbuf[1] = (char *)ucp;
155 #ifdef NEVER
156 /*
157 * XXX - Sorry, we can never pass the saved register windows
158 * on in the sigcontext because we use that space to save the
159 * ucontext_t.
160 */
161 if (ucp->uc_mcontext.gwins != (gwindows_t *)0) {
162 int i, j;
163
164 gwinswitch = 1;
165 sc.sc_wbcnt = ucp->uc_mcontext.gwins->wbcnt;
166 /* XXX - should use bcopy to move this in bulk */
167 for (i = 0; i < ucp->uc_mcontext.gwins; i++) {
168 sc.sc_spbuf[i] = ucp->uc_mcontext.gwins->spbuf[i];
169 for (j = 0; j < 8; j++)
170 sc.sc_wbuf[i][j] =
171 ucp->uc_mcontext.gwins->wbuf[i].rw_local[j];
172 for (j = 0; j < 8; j++)
173 sc.sc_wbuf[i][j+8] =
174 ucp->uc_mcontext.gwins->wbuf[i].rw_in[j];
175 }
176 }
177 #endif
178 #endif
179
180 /*
181 * Translate signal codes from new to old.
182 * /usr/include/sys/siginfo.h contains new codes.
183 * /usr/ucbinclude/sys/signal.h contains old codes.
184 */
185 code = 0;
186 addr = SIG_NOADDR;
187 if (sip != NULL && SI_FROMKERNEL(sip)) {
188 addr = sip->si_addr;
189
190 switch (sig) {
191 case SIGILL:
192 switch (sip->si_code) {
193 case ILL_PRVOPC:
194 code = ILL_PRIVINSTR_FAULT;
195 break;
196 case ILL_BADSTK:
197 code = ILL_STACK;
198 break;
199 case ILL_ILLTRP:
200 code = ILL_TRAP_FAULT(sip->si_trapno);
201 break;
202 default:
203 code = ILL_ILLINSTR_FAULT;
204 break;
205 }
206 break;
207
208 case SIGEMT:
209 code = EMT_TAG;
210 break;
211
212 case SIGFPE:
213 switch (sip->si_code) {
214 case FPE_INTDIV:
215 code = FPE_INTDIV_TRAP;
216 break;
217 case FPE_INTOVF:
218 code = FPE_INTOVF_TRAP;
219 break;
220 case FPE_FLTDIV:
221 code = FPE_FLTDIV_TRAP;
222 break;
223 case FPE_FLTOVF:
224 code = FPE_FLTOVF_TRAP;
225 break;
226 case FPE_FLTUND:
227 code = FPE_FLTUND_TRAP;
228 break;
229 case FPE_FLTRES:
230 code = FPE_FLTINEX_TRAP;
231 break;
232 default:
233 code = FPE_FLTOPERR_TRAP;
234 break;
235 }
236 break;
237
238 case SIGBUS:
239 switch (sip->si_code) {
240 case BUS_ADRALN:
241 code = BUS_ALIGN;
242 break;
243 case BUS_ADRERR:
244 code = BUS_HWERR;
245 break;
246 default: /* BUS_OBJERR */
247 code = FC_MAKE_ERR(sip->si_errno);
248 break;
249 }
250 break;
251
252 case SIGSEGV:
253 switch (sip->si_code) {
254 case SEGV_MAPERR:
255 code = SEGV_NOMAP;
256 break;
257 case SEGV_ACCERR:
258 code = SEGV_PROT;
259 break;
260 default:
261 code = FC_MAKE_ERR(sip->si_errno);
262 break;
263 }
264 break;
265
266 default:
267 addr = SIG_NOADDR;
268 break;
269 }
270 }
271
272 (*_siguhandler[sig])(sig, code, &sc, addr);
273
274 if (sc.sc_onstack)
275 ucp->uc_stack.ss_flags |= SS_ONSTACK;
276 else
277 ucp->uc_stack.ss_flags &= ~SS_ONSTACK;
278 mask2set(sc.sc_mask, &ucp->uc_sigmask);
279
280 #if defined(__sparc)
281 ucp->uc_mcontext.gregs[REG_SP] = sc.sc_sp;
282 ucp->uc_mcontext.gregs[REG_PC] = sc.sc_pc;
283 ucp->uc_mcontext.gregs[REG_nPC] = sc.sc_npc;
284 #if defined(__sparcv9)
285 ucp->uc_mcontext.gregs[REG_CCR] = sc.sc_psr;
286 #else
287 ucp->uc_mcontext.gregs[REG_PSR] = sc.sc_psr;
288 #endif
289 ucp->uc_mcontext.gregs[REG_G1] = sc.sc_g1;
290 ucp->uc_mcontext.gregs[REG_O0] = sc.sc_o0;
291 #ifdef NEVER
292 if (gwinswitch == 1) {
293 int i, j;
294
295 ucp->uc_mcontext.gwins->wbcnt = sc.sc_wbcnt;
296 /* XXX - should use bcopy to move this in bulk */
297 for (i = 0; i < sc.sc_wbcnt; i++) {
298 ucp->uc_mcontext.gwins->spbuf[i] = sc.sc_spbuf[i];
299 for (j = 0; j < 8; j++)
300 ucp->uc_mcontext.gwins->wbuf[i].rw_local[j] =
301 sc.sc_wbuf[i][j];
302 for (j = 0; j < 8; j++)
303 ucp->uc_mcontext.gwins->wbuf[i].rw_in[j] =
304 sc.sc_wbuf[i][j+8];
305 }
306 }
307 #endif
308
309 if (sig == SIGFPE) {
310 if (ucp->uc_mcontext.fpregs.fpu_qcnt > 0) {
311 ucp->uc_mcontext.fpregs.fpu_qcnt--;
312 ucp->uc_mcontext.fpregs.fpu_q++;
313 }
314 }
315 #endif
316
317 (void) setcontext(ucp);
318 }
319
320 #if defined(__sparc)
321 /*
322 * Emulate the special sigcleanup trap.
323 * This is only used by statically linked 4.x applications
324 * and thus is only called by the static BCP support.
325 * It lives here because of its close relationship with
326 * the ucbsigvechandler code above.
327 *
328 * It's used by 4.x applications to:
329 * 1. return from a signal handler (in __sigtramp)
330 * 2. [sig]longjmp
331 * 3. context switch, in the old 4.x liblwp
332 */
333
334 void
__sigcleanup(struct sigcontext * scp)335 __sigcleanup(struct sigcontext *scp)
336 {
337 ucontext_t uc, *ucp;
338 int sig;
339
340 /*
341 * If there's a pointer to a ucontext_t hiding in the sigcontext,
342 * we *must* use that to return, since it contains important data
343 * such as the original "out" registers when the signal occurred.
344 */
345 if (scp->sc_wbcnt == sizeof (*ucp)) {
346 sig = (int)(uintptr_t)scp->sc_spbuf[0];
347 ucp = (ucontext_t *)scp->sc_spbuf[1];
348 } else {
349 /*
350 * Otherwise, use a local ucontext_t and
351 * initialize it with getcontext.
352 */
353 sig = 0;
354 ucp = &uc;
355 (void) getcontext(ucp);
356 }
357
358 if (scp->sc_onstack) {
359 ucp->uc_stack.ss_flags |= SS_ONSTACK;
360 } else
361 ucp->uc_stack.ss_flags &= ~SS_ONSTACK;
362 mask2set(scp->sc_mask, &ucp->uc_sigmask);
363
364 ucp->uc_mcontext.gregs[REG_SP] = scp->sc_sp;
365 ucp->uc_mcontext.gregs[REG_PC] = scp->sc_pc;
366 ucp->uc_mcontext.gregs[REG_nPC] = scp->sc_npc;
367 #if defined(__sparcv9)
368 ucp->uc_mcontext.gregs[REG_CCR] = scp->sc_psr;
369 #else
370 ucp->uc_mcontext.gregs[REG_PSR] = scp->sc_psr;
371 #endif
372 ucp->uc_mcontext.gregs[REG_G1] = scp->sc_g1;
373 ucp->uc_mcontext.gregs[REG_O0] = scp->sc_o0;
374
375 if (sig == SIGFPE) {
376 if (ucp->uc_mcontext.fpregs.fpu_qcnt > 0) {
377 ucp->uc_mcontext.fpregs.fpu_qcnt--;
378 ucp->uc_mcontext.fpregs.fpu_q++;
379 }
380 }
381 (void) setcontext(ucp);
382 /* NOTREACHED */
383 }
384 #endif
385
386 int
_sigsetmask(int mask)387 _sigsetmask(int mask)
388 {
389 return (ucbsigsetmask(mask));
390 }
391
392 int
ucbsigsetmask(int mask)393 ucbsigsetmask(int mask)
394 {
395 sigset_t oset;
396 sigset_t nset;
397
398 (void) _sigprocmask(0, (sigset_t *)0, &nset);
399 mask2set(mask, &nset);
400 (void) _sigprocmask(SIG_SETMASK, &nset, &oset);
401 return (set2mask(&oset));
402 }
403
404 int
_sigblock(int mask)405 _sigblock(int mask)
406 {
407 return (ucbsigblock(mask));
408 }
409
410 int
ucbsigblock(int mask)411 ucbsigblock(int mask)
412 {
413 sigset_t oset;
414 sigset_t nset;
415
416 (void) _sigprocmask(0, (sigset_t *)0, &nset);
417 mask2set(mask, &nset);
418 (void) _sigprocmask(SIG_BLOCK, &nset, &oset);
419 return (set2mask(&oset));
420 }
421
422 int
usigpause(int mask)423 usigpause(int mask)
424 {
425 return (ucbsigpause(mask));
426 }
427
428 int
ucbsigpause(int mask)429 ucbsigpause(int mask)
430 {
431 sigset_t set, oset;
432 int ret;
433
434 (void) _sigprocmask(0, (sigset_t *)0, &set);
435 oset = set;
436 mask2set(mask, &set);
437 ret = sigsuspend(&set);
438 (void) _sigprocmask(SIG_SETMASK, &oset, (sigset_t *)0);
439 return (ret);
440 }
441
442 int
_sigvec(int sig,struct sigvec * nvec,struct sigvec * ovec)443 _sigvec(int sig, struct sigvec *nvec, struct sigvec *ovec)
444 {
445 return (ucbsigvec(sig, nvec, ovec));
446 }
447
448 int
ucbsigvec(int sig,struct sigvec * nvec,struct sigvec * ovec)449 ucbsigvec(int sig, struct sigvec *nvec, struct sigvec *ovec)
450 {
451 struct sigaction nact;
452 struct sigaction oact;
453 struct sigaction *nactp;
454 void (*ohandler)(int, int, struct sigcontext *, char *);
455 void (*nhandler)(int, int, struct sigcontext *, char *);
456
457 if (sig <= 0 || sig >= NSIG) {
458 errno = EINVAL;
459 return (-1);
460 }
461
462 if ((long)ovec == -1L || (long)nvec == -1L) {
463 errno = EFAULT;
464 return (-1);
465 }
466
467 ohandler = _siguhandler[sig];
468
469 if (nvec) {
470 (void) _sigaction(sig, (struct sigaction *)0, &nact);
471 nhandler = nvec->sv_handler;
472 /*
473 * To be compatible with the behavior of SunOS 4.x:
474 * If the new signal handler is SIG_IGN or SIG_DFL,
475 * do not change the signal's entry in the handler array.
476 * This allows a child of vfork(2) to set signal handlers
477 * to SIG_IGN or SIG_DFL without affecting the parent.
478 */
479 if ((void (*)(int))(uintptr_t)nhandler != SIG_DFL &&
480 (void (*)(int))(uintptr_t)nhandler != SIG_IGN) {
481 _siguhandler[sig] = nhandler;
482 nact.sa_handler =
483 (void (*)(int))(uintptr_t)ucbsigvechandler;
484 } else {
485 nact.sa_handler = (void (*)(int))(uintptr_t)nhandler;
486 }
487 mask2set(nvec->sv_mask, &nact.sa_mask);
488 if (sig == SIGKILL || sig == SIGSTOP)
489 nact.sa_handler = SIG_DFL;
490 nact.sa_flags = SA_SIGINFO;
491 if (!(nvec->sv_flags & SV_INTERRUPT))
492 nact.sa_flags |= SA_RESTART;
493 if (nvec->sv_flags & SV_RESETHAND)
494 nact.sa_flags |= SA_RESETHAND;
495 if (nvec->sv_flags & SV_ONSTACK)
496 nact.sa_flags |= SA_ONSTACK;
497 nactp = &nact;
498 } else
499 nactp = (struct sigaction *)0;
500
501 if (_sigaction(sig, nactp, &oact) < 0) {
502 _siguhandler[sig] = ohandler;
503 return (-1);
504 }
505
506 if (ovec) {
507 if (oact.sa_handler == SIG_DFL || oact.sa_handler == SIG_IGN)
508 ovec->sv_handler =
509 (void (*) (int, int, struct sigcontext *, char *))
510 oact.sa_handler;
511 else
512 ovec->sv_handler = ohandler;
513 ovec->sv_mask = set2mask(&oact.sa_mask);
514 ovec->sv_flags = 0;
515 if (oact.sa_flags & SA_ONSTACK)
516 ovec->sv_flags |= SV_ONSTACK;
517 if (oact.sa_flags & SA_RESETHAND)
518 ovec->sv_flags |= SV_RESETHAND;
519 if (!(oact.sa_flags & SA_RESTART))
520 ovec->sv_flags |= SV_INTERRUPT;
521 }
522
523 return (0);
524 }
525
526 int
_sigstack(struct sigstack * nss,struct sigstack * oss)527 _sigstack(struct sigstack *nss, struct sigstack *oss)
528 {
529 struct sigaltstack nalt;
530 struct sigaltstack oalt;
531 struct sigaltstack *naltp;
532
533 if (nss) {
534 /*
535 * XXX: assumes stack growth is down (like sparc)
536 */
537 nalt.ss_sp = nss->ss_sp - SIGSTKSZ;
538 nalt.ss_size = SIGSTKSZ;
539 nalt.ss_flags = 0;
540 naltp = &nalt;
541 } else
542 naltp = (struct sigaltstack *)0;
543
544 if (sigaltstack(naltp, &oalt) < 0)
545 return (-1);
546
547 if (oss) {
548 /*
549 * XXX: assumes stack growth is down (like sparc)
550 */
551 oss->ss_sp = oalt.ss_sp + oalt.ss_size;
552 oss->ss_onstack = ((oalt.ss_flags & SS_ONSTACK) != 0);
553 }
554
555 return (0);
556 }
557
558 void (*
ucbsignal(int s,void (* a)(int))559 ucbsignal(int s, void (*a)(int)))(int)
560 {
561 struct sigvec osv;
562 struct sigvec nsv;
563 static int mask[NSIG];
564 static int flags[NSIG];
565
566 nsv.sv_handler =
567 (void (*) (int, int, struct sigcontext *, char *))(uintptr_t)a;
568 nsv.sv_mask = mask[s];
569 nsv.sv_flags = flags[s];
570 if (ucbsigvec(s, &nsv, &osv) < 0)
571 return (SIG_ERR);
572 if (nsv.sv_mask != osv.sv_mask || nsv.sv_flags != osv.sv_flags) {
573 mask[s] = nsv.sv_mask = osv.sv_mask;
574 flags[s] = nsv.sv_flags =
575 osv.sv_flags & ~(SV_RESETHAND|SV_INTERRUPT);
576 if (ucbsigvec(s, &nsv, (struct sigvec *)0) < 0)
577 return (SIG_ERR);
578 }
579 return ((void (*) (int)) osv.sv_handler);
580 }
581
582 void (*
usignal(int s,void (* a)(int))583 usignal(int s, void (*a) (int)))(int)
584 {
585 return (ucbsignal(s, a));
586 }
587
588 /*
589 * Set signal state to prevent restart of system calls
590 * after an instance of the indicated signal.
591 */
592
593 int
_siginterrupt(int sig,int flag)594 _siginterrupt(int sig, int flag)
595 {
596 return (ucbsiginterrupt(sig, flag));
597 }
598
599 int
ucbsiginterrupt(int sig,int flag)600 ucbsiginterrupt(int sig, int flag)
601 {
602 struct sigvec sv;
603 int ret;
604
605 if ((ret = ucbsigvec(sig, 0, &sv)) < 0)
606 return (ret);
607 if (flag)
608 sv.sv_flags |= SV_INTERRUPT;
609 else
610 sv.sv_flags &= ~SV_INTERRUPT;
611 return (ucbsigvec(sig, &sv, 0));
612 }
613