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