root/compat/hpux/hpux_sig.c

DEFINITIONS

1. hpux_sys_sigvec
2. hpux_sys_sigblock
3. hpux_sys_sigsetmask
4. hpux_sys_sigpause
5. hpux_sys_kill
6. hpux_sys_sigprocmask
7. hpux_sys_sigpending
8. hpux_sys_sigsuspend
9. hpux_sys_sigaction
10. hpuxtobsdsig
11. bsdtohpuxsig
12. hpuxtobsdmask
13. bsdtohpuxmask

    1 /*      $OpenBSD: hpux_sig.c,v 1.9 2004/09/19 21:56:18 mickey Exp $     */
    2 /*      $NetBSD: hpux_sig.c,v 1.16 1997/04/01 19:59:02 scottr Exp $     */
    4 /*
    5  * Copyright (c) 1988 University of Utah.
    6  * Copyright (c) 1990, 1993
    7  *      The Regents of the University of California.  All rights reserved.
    8  *
    9  * This code is derived from software contributed to Berkeley by
   10  * the Systems Programming Group of the University of Utah Computer
   11  * Science Department.
   12  *
   13  * Redistribution and use in source and binary forms, with or without
   14  * modification, are permitted provided that the following conditions
   15  * are met:
   16  * 1. Redistributions of source code must retain the above copyright
   17  *    notice, this list of conditions and the following disclaimer.
   18  * 2. Redistributions in binary form must reproduce the above copyright
   19  *    notice, this list of conditions and the following disclaimer in the
   20  *    documentation and/or other materials provided with the distribution.
   21  * 3. Neither the name of the University nor the names of its contributors
   22  *    may be used to endorse or promote products derived from this software
   23  *    without specific prior written permission.
   24  *
   25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   35  * SUCH DAMAGE.
   36  *
   37  * from: Utah $Hdr: hpux_sig.c 1.4 92/01/20$
   38  *
   39  *      @(#)hpux_sig.c  8.2 (Berkeley) 9/23/93
   40  */
   42 /*
   43  * Signal related HPUX compatibility routines
   44  */
   46 #include <sys/param.h>
   47 #include <sys/systm.h>
   48 #include <sys/kernel.h>
   49 #include <sys/mount.h>
   50 #include <sys/proc.h>
   51 #include <sys/signalvar.h>
   52 #include <sys/syscallargs.h>
   54 #include <compat/hpux/hpux.h>
   55 #include <compat/hpux/hpux_sig.h>
   56 #include <compat/hpux/hpux_syscallargs.h>
   58 /* indexed by HPUX signal number - 1 */
   59 char hpuxtobsdsigmap[NSIG] = {
   60 /*01*/  SIGHUP,  SIGINT, SIGQUIT, SIGILL,   SIGTRAP, SIGIOT,  SIGEMT,   SIGFPE,
   61 /*09*/  SIGKILL, SIGBUS, SIGSEGV, SIGSYS,   SIGPIPE, SIGALRM, SIGTERM,  SIGUSR1,
   62 /*17*/  SIGUSR2, SIGCHLD, 0,      SIGVTALRM,SIGPROF, SIGIO,   SIGWINCH, SIGSTOP,
   63 /*25*/  SIGTSTP, SIGCONT,SIGTTIN, SIGTTOU,  SIGURG,  0,       0,        0
   64 };
   66 /* indexed by BSD signal number - 1 */
   67 char bsdtohpuxsigmap[NSIG] = {
   68 /*01*/   1,  2,  3,  4,  5,  6,  7,  8,
   69 /*09*/   9, 10, 11, 12, 13, 14, 15, 29,
   70 /*17*/  24, 25, 26, 18, 27, 28, 22,  0,
   71 /*25*/   0, 20, 21, 23,  0, 16, 17,  0
   72 };
   74 /*
   75  * XXX: In addition to mapping the signal number we also have
   76  * to see if the "old" style signal mechinism is needed.
   77  * If so, we set the OUSIG flag.  This is not really correct
   78  * as under HP-UX "old" style handling can be set on a per
   79  * signal basis and we are setting it for all signals in one
   80  * swell foop.  I suspect we can get away with this since I
   81  * doubt any program of interest mixes the two semantics.
   82  */
   83 int
