root/compat/ibcs2/ibcs2_signal.c

DEFINITIONS

1. ibcs2_to_bsd_sigset
2. bsd_to_ibcs2_sigset
3. ibcs2_to_bsd_sigaction
4. bsd_to_ibcs2_sigaction
5. ibcs2_sys_sigaction
6. ibcs2_sys_sigsys
7. ibcs2_sys_sigprocmask
8. ibcs2_sys_sigpending
9. ibcs2_sys_sigsuspend
10. ibcs2_sys_pause
11. ibcs2_sys_kill

    1 /*      $OpenBSD: ibcs2_signal.c,v 1.7 2002/03/14 01:26:50 millert Exp $        */
    2 /*      $NetBSD: ibcs2_signal.c,v 1.8 1996/05/03 17:05:27 christos Exp $        */
    4 /*
    5  * Copyright (c) 1995 Scott Bartram
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. The name of the author may not be used to endorse or promote products
   17  *    derived from this software without specific prior written permission
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   29  */
   31 #include <sys/param.h>
   32 #include <sys/systm.h>
   33 #include <sys/namei.h>
   34 #include <sys/proc.h>
   35 #include <sys/filedesc.h>
   36 #include <sys/ioctl.h>
   37 #include <sys/mount.h>
   38 #include <sys/kernel.h>
   39 #include <sys/signal.h>
   40 #include <sys/signalvar.h>
   41 #include <sys/malloc.h>
   43 #include <sys/syscallargs.h>
   45 #include <compat/ibcs2/ibcs2_types.h>
   46 #include <compat/ibcs2/ibcs2_signal.h>
   47 #include <compat/ibcs2/ibcs2_syscallargs.h>
   48 #include <compat/ibcs2/ibcs2_util.h>
   50 #define sigemptyset(s)          bzero((s), sizeof(*(s)))
   51 #define sigismember(s, n)       (*(s) & sigmask(n))
   52 #define sigaddset(s, n)         (*(s) |= sigmask(n))
   54 #define ibcs2_sigmask(n)        (1 << ((n) - 1))
   55 #define ibcs2_sigemptyset(s)    bzero((s), sizeof(*(s)))
   56 #define ibcs2_sigismember(s, n) (*(s) & ibcs2_sigmask(n))
   57 #define ibcs2_sigaddset(s, n)   (*(s) |= ibcs2_sigmask(n))
   59 int bsd_to_ibcs2_sig[] = {
   60         0,                      /* 0 */
IBCS2_SIGHUP,           /* 1 */
IBCS2_SIGINT,           /* 2 */
IBCS2_SIGQUIT,          /* 3 */
IBCS2_SIGILL,           /* 4 */
IBCS2_SIGTRAP,          /* 5 */
IBCS2_SIGABRT,          /* 6 */
IBCS2_SIGEMT,           /* 7 */
IBCS2_SIGFPE,           /* 8 */
IBCS2_SIGKILL,          /* 9 */
IBCS2_SIGBUS,           /* 10 */
IBCS2_SIGSEGV,          /* 11 */
IBCS2_SIGSYS,           /* 12 */
IBCS2_SIGPIPE,          /* 13 */
IBCS2_SIGALRM,          /* 14 */
IBCS2_SIGTERM,          /* 15 */
   76         0,                      /* 16 - SIGURG */
IBCS2_SIGSTOP,          /* 17 */
IBCS2_SIGTSTP,          /* 18 */
IBCS2_SIGCONT,          /* 19 */
IBCS2_SIGCLD,           /* 20 */
IBCS2_SIGTTIN,          /* 21 */
IBCS2_SIGTTOU,          /* 22 */
IBCS2_SIGPOLL,          /* 23 */
   84         0,                      /* 24 - SIGXCPU */
   85         0,                      /* 25 - SIGXFSZ */
IBCS2_SIGVTALRM,        /* 26 */
IBCS2_SIGPROF,          /* 27 */
IBCS2_SIGWINCH,         /* 28 */
   89         0,                      /* 29 */
IBCS2_SIGUSR1,          /* 30 */
IBCS2_SIGUSR2,          /* 31 */
   92 };
   94 int ibcs2_to_bsd_sig[] = {
   95         0,                      /* 0 */
SIGHUP,                 /* 1 */
SIGINT,                 /* 2 */
SIGQUIT,                /* 3 */
SIGILL,                 /* 4 */
SIGTRAP,                /* 5 */
SIGABRT,                /* 6 */
SIGEMT,                 /* 7 */
SIGFPE,                 /* 8 */
SIGKILL,                /* 9 */
SIGBUS,                 /* 10 */
SIGSEGV,                /* 11 */
SIGSYS,                 /* 12 */
SIGPIPE,                /* 13 */
SIGALRM,                /* 14 */
SIGTERM,                /* 15 */
SIGUSR1,                /* 16 */
SIGUSR2,                /* 17 */
SIGCHLD,                /* 18 */
  114         0,                      /* 19 - SIGPWR */
SIGWINCH,               /* 20 */
  116         0,                      /* 21 */
SIGIO,                  /* 22 */
SIGSTOP,                /* 23 */
SIGTSTP,                /* 24 */
SIGCONT,                /* 25 */
SIGTTIN,                /* 26 */
SIGTTOU,                /* 27 */
SIGVTALRM,              /* 28 */
SIGPROF,                /* 29 */
  125         0,                      /* 30 */
  126         0,                      /* 31 */
  127 };
  129 void ibcs2_to_bsd_sigset(const ibcs2_sigset_t *, sigset_t *);
  130 void bsd_to_ibcs2_sigset(const sigset_t *, ibcs2_sigset_t *);
  131 void ibcs2_to_bsd_sigaction(struct ibcs2_sigaction *,
  132     struct sigaction *);
  133 void bsd_to_ibcs2_sigaction(struct sigaction *, struct ibcs2_sigaction *);
  135 void
