sys/emulation/ibcs2/i386/ibcs2_signal.c

   1 /*
   2  * Copyright (c) 1995 Scott Bartram
   3  * Copyright (c) 1995 Steven Wallace
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/i386/ibcs2/ibcs2_signal.c,v 1.16 1999/10/10 09:14:31 marcel Exp $
  29  * $DragonFly: src/sys/emulation/ibcs2/i386/Attic/ibcs2_signal.c,v 1.7 2003/08/27 06:30:03 rob Exp $
  30  */
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/signalvar.h>
  35 #include <sys/sysproto.h>
  36
  37 #include "ibcs2_types.h"
  38 #include "ibcs2_signal.h"
  39 #include "ibcs2_proto.h"
  40 #include "ibcs2_xenix.h"
  41 #include "ibcs2_util.h"
  42
  43 #define sigemptyset(s)          SIGEMPTYSET(*(s))
  44 #define sigismember(s, n)       SIGISMEMBER(*(s), n)
  45 #define sigaddset(s, n)         SIGADDSET(*(s), n)
  46
  47 #define ibcs2_sigmask(n)        (1 << ((n) - 1))
  48 #define ibcs2_sigemptyset(s)    bzero((s), sizeof(*(s)))
  49 #define ibcs2_sigismember(s, n) (*(s) & ibcs2_sigmask(n))
  50 #define ibcs2_sigaddset(s, n)   (*(s) |= ibcs2_sigmask(n))
  51
  52 static void ibcs2_to_bsd_sigset    (const ibcs2_sigset_t *, sigset_t *);
  53 static void bsd_to_ibcs2_sigset    (const sigset_t *, ibcs2_sigset_t *);
  54 static void ibcs2_to_bsd_sigaction (struct ibcs2_sigaction *,
  55                                         struct sigaction *);
  56 static void bsd_to_ibcs2_sigaction (struct sigaction *,
  57                                         struct ibcs2_sigaction *);
  58
  59 int bsd_to_ibcs2_sig[IBCS2_SIGTBLSZ] = {
  60         IBCS2_SIGHUP,           /* 1 */
  61         IBCS2_SIGINT,           /* 2 */
  62         IBCS2_SIGQUIT,          /* 3 */
  63         IBCS2_SIGILL,           /* 4 */
  64         IBCS2_SIGTRAP,          /* 5 */
  65         IBCS2_SIGABRT,          /* 6 */
  66         IBCS2_SIGEMT,           /* 7 */
  67         IBCS2_SIGFPE,           /* 8 */
  68         IBCS2_SIGKILL,          /* 9 */
  69         IBCS2_SIGBUS,           /* 10 */
  70         IBCS2_SIGSEGV,          /* 11 */
  71         IBCS2_SIGSYS,           /* 12 */
  72         IBCS2_SIGPIPE,          /* 13 */
  73         IBCS2_SIGALRM,          /* 14 */
  74         IBCS2_SIGTERM,          /* 15 */
  75         0,                      /* 16 - SIGURG */
  76         IBCS2_SIGSTOP,          /* 17 */
  77         IBCS2_SIGTSTP,          /* 18 */
  78         IBCS2_SIGCONT,          /* 19 */
  79         IBCS2_SIGCLD,           /* 20 */
  80         IBCS2_SIGTTIN,          /* 21 */
  81         IBCS2_SIGTTOU,          /* 22 */
  82         IBCS2_SIGPOLL,          /* 23 */
  83         0,                      /* 24 - SIGXCPU */
  84         0,                      /* 25 - SIGXFSZ */
  85         IBCS2_SIGVTALRM,        /* 26 */
  86         IBCS2_SIGPROF,          /* 27 */
  87         IBCS2_SIGWINCH,         /* 28 */
  88         0,                      /* 29 */
  89         IBCS2_SIGUSR1,          /* 30 */
  90         IBCS2_SIGUSR2,          /* 31 */
  91         0                       /* 32 */
  92 };
  93
  94 static int ibcs2_to_bsd_sig[IBCS2_SIGTBLSZ] = {
  95         SIGHUP,                 /* 1 */
  96         SIGINT,                 /* 2 */
  97         SIGQUIT,                /* 3 */
  98         SIGILL,                 /* 4 */
  99         SIGTRAP,                /* 5 */
 100         SIGABRT,                /* 6 */
 101         SIGEMT,                 /* 7 */
 102         SIGFPE,                 /* 8 */
 103         SIGKILL,                /* 9 */
 104         SIGBUS,                 /* 10 */
 105         SIGSEGV,                /* 11 */
 106         SIGSYS,                 /* 12 */
 107         SIGPIPE,                /* 13 */
 108         SIGALRM,                /* 14 */
 109         SIGTERM,                /* 15 */
 110         SIGUSR1,                /* 16 */
 111         SIGUSR2,                /* 17 */
 112         SIGCHLD,                /* 18 */
 113         0,                      /* 19 - SIGPWR */
 114         SIGWINCH,               /* 20 */
 115         0,                      /* 21 */
 116         SIGIO,                  /* 22 */
 117         SIGSTOP,                /* 23 */
 118         SIGTSTP,                /* 24 */
 119         SIGCONT,                /* 25 */
 120         SIGTTIN,                /* 26 */
 121         SIGTTOU,                /* 27 */
 122         SIGVTALRM,              /* 28 */
 123         SIGPROF,                /* 29 */
 124         0,                      /* 30 */
 125         0,                      /* 31 */
 126         0                       /* 32 */
 127 };
 128
 129 void
 130 ibcs2_to_bsd_sigset(iss, bss)
 131         const ibcs2_sigset_t *iss;
 132         sigset_t *bss;
 133 {
 134         int i, newsig;
 135
 136         sigemptyset(bss);
 137         for (i = 1; i <= IBCS2_SIGTBLSZ; i++) {
 138                 if (ibcs2_sigismember(iss, i)) {
 139                         newsig = ibcs2_to_bsd_sig[_SIG_IDX(i)];
 140                         if (newsig)
 141                                 sigaddset(bss, newsig);
 142                 }
 143         }
 144 }
 145
 146 static void
 147 bsd_to_ibcs2_sigset(bss, iss)
 148         const sigset_t *bss;
 149         ibcs2_sigset_t *iss;
 150 {
 151         int i, newsig;
 152
 153         ibcs2_sigemptyset(iss);
 154         for (i = 1; i <= IBCS2_SIGTBLSZ; i++) {
 155                 if (sigismember(bss, i)) {
 156                         newsig = bsd_to_ibcs2_sig[_SIG_IDX(i)];
 157                         if (newsig)
 158                                 ibcs2_sigaddset(iss, newsig);
 159                 }
 160         }
 161 }
 162
 163 static void
 164 ibcs2_to_bsd_sigaction(isa, bsa)
 165         struct ibcs2_sigaction *isa;
 166         struct sigaction *bsa;
 167 {
 168
 169         bsa->sa_handler = isa->isa_handler;
 170         ibcs2_to_bsd_sigset(&isa->isa_mask, &bsa->sa_mask);
 171         bsa->sa_flags = 0;      /* ??? SA_NODEFER */
 172         if ((isa->isa_flags & IBCS2_SA_NOCLDSTOP) != 0)
 173                 bsa->sa_flags |= SA_NOCLDSTOP;
 174 }
 175
 176 static void
 177 bsd_to_ibcs2_sigaction(bsa, isa)
 178         struct sigaction *bsa;
 179         struct ibcs2_sigaction *isa;
 180 {
 181
 182         isa->isa_handler = bsa->sa_handler;
 183         bsd_to_ibcs2_sigset(&bsa->sa_mask, &isa->isa_mask);
 184         isa->isa_flags = 0;
 185         if ((bsa->sa_flags & SA_NOCLDSTOP) != 0)
 186                 isa->isa_flags |= IBCS2_SA_NOCLDSTOP;
 187 }
 188
 189 int
 190 ibcs2_sigaction(struct ibcs2_sigaction_args *uap)
 191 {
 192         struct ibcs2_sigaction *nisa, *oisa, tmpisa;
 193         struct sigaction *nbsa, *obsa, tmpbsa;
 194         struct sigaction_args sa;
 195         caddr_t sg;
 196         int error;
 197
 198         sg = stackgap_init();
 199         nisa = SCARG(uap, act);
 200         oisa = SCARG(uap, oact);
 201
 202         if (oisa != NULL)
 203                 obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 204         else
 205                 obsa = NULL;
 206
 207         if (nisa != NULL) {
 208                 nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 209                 if ((error = copyin(nisa, &tmpisa, sizeof(tmpisa))) != 0)
 210                         return error;
 211                 ibcs2_to_bsd_sigaction(&tmpisa, &tmpbsa);
 212                 if ((error = copyout(&tmpbsa, nbsa, sizeof(tmpbsa))) != 0)
 213                         return error;
 214         } else
 215                 nbsa = NULL;
 216
 217         SCARG(&sa, sig) = ibcs2_to_bsd_sig[_SIG_IDX(SCARG(uap, sig))];
 218         SCARG(&sa, act) = nbsa;
 219         SCARG(&sa, oact) = obsa;
 220
 221         if ((error = sigaction(&sa)) != 0)
 222                 return error;
 223
 224         if (oisa != NULL) {
 225                 if ((error = copyin(obsa, &tmpbsa, sizeof(tmpbsa))) != 0)
 226                         return error;
 227                 bsd_to_ibcs2_sigaction(&tmpbsa, &tmpisa);
 228                 if ((error = copyout(&tmpisa, oisa, sizeof(tmpisa))) != 0)
 229                         return error;
 230         }
 231
 232         return 0;
 233 }
 234
 235 int
 236 ibcs2_sigsys(struct ibcs2_sigsys_args *uap)
 237 {
 238         struct proc *p = curproc;
 239         struct sigaction sa;
 240         int signum = ibcs2_to_bsd_sig[_SIG_IDX(IBCS2_SIGNO(SCARG(uap, sig)))];
 241         int error;
 242         caddr_t sg = stackgap_init();
 243
 244         if (signum <= 0 || signum >= IBCS2_NSIG) {
 245                 if (IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGNAL_MASK ||
 246                     IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGSET_MASK)
 247                         uap->sysmsg_result = (int)IBCS2_SIG_ERR;
 248                 return EINVAL;
 249         }
 250
 251         switch (IBCS2_SIGCALL(SCARG(uap, sig))) {
 252         case IBCS2_SIGSET_MASK:
 253                 /*
 254                  * Check for SIG_HOLD action.
 255                  * Otherwise, perform signal() except with different sa_flags.
 256                  */
 257                 if (SCARG(uap, fp) != IBCS2_SIG_HOLD) {
 258                         /* add sig to mask before exececuting signal handler */
 259                         sa.sa_flags = 0;
 260                         goto ibcs2_sigset;
 261                 }
 262                 /* else fallthrough to sighold */
 263
 264         case IBCS2_SIGHOLD_MASK:
 265                 {
 266                         sigset_t mask;
 267                         struct sigprocmask_args sa;
 268
 269                         SIGEMPTYSET(mask);
 270                         SIGADDSET(mask, signum);
 271                         SCARG(&sa, how) = SIG_BLOCK;
 272                         SCARG(&sa, set) = &mask;
 273                         SCARG(&sa, oset) = NULL;
 274                         return sigprocmask(&sa);
 275                 }
 276
 277         case IBCS2_SIGNAL_MASK:
 278                 {
 279                         struct sigaction_args sa_args;
 280                         struct sigaction *nbsa, *obsa;
 281
 282                         /* do not automatically block signal */
 283                         sa.sa_flags = SA_NODEFER;
 284 #ifdef SA_RESETHAND
 285                         if((signum != IBCS2_SIGILL) &&
 286                            (signum != IBCS2_SIGTRAP) &&
 287                            (signum != IBCS2_SIGPWR))
 288                                 /* set to SIG_DFL before executing handler */
 289                                 sa.sa_flags |= SA_RESETHAND;
 290 #endif
 291                 ibcs2_sigset:
 292                         nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 293                         obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 294                         SCARG(&sa_args, sig) = signum;
 295                         SCARG(&sa_args, act) = nbsa;
 296                         SCARG(&sa_args, oact) = obsa;
 297
 298                         sa.sa_handler = SCARG(uap, fp);
 299                         sigemptyset(&sa.sa_mask);
 300 #if 0
 301                         if (signum != SIGALRM)
 302                                 sa.sa_flags |= SA_RESTART;
 303 #endif
 304                         uap->sysmsg_result = (int)IBCS2_SIG_ERR; /* init error return */
 305
 306                         /* perform native sigaction() */
 307                         if ((error = copyout(&sa, nbsa, sizeof(sa))) != 0)
 308                                 return error;
 309                         if ((error = sigaction(&sa_args)) != 0) {
 310                                 DPRINTF(("signal: sigaction failed: %d\n",
 311                                          error));
 312                                 return error;
 313                         }
 314                         if ((error = copyin(obsa, &sa, sizeof(sa))) != 0)
 315                                 return error;
 316                         uap->sysmsg_result = (int)sa.sa_handler;
 317
 318                         /* special sigset() check */
 319                         if(IBCS2_SIGCALL(SCARG(uap, sig)) == IBCS2_SIGSET_MASK)
 320                                 /* check to make sure signal is not blocked */
 321                                 if(sigismember(&p->p_sigmask, signum)) {
 322                                         /* return SIG_HOLD and unblock signal*/
 323                                         uap->sysmsg_result = (int)IBCS2_SIG_HOLD;
 324                                         SIGDELSET(p->p_sigmask, signum);
 325                                 }
 326
 327                         return 0;
 328                 }
 329
 330         case IBCS2_SIGRELSE_MASK:
 331                 {
 332                         sigset_t mask;
 333                         struct sigprocmask_args sa;
 334
 335                         SIGEMPTYSET(mask);
 336                         SIGADDSET(mask, signum);
 337                         SCARG(&sa, how) = SIG_UNBLOCK;
 338                         SCARG(&sa, set) = &mask;
 339                         SCARG(&sa, oset) = NULL;
 340                         return sigprocmask(&sa);
 341                 }
 342
 343         case IBCS2_SIGIGNORE_MASK:
 344                 {
 345                         struct sigaction_args sa_args;
 346                         struct sigaction *bsa;
 347
 348                         bsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 349                         SCARG(&sa_args, sig) = signum;
 350                         SCARG(&sa_args, act) = bsa;
 351                         SCARG(&sa_args, oact) = NULL;
 352
 353                         sa.sa_handler = SIG_IGN;
 354                         sigemptyset(&sa.sa_mask);
 355                         sa.sa_flags = 0;
 356                         if ((error = copyout(&sa, bsa, sizeof(sa))) != 0)
 357                                 return error;
 358                         if ((error = sigaction(&sa_args)) != 0) {
 359                                 DPRINTF(("sigignore: sigaction failed\n"));
 360                                 return error;
 361                         }
 362                         return 0;
 363                 }
 364
 365         case IBCS2_SIGPAUSE_MASK:
 366                 {
 367                         sigset_t mask;
 368                         struct sigsuspend_args sa;
 369
 370                         mask = p->p_sigmask;
 371                         SIGDELSET(mask, signum);
 372                         SCARG(&sa, sigmask) = &mask;
 373                         return sigsuspend(&sa);
 374                 }
 375
 376         default:
 377                 return ENOSYS;
 378         }
 379 }
 380
 381 int
 382 ibcs2_sigprocmask(struct ibcs2_sigprocmask_args *uap)
 383 {
 384         struct proc *p = curproc;
 385         ibcs2_sigset_t iss;
 386         sigset_t bss;
 387         int error = 0;
 388
 389         if (SCARG(uap, oset) != NULL) {
 390                 /* Fix the return value first if needed */
 391                 bsd_to_ibcs2_sigset(&p->p_sigmask, &iss);
 392                 if ((error = copyout(&iss, SCARG(uap, oset), sizeof(iss))) != 0)
 393                         return error;
 394         }
 395
 396         if (SCARG(uap, set) == NULL)
 397                 /* Just examine */
 398                 return 0;
 399
 400         if ((error = copyin(SCARG(uap, set), &iss, sizeof(iss))) != 0)
 401                 return error;
 402
 403         ibcs2_to_bsd_sigset(&iss, &bss);
 404
 405         (void) splhigh();
 406
 407         switch (SCARG(uap, how)) {
 408         case IBCS2_SIG_BLOCK:
 409                 SIGSETOR(p->p_sigmask, bss);
 410                 SIG_CANTMASK(p->p_sigmask);
 411                 break;
 412
 413         case IBCS2_SIG_UNBLOCK:
 414                 SIGSETNAND(p->p_sigmask, bss);
 415                 break;
 416
 417         case IBCS2_SIG_SETMASK:
 418                 p->p_sigmask = bss;
 419                 SIG_CANTMASK(p->p_sigmask);
 420                 break;
 421
 422         default:
 423                 error = EINVAL;
 424                 break;
 425         }
 426
 427         (void) spl0();
 428
 429         return error;
 430 }
 431
 432 int
 433 ibcs2_sigpending(struct ibcs2_sigpending_args *uap)
 434 {
 435         struct proc *p = curproc;
 436         sigset_t bss;
 437         ibcs2_sigset_t iss;
 438
 439         bss = p->p_siglist;
 440         SIGSETAND(bss, p->p_sigmask);
 441         bsd_to_ibcs2_sigset(&bss, &iss);
 442
 443         return copyout(&iss, SCARG(uap, mask), sizeof(iss));
 444 }
 445
 446 int
 447 ibcs2_sigsuspend(struct ibcs2_sigsuspend_args *uap)
 448 {
 449         ibcs2_sigset_t sss;
 450         sigset_t bss;
 451         struct sigsuspend_args sa;
 452         int error;
 453
 454         if ((error = copyin(SCARG(uap, mask), &sss, sizeof(sss))) != 0)
 455                 return error;
 456
 457         ibcs2_to_bsd_sigset(&sss, &bss);
 458         SCARG(&sa, sigmask) = &bss;
 459         return sigsuspend(&sa);
 460 }
 461
 462 int
 463 ibcs2_pause(struct ibcs2_pause_args *uap)
 464 {
 465         struct proc *p = curproc;
 466         sigset_t mask;
 467         struct sigsuspend_args sa;
 468
 469         mask = p->p_sigmask;
 470         SCARG(&sa, sigmask) = &mask;
 471         return sigsuspend(&sa);
 472 }
 473
 474 int
 475 ibcs2_kill(struct ibcs2_kill_args *uap)
 476 {
 477         struct kill_args ka;
 478
 479         SCARG(&ka, pid) = SCARG(uap, pid);
 480         SCARG(&ka, signum) = ibcs2_to_bsd_sig[_SIG_IDX(SCARG(uap, signo))];
 481         return kill(&ka);
 482 }