hpux_sys_sigvec(p, v, retval)
   85         struct proc *p;
   86         void *v;
register_t *retval;
   88 {
   89         struct hpux_sys_sigvec_args *uap = v;
   90         struct sigvec vec;
   91         struct sigacts *ps = p->p_sigacts;
   92         struct sigvec *sv;
   93         int sig;
   94         int bit, error;
sig = hpuxtobsdsig(SCARG(uap, signo));
   97         if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP)
   98                 return (EINVAL);
sv = &vec;
  100         if (SCARG(uap, osv)) {
sv->sv_handler = ps->ps_sigact[sig];
sv->sv_mask = ps->ps_catchmask[sig];
bit = sigmask(sig);
sv->sv_flags = 0;
  105                 if ((ps->ps_sigonstack & bit) != 0)
sv->sv_flags |= SV_ONSTACK;
  107                 if ((ps->ps_sigintr & bit) != 0)
sv->sv_flags |= SV_INTERRUPT;
  109                 if ((ps->ps_sigreset & bit) != 0)
sv->sv_flags |= HPUXSV_RESET;
sv->sv_mask &= ~bit;
error = copyout((caddr_t)sv, (caddr_t)SCARG(uap, osv),
  113                     sizeof (vec));
  114                 if (error)
  115                         return (error);
  116         }
  117         if (SCARG(uap, nsv)) {
error = copyin((caddr_t)SCARG(uap, nsv), (caddr_t)sv,
  119                     sizeof (vec));
  120                 if (error)
  121                         return (error);
  122                 if (sig == SIGCONT && sv->sv_handler == SIG_IGN)
  123                         return (EINVAL);
sv->sv_flags ^= SA_RESTART;
setsigvec(p, sig, (struct sigaction *)sv);
  126 #if 0
  127 /* XXX -- SOUSIG no longer exists, do something here */
  128                 if (sv->sv_flags & HPUXSV_RESET)
p->p_flag |= SOUSIG;            /* XXX */
  130 #endif
  131         }
  132         return (0);
  133 }
  135 int
hpux_sys_sigblock(p, v, retval)
  137         struct proc *p;
  138         void *v;
register_t *retval;
  140 {
  141         struct hpux_sys_sigblock_args *uap = v;
  143         (void) splhigh();
  144         *retval = bsdtohpuxmask(p->p_sigmask);
p->p_sigmask |= hpuxtobsdmask(SCARG(uap, mask)) &~ sigcantmask;
  146         (void) spl0();
  147         return (0);
  148 }
  150 int
hpux_sys_sigsetmask(p, v, retval)
  152         struct proc *p;
  153         void *v;
register_t *retval;
  155 {
  156         struct hpux_sys_sigsetmask_args *uap = v;
  158         (void) splhigh();
  159         *retval = bsdtohpuxmask(p->p_sigmask);
p->p_sigmask = hpuxtobsdmask(SCARG(uap, mask)) &~ sigcantmask;
  161         (void) spl0();
  162         return (0);
  163 }
  165 int
hpux_sys_sigpause(p, v, retval)
  167         struct proc *p;
  168         void *v;
register_t *retval;
  170 {
  171         struct hpux_sys_sigpause_args *uap = v;
SCARG(uap, mask) = hpuxtobsdmask(SCARG(uap, mask));
  174         return (sys_sigsuspend(p, uap, retval));
  175 }
  177 /* not totally correct, but close enuf' */
  178 int
hpux_sys_kill(p, v, retval)
  180         struct proc *p;
  181         void *v;
