usr/src/ucblib/libucb/sparc/sys/signal.c

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