ibcs2_to_bsd_sigset(iss, bss)
  137         const ibcs2_sigset_t *iss;
sigset_t *bss;
  139 {
  140         int i, newsig;
sigemptyset(bss);
  143         for (i = 1; i < IBCS2_NSIG; i++) {
  144                 if (ibcs2_sigismember(iss, i)) {
newsig = ibcs2_to_bsd_sig[i];
  146                         if (newsig)
sigaddset(bss, newsig);
  148                 }
  149         }
  150 }
  152 void
bsd_to_ibcs2_sigset(bss, iss)
  154         const sigset_t *bss;
ibcs2_sigset_t *iss;
  156 {
  157         int i, newsig;
ibcs2_sigemptyset(iss);
  160         for (i = 1; i < NSIG; i++) {
  161                 if (sigismember(bss, i)) {
newsig = bsd_to_ibcs2_sig[i];
  163                         if (newsig)
ibcs2_sigaddset(iss, newsig);
  165                 }
  166         }
  167 }
  169 void
ibcs2_to_bsd_sigaction(isa, bsa)
  171         struct ibcs2_sigaction *isa;
  172         struct sigaction *bsa;
  173 {
bsa->sa_handler = isa->sa__handler;
ibcs2_to_bsd_sigset(&isa->sa_mask, &bsa->sa_mask);
bsa->sa_flags = 0;
  178         if ((isa->sa_flags & IBCS2_SA_NOCLDSTOP) != 0)
bsa->sa_flags |= SA_NOCLDSTOP;
  180 }
  182 void
bsd_to_ibcs2_sigaction(bsa, isa)
  184         struct sigaction *bsa;
  185         struct ibcs2_sigaction *isa;
  186 {
isa->sa__handler = bsa->sa_handler;
bsd_to_ibcs2_sigset(&bsa->sa_mask, &isa->sa_mask);
isa->sa_flags = 0;
  191         if ((bsa->sa_flags & SA_NOCLDSTOP) != 0)
isa->sa_flags |= IBCS2_SA_NOCLDSTOP;
  193 }
  195 int
ibcs2_sys_sigaction(p, v, retval)
  197         register struct proc *p;
  198         void *v;
register_t *retval;
  200 {
  201         struct ibcs2_sys_sigaction_args /* {
  202                 syscallarg(int) signum;
  203                 syscallarg(struct ibcs2_sigaction *) nsa;
  204                 syscallarg(struct ibcs2_sigaction *) osa;
  205         } */ *uap = v;
  206         struct ibcs2_sigaction *nisa, *oisa, tmpisa;
  207         struct sigaction *nbsa, *obsa, tmpbsa;
  208         struct sys_sigaction_args sa;
caddr_t sg;
  210         int error;
  212         if (SCARG(uap, signum) < 0 || SCARG(uap, signum) >= IBCS2_NSIG)
  213                 return (EINVAL);
sg = stackgap_init(p->p_emul);
nisa = SCARG(uap, nsa);
oisa = SCARG(uap, osa);
  219         if (oisa != NULL)
obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
  221         else
obsa = NULL;
  224         if (nisa != NULL) {
nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
  226                 if ((error = copyin(nisa, &tmpisa, sizeof(tmpisa))) != 0)
  227                         return error;
ibcs2_to_bsd_sigaction(&tmpisa, &tmpbsa);
  229                 if ((error = copyout(&tmpbsa, nbsa, sizeof(tmpbsa))) != 0)
  230                         return error;
  231         } else
nbsa = NULL;
SCARG(&sa, signum) = ibcs2_to_bsd_sig[SCARG(uap, signum)];
SCARG(&sa, nsa) = nbsa;
SCARG(&sa, osa) = obsa;
  238         if ((error = sys_sigaction(p, &sa, retval)) != 0)
  239                 return error;
  241         if (oisa != NULL) {
  242                 if ((error = copyin(obsa, &tmpbsa, sizeof(tmpbsa))) != 0)
  243                         return error;
bsd_to_ibcs2_sigaction(&tmpbsa, &tmpisa);
  245                 if ((error = copyout(&tmpisa, oisa, sizeof(tmpisa))) != 0)
  246                         return error;
  247         }
  249         return 0;
  250 }
  252 int