register_t *retval;
  183 {
  184         struct hpux_sys_kill_args *uap = v;
  186         if (SCARG(uap, signo)) {
SCARG(uap, signo) = hpuxtobsdsig(SCARG(uap, signo));
  188                 if (SCARG(uap, signo) == 0)
SCARG(uap, signo) = NSIG;
  190         }
  191         return (sys_kill(p, uap, retval));
  192 }
  194 /*
  195  * The following (sigprocmask, sigpending, sigsuspend, sigaction are
  196  * POSIX calls.  Under BSD, the library routine dereferences the sigset_t
  197  * pointers before traping.  Not so under HP-UX.
  198  */
  200 /*
  201  * Manipulate signal mask.
  202  * Note that we receive new mask, not pointer,
  203  * and return old mask as return value;
  204  * the library stub does the rest.
  205  */
  206 int
hpux_sys_sigprocmask(p, v, retval)
  208         struct proc *p;
  209         void *v;
register_t *retval;
  211 {
  212         struct hpux_sys_sigprocmask_args *uap = v;
  213         int mask, error = 0;
hpux_sigset_t sigset;
  216         /*
  217          * Copy out old mask first to ensure no errors.
  218          * (proc sigmask should not be changed if call fails for any reason)
  219          */
  220         if (SCARG(uap, oset)) {
bzero((caddr_t)&sigset, sizeof(sigset));
sigset.sigset[0] = bsdtohpuxmask(p->p_sigmask);
  223                 if (copyout((caddr_t)&sigset, (caddr_t)SCARG(uap, oset),
  224                     sizeof(sigset)))
  225                         return (EFAULT);
  226         }
  227         if (SCARG(uap, set)) {
  228                 if (copyin((caddr_t)SCARG(uap, set), (caddr_t)&sigset,
  229                     sizeof(sigset)))
  230                         return (EFAULT);
mask = hpuxtobsdmask(sigset.sigset[0]);
  232                 (void) splhigh();
  233                 switch (SCARG(uap, how)) {
  234                 case HPUXSIG_BLOCK:
p->p_sigmask |= mask &~ sigcantmask;
  236                         break;
  237                 case HPUXSIG_UNBLOCK:
p->p_sigmask &= ~mask;
  239                         break;
  240                 case HPUXSIG_SETMASK:
p->p_sigmask = mask &~ sigcantmask;
  242                         break;
  243                 default:
error = EINVAL;
  245                         break;
  246                 }
  247                 (void) spl0();
  248         }
  249         return (error);
  250 }
  252 int
hpux_sys_sigpending(p, v, retval)
  254         struct proc *p;
  255         void *v;
register_t *retval;
  257 {
  258         struct hpux_sys_sigpending_args *uap = v;
hpux_sigset_t sigset;
sigset.sigset[0] = bsdtohpuxmask(p->p_siglist);
  262         return (copyout((caddr_t)&sigset, (caddr_t)SCARG(uap, set),
  263             sizeof(sigset)));
  264 }
  266 int
hpux_sys_sigsuspend(p, v, retval)
  268         struct proc *p;
  269         void *v;
register_t *retval;
  271 {
  272         struct hpux_sys_sigsuspend_args *uap = v;
  273         struct sigacts *ps = p->p_sigacts;
hpux_sigset_t sigset;
  275         int mask;
  277         if (copyin((caddr_t)SCARG(uap, set), (caddr_t)&sigset, sizeof(sigset)))
  278                 return (EFAULT);
mask = hpuxtobsdmask(sigset.sigset[0]);
ps->ps_oldmask = p->p_sigmask;
ps->ps_flags |= SAS_OLDMASK;
p->p_sigmask = mask &~ sigcantmask;
  283         (void) tsleep((caddr_t)ps, PPAUSE | PCATCH, "pause", 0);
  284         /* always return EINTR rather than ERESTART... */
  285         return (EINTR);
  286 }
  288 int
hpux_sys_sigaction(p, v, retval)
  290         struct proc *p;
  291         void *v;
register_t *retval;
  293 {
  294         struct hpux_sys_sigaction_args *uap = v;
  295         struct hpux_sigaction action;
  296         struct sigacts *ps = p->p_sigacts;
  297         struct hpux_sigaction *sa;
  298         int sig;
  299         int bit;
sig = hpuxtobsdsig(SCARG(uap, signo));
  302         if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP)
  303                 return (EINVAL);
