arch/x86/kernel/os/sendsig.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */
  28 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T   */
  29 /*      All Rights Reserved   */
  30
  31 #include <sys/types.h>
  32 #include <sys/param.h>
  33 #include <sys/sysmacros.h>
  34 #include <sys/signal.h>
  35 #include <sys/systm.h>
  36 #include <sys/user.h>
  37 #include <sys/mman.h>
  38 #include <sys/class.h>
  39 #include <sys/proc.h>
  40 #include <sys/procfs.h>
  41 #include <sys/buf.h>
  42 #include <sys/kmem.h>
  43 #include <sys/cred.h>
  44 #include <sys/archsystm.h>
  45 #include <sys/vmparam.h>
  46 #include <sys/prsystm.h>
  47 #include <sys/reboot.h>
  48 #include <sys/uadmin.h>
  49 #include <sys/vfs.h>
  50 #include <sys/vnode.h>
  51 #include <sys/file.h>
  52 #include <sys/session.h>
  53 #include <sys/ucontext.h>
  54 #include <sys/dnlc.h>
  55 #include <sys/var.h>
  56 #include <sys/cmn_err.h>
  57 #include <sys/debugreg.h>
  58 #include <sys/thread.h>
  59 #include <sys/vtrace.h>
  60 #include <sys/consdev.h>
  61 #include <sys/psw.h>
  62 #include <sys/regset.h>
  63
  64 #include <sys/privregs.h>
  65
  66 #include <sys/stack.h>
  67 #include <sys/swap.h>
  68 #include <vm/hat.h>
  69 #include <vm/anon.h>
  70 #include <vm/as.h>
  71 #include <vm/page.h>
  72 #include <vm/seg.h>
  73 #include <vm/seg_kmem.h>
  74 #include <vm/seg_map.h>
  75 #include <vm/seg_vn.h>
  76 #include <sys/exec.h>
  77 #include <sys/acct.h>
  78 #include <sys/core.h>
  79 #include <sys/corectl.h>
  80 #include <sys/modctl.h>
  81 #include <sys/tuneable.h>
  82 #include <c2/audit.h>
  83 #include <sys/bootconf.h>
  84 #include <sys/dumphdr.h>
  85 #include <sys/promif.h>
  86 #include <sys/systeminfo.h>
  87 #include <sys/kdi.h>
  88 #include <sys/contract_impl.h>
  89 #include <sys/x86_archext.h>
  90
  91 /*
  92  * Construct the execution environment for the user's signal
  93  * handler and arrange for control to be given to it on return
  94  * to userland.  The library code now calls setcontext() to
  95  * clean up after the signal handler, so sigret() is no longer
  96  * needed.
  97  *
  98  * (The various 'volatile' declarations are need to ensure that values
  99  * are correct on the error return from on_fault().)
 100  */
 101
 102 #if defined(__amd64)
 103
 104 /*
 105  * An amd64 signal frame looks like this on the stack:
 106  *
 107  * old %rsp:
 108  *              <128 bytes of untouched stack space>
 109  *              <a siginfo_t [optional]>
 110  *              <a ucontext_t>
 111  *              <siginfo_t *>
 112  *              <signal number>
 113  * new %rsp:    <return address (deliberately invalid)>
 114  *
 115  * The signal number and siginfo_t pointer are only pushed onto the stack in
 116  * order to allow stack backtraces.  The actual signal handling code expects the
 117  * arguments in registers.
 118  */
 119
 120 struct sigframe {
 121         caddr_t retaddr;
 122         long    signo;
 123         siginfo_t *sip;
 124 };
 125
 126 int
 127 sendsig(int sig, k_siginfo_t *sip, void (*hdlr)())
 128 {
 129         volatile int minstacksz;
 130         int newstack;
 131         label_t ljb;
 132         volatile caddr_t sp;
 133         caddr_t fp;
 134         volatile struct regs *rp;
 135         volatile greg_t upc;
 136         volatile proc_t *p = ttoproc(curthread);
 137         struct as *as = p->p_as;
 138         klwp_t *lwp = ttolwp(curthread);
 139         ucontext_t *volatile tuc = NULL;
 140         ucontext_t *uc;
 141         siginfo_t *sip_addr;
 142         volatile int watched;
 143
 144         /*
 145          * This routine is utterly dependent upon STACK_ALIGN being
 146          * 16 and STACK_ENTRY_ALIGN being 8. Let's just acknowledge
 147          * that and require it.
 148          */
 149
 150 #if STACK_ALIGN != 16 || STACK_ENTRY_ALIGN != 8
 151 #error "sendsig() amd64 did not find the expected stack alignments"
 152 #endif
 153
 154         rp = lwptoregs(lwp);
 155         upc = rp->r_pc;
 156
 157         /*
 158          * Since we're setting up to run the signal handler we have to
 159          * arrange that the stack at entry to the handler is (only)
 160          * STACK_ENTRY_ALIGN (i.e. 8) byte aligned so that when the handler
 161          * executes its push of %rbp, the stack realigns to STACK_ALIGN
 162          * (i.e. 16) correctly.
 163          *
 164          * The new sp will point to the sigframe and the ucontext_t. The
 165          * above means that sp (and thus sigframe) will be 8-byte aligned,
 166          * but not 16-byte aligned. ucontext_t, however, contains %xmm regs
 167          * which must be 16-byte aligned. Because of this, for correct
 168          * alignment, sigframe must be a multiple of 8-bytes in length, but
 169          * not 16-bytes. This will place ucontext_t at a nice 16-byte boundary.
 170          */
 171
 172         /* LINTED: logical expression always true: op "||" */
 173         ASSERT((sizeof (struct sigframe) % 16) == 8);
 174
 175         minstacksz = sizeof (struct sigframe) + SA(sizeof (*uc));
 176         if (sip != NULL)
 177                 minstacksz += SA(sizeof (siginfo_t));
 178         ASSERT((minstacksz & (STACK_ENTRY_ALIGN - 1ul)) == 0);
 179
 180         /*
 181          * Figure out whether we will be handling this signal on
 182          * an alternate stack specified by the user.  Then allocate
 183          * and validate the stack requirements for the signal handler
 184          * context.  on_fault will catch any faults.
 185          */
 186         newstack = sigismember(&PTOU(curproc)->u_sigonstack, sig) &&
 187             !(lwp->lwp_sigaltstack.ss_flags & (SS_ONSTACK|SS_DISABLE));
 188
 189         if (newstack) {
 190                 fp = (caddr_t)(SA((uintptr_t)lwp->lwp_sigaltstack.ss_sp) +
 191                     SA(lwp->lwp_sigaltstack.ss_size) - STACK_ALIGN);
 192         } else {
 193                 /*
 194                  * Drop below the 128-byte reserved region of the stack frame
 195                  * we're interrupting.
 196                  */
 197                 fp = (caddr_t)rp->r_sp - STACK_RESERVE;
 198         }
 199
 200         /*
 201          * Force proper stack pointer alignment, even in the face of a
 202          * misaligned stack pointer from user-level before the signal.
 203          */
 204         fp = (caddr_t)((uintptr_t)fp & ~(STACK_ENTRY_ALIGN - 1ul));
 205
 206         /*
 207          * Most of the time during normal execution, the stack pointer
 208          * is aligned on a STACK_ALIGN (i.e. 16 byte) boundary.  However,
 209          * (for example) just after a call instruction (which pushes
 210          * the return address), the callers stack misaligns until the
 211          * 'push %rbp' happens in the callee prolog.  So while we should
 212          * expect the stack pointer to be always at least STACK_ENTRY_ALIGN
 213          * aligned, we should -not- expect it to always be STACK_ALIGN aligned.
 214          * We now adjust to ensure that the new sp is aligned to
 215          * STACK_ENTRY_ALIGN but not to STACK_ALIGN.
 216          */
 217         sp = fp - minstacksz;
 218         if (((uintptr_t)sp & (STACK_ALIGN - 1ul)) == 0) {
 219                 sp -= STACK_ENTRY_ALIGN;
 220                 minstacksz = fp - sp;
 221         }
 222
 223         /*
 224          * Now, make sure the resulting signal frame address is sane
 225          */
 226         if (sp >= as->a_userlimit || fp >= as->a_userlimit) {
 227 #ifdef DEBUG
 228                 printf("sendsig: bad signal stack cmd=%s, pid=%d, sig=%d\n",
 229                     PTOU(p)->u_comm, p->p_pid, sig);
 230                 printf("sigsp = 0x%p, action = 0x%p, upc = 0x%lx\n",
 231                     (void *)sp, (void *)hdlr, (uintptr_t)upc);
 232                 printf("sp above USERLIMIT\n");
 233 #endif
 234                 return (0);
 235         }
 236
 237         watched = watch_disable_addr((caddr_t)sp, minstacksz, S_WRITE);
 238
 239         if (on_fault(&ljb))
 240                 goto badstack;
 241
 242         if (sip != NULL) {
 243                 zoneid_t zoneid;
 244
 245                 fp -= SA(sizeof (siginfo_t));
 246                 uzero(fp, sizeof (siginfo_t));
 247                 if (SI_FROMUSER(sip) &&
 248                     (zoneid = p->p_zone->zone_id) != GLOBAL_ZONEID &&
 249                     zoneid != sip->si_zoneid) {
 250                         k_siginfo_t sani_sip = *sip;
 251
 252                         sani_sip.si_pid = p->p_zone->zone_zsched->p_pid;
 253                         sani_sip.si_uid = 0;
 254                         sani_sip.si_ctid = -1;
 255                         sani_sip.si_zoneid = zoneid;
 256                         copyout_noerr(&sani_sip, fp, sizeof (sani_sip));
 257                 } else
 258                         copyout_noerr(sip, fp, sizeof (*sip));
 259                 sip_addr = (siginfo_t *)fp;
 260
 261                 if (sig == SIGPROF &&
 262                     curthread->t_rprof != NULL &&
 263                     curthread->t_rprof->rp_anystate) {
 264                         /*
 265                          * We stand on our head to deal with
 266                          * the real time profiling signal.
 267                          * Fill in the stuff that doesn't fit
 268                          * in a normal k_siginfo structure.
 269                          */
 270                         int i = sip->si_nsysarg;
 271
 272                         while (--i >= 0)
 273                                 sulword_noerr(
 274                                     (ulong_t *)&(sip_addr->si_sysarg[i]),
 275                                     (ulong_t)lwp->lwp_arg[i]);
 276                         copyout_noerr(curthread->t_rprof->rp_state,
 277                             sip_addr->si_mstate,
 278                             sizeof (curthread->t_rprof->rp_state));
 279                 }
 280         } else
 281                 sip_addr = NULL;
 282
 283         /*
 284          * save the current context on the user stack directly after the
 285          * sigframe. Since sigframe is 8-byte-but-not-16-byte aligned,
 286          * and since sizeof (struct sigframe) is 24, this guarantees
 287          * 16-byte alignment for ucontext_t and its %xmm registers.
 288          */
 289         uc = (ucontext_t *)(sp + sizeof (struct sigframe));
 290         tuc = kmem_alloc(sizeof (*tuc), KM_SLEEP);
 291         no_fault();
 292         savecontext(tuc, &lwp->lwp_sigoldmask);
 293         if (on_fault(&ljb))
 294                 goto badstack;
 295         copyout_noerr(tuc, uc, sizeof (*tuc));
 296         kmem_free(tuc, sizeof (*tuc));
 297         tuc = NULL;
 298
 299         lwp->lwp_oldcontext = (uintptr_t)uc;
 300
 301         if (newstack) {
 302                 lwp->lwp_sigaltstack.ss_flags |= SS_ONSTACK;
 303                 if (lwp->lwp_ustack)
 304                         copyout_noerr(&lwp->lwp_sigaltstack,
 305                             (stack_t *)lwp->lwp_ustack, sizeof (stack_t));
 306         }
 307
 308         /*
 309          * Set up signal handler return and stack linkage
 310          */
 311         {
 312                 struct sigframe frame;
 313
 314                 /*
 315                  * ensure we never return "normally"
 316                  */
 317                 frame.retaddr = (caddr_t)(uintptr_t)-1L;
 318                 frame.signo = sig;
 319                 frame.sip = sip_addr;
 320                 copyout_noerr(&frame, sp, sizeof (frame));
 321         }
 322
 323         no_fault();
 324         if (watched)
 325                 watch_enable_addr((caddr_t)sp, minstacksz, S_WRITE);
 326
 327         /*
 328          * Set up user registers for execution of signal handler.
 329          */
 330         rp->r_sp = (greg_t)sp;
 331         rp->r_pc = (greg_t)hdlr;
 332         rp->r_ps = PSL_USER | (rp->r_ps & PS_IOPL);
 333
 334         rp->r_rdi = sig;
 335         rp->r_rsi = (uintptr_t)sip_addr;
 336         rp->r_rdx = (uintptr_t)uc;
 337
 338         if ((rp->r_cs & 0xffff) != UCS_SEL ||
 339             (rp->r_ss & 0xffff) != UDS_SEL) {
 340                 /*
 341                  * Try our best to deliver the signal.
 342                  */
 343                 rp->r_cs = UCS_SEL;
 344                 rp->r_ss = UDS_SEL;
 345         }
 346
 347         /*
 348          * Don't set lwp_eosys here.  sendsig() is called via psig() after
 349          * lwp_eosys is handled, so setting it here would affect the next
 350          * system call.
 351          */
 352         return (1);
 353
 354 badstack:
 355         no_fault();
 356         if (watched)
 357                 watch_enable_addr((caddr_t)sp, minstacksz, S_WRITE);
 358         if (tuc)
 359                 kmem_free(tuc, sizeof (*tuc));
 360 #ifdef DEBUG
 361         printf("sendsig: bad signal stack cmd=%s, pid=%d, sig=%d\n",
 362             PTOU(p)->u_comm, p->p_pid, sig);
 363         printf("on fault, sigsp = 0x%p, action = 0x%p, upc = 0x%lx\n",
 364             (void *)sp, (void *)hdlr, (uintptr_t)upc);
 365 #endif
 366         return (0);
 367 }
 368
 369 #ifdef _SYSCALL32_IMPL
 370
 371 /*
 372  * An i386 SVR4/ABI signal frame looks like this on the stack:
 373  *
 374  * old %esp:
 375  *              <a siginfo32_t [optional]>
 376  *              <a ucontext32_t>
 377  *              <pointer to that ucontext32_t>
 378  *              <pointer to that siginfo32_t>
 379  *              <signo>
 380  * new %esp:    <return address (deliberately invalid)>
 381  */
 382 struct sigframe32 {
 383         caddr32_t       retaddr;
 384         uint32_t        signo;
 385         caddr32_t       sip;
 386         caddr32_t       ucp;
 387 };
 388
 389 int
 390 sendsig32(int sig, k_siginfo_t *sip, void (*hdlr)())
 391 {
 392         volatile int minstacksz;
 393         int newstack;
 394         label_t ljb;
 395         volatile caddr_t sp;
 396         caddr_t fp;
 397         volatile struct regs *rp;
 398         volatile greg_t upc;
 399         volatile proc_t *p = ttoproc(curthread);
 400         klwp_t *lwp = ttolwp(curthread);
 401         ucontext32_t *volatile tuc = NULL;
 402         ucontext32_t *uc;
 403         siginfo32_t *sip_addr;
 404         volatile int watched;
 405
 406         rp = lwptoregs(lwp);
 407         upc = rp->r_pc;
 408
 409         minstacksz = SA32(sizeof (struct sigframe32)) + SA32(sizeof (*uc));
 410         if (sip != NULL)
 411                 minstacksz += SA32(sizeof (siginfo32_t));
 412         ASSERT((minstacksz & (STACK_ALIGN32 - 1)) == 0);
 413
 414         /*
 415          * Figure out whether we will be handling this signal on
 416          * an alternate stack specified by the user.  Then allocate
 417          * and validate the stack requirements for the signal handler
 418          * context.  on_fault will catch any faults.
 419          */
 420         newstack = sigismember(&PTOU(curproc)->u_sigonstack, sig) &&
 421             !(lwp->lwp_sigaltstack.ss_flags & (SS_ONSTACK|SS_DISABLE));
 422
 423         if (newstack) {
 424                 fp = (caddr_t)(SA32((uintptr_t)lwp->lwp_sigaltstack.ss_sp) +
 425                     SA32(lwp->lwp_sigaltstack.ss_size) - STACK_ALIGN32);
 426         } else if ((rp->r_ss & 0xffff) != UDS_SEL) {
 427                 user_desc_t *ldt;
 428                 /*
 429                  * If the stack segment selector is -not- pointing at
 430                  * the UDS_SEL descriptor and we have an LDT entry for
 431                  * it instead, add the base address to find the effective va.
 432                  */
 433                 if ((ldt = p->p_ldt) != NULL)
 434                         fp = (caddr_t)rp->r_sp +
 435                             USEGD_GETBASE(&ldt[SELTOIDX(rp->r_ss)]);
 436                 else
 437                         fp = (caddr_t)rp->r_sp;
 438         } else
 439                 fp = (caddr_t)rp->r_sp;
 440
 441         /*
 442          * Force proper stack pointer alignment, even in the face of a
 443          * misaligned stack pointer from user-level before the signal.
 444          * Don't use the SA32() macro because that rounds up, not down.
 445          */
 446         fp = (caddr_t)((uintptr_t)fp & ~(STACK_ALIGN32 - 1));
 447         sp = fp - minstacksz;
 448
 449         /*
 450          * Make sure lwp hasn't trashed its stack
 451          */
 452         if (sp >= (caddr_t)(uintptr_t)USERLIMIT32 ||
 453             fp >= (caddr_t)(uintptr_t)USERLIMIT32) {
 454 #ifdef DEBUG
 455                 printf("sendsig32: bad signal stack cmd=%s, pid=%d, sig=%d\n",
 456                     PTOU(p)->u_comm, p->p_pid, sig);
 457                 printf("sigsp = 0x%p, action = 0x%p, upc = 0x%lx\n",
 458                     (void *)sp, (void *)hdlr, (uintptr_t)upc);
 459                 printf("sp above USERLIMIT\n");
 460 #endif
 461                 return (0);
 462         }
 463
 464         watched = watch_disable_addr((caddr_t)sp, minstacksz, S_WRITE);
 465
 466         if (on_fault(&ljb))
 467                 goto badstack;
 468
 469         if (sip != NULL) {
 470                 siginfo32_t si32;
 471                 zoneid_t zoneid;
 472
 473                 siginfo_kto32(sip, &si32);
 474                 if (SI_FROMUSER(sip) &&
 475                     (zoneid = p->p_zone->zone_id) != GLOBAL_ZONEID &&
 476                     zoneid != sip->si_zoneid) {
 477                         si32.si_pid = p->p_zone->zone_zsched->p_pid;
 478                         si32.si_uid = 0;
 479                         si32.si_ctid = -1;
 480                         si32.si_zoneid = zoneid;
 481                 }
 482                 fp -= SA32(sizeof (si32));
 483                 uzero(fp, sizeof (si32));
 484                 copyout_noerr(&si32, fp, sizeof (si32));
 485                 sip_addr = (siginfo32_t *)fp;
 486
 487                 if (sig == SIGPROF &&
 488                     curthread->t_rprof != NULL &&
 489                     curthread->t_rprof->rp_anystate) {
 490                         /*
 491                          * We stand on our head to deal with
 492                          * the real-time profiling signal.
 493                          * Fill in the stuff that doesn't fit
 494                          * in a normal k_siginfo structure.
 495                          */
 496                         int i = sip->si_nsysarg;
 497
 498                         while (--i >= 0)
 499                                 suword32_noerr(&(sip_addr->si_sysarg[i]),
 500                                     (uint32_t)lwp->lwp_arg[i]);
 501                         copyout_noerr(curthread->t_rprof->rp_state,
 502                             sip_addr->si_mstate,
 503                             sizeof (curthread->t_rprof->rp_state));
 504                 }
 505         } else
 506                 sip_addr = NULL;
 507
 508         /* save the current context on the user stack */
 509         fp -= SA32(sizeof (*tuc));
 510         uc = (ucontext32_t *)fp;
 511         tuc = kmem_alloc(sizeof (*tuc), KM_SLEEP);
 512         no_fault();
 513         savecontext32(tuc, &lwp->lwp_sigoldmask);
 514         if (on_fault(&ljb))
 515                 goto badstack;
 516         copyout_noerr(tuc, uc, sizeof (*tuc));
 517         kmem_free(tuc, sizeof (*tuc));
 518         tuc = NULL;
 519
 520         lwp->lwp_oldcontext = (uintptr_t)uc;
 521
 522         if (newstack) {
 523                 lwp->lwp_sigaltstack.ss_flags |= SS_ONSTACK;
 524                 if (lwp->lwp_ustack) {
 525                         stack32_t stk32;
 526
 527                         stk32.ss_sp = (caddr32_t)(uintptr_t)
 528                             lwp->lwp_sigaltstack.ss_sp;
 529                         stk32.ss_size = (size32_t)
 530                             lwp->lwp_sigaltstack.ss_size;
 531                         stk32.ss_flags = (int32_t)
 532                             lwp->lwp_sigaltstack.ss_flags;
 533                         copyout_noerr(&stk32,
 534                             (stack32_t *)lwp->lwp_ustack, sizeof (stk32));
 535                 }
 536         }
 537
 538         /*
 539          * Set up signal handler arguments
 540          */
 541         {
 542                 struct sigframe32 frame32;
 543
 544                 frame32.sip = (caddr32_t)(uintptr_t)sip_addr;
 545                 frame32.ucp = (caddr32_t)(uintptr_t)uc;
 546                 frame32.signo = sig;
 547                 frame32.retaddr = 0xffffffff;   /* never return! */
 548                 copyout_noerr(&frame32, sp, sizeof (frame32));
 549         }
 550
 551         no_fault();
 552         if (watched)
 553                 watch_enable_addr((caddr_t)sp, minstacksz, S_WRITE);
 554
 555         rp->r_sp = (greg_t)(uintptr_t)sp;
 556         rp->r_pc = (greg_t)(uintptr_t)hdlr;
 557         rp->r_ps = PSL_USER | (rp->r_ps & PS_IOPL);
 558
 559         if ((rp->r_cs & 0xffff) != U32CS_SEL ||
 560             (rp->r_ss & 0xffff) != UDS_SEL) {
 561                 /*
 562                  * Try our best to deliver the signal.
 563                  */
 564                 rp->r_cs = U32CS_SEL;
 565                 rp->r_ss = UDS_SEL;
 566         }
 567
 568         /*
 569          * Don't set lwp_eosys here.  sendsig() is called via psig() after
 570          * lwp_eosys is handled, so setting it here would affect the next
 571          * system call.
 572          */
 573         return (1);
 574
 575 badstack:
 576         no_fault();
 577         if (watched)
 578                 watch_enable_addr((caddr_t)sp, minstacksz, S_WRITE);
 579         if (tuc)
 580                 kmem_free(tuc, sizeof (*tuc));
 581 #ifdef DEBUG
 582         printf("sendsig32: bad signal stack cmd=%s pid=%d, sig=%d\n",
 583             PTOU(p)->u_comm, p->p_pid, sig);
 584         printf("on fault, sigsp = 0x%p, action = 0x%p, upc = 0x%lx\n",
 585             (void *)sp, (void *)hdlr, (uintptr_t)upc);
 586 #endif
 587         return (0);
 588 }
 589
 590 #endif  /* _SYSCALL32_IMPL */
 591
 592 #elif defined(__i386)
 593
 594 /*
 595  * An i386 SVR4/ABI signal frame looks like this on the stack:
 596  *
 597  * old %esp:
 598  *              <a siginfo32_t [optional]>
 599  *              <a ucontext32_t>
 600  *              <pointer to that ucontext32_t>
 601  *              <pointer to that siginfo32_t>
 602  *              <signo>
 603  * new %esp:    <return address (deliberately invalid)>
 604  */
 605 struct sigframe {
 606         void            (*retaddr)();
 607         uint_t          signo;
 608         siginfo_t       *sip;
 609         ucontext_t      *ucp;
 610 };
 611
 612 int
 613 sendsig(int sig, k_siginfo_t *sip, void (*hdlr)())
 614 {
 615         volatile int minstacksz;
 616         int newstack;
 617         label_t ljb;
 618         volatile caddr_t sp;
 619         caddr_t fp;
 620         struct regs *rp;
 621         volatile greg_t upc;
 622         volatile proc_t *p = ttoproc(curthread);
 623         klwp_t *lwp = ttolwp(curthread);
 624         ucontext_t *volatile tuc = NULL;
 625         ucontext_t *uc;
 626         siginfo_t *sip_addr;
 627         volatile int watched;
 628
 629         rp = lwptoregs(lwp);
 630         upc = rp->r_pc;
 631
 632         minstacksz = SA(sizeof (struct sigframe)) + SA(sizeof (*uc));
 633         if (sip != NULL)
 634                 minstacksz += SA(sizeof (siginfo_t));
 635         ASSERT((minstacksz & (STACK_ALIGN - 1ul)) == 0);
 636
 637         /*
 638          * Figure out whether we will be handling this signal on
 639          * an alternate stack specified by the user. Then allocate
 640          * and validate the stack requirements for the signal handler
 641          * context. on_fault will catch any faults.
 642          */
 643         newstack = sigismember(&PTOU(curproc)->u_sigonstack, sig) &&
 644             !(lwp->lwp_sigaltstack.ss_flags & (SS_ONSTACK|SS_DISABLE));
 645
 646         if (newstack) {
 647                 fp = (caddr_t)(SA((uintptr_t)lwp->lwp_sigaltstack.ss_sp) +
 648                     SA(lwp->lwp_sigaltstack.ss_size) - STACK_ALIGN);
 649         } else if ((rp->r_ss & 0xffff) != UDS_SEL) {
 650                 user_desc_t *ldt;
 651                 /*
 652                  * If the stack segment selector is -not- pointing at
 653                  * the UDS_SEL descriptor and we have an LDT entry for
 654                  * it instead, add the base address to find the effective va.
 655                  */
 656                 if ((ldt = p->p_ldt) != NULL)
 657                         fp = (caddr_t)rp->r_sp +
 658                             USEGD_GETBASE(&ldt[SELTOIDX(rp->r_ss)]);
 659                 else
 660                         fp = (caddr_t)rp->r_sp;
 661         } else
 662                 fp = (caddr_t)rp->r_sp;
 663
 664         /*
 665          * Force proper stack pointer alignment, even in the face of a
 666          * misaligned stack pointer from user-level before the signal.
 667          * Don't use the SA() macro because that rounds up, not down.
 668          */
 669         fp = (caddr_t)((uintptr_t)fp & ~(STACK_ALIGN - 1ul));
 670         sp = fp - minstacksz;
 671
 672         /*
 673          * Make sure lwp hasn't trashed its stack.
 674          */
 675         if (sp >= (caddr_t)USERLIMIT || fp >= (caddr_t)USERLIMIT) {
 676 #ifdef DEBUG
 677                 printf("sendsig: bad signal stack cmd=%s, pid=%d, sig=%d\n",
 678                     PTOU(p)->u_comm, p->p_pid, sig);
 679                 printf("sigsp = 0x%p, action = 0x%p, upc = 0x%lx\n",
 680                     (void *)sp, (void *)hdlr, (uintptr_t)upc);
 681                 printf("sp above USERLIMIT\n");
 682 #endif
 683                 return (0);
 684         }
 685
 686         watched = watch_disable_addr((caddr_t)sp, minstacksz, S_WRITE);
 687
 688         if (on_fault(&ljb))
 689                 goto badstack;
 690
 691         if (sip != NULL) {
 692                 zoneid_t zoneid;
 693
 694                 fp -= SA(sizeof (siginfo_t));
 695                 uzero(fp, sizeof (siginfo_t));
 696                 if (SI_FROMUSER(sip) &&
 697                     (zoneid = p->p_zone->zone_id) != GLOBAL_ZONEID &&
 698                     zoneid != sip->si_zoneid) {
 699                         k_siginfo_t sani_sip = *sip;
 700
 701                         sani_sip.si_pid = p->p_zone->zone_zsched->p_pid;
 702                         sani_sip.si_uid = 0;
 703                         sani_sip.si_ctid = -1;
 704                         sani_sip.si_zoneid = zoneid;
 705                         copyout_noerr(&sani_sip, fp, sizeof (sani_sip));
 706                 } else
 707                         copyout_noerr(sip, fp, sizeof (*sip));
 708                 sip_addr = (siginfo_t *)fp;
 709
 710                 if (sig == SIGPROF &&
 711                     curthread->t_rprof != NULL &&
 712                     curthread->t_rprof->rp_anystate) {
 713                         /*
 714                          * We stand on our head to deal with
 715                          * the real time profiling signal.
 716                          * Fill in the stuff that doesn't fit
 717                          * in a normal k_siginfo structure.
 718                          */
 719                         int i = sip->si_nsysarg;
 720
 721                         while (--i >= 0)
 722                                 suword32_noerr(&(sip_addr->si_sysarg[i]),
 723                                     (uint32_t)lwp->lwp_arg[i]);
 724                         copyout_noerr(curthread->t_rprof->rp_state,
 725                             sip_addr->si_mstate,
 726                             sizeof (curthread->t_rprof->rp_state));
 727                 }
 728         } else
 729                 sip_addr = NULL;
 730
 731         /* save the current context on the user stack */
 732         fp -= SA(sizeof (*tuc));
 733         uc = (ucontext_t *)fp;
 734         tuc = kmem_alloc(sizeof (*tuc), KM_SLEEP);
 735         savecontext(tuc, &lwp->lwp_sigoldmask);
 736         copyout_noerr(tuc, uc, sizeof (*tuc));
 737         kmem_free(tuc, sizeof (*tuc));
 738         tuc = NULL;
 739
 740         lwp->lwp_oldcontext = (uintptr_t)uc;
 741
 742         if (newstack) {
 743                 lwp->lwp_sigaltstack.ss_flags |= SS_ONSTACK;
 744                 if (lwp->lwp_ustack)
 745                         copyout_noerr(&lwp->lwp_sigaltstack,
 746                             (stack_t *)lwp->lwp_ustack, sizeof (stack_t));
 747         }
 748
 749         /*
 750          * Set up signal handler arguments
 751          */
 752         {
 753                 struct sigframe frame;
 754
 755                 frame.sip = sip_addr;
 756                 frame.ucp = uc;
 757                 frame.signo = sig;
 758                 frame.retaddr = (void (*)())0xffffffff; /* never return! */
 759                 copyout_noerr(&frame, sp, sizeof (frame));
 760         }
 761
 762         no_fault();
 763         if (watched)
 764                 watch_enable_addr((caddr_t)sp, minstacksz, S_WRITE);
 765
 766         rp->r_sp = (greg_t)sp;
 767         rp->r_pc = (greg_t)hdlr;
 768         rp->r_ps = PSL_USER | (rp->r_ps & PS_IOPL);
 769
 770         if ((rp->r_cs & 0xffff) != UCS_SEL ||
 771             (rp->r_ss & 0xffff) != UDS_SEL) {
 772                 rp->r_cs = UCS_SEL;
 773                 rp->r_ss = UDS_SEL;
 774         }
 775
 776         /*
 777          * Don't set lwp_eosys here.  sendsig() is called via psig() after
 778          * lwp_eosys is handled, so setting it here would affect the next
 779          * system call.
 780          */
 781         return (1);
 782
 783 badstack:
 784         no_fault();
 785         if (watched)
 786                 watch_enable_addr((caddr_t)sp, minstacksz, S_WRITE);
 787         if (tuc)
 788                 kmem_free(tuc, sizeof (*tuc));
 789 #ifdef DEBUG
 790         printf("sendsig: bad signal stack cmd=%s, pid=%d, sig=%d\n",
 791             PTOU(p)->u_comm, p->p_pid, sig);
 792         printf("on fault, sigsp = 0x%p, action = 0x%p, upc = 0x%lx\n",
 793             (void *)sp, (void *)hdlr, (uintptr_t)upc);
 794 #endif
 795         return (0);
 796 }
 797
 798 #endif  /* __i386 */