ibcs2_sys_sigsys(p, v, retval)
  254         register struct proc *p;
  255         void *v;
register_t *retval;
  257 {
  258         struct ibcs2_sys_sigsys_args /* {
  259                 syscallarg(int) sig;
  260                 syscallarg(ibcs2_sig_t) fp;
  261         } */ *uap = v;
  262         int signum, error;
caddr_t sg = stackgap_init(p->p_emul);
signum = IBCS2_SIGNO(SCARG(uap, sig));
  266         if (signum < 0 || signum >= IBCS2_NSIG) {
  267                 if (IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGNAL_MASK ||
IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGSET_MASK)
  269                         *retval = (int)IBCS2_SIG_ERR;
  270                 return EINVAL;
  271         }
signum = ibcs2_to_bsd_sig[signum];
  274         switch (IBCS2_SIGCALL(SCARG(uap, sig))) {
  275         /*
  276          * sigset is identical to signal() except that SIG_HOLD is allowed as
  277          * an action.
  278          */
  279         case IBCS2_SIGSET_MASK:
  280                 /*
  281                  * sigset is identical to signal() except
  282                  * that SIG_HOLD is allowed as
  283                  * an action.
  284                  */
  285                 if (SCARG(uap, fp) == IBCS2_SIG_HOLD) {
  286                         struct sys_sigprocmask_args sa;
SCARG(&sa, how) = SIG_BLOCK;
SCARG(&sa, mask) = sigmask(signum);
  290                         return sys_sigprocmask(p, &sa, retval);
  291                 }
  292                 /* FALLTHROUGH */
  294         case IBCS2_SIGNAL_MASK:
  295                 {
  296                         struct sys_sigaction_args sa_args;
  297                         struct sigaction *nbsa, *obsa, sa;
nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
SCARG(&sa_args, signum) = signum;
SCARG(&sa_args, nsa) = nbsa;
SCARG(&sa_args, osa) = obsa;
sa.sa_handler = SCARG(uap, fp);
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
  308 #if 0
  309                         if (signum != SIGALRM)
sa.sa_flags = SA_RESTART;
  311 #endif
  312                         if ((error = copyout(&sa, nbsa, sizeof(sa))) != 0)
  313                                 return error;
  314                         if ((error = sys_sigaction(p, &sa_args, retval)) != 0) {
DPRINTF(("signal: sigaction failed: %d\n",
error));
  317                                 *retval = (int)IBCS2_SIG_ERR;
  318                                 return error;
  319                         }
  320                         if ((error = copyin(obsa, &sa, sizeof(sa))) != 0)
  321                                 return error;
  322                         *retval = (int)sa.sa_handler;
  323                         return 0;
  324                 }
  326         case IBCS2_SIGHOLD_MASK:
  327                 {
  328                         struct sys_sigprocmask_args sa;
SCARG(&sa, how) = SIG_BLOCK;
SCARG(&sa, mask) = sigmask(signum);
  332                         return sys_sigprocmask(p, &sa, retval);
  333                 }
  335         case IBCS2_SIGRELSE_MASK:
  336                 {
  337                         struct sys_sigprocmask_args sa;
SCARG(&sa, how) = SIG_UNBLOCK;
SCARG(&sa, mask) = sigmask(signum);
  341                         return sys_sigprocmask(p, &sa, retval);
  342                 }
  344         case IBCS2_SIGIGNORE_MASK:
  345                 {
  346                         struct sys_sigaction_args sa_args;
  347                         struct sigaction *bsa, sa;
bsa = stackgap_alloc(&sg, sizeof(struct sigaction));
SCARG(&sa_args, signum) = signum;
SCARG(&sa_args, nsa) = bsa;
SCARG(&sa_args, osa) = NULL;
sa.sa_handler = SIG_IGN;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
  357                         if ((error = copyout(&sa, bsa, sizeof(sa))) != 0)
  358                                 return error;
  359                         if ((error = sys_sigaction(p, &sa_args, retval)) != 0) {
DPRINTF(("sigignore: sigaction failed\n"));
  361                                 return error;
  362                         }
  363                         return 0;
  364                 }
  366         case IBCS2_SIGPAUSE_MASK:
  367                 {
  368                         struct sys_sigsuspend_args sa;
SCARG(&sa, mask) = p->p_sigmask &~ sigmask(signum);
  371                         return sys_sigsuspend(p, &sa, retval);
  372                 }
  374         default:
  375                 return ENOSYS;
  376         }
  377 }
  379 int