sa = &action;
  306         if (SCARG(uap, osa)) {
sa->sa__handler = ps->ps_sigact[sig];
bzero((caddr_t)&sa->sa_mask, sizeof(sa->sa_mask));
sa->sa_mask.sigset[0] = bsdtohpuxmask(ps->ps_catchmask[sig]);
bit = sigmask(sig);
sa->sa_flags = 0;
  312                 if ((ps->ps_sigonstack & bit) != 0)
sa->sa_flags |= HPUXSA_ONSTACK;
  314                 if ((ps->ps_sigreset & bit) != 0)
sa->sa_flags |= HPUXSA_RESETHAND;
  316                 if (p->p_flag & P_NOCLDSTOP)
sa->sa_flags |= HPUXSA_NOCLDSTOP;
  318                 if (p->p_flag & P_NOCLDWAIT)
sa->sa_flags |= HPUXSA_NOCLDWAIT;
  320                 if (copyout((caddr_t)sa, (caddr_t)SCARG(uap, osa),
  321                     sizeof (action)))
  322                         return (EFAULT);
  323         }
  324         if (SCARG(uap, nsa)) {
  325                 struct sigaction act;
  327                 if (copyin((caddr_t)SCARG(uap, nsa), (caddr_t)sa,
  328                     sizeof (action)))
  329                         return (EFAULT);
  330                 if (sig == SIGCONT && sa->sa__handler == SIG_IGN)
  331                         return (EINVAL);
  332                 /*
  333                  * Create a sigaction struct for setsigvec
  334                  */
act.sa_handler = sa->sa__handler;
act.sa_mask = hpuxtobsdmask(sa->sa_mask.sigset[0]);
act.sa_flags = SA_RESTART;
  338                 if (sa->sa_flags & HPUXSA_ONSTACK)
act.sa_flags |= SA_ONSTACK;
  340                 if (sa->sa_flags & HPUXSA_NOCLDSTOP)
act.sa_flags |= SA_NOCLDSTOP;
  342                 if (sa->sa_flags & HPUXSA_NOCLDWAIT)
act.sa_flags |= SA_NOCLDWAIT;
setsigvec(p, sig, &act);
  345 #if 0
  346 /* XXX -- SOUSIG no longer exists, do something here */
  347                 if (sa->sa_flags & HPUXSA_RESETHAND)
p->p_flag |= SOUSIG;            /* XXX */
  349 #endif
  350         }
  351         return (0);
  352 }
  354 /* signal numbers: convert from HPUX to BSD */
  355 int
hpuxtobsdsig(sig)
  357         int sig;
  358 {
  359         if (--sig < 0 || sig >= NSIG)
  360                 return(0);
  361         return((int)hpuxtobsdsigmap[sig]);
  362 }
  364 /* signal numbers: convert from BSD to HPUX */
  365 int
bsdtohpuxsig(sig)
  367         int sig;
  368 {
  369         if (--sig < 0 || sig >= NSIG)
  370                 return(0);
  371         return((int)bsdtohpuxsigmap[sig]);
  372 }
  374 /* signal masks: convert from HPUX to BSD (not pretty or fast) */
  375 int
hpuxtobsdmask(mask)
  377         int mask;
  378 {
  379         int nmask, sig, nsig;
  381         if (mask == 0 || mask == -1)
  382                 return(mask);
nmask = 0;
  384         for (sig = 1; sig < NSIG; sig++)
  385                 if ((mask & sigmask(sig)) && (nsig = hpuxtobsdsig(sig)))
nmask |= sigmask(nsig);
  387         return(nmask);
  388 }
  390 int
bsdtohpuxmask(mask)
  392         int mask;
  393 {
  394         int nmask, sig, nsig;
  396         if (mask == 0 || mask == -1)
  397                 return(mask);
nmask = 0;
  399         for (sig = 1; sig < NSIG; sig++)
  400                 if ((mask & sigmask(sig)) && (nsig = bsdtohpuxsig(sig)))
nmask |= sigmask(nsig);
  402         return(nmask);
  403 }