sys/svr4/svr4_signal.c

   1 /*
   2  * Copyright (c) 1998 Mark Newton
   3  * Copyright (c) 1994 Christos Zoulas
   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$
  29  */
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/proc.h>
  34 #include <sys/filedesc.h>
  35 #include <sys/signal.h>
  36 #include <sys/signalvar.h>
  37 #include <sys/sysproto.h>
  38
  39 #include <svr4/svr4.h>
  40 #include <svr4/svr4_types.h>
  41 #include <svr4/svr4_signal.h>
  42 #include <svr4/svr4_proto.h>
  43 #include <svr4/svr4_util.h>
  44 #include <svr4/svr4_ucontext.h>
  45
  46 #define svr4_sigmask(n)         (1 << (((n) - 1) & 31))
  47 #define svr4_sigword(n)         (((n) - 1) >> 5)
  48 #define svr4_sigemptyset(s)     memset((s), 0, sizeof(*(s)))
  49 #define svr4_sigfillset(s)      memset((s), 0xffffffff, sizeof(*(s)))
  50 #define svr4_sigismember(s, n)  ((s)->bits[svr4_sigword(n)] & svr4_sigmask(n))
  51 #define svr4_sigaddset(s, n)    ((s)->bits[svr4_sigword(n)] |= svr4_sigmask(n))
  52
  53 void svr4_to_bsd_sigaction __P((const struct svr4_sigaction *,
  54                                 struct sigaction *));
  55 void bsd_to_svr4_sigaction __P((const struct sigaction *,
  56                                 struct svr4_sigaction *));
  57
  58 int bsd_to_svr4_sig[SVR4_SIGTBLSZ] = {
  59         SVR4_SIGHUP,
  60         SVR4_SIGINT,
  61         SVR4_SIGQUIT,
  62         SVR4_SIGILL,
  63         SVR4_SIGTRAP,
  64         SVR4_SIGABRT,
  65         SVR4_SIGEMT,
  66         SVR4_SIGFPE,
  67         SVR4_SIGKILL,
  68         SVR4_SIGBUS,
  69         SVR4_SIGSEGV,
  70         SVR4_SIGSYS,
  71         SVR4_SIGPIPE,
  72         SVR4_SIGALRM,
  73         SVR4_SIGTERM,
  74         SVR4_SIGURG,
  75         SVR4_SIGSTOP,
  76         SVR4_SIGTSTP,
  77         SVR4_SIGCONT,
  78         SVR4_SIGCHLD,
  79         SVR4_SIGTTIN,
  80         SVR4_SIGTTOU,
  81         SVR4_SIGIO,
  82         SVR4_SIGXCPU,
  83         SVR4_SIGXFSZ,
  84         SVR4_SIGVTALRM,
  85         SVR4_SIGPROF,
  86         SVR4_SIGWINCH,
  87         0,                      /* SIGINFO */
  88         SVR4_SIGUSR1,
  89         SVR4_SIGUSR2,
  90 };
  91
  92 int svr4_to_bsd_sig[SVR4_SIGTBLSZ] = {
  93         SIGHUP,
  94         SIGINT,
  95         SIGQUIT,
  96         SIGILL,
  97         SIGTRAP,
  98         SIGABRT,
  99         SIGEMT,
 100         SIGFPE,
 101         SIGKILL,
 102         SIGBUS,
 103         SIGSEGV,
 104         SIGSYS,
 105         SIGPIPE,
 106         SIGALRM,
 107         SIGTERM,
 108         SIGUSR1,
 109         SIGUSR2,
 110         SIGCHLD,
 111         0,              /* XXX NetBSD uses SIGPWR here, but we don't seem to have one */
 112         SIGWINCH,
 113         SIGURG,
 114         SIGIO,
 115         SIGSTOP,
 116         SIGTSTP,
 117         SIGCONT,
 118         SIGTTIN,
 119         SIGTTOU,
 120         SIGVTALRM,
 121         SIGPROF,
 122         SIGXCPU,
 123         SIGXFSZ,
 124 };
 125
 126 void
 127 svr4_to_bsd_sigset(sss, bss)
 128         const svr4_sigset_t *sss;
 129         sigset_t *bss;
 130 {
 131         int i, newsig;
 132
 133         SIGEMPTYSET(*bss);
 134         bss->__bits[0] = sss->bits[0] & ~((1U << SVR4_SIGTBLSZ) - 1);
 135         bss->__bits[1] = sss->bits[1];
 136         bss->__bits[2] = sss->bits[2];
 137         bss->__bits[3] = sss->bits[3];
 138         for (i = 1; i <= SVR4_SIGTBLSZ; i++) {
 139                 if (svr4_sigismember(sss, i)) {
 140                         newsig = svr4_to_bsd_sig[_SIG_IDX(i)];
 141                         if (newsig)
 142                                 SIGADDSET(*bss, newsig);
 143                 }
 144         }
 145 }
 146
 147 void
 148 bsd_to_svr4_sigset(bss, sss)
 149         const sigset_t *bss;
 150         svr4_sigset_t *sss;
 151 {
 152         int i, newsig;
 153
 154         svr4_sigemptyset(sss);
 155         sss->bits[0] = bss->__bits[0] & ~((1U << SVR4_SIGTBLSZ) - 1);
 156         sss->bits[1] = bss->__bits[1];
 157         sss->bits[2] = bss->__bits[2];
 158         sss->bits[3] = bss->__bits[3];
 159         for (i = 1; i <= SVR4_SIGTBLSZ; i++) {
 160                 if (SIGISMEMBER(*bss, i)) {
 161                         newsig = bsd_to_svr4_sig[_SIG_IDX(i)];
 162                         if (newsig)
 163                                 svr4_sigaddset(sss, newsig);
 164                 }
 165         }
 166 }
 167
 168 /*
 169  * XXX: Only a subset of the flags is currently implemented.
 170  */
 171 void
 172 svr4_to_bsd_sigaction(ssa, bsa)
 173         const struct svr4_sigaction *ssa;
 174         struct sigaction *bsa;
 175 {
 176
 177         bsa->sa_handler = (sig_t) ssa->ssa_handler;
 178         svr4_to_bsd_sigset(&ssa->ssa_mask, &bsa->sa_mask);
 179         bsa->sa_flags = 0;
 180         if ((ssa->ssa_flags & SVR4_SA_ONSTACK) != 0)
 181                 bsa->sa_flags |= SA_ONSTACK;
 182         if ((ssa->ssa_flags & SVR4_SA_RESETHAND) != 0)
 183                 bsa->sa_flags |= SA_RESETHAND;
 184         if ((ssa->ssa_flags & SVR4_SA_RESTART) != 0)
 185                 bsa->sa_flags |= SA_RESTART;
 186         if ((ssa->ssa_flags & SVR4_SA_SIGINFO) != 0)
 187                 DPRINTF(("svr4_to_bsd_sigaction: SA_SIGINFO ignored\n"));
 188         if ((ssa->ssa_flags & SVR4_SA_NOCLDSTOP) != 0)
 189                 bsa->sa_flags |= SA_NOCLDSTOP;
 190         if ((ssa->ssa_flags & SVR4_SA_NODEFER) != 0)
 191                 bsa->sa_flags |= SA_NODEFER;
 192         if ((ssa->ssa_flags & SVR4_SA_NOCLDWAIT) != 0)
 193                 bsa->sa_flags |= SA_NOCLDWAIT;
 194         if ((ssa->ssa_flags & ~SVR4_SA_ALLBITS) != 0)
 195                 DPRINTF(("svr4_to_bsd_sigaction: extra bits ignored\n"));
 196 }
 197
 198 void
 199 bsd_to_svr4_sigaction(bsa, ssa)
 200         const struct sigaction *bsa;
 201         struct svr4_sigaction *ssa;
 202 {
 203
 204         ssa->ssa_handler = (svr4_sig_t) bsa->sa_handler;
 205         bsd_to_svr4_sigset(&bsa->sa_mask, &ssa->ssa_mask);
 206         ssa->ssa_flags = 0;
 207         if ((bsa->sa_flags & SA_ONSTACK) != 0)
 208                 ssa->ssa_flags |= SVR4_SA_ONSTACK;
 209         if ((bsa->sa_flags & SA_RESETHAND) != 0)
 210                 ssa->ssa_flags |= SVR4_SA_RESETHAND;
 211         if ((bsa->sa_flags & SA_RESTART) != 0)
 212                 ssa->ssa_flags |= SVR4_SA_RESTART;
 213         if ((bsa->sa_flags & SA_NODEFER) != 0)
 214                 ssa->ssa_flags |= SVR4_SA_NODEFER;
 215         if ((bsa->sa_flags & SA_NOCLDSTOP) != 0)
 216                 ssa->ssa_flags |= SVR4_SA_NOCLDSTOP;
 217 }
 218
 219 void
 220 svr4_to_bsd_sigaltstack(sss, bss)
 221         const struct svr4_sigaltstack *sss;
 222         struct sigaltstack *bss;
 223 {
 224
 225         bss->ss_sp = sss->ss_sp;
 226         bss->ss_size = sss->ss_size;
 227         bss->ss_flags = 0;
 228         if ((sss->ss_flags & SVR4_SS_DISABLE) != 0)
 229                 bss->ss_flags |= SS_DISABLE;
 230         if ((sss->ss_flags & SVR4_SS_ONSTACK) != 0)
 231                 bss->ss_flags |= SS_ONSTACK;
 232         if ((sss->ss_flags & ~SVR4_SS_ALLBITS) != 0)
 233           /*XXX*/ uprintf("svr4_to_bsd_sigaltstack: extra bits ignored\n");
 234 }
 235
 236 void
 237 bsd_to_svr4_sigaltstack(bss, sss)
 238         const struct sigaltstack *bss;
 239         struct svr4_sigaltstack *sss;
 240 {
 241
 242         sss->ss_sp = bss->ss_sp;
 243         sss->ss_size = bss->ss_size;
 244         sss->ss_flags = 0;
 245         if ((bss->ss_flags & SS_DISABLE) != 0)
 246                 sss->ss_flags |= SVR4_SS_DISABLE;
 247         if ((bss->ss_flags & SS_ONSTACK) != 0)
 248                 sss->ss_flags |= SVR4_SS_ONSTACK;
 249 }
 250
 251 int
 252 svr4_sys_sigaction(p, uap)
 253         register struct proc *p;
 254         struct svr4_sys_sigaction_args *uap;
 255 {
 256         struct svr4_sigaction *nisa, *oisa, tmpisa;
 257         struct sigaction *nbsa, *obsa, tmpbsa;
 258         struct sigaction_args sa;
 259         caddr_t sg;
 260         int error;
 261
 262         sg = stackgap_init();
 263         nisa = SCARG(uap, nsa);
 264         oisa = SCARG(uap, osa);
 265
 266         if (oisa != NULL)
 267                 obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 268         else
 269                 obsa = NULL;
 270
 271         if (nisa != NULL) {
 272                 nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 273                 if ((error = copyin(nisa, &tmpisa, sizeof(tmpisa))) != 0)
 274                         return error;
 275                 svr4_to_bsd_sigaction(&tmpisa, &tmpbsa);
 276                 if ((error = copyout(&tmpbsa, nbsa, sizeof(tmpbsa))) != 0)
 277                         return error;
 278         } else
 279                 nbsa = NULL;
 280
 281         SCARG(&sa, sig) = SVR4_SVR42BSD_SIG(SCARG(uap, signum));
 282         SCARG(&sa, act) = nbsa;
 283         SCARG(&sa, oact) = obsa;
 284
 285         if ((error = sigaction(p, &sa)) != 0)
 286                 return error;
 287
 288         if (oisa != NULL) {
 289                 if ((error = copyin(obsa, &tmpbsa, sizeof(tmpbsa))) != 0)
 290                         return error;
 291                 bsd_to_svr4_sigaction(&tmpbsa, &tmpisa);
 292                 if ((error = copyout(&tmpisa, oisa, sizeof(tmpisa))) != 0)
 293                         return error;
 294         }
 295
 296         return 0;
 297 }
 298
 299 int
 300 svr4_sys_sigaltstack(p, uap)
 301         register struct proc *p;
 302         struct svr4_sys_sigaltstack_args *uap;
 303 {
 304         struct svr4_sigaltstack *nsss, *osss, tmpsss;
 305         struct sigaltstack *nbss, *obss, tmpbss;
 306         struct sigaltstack_args sa;
 307         caddr_t sg;
 308         int error, *retval;
 309
 310         retval = p->p_retval;
 311         sg = stackgap_init();
 312         nsss = SCARG(uap, nss);
 313         osss = SCARG(uap, oss);
 314
 315         if (osss != NULL)
 316                 obss = stackgap_alloc(&sg, sizeof(struct sigaltstack));
 317         else
 318                 obss = NULL;
 319
 320         if (nsss != NULL) {
 321                 nbss = stackgap_alloc(&sg, sizeof(struct sigaltstack));
 322                 if ((error = copyin(nsss, &tmpsss, sizeof(tmpsss))) != 0)
 323                         return error;
 324                 svr4_to_bsd_sigaltstack(&tmpsss, &tmpbss);
 325                 if ((error = copyout(&tmpbss, nbss, sizeof(tmpbss))) != 0)
 326                         return error;
 327         } else
 328                 nbss = NULL;
 329
 330         SCARG(&sa, ss) = nbss;
 331         SCARG(&sa, oss) = obss;
 332
 333         if ((error = sigaltstack(p, &sa)) != 0)
 334                 return error;
 335
 336         if (obss != NULL) {
 337                 if ((error = copyin(obss, &tmpbss, sizeof(tmpbss))) != 0)
 338                         return error;
 339                 bsd_to_svr4_sigaltstack(&tmpbss, &tmpsss);
 340                 if ((error = copyout(&tmpsss, osss, sizeof(tmpsss))) != 0)
 341                         return error;
 342         }
 343
 344         return 0;
 345 }
 346
 347 /*
 348  * Stolen from the ibcs2 one
 349  */
 350 int
 351 svr4_sys_signal(p, uap)
 352         register struct proc *p;
 353         struct svr4_sys_signal_args *uap;
 354 {
 355         int signum;
 356         int error, *retval;
 357         caddr_t sg = stackgap_init();
 358
 359         signum = SVR4_SVR42BSD_SIG(SVR4_SIGNO(SCARG(uap, signum)));
 360         retval = p->p_retval;
 361         if (signum <= 0 || signum > SVR4_NSIG)
 362                 return (EINVAL);
 363
 364         switch (SVR4_SIGCALL(SCARG(uap, signum))) {
 365         case SVR4_SIGDEFER_MASK:
 366                 if (SCARG(uap, handler) == SVR4_SIG_HOLD)
 367                         goto sighold;
 368                 /* FALLTHROUGH */
 369
 370         case SVR4_SIGNAL_MASK:
 371                 {
 372                         struct sigaction_args sa_args;
 373                         struct sigaction *nbsa, *obsa, sa;
 374
 375                         nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 376                         obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 377                         SCARG(&sa_args, sig) = signum;
 378                         SCARG(&sa_args, act) = nbsa;
 379                         SCARG(&sa_args, oact) = obsa;
 380
 381                         sa.sa_handler = (sig_t) SCARG(uap, handler);
 382                         SIGEMPTYSET(sa.sa_mask);
 383                         sa.sa_flags = 0;
 384
 385                         if (signum != SIGALRM)
 386                                 sa.sa_flags = SA_RESTART;
 387
 388                         if ((error = copyout(&sa, nbsa, sizeof(sa))) != 0)
 389                                 return error;
 390                         if ((error = sigaction(p, &sa_args)) != 0) {
 391                                 DPRINTF(("signal: sigaction failed: %d\n",
 392                                          error));
 393                                 *retval = (int)SVR4_SIG_ERR;
 394                                 return error;
 395                         }
 396                         if ((error = copyin(obsa, &sa, sizeof(sa))) != 0)
 397                                 return error;
 398                         *retval = (int)sa.sa_handler;
 399                         return 0;
 400                 }
 401
 402         case SVR4_SIGHOLD_MASK:
 403 sighold:
 404                 {
 405                         struct sigprocmask_args sa;
 406                         sigset_t *set;
 407
 408                         set = stackgap_alloc(&sg, sizeof(sigset_t));
 409                         SIGEMPTYSET(*set);
 410                         SIGADDSET(*set, signum);
 411                         SCARG(&sa, how) = SIG_BLOCK;
 412                         SCARG(&sa, set) = set;
 413                         SCARG(&sa, oset) = NULL;
 414                         return sigprocmask(p, &sa);
 415                 }
 416
 417         case SVR4_SIGRELSE_MASK:
 418                 {
 419                         struct sigprocmask_args sa;
 420                         sigset_t *set;
 421
 422                         set = stackgap_alloc(&sg, sizeof(sigset_t));
 423                         SIGEMPTYSET(*set);
 424                         SIGADDSET(*set, signum);
 425                         SCARG(&sa, how) = SIG_UNBLOCK;
 426                         SCARG(&sa, set) = set;
 427                         SCARG(&sa, oset) = NULL;
 428                         return sigprocmask(p, &sa);
 429                 }
 430
 431         case SVR4_SIGIGNORE_MASK:
 432                 {
 433                         struct sigaction_args sa_args;
 434                         struct sigaction *bsa, sa;
 435
 436                         bsa = stackgap_alloc(&sg, sizeof(struct sigaction));
 437                         SCARG(&sa_args, sig) = signum;
 438                         SCARG(&sa_args, act) = bsa;
 439                         SCARG(&sa_args, oact) = NULL;
 440
 441                         sa.sa_handler = SIG_IGN;
 442                         SIGEMPTYSET(sa.sa_mask);
 443                         sa.sa_flags = 0;
 444                         if ((error = copyout(&sa, bsa, sizeof(sa))) != 0)
 445                                 return error;
 446                         if ((error = sigaction(p, &sa_args)) != 0) {
 447                                 DPRINTF(("sigignore: sigaction failed\n"));
 448                                 return error;
 449                         }
 450                         return 0;
 451                 }
 452
 453         case SVR4_SIGPAUSE_MASK:
 454                 {
 455                         struct sigsuspend_args sa;
 456                         sigset_t *set;
 457
 458                         set = stackgap_alloc(&sg, sizeof(sigset_t));
 459                         *set = p->p_sigmask;
 460                         SIGDELSET(*set, signum);
 461                         SCARG(&sa, sigmask) = set;
 462                         return sigsuspend(p, &sa);
 463                 }
 464
 465         default:
 466                 return (ENOSYS);
 467         }
 468 }
 469
 470
 471 int
 472 svr4_sys_sigprocmask(p, uap)
 473         struct proc *p;
 474         struct svr4_sys_sigprocmask_args *uap;
 475 {
 476         svr4_sigset_t sss;
 477         sigset_t bss;
 478         int error = 0, *retval;
 479
 480         retval = p->p_retval;
 481         if (SCARG(uap, oset) != NULL) {
 482                 /* Fix the return value first if needed */
 483                 bsd_to_svr4_sigset(&p->p_sigmask, &sss);
 484                 if ((error = copyout(&sss, SCARG(uap, oset), sizeof(sss))) != 0)
 485                         return error;
 486         }
 487
 488         if (SCARG(uap, set) == NULL)
 489                 /* Just examine */
 490                 return 0;
 491
 492         if ((error = copyin(SCARG(uap, set), &sss, sizeof(sss))) != 0)
 493                 return error;
 494
 495         svr4_to_bsd_sigset(&sss, &bss);
 496
 497         (void) splhigh();
 498
 499         switch (SCARG(uap, how)) {
 500         case SVR4_SIG_BLOCK:
 501                 SIGSETOR(p->p_sigmask, bss);
 502                 SIG_CANTMASK(p->p_sigmask);
 503                 break;
 504
 505         case SVR4_SIG_UNBLOCK:
 506                 SIGSETNAND(p->p_sigmask, bss);
 507                 break;
 508
 509         case SVR4_SIG_SETMASK:
 510                 p->p_sigmask = bss;
 511                 SIG_CANTMASK(p->p_sigmask);
 512                 break;
 513
 514         default:
 515                 error = EINVAL;
 516                 break;
 517         }
 518
 519         (void) spl0();
 520
 521         return error;
 522 }
 523
 524 int
 525 svr4_sys_sigpending(p, uap)
 526         struct proc *p;
 527         struct svr4_sys_sigpending_args *uap;
 528 {
 529         sigset_t bss;
 530         int *retval;
 531         svr4_sigset_t sss;
 532
 533         retval = p->p_retval;
 534         switch (SCARG(uap, what)) {
 535         case 1: /* sigpending */
 536                 if (SCARG(uap, mask) == NULL)
 537                         return 0;
 538                 bss = p->p_siglist;
 539                 SIGSETAND(bss, p->p_sigmask);
 540                 bsd_to_svr4_sigset(&bss, &sss);
 541                 break;
 542
 543         case 2: /* sigfillset */
 544                 svr4_sigfillset(&sss);
 545                 break;
 546
 547         default:
 548                 return EINVAL;
 549         }
 550
 551         return copyout(&sss, SCARG(uap, mask), sizeof(sss));
 552 }
 553
 554 int
 555 svr4_sys_sigsuspend(p, uap)
 556         register struct proc *p;
 557         struct svr4_sys_sigsuspend_args *uap;
 558 {
 559         svr4_sigset_t sss;
 560         sigset_t *bss;
 561         struct sigsuspend_args sa;
 562         int error;
 563         caddr_t sg = stackgap_init();
 564
 565         if ((error = copyin(SCARG(uap, ss), &sss, sizeof(sss))) != 0)
 566                 return error;
 567
 568         bss = stackgap_alloc(&sg, sizeof(sigset_t));
 569         svr4_to_bsd_sigset(&sss, bss);
 570
 571         SCARG(&sa, sigmask) = bss;
 572         return sigsuspend(p, &sa);
 573 }
 574
 575
 576 int
 577 svr4_sys_kill(p, uap)
 578         register struct proc *p;
 579         struct svr4_sys_kill_args *uap;
 580 {
 581         struct kill_args ka;
 582
 583         SCARG(&ka, pid) = SCARG(uap, pid);
 584         SCARG(&ka, signum) = SVR4_SVR42BSD_SIG(SCARG(uap, signum));
 585         return kill(p, &ka);
 586 }
 587
 588
 589 int
 590 svr4_sys_context(p, uap)
 591         register struct proc *p;
 592         struct svr4_sys_context_args *uap;
 593 {
 594         struct svr4_ucontext uc;
 595         int error;
 596
 597         switch (uap->func) {
 598         case 0:
 599                 DPRINTF(("getcontext(%p)\n", uap->uc));
 600                 svr4_getcontext(p, &uc, &p->p_sigmask,
 601                     p->p_sigstk.ss_flags & SS_ONSTACK);
 602                 return copyout(&uc, uap->uc, sizeof(uc));
 603
 604         case 1:
 605                 DPRINTF(("setcontext(%p)\n", uap->uc));
 606                 if ((error = copyin(uap->uc, &uc, sizeof(uc))) != 0)
 607                         return error;
 608                 DPRINTF(("uc_flags = %x\n", uc.uc_flags));
 609                 DPRINTF(("uc_sigmask = %x\n", uc.uc_sigmask));
 610
 611                 return svr4_setcontext(p, &uc);
 612
 613         default:
 614                 DPRINTF(("context(%d, %p)\n", uap->func,
 615                     uap->uc));
 616                 return ENOSYS;
 617         }
 618         return 0;
 619 }
 620
 621 int
 622 svr4_sys_pause(p, uap)
 623         register struct proc *p;
 624         struct svr4_sys_pause_args *uap;
 625 {
 626         struct sigsuspend_args bsa;
 627
 628         SCARG(&bsa, sigmask) = &p->p_sigmask;
 629         return sigsuspend(p, &bsa);
 630 }