ibcs2_sys_sigprocmask(p, v, retval)
  381         register struct proc *p;
  382         void *v;
register_t *retval;
  384 {
  385         struct ibcs2_sys_sigprocmask_args /* {
  386                 syscallarg(int) how;
  387                 syscallarg(ibcs2_sigset_t *) set;
  388                 syscallarg(ibcs2_sigset_t *) oset;
  389         } */ *uap = v;
ibcs2_sigset_t iss;
sigset_t bss;
  392         int error = 0;
  394         if (SCARG(uap, oset) != NULL) {
  395                 /* Fix the return value first if needed */
bsd_to_ibcs2_sigset(&p->p_sigmask, &iss);
  397                 if ((error = copyout(&iss, SCARG(uap, oset), sizeof(iss))) != 0)
  398                         return error;
  399         }
  401         if (SCARG(uap, set) == NULL)
  402                 /* Just examine */
  403                 return 0;
  405         if ((error = copyin(SCARG(uap, set), &iss, sizeof(iss))) != 0)
  406                 return error;
ibcs2_to_bsd_sigset(&iss, &bss);
  410         (void) splhigh();
  412         switch (SCARG(uap, how)) {
  413         case IBCS2_SIG_BLOCK:
p->p_sigmask |= bss & ~sigcantmask;
  415                 break;
  417         case IBCS2_SIG_UNBLOCK:
p->p_sigmask &= ~bss;
  419                 break;
  421         case IBCS2_SIG_SETMASK:
p->p_sigmask = bss & ~sigcantmask;
  423                 break;
  425         default:
error = EINVAL;
  427                 break;
  428         }
  430         (void) spl0();
  432         return error;
  433 }
  435 int
ibcs2_sys_sigpending(p, v, retval)
  437         register struct proc *p;
  438         void *v;
register_t *retval;
  440 {
  441         struct ibcs2_sys_sigpending_args /* {
  442                 syscallarg(ibcs2_sigset_t *) mask;
  443         } */ *uap = v;
sigset_t bss;
ibcs2_sigset_t iss;
bss = p->p_siglist & p->p_sigmask;
bsd_to_ibcs2_sigset(&bss, &iss);
  450         return copyout(&iss, SCARG(uap, mask), sizeof(iss));
  451 }
  453 int
ibcs2_sys_sigsuspend(p, v, retval)
  455         register struct proc *p;
  456         void *v;
register_t *retval;
  458 {
  459         struct ibcs2_sys_sigsuspend_args /* {
  460                 syscallarg(ibcs2_sigset_t *) mask;
  461         } */ *uap = v;
ibcs2_sigset_t sss;
sigset_t bss;
  464         struct sys_sigsuspend_args sa;
  465         int error;
  467         if ((error = copyin(SCARG(uap, mask), &sss, sizeof(sss))) != 0)
  468                 return error;
ibcs2_to_bsd_sigset(&sss, &bss);
SCARG(&sa, mask) = bss;
  473         return sys_sigsuspend(p, &sa, retval);
  474 }
  476 int
ibcs2_sys_pause(p, v, retval)
  478         register struct proc *p;
  479         void *v;
register_t *retval;
  481 {
  482         struct sys_sigsuspend_args bsa;
SCARG(&bsa, mask) = p->p_sigmask;
  485         return sys_sigsuspend(p, &bsa, retval);
  486 }
  488 int
ibcs2_sys_kill(p, v, retval)
  490         register struct proc *p;
  491         void *v;
register_t *retval;
  493 {
  494         struct ibcs2_sys_kill_args /* {
  495                 syscallarg(int) pid;
  496                 syscallarg(int) signo;
  497         } */ *uap = v;
  498         struct sys_kill_args ka;
  500         if (SCARG(uap, signo) < 0 || SCARG(uap, signo) >= IBCS2_NSIG)
  501                 return (EINVAL);
SCARG(&ka, pid) = SCARG(uap, pid);
SCARG(&ka, signum) = ibcs2_to_bsd_sig[SCARG(uap, signo)];
  504         return sys_kill(p, &ka, retval);
  505 }