usr/src/cmd/csh/i386/signal.c

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