xnu-1504.3.12.tar.gz

[apple/xnu.git] / bsd / dev / i386 / unix_signal.c

diff --git a/bsd/dev/i386/unix_signal.c b/bsd/dev/i386/unix_signal.c
index 8c6305d52e6822739898be8436a3564d096dad7e..eb96e879edaba0d778bd1f805c533b7a71a52a6c 100644 (file)
--- a/bsd/dev/i386/unix_signal.c
+++ b/bsd/dev/i386/unix_signal.c
@@ -1,23 +1,29 @@
 /*
  * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
  *
 /*
  * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.

  * 
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /* 
  * Copyright (c) 1992 NeXT, Inc.
  */
 /* 
  * Copyright (c) 1992 NeXT, Inc.


@@ -42,16 +48,21 @@
 #include <sys/wait.h>
 #include <mach/thread_act.h>   /* for thread_abort_safely */
 #include <mach/thread_status.h>        
 #include <sys/wait.h>
 #include <mach/thread_act.h>   /* for thread_abort_safely */
 #include <mach/thread_status.h>        

-#include <i386/machine_routines.h>

 
 #include <i386/eflags.h>
 #include <i386/psl.h>
 
 #include <i386/eflags.h>
 #include <i386/psl.h>

+#include <i386/machine_routines.h>

 #include <i386/seg.h>
 
 #include <sys/kdebug.h>
 
 #include <i386/seg.h>
 
 #include <sys/kdebug.h>
 

+#include <sys/sdt.h>
+
+
+

 /* Forward: */
 /* Forward: */

-extern boolean_t machine_exception(int, int, int, int *, int *);
+extern boolean_t machine_exception(int, mach_exception_code_t, 
+               mach_exception_subcode_t, int *, mach_exception_subcode_t *);

 extern kern_return_t thread_getstatus(register thread_t act, int flavor,
                        thread_state_t tstate, mach_msg_type_number_t *count);
 extern kern_return_t thread_setstatus(thread_t thread, int flavor,
 extern kern_return_t thread_getstatus(register thread_t act, int flavor,
                        thread_state_t tstate, mach_msg_type_number_t *count);
 extern kern_return_t thread_setstatus(thread_t thread, int flavor,


@@ -61,6 +72,8 @@ extern kern_return_t thread_setstatus(thread_t thread, int flavor,
 /* These defns should match the Libc implmn */
 #define UC_TRAD                        1
 #define UC_FLAVOR              30
 /* These defns should match the Libc implmn */
 #define UC_TRAD                        1
 #define UC_FLAVOR              30

+#define        UC_SET_ALT_STACK        0x40000000
+#define        UC_RESET_ALT_STACK      0x80000000

 
 #define        C_32_STK_ALIGN          16
 #define        C_64_STK_ALIGN          16
 
 #define        C_32_STK_ALIGN          16
 #define        C_64_STK_ALIGN          16


@@ -79,18 +92,50 @@ extern kern_return_t thread_setstatus(thread_t thread, int flavor,
  * to the user specified pc, psl.
  */
 struct sigframe32 {
  * to the user specified pc, psl.
  */
 struct sigframe32 {

-        int              retaddr;
-       sig_t             catcher;
-       int               sigstyle;
-       int               sig;
-       siginfo_t       * sinfo;
-       struct ucontext * uctx;
+       int             retaddr;
+       user32_addr_t   catcher; /* sig_t */
+       int             sigstyle;
+       int             sig;
+       user32_addr_t   sinfo;  /* siginfo32_t* */
+       user32_addr_t   uctx;   /* struct ucontext32 */

 };
 
 };
 

+/*
+ * NOTE: Source and target may *NOT* overlap!
+ */
+static void
+siginfo_user_to_user32(user_siginfo_t *in, user32_siginfo_t *out)
+{
+       out->si_signo   = in->si_signo;
+       out->si_errno   = in->si_errno;
+       out->si_code    = in->si_code;
+       out->si_pid     = in->si_pid;
+       out->si_uid     = in->si_uid;
+       out->si_status  = in->si_status;
+       out->si_addr    = CAST_DOWN_EXPLICIT(user32_addr_t,in->si_addr);
+       /* following cast works for sival_int because of padding */
+       out->si_value.sival_ptr = CAST_DOWN_EXPLICIT(user32_addr_t,in->si_value.sival_ptr);
+       out->si_band    = in->si_band;                  /* range reduction */
+       out->__pad[0]   = in->pad[0];                   /* mcontext.ss.r1 */
+}

 
 

+static void
+siginfo_user_to_user64(user_siginfo_t *in, user64_siginfo_t *out)
+{
+       out->si_signo   = in->si_signo;
+       out->si_errno   = in->si_errno;
+       out->si_code    = in->si_code;
+       out->si_pid     = in->si_pid;
+       out->si_uid     = in->si_uid;
+       out->si_status  = in->si_status;
+       out->si_addr    = in->si_addr;
+       out->si_value.sival_ptr = in->si_value.sival_ptr;
+       out->si_band    = in->si_band;                  /* range reduction */
+       out->__pad[0]   = in->pad[0];                   /* mcontext.ss.r1 */
+}

 
 void
 
 void

-sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_long code)
+sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused uint32_t code)

 {
         union {
            struct mcontext32   mctx32;
 {
         union {
            struct mcontext32   mctx32;


@@ -106,36 +151,35 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
 
        struct sigacts *ps = p->p_sigacts;
        int oonstack, flavor; 
 
        struct sigacts *ps = p->p_sigacts;
        int oonstack, flavor; 

+       user_addr_t trampact;
+       int sigonstack;

        void * state;
        mach_msg_type_number_t state_count;
        void * state;
        mach_msg_type_number_t state_count;

-       int uthsigaltstack = 0;
-       int altstack = 0;

 
 

-       thread_t thread = current_thread();
+       thread_t thread;

        struct uthread * ut;
        int stack_size = 0;
        int infostyle = UC_TRAD;
     
        struct uthread * ut;
        int stack_size = 0;
        int infostyle = UC_TRAD;
     

+       thread = current_thread();
+       ut = get_bsdthread_info(thread);
+

        if (p->p_sigacts->ps_siginfo & sigmask(sig))
                infostyle = UC_FLAVOR;
 
        if (p->p_sigacts->ps_siginfo & sigmask(sig))
                infostyle = UC_FLAVOR;
 

-       ut = get_bsdthread_info(thread);
-
-       uthsigaltstack = p->p_lflag & P_LTHSIGSTACK;
+       oonstack = ut->uu_sigstk.ss_flags & SA_ONSTACK;
+       trampact = ps->ps_trampact[sig];
+       sigonstack = (ps->ps_sigonstack & sigmask(sig));

 
 

-       if (uthsigaltstack != 0 )  {
-               oonstack = ut->uu_sigstk.ss_flags & SA_ONSTACK;
-               altstack = ut->uu_flag & UT_ALTSTACK;
-       } else {
-               oonstack = ps->ps_sigstk.ss_flags & SA_ONSTACK;
-               altstack = ps->ps_flags & SAS_ALTSTACK;
-       }

        /*
         * init siginfo
         */
        /*
         * init siginfo
         */

-       bzero((caddr_t)&sinfo64, sizeof(user_siginfo_t));
+       proc_unlock(p);
+
+       bzero((caddr_t)&sinfo64, sizeof(sinfo64));

        sinfo64.si_signo = sig;
                
        sinfo64.si_signo = sig;
                

+

        if (proc_is64bit(p)) {
                x86_thread_state64_t    *tstate64;
                struct user_ucontext64  uctx64;
        if (proc_is64bit(p)) {
                x86_thread_state64_t    *tstate64;
                struct user_ucontext64  uctx64;


@@ -160,20 +204,16 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
 
                tstate64 = &mctx.mctx64.ss;
 
 
                tstate64 = &mctx.mctx64.ss;
 

-               if (altstack && !oonstack && (ps->ps_sigonstack & sigmask(sig))) {
-                       if (uthsigaltstack != 0) {
-                               ua_sp = ut->uu_sigstk.ss_sp;
-                               stack_size = ut->uu_sigstk.ss_size;
-                               ua_sp += stack_size;
-                               ut->uu_sigstk.ss_flags |= SA_ONSTACK;
-                       } else {
-                               ua_sp = ps->ps_sigstk.ss_sp;
-                               stack_size = ps->ps_sigstk.ss_size;
-                               ua_sp += stack_size;
-                               ps->ps_sigstk.ss_flags |= SA_ONSTACK;
-                       }
-               } else
+               /* figure out where our new stack lives */
+               if ((ut->uu_flag & UT_ALTSTACK) && !oonstack &&
+                   (sigonstack)) {
+                       ua_sp = ut->uu_sigstk.ss_sp;
+                       stack_size = ut->uu_sigstk.ss_size;
+                       ua_sp += stack_size;
+                       ut->uu_sigstk.ss_flags |= SA_ONSTACK;
+               } else {

                        ua_sp = tstate64->rsp;
                        ua_sp = tstate64->rsp;

+               }

                ua_cr2 = mctx.mctx64.es.faultvaddr;
 
                /* The x86_64 ABI defines a 128-byte red zone. */
                ua_cr2 = mctx.mctx64.es.faultvaddr;
 
                /* The x86_64 ABI defines a 128-byte red zone. */


@@ -182,7 +222,7 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
                ua_sp -= sizeof (struct user_ucontext64);
                ua_uctxp = ua_sp;                        // someone tramples the first word!
 
                ua_sp -= sizeof (struct user_ucontext64);
                ua_uctxp = ua_sp;                        // someone tramples the first word!
 

-               ua_sp -= sizeof (user_siginfo_t);
+               ua_sp -= sizeof (user64_siginfo_t);

                ua_sip = ua_sp;
 
                ua_sp -= sizeof (struct mcontext64);
                ua_sip = ua_sp;
 
                ua_sp -= sizeof (struct mcontext64);


@@ -226,7 +266,7 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
                sinfo64.pad[0]  = tstate64->rsp;
                sinfo64.si_addr = tstate64->rip;
 
                sinfo64.pad[0]  = tstate64->rsp;
                sinfo64.si_addr = tstate64->rip;
 

-               tstate64->rip = ps->ps_trampact[sig];
+               tstate64->rip = trampact;

                tstate64->rsp = ua_fp;
                tstate64->rflags = get_eflags_exportmask();
                /*
                tstate64->rsp = ua_fp;
                tstate64->rflags = get_eflags_exportmask();
                /*


@@ -248,7 +288,7 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
 
        } else {
                x86_thread_state32_t    *tstate32;
 
        } else {
                x86_thread_state32_t    *tstate32;

-               struct ucontext         uctx32;
+               struct user_ucontext32  uctx32;

                struct sigframe32       frame32;
 
                flavor = x86_THREAD_STATE32;
                struct sigframe32       frame32;
 
                flavor = x86_THREAD_STATE32;


@@ -271,26 +311,22 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
 
                tstate32 = &mctx.mctx32.ss;
 
 
                tstate32 = &mctx.mctx32.ss;
 

-               if (altstack && !oonstack && (ps->ps_sigonstack & sigmask(sig))) {
-                       if (uthsigaltstack != 0) {
-                               ua_sp = ut->uu_sigstk.ss_sp;
-                               stack_size = ut->uu_sigstk.ss_size;
-                               ua_sp += stack_size;
-                               ut->uu_sigstk.ss_flags |= SA_ONSTACK;
-                       } else {
-                               ua_sp = ps->ps_sigstk.ss_sp;
-                               stack_size = ps->ps_sigstk.ss_size;
-                               ua_sp += stack_size;
-                               ps->ps_sigstk.ss_flags |= SA_ONSTACK;
-                       }
-               } else
+               /* figure out where our new stack lives */
+               if ((ut->uu_flag & UT_ALTSTACK) && !oonstack &&
+                   (sigonstack)) {
+                       ua_sp = ut->uu_sigstk.ss_sp;
+                       stack_size = ut->uu_sigstk.ss_size;
+                       ua_sp += stack_size;
+                       ut->uu_sigstk.ss_flags |= SA_ONSTACK;
+               } else {

                        ua_sp = tstate32->esp;
                        ua_sp = tstate32->esp;

+               }

                ua_cr2 = mctx.mctx32.es.faultvaddr;
 
                ua_cr2 = mctx.mctx32.es.faultvaddr;
 

-               ua_sp -= sizeof (struct ucontext);
+               ua_sp -= sizeof (struct user_ucontext32);

                ua_uctxp = ua_sp;                        // someone tramples the first word!
 
                ua_uctxp = ua_sp;                        // someone tramples the first word!
 

-               ua_sp -= sizeof (siginfo_t);
+               ua_sp -= sizeof (user32_siginfo_t);

                ua_sip = ua_sp;
 
                ua_sp -= sizeof (struct mcontext32);
                ua_sip = ua_sp;
 
                ua_sp -= sizeof (struct mcontext32);


@@ -318,9 +354,9 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
                frame32.retaddr = -1;   
                frame32.sigstyle = infostyle;
                frame32.sig = sig;
                frame32.retaddr = -1;   
                frame32.sigstyle = infostyle;
                frame32.sig = sig;

-               frame32.catcher = CAST_DOWN(sig_t, ua_catcher);
-               frame32.sinfo = CAST_DOWN(siginfo_t *, ua_sip);
-               frame32.uctx = CAST_DOWN(struct ucontext *, ua_uctxp);
+               frame32.catcher = CAST_DOWN_EXPLICIT(user32_addr_t, ua_catcher);
+               frame32.sinfo = CAST_DOWN_EXPLICIT(user32_addr_t, ua_sip);
+               frame32.uctx = CAST_DOWN_EXPLICIT(user32_addr_t, ua_uctxp);

 
                if (copyout((caddr_t)&frame32, ua_fp, sizeof (frame32))) 
                        goto bad;
 
                if (copyout((caddr_t)&frame32, ua_fp, sizeof (frame32))) 
                        goto bad;


@@ -332,7 +368,7 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
 
                uctx32.uc_onstack = oonstack;
                uctx32.uc_sigmask = mask;
 
                uctx32.uc_onstack = oonstack;
                uctx32.uc_sigmask = mask;

-               uctx32.uc_stack.ss_sp = CAST_DOWN(char *, ua_fp);
+               uctx32.uc_stack.ss_sp = CAST_DOWN_EXPLICIT(user32_addr_t, ua_fp);

                uctx32.uc_stack.ss_size = stack_size;
 
                if (oonstack)
                uctx32.uc_stack.ss_size = stack_size;
 
                if (oonstack)


@@ -341,7 +377,7 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
 
                uctx32.uc_mcsize = sizeof(struct mcontext32);
 
 
                uctx32.uc_mcsize = sizeof(struct mcontext32);
 

-               uctx32.uc_mcontext = CAST_DOWN(struct mcontext *, ua_mctxp);
+               uctx32.uc_mcontext = CAST_DOWN_EXPLICIT(user32_addr_t, ua_mctxp);

                
                if (copyout((caddr_t)&uctx32, ua_uctxp, sizeof (uctx32))) 
                        goto bad;
                
                if (copyout((caddr_t)&uctx32, ua_uctxp, sizeof (uctx32))) 
                        goto bad;


@@ -354,36 +390,12 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
        }
 
        switch (sig) {
        }
 
        switch (sig) {

-               case SIGCHLD:
-                       sinfo64.si_pid = p->si_pid;
-                       p->si_pid =0;
-                       sinfo64.si_status = p->si_status;
-                       p->si_status = 0;
-                       sinfo64.si_uid = p->si_uid;
-                       p->si_uid =0;
-                       sinfo64.si_code = p->si_code;
-                       p->si_code = 0;
-                       if (sinfo64.si_code == CLD_EXITED) {
-                               if (WIFEXITED(sinfo64.si_status)) 
-                                       sinfo64.si_code = CLD_EXITED;
-                               else if (WIFSIGNALED(sinfo64.si_status)) {
-                                       if (WCOREDUMP(sinfo64.si_status))
-                                               sinfo64.si_code = CLD_DUMPED;
-                                       else    
-                                               sinfo64.si_code = CLD_KILLED;
-                               }
-                       }
-                       break;

                case SIGILL:
                        switch (ut->uu_code) {
                                case EXC_I386_INVOP:
                                        sinfo64.si_code = ILL_ILLOPC;
                                        break;
                case SIGILL:
                        switch (ut->uu_code) {
                                case EXC_I386_INVOP:
                                        sinfo64.si_code = ILL_ILLOPC;
                                        break;

-                               case EXC_I386_GPFLT:
-                                       sinfo64.si_code = ILL_PRVOPC;
-                                       break;

                                default:
                                default:

-                                       printf("unknown SIGILL code %d\n", ut->uu_code);

                                        sinfo64.si_code = ILL_NOOP;
                        }
                        break;
                                        sinfo64.si_code = ILL_NOOP;
                        }
                        break;


@@ -394,7 +406,13 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
 #define FP_OE 3 /* overflow */
 #define FP_UE 4 /* underflow */
 #define FP_PE 5 /* precision */
 #define FP_OE 3 /* overflow */
 #define FP_UE 4 /* underflow */
 #define FP_PE 5 /* precision */

-                       if (ut->uu_subcode & (1 << FP_ZE)) {
+                       if (ut->uu_code == EXC_I386_DIV) {
+                               sinfo64.si_code = FPE_INTDIV;
+                       }
+                       else if (ut->uu_code == EXC_I386_INTO) {
+                               sinfo64.si_code = FPE_INTOVF;
+                       }
+                       else if (ut->uu_subcode & (1 << FP_ZE)) {

                                sinfo64.si_code = FPE_FLTDIV;
                        } else if (ut->uu_subcode & (1 << FP_OE)) {
                                sinfo64.si_code = FPE_FLTOVF;
                                sinfo64.si_code = FPE_FLTDIV;
                        } else if (ut->uu_subcode & (1 << FP_OE)) {
                                sinfo64.si_code = FPE_FLTOVF;


@@ -405,8 +423,6 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
                        } else if (ut->uu_subcode & (1 << FP_IE)) {
                                sinfo64.si_code = FPE_FLTINV;
                        } else {
                        } else if (ut->uu_subcode & (1 << FP_IE)) {
                                sinfo64.si_code = FPE_FLTINV;
                        } else {

-                               printf("unknown SIGFPE code %d, subcode %x\n",
-                                      ut->uu_code, ut->uu_subcode);

                                sinfo64.si_code = FPE_NOOP;
                        }
                        break;
                                sinfo64.si_code = FPE_NOOP;
                        }
                        break;


@@ -421,6 +437,12 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
                        sinfo64.si_addr = ua_cr2;
 
                        switch (ut->uu_code) {
                        sinfo64.si_addr = ua_cr2;
 
                        switch (ut->uu_code) {

+                               case EXC_I386_GPFLT:
+                                       /* CR2 is meaningless after GP fault */
+                                       /* XXX namespace clash! */
+                                       sinfo64.si_addr = 0ULL;
+                                       sinfo64.si_code = 0;
+                                       break;

                                case KERN_PROTECTION_FAILURE:
                                        sinfo64.si_code = SEGV_ACCERR;
                                        break;
                                case KERN_PROTECTION_FAILURE:
                                        sinfo64.si_code = SEGV_ACCERR;
                                        break;


@@ -428,41 +450,132 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
                                        sinfo64.si_code = SEGV_MAPERR;
                                        break;
                                default:
                                        sinfo64.si_code = SEGV_MAPERR;
                                        break;
                                default:

-                                       printf("unknown SIGSEGV code %d\n", ut->uu_code);

                                        sinfo64.si_code = FPE_NOOP;
                        }
                                break;
                default:
                                        sinfo64.si_code = FPE_NOOP;
                        }
                                break;
                default:

+               {
+                       int status_and_exitcode;
+
+                       /*
+                        * All other signals need to fill out a minimum set of
+                        * information for the siginfo structure passed into
+                        * the signal handler, if SA_SIGINFO was specified.
+                        *
+                        * p->si_status actually contains both the status and
+                        * the exit code; we save it off in its own variable
+                        * for later breakdown.
+                        */
+                       proc_lock(p);
+                       sinfo64.si_pid = p->si_pid;
+                       p->si_pid =0;
+                       status_and_exitcode = p->si_status;
+                       p->si_status = 0;
+                       sinfo64.si_uid = p->si_uid;
+                       p->si_uid =0;
+                       sinfo64.si_code = p->si_code;
+                       p->si_code = 0;
+                       proc_unlock(p);
+                       if (sinfo64.si_code == CLD_EXITED) {
+                               if (WIFEXITED(status_and_exitcode)) 
+                                       sinfo64.si_code = CLD_EXITED;
+                               else if (WIFSIGNALED(status_and_exitcode)) {
+                                       if (WCOREDUMP(status_and_exitcode)) {
+                                               sinfo64.si_code = CLD_DUMPED;
+                                               status_and_exitcode = W_EXITCODE(status_and_exitcode,status_and_exitcode);
+                                       } else {
+                                               sinfo64.si_code = CLD_KILLED;
+                                               status_and_exitcode = W_EXITCODE(status_and_exitcode,status_and_exitcode);
+                                       }
+                               }
+                       }
+                       /*
+                        * The recorded status contains the exit code and the
+                        * signal information, but the information to be passed
+                        * in the siginfo to the handler is supposed to only
+                        * contain the status, so we have to shift it out.
+                        */
+                       sinfo64.si_status = WEXITSTATUS(status_and_exitcode);

                        break;
                        break;

+               }

        }
        if (proc_is64bit(p)) {
        }
        if (proc_is64bit(p)) {

-               if (copyout((caddr_t)&sinfo64, ua_sip, sizeof (sinfo64))) 
-                       goto bad;
+               user64_siginfo_t sinfo64_user64;
+               
+               bzero((caddr_t)&sinfo64_user64, sizeof(sinfo64_user64));
+                         
+               siginfo_user_to_user64(&sinfo64,&sinfo64_user64);
+
+#if CONFIG_DTRACE
+        bzero((caddr_t)&(ut->t_dtrace_siginfo), sizeof(ut->t_dtrace_siginfo));
+
+        ut->t_dtrace_siginfo.si_signo = sinfo64.si_signo;
+        ut->t_dtrace_siginfo.si_code = sinfo64.si_code;
+        ut->t_dtrace_siginfo.si_pid = sinfo64.si_pid;
+        ut->t_dtrace_siginfo.si_uid = sinfo64.si_uid;
+        ut->t_dtrace_siginfo.si_status = sinfo64.si_status;
+               /* XXX truncates faulting address to void * on K32  */
+        ut->t_dtrace_siginfo.si_addr = CAST_DOWN(void *, sinfo64.si_addr);
+
+               /* Fire DTrace proc:::fault probe when signal is generated by hardware. */
+               switch (sig) {
+               case SIGILL: case SIGBUS: case SIGSEGV: case SIGFPE: case SIGTRAP:
+                       DTRACE_PROC2(fault, int, (int)(ut->uu_code), siginfo_t *, &(ut->t_dtrace_siginfo));
+                       break;
+               default:
+                       break;
+               }
+
+               /* XXX truncates catcher address to uintptr_t */
+               DTRACE_PROC3(signal__handle, int, sig, siginfo_t *, &(ut->t_dtrace_siginfo),
+                       void (*)(void), CAST_DOWN(sig_t, ua_catcher));
+#endif /* CONFIG_DTRACE */
+
+               if (copyout((caddr_t)&sinfo64_user64, ua_sip, sizeof (sinfo64_user64))) 
+                       goto bad;

 
                flavor = x86_THREAD_STATE64;
                state_count = x86_THREAD_STATE64_COUNT;
                state = (void *)&mctx.mctx64.ss;
        } else {
 
                flavor = x86_THREAD_STATE64;
                state_count = x86_THREAD_STATE64_COUNT;
                state = (void *)&mctx.mctx64.ss;
        } else {

-               x86_thread_state32_t    *tstate32;
-               siginfo_t               sinfo32;
+               x86_thread_state32_t    *tstate32;
+               user32_siginfo_t sinfo32;

 
 

-               bzero((caddr_t)&sinfo32, sizeof(siginfo_t));
+               bzero((caddr_t)&sinfo32, sizeof(sinfo32));

 
 

-               sinfo32.si_signo  = sinfo64.si_signo;
-               sinfo32.si_code   = sinfo64.si_code;
-               sinfo32.si_pid    = sinfo64.si_pid;
-               sinfo32.si_uid    = sinfo64.si_uid;
-               sinfo32.si_status = sinfo64.si_status;
-               sinfo32.si_addr   = CAST_DOWN(void *, sinfo64.si_addr);
-               sinfo32.pad[0]    = sinfo64.pad[0];
+               siginfo_user_to_user32(&sinfo64,&sinfo32);

 
 

-               if (copyout((caddr_t)&sinfo32, ua_sip, sizeof (sinfo32))) 
-                       goto bad;
+#if CONFIG_DTRACE
+        bzero((caddr_t)&(ut->t_dtrace_siginfo), sizeof(ut->t_dtrace_siginfo));
+
+        ut->t_dtrace_siginfo.si_signo = sinfo32.si_signo;
+        ut->t_dtrace_siginfo.si_code = sinfo32.si_code;
+        ut->t_dtrace_siginfo.si_pid = sinfo32.si_pid;
+        ut->t_dtrace_siginfo.si_uid = sinfo32.si_uid;
+        ut->t_dtrace_siginfo.si_status = sinfo32.si_status;
+        ut->t_dtrace_siginfo.si_addr = CAST_DOWN(void *, sinfo32.si_addr);
+
+               /* Fire DTrace proc:::fault probe when signal is generated by hardware. */
+               switch (sig) {
+               case SIGILL: case SIGBUS: case SIGSEGV: case SIGFPE: case SIGTRAP:
+                       DTRACE_PROC2(fault, int, (int)(ut->uu_code), siginfo_t *, &(ut->t_dtrace_siginfo));
+                       break;
+               default:
+                       break;
+               }
+
+               DTRACE_PROC3(signal__handle, int, sig, siginfo_t *, &(ut->t_dtrace_siginfo),
+                       void (*)(void), CAST_DOWN(sig_t, ua_catcher));
+#endif /* CONFIG_DTRACE */
+
+               if (copyout((caddr_t)&sinfo32, ua_sip, sizeof (sinfo32))) 
+                       goto bad;

        
                tstate32 = &mctx.mctx32.ss;
        
                tstate32 = &mctx.mctx32.ss;

-               tstate32->eip = CAST_DOWN(unsigned int, ps->ps_trampact[sig]);
-               tstate32->esp = CAST_DOWN(unsigned int, ua_fp);
-               
+
+               tstate32->eip = CAST_DOWN_EXPLICIT(user32_addr_t, trampact);
+               tstate32->esp = CAST_DOWN_EXPLICIT(user32_addr_t, ua_fp);
+

                tstate32->eflags = get_eflags_exportmask();
 
                tstate32->cs = USER_CS;
                tstate32->eflags = get_eflags_exportmask();
 
                tstate32->cs = USER_CS;


@@ -480,16 +593,22 @@ sendsig(struct proc *p, user_addr_t ua_catcher, int sig, int mask, __unused u_lo
                goto bad;
        ml_fp_setvalid(FALSE);
 
                goto bad;
        ml_fp_setvalid(FALSE);
 

+
+       proc_lock(p);
+

        return;
 
 bad:
        return;
 
 bad:

+       proc_lock(p);

        SIGACTION(p, SIGILL) = SIG_DFL;
        sig = sigmask(SIGILL);
        p->p_sigignore &= ~sig;
        p->p_sigcatch &= ~sig;
        ut->uu_sigmask &= ~sig;
        /* sendsig is called with signal lock held */
        SIGACTION(p, SIGILL) = SIG_DFL;
        sig = sigmask(SIGILL);
        p->p_sigignore &= ~sig;
        p->p_sigcatch &= ~sig;
        ut->uu_sigmask &= ~sig;
        /* sendsig is called with signal lock held */

-       psignal_lock(p, SIGILL, 0);
+       proc_unlock(p);
+       psignal_locked(p, SIGILL);
+       proc_lock(p);

        return;
 }
 
        return;
 }
 


@@ -505,10 +624,7 @@ bad:
  */
 
 int
  */
 
 int

-sigreturn(
-       struct proc *p,
-       struct sigreturn_args *uap,
-       __unused int *retval)
+sigreturn(struct proc *p, struct sigreturn_args *uap, __unused int *retval)

 {
         union {
            struct mcontext32   mctx32;
 {
         union {
            struct mcontext32   mctx32;


@@ -517,7 +633,6 @@ sigreturn(
        thread_t thread = current_thread();
        struct uthread * ut;
        int     error;
        thread_t thread = current_thread();
        struct uthread * ut;
        int     error;

-       int     uthsigaltstack = 0;

        int     onstack = 0;
 
        mach_msg_type_number_t ts_count;
        int     onstack = 0;
 
        mach_msg_type_number_t ts_count;


@@ -528,7 +643,18 @@ sigreturn(
        void                *  fs;
 
        ut = (struct uthread *)get_bsdthread_info(thread);
        void                *  fs;
 
        ut = (struct uthread *)get_bsdthread_info(thread);

-       uthsigaltstack = p->p_lflag & P_LTHSIGSTACK;
+
+       /*
+        * If we are being asked to change the altstack flag on the thread, we
+        * just set/reset it and return (the uap->uctx is not used).
+        */
+       if ((unsigned int)uap->infostyle == UC_SET_ALT_STACK) {
+               ut->uu_sigstk.ss_flags |= SA_ONSTACK;
+               return (0);
+       } else if ((unsigned int)uap->infostyle == UC_RESET_ALT_STACK) {
+               ut->uu_sigstk.ss_flags &= ~SA_ONSTACK;
+               return (0);
+       }

 
        if (proc_is64bit(p)) {
                struct user_ucontext64  uctx64;
 
        if (proc_is64bit(p)) {
                struct user_ucontext64  uctx64;


@@ -551,7 +677,7 @@ sigreturn(
                fs = (void *)&mctx.mctx64.fs;
 
       } else {
                fs = (void *)&mctx.mctx64.fs;
 
       } else {

-               struct ucontext         uctx32;
+               struct user_ucontext32  uctx32;

 
                if ((error = copyin(uap->uctx, (void *)&uctx32, sizeof (uctx32)))) 
                        return(error);
 
                if ((error = copyin(uap->uctx, (void *)&uctx32, sizeof (uctx32)))) 
                        return(error);


@@ -570,22 +696,18 @@ sigreturn(
                fs_count  = x86_FLOAT_STATE32_COUNT;
                fs = (void *)&mctx.mctx32.fs;
        }
                fs_count  = x86_FLOAT_STATE32_COUNT;
                fs = (void *)&mctx.mctx32.fs;
        }

-       if (onstack) {
-               if (uthsigaltstack != 0)
-                       ut->uu_sigstk.ss_flags |= SA_ONSTACK;
-               else
-                       p->p_sigacts->ps_sigstk.ss_flags |= SA_ONSTACK;
-       } else {
-               if (uthsigaltstack != 0)
-                       ut->uu_sigstk.ss_flags &= ~SA_ONSTACK;
-               else
-                       p->p_sigacts->ps_sigstk.ss_flags &= ~SA_ONSTACK;
-       }
+
+       if (onstack)
+               ut->uu_sigstk.ss_flags |= SA_ONSTACK;
+       else
+               ut->uu_sigstk.ss_flags &= ~SA_ONSTACK;
+

        if (ut->uu_siglist & ~ut->uu_sigmask)
                signal_setast(thread);
 
        /*
        if (ut->uu_siglist & ~ut->uu_sigmask)
                signal_setast(thread);
 
        /*

-        * thread_set_state() does all the needed checks for the passed in content
+        * thread_set_state() does all the needed checks for the passed in
+        * content

         */
        if (thread_setstatus(thread, ts_flavor, ts, ts_count) != KERN_SUCCESS)
                return(EINVAL);
         */
        if (thread_setstatus(thread, ts_flavor, ts, ts_count) != KERN_SUCCESS)
                return(EINVAL);


@@ -606,78 +728,49 @@ sigreturn(
 
 boolean_t
 machine_exception(
 
 boolean_t
 machine_exception(

-    int                        exception,
-    int                        code,
-    __unused int       subcode,
-    int                        *unix_signal,
-    int                        *unix_code
-)
-{
-
-    switch(exception) {
-
-    case EXC_BAD_INSTRUCTION:
-       *unix_signal = SIGILL;
-       *unix_code = code;
-       break;
-
-    case EXC_ARITHMETIC:
-       *unix_signal = SIGFPE;
-       *unix_code = code;
-       break;
-
-    default:
-       return(FALSE);
-    }
-   
-    return(TRUE);
-}
-
-#include <sys/systm.h>
-#include <sys/sysent.h>
-
-int __pthread_cset(struct sysent *);
-void __pthread_creset(struct sysent *);
-
-int
-__pthread_cset(struct sysent *callp)
+       int                             exception,
+       mach_exception_code_t           code,
+       __unused mach_exception_subcode_t subcode,
+       int                             *unix_signal,
+       mach_exception_code_t           *unix_code)

 {
 {

-       unsigned int cancel_enable;
-       thread_t thread;
-       struct uthread * uthread; 

 
 

-       thread = current_thread();
-       uthread = get_bsdthread_info(thread);
+       switch(exception) {

 
 

-       cancel_enable = callp->sy_cancel;
-       if (cancel_enable == _SYSCALL_CANCEL_NONE) {
-               uthread->uu_flag |= UT_NOTCANCELPT;
-       } else {
-               if((uthread->uu_flag & (UT_CANCELDISABLE | UT_CANCEL | UT_CANCELED)) == UT_CANCEL) {
-                       if (cancel_enable == _SYSCALL_CANCEL_PRE)
-                               return(EINTR);
-                       else
-                               thread_abort_safely(thread);
+       case EXC_BAD_ACCESS:
+               /* Map GP fault to SIGSEGV, otherwise defer to caller */
+               if (code == EXC_I386_GPFLT) {
+                       *unix_signal = SIGSEGV;
+                       *unix_code = code;
+                       break;
+               }
+               return(FALSE);
+
+       case EXC_BAD_INSTRUCTION:
+               *unix_signal = SIGILL;
+               *unix_code = code;
+               break;
+
+       case EXC_ARITHMETIC:
+               *unix_signal = SIGFPE;
+               *unix_code = code;
+               break;
+
+       case EXC_SOFTWARE:
+               if (code == EXC_I386_BOUND) {
+                       /*
+                        * Map #BR, the Bound Range Exceeded exception, to
+                        * SIGTRAP.
+                        */
+                       *unix_signal = SIGTRAP;
+                       *unix_code = code;
+                       break;

                }
                }

-       }   
-       return(0);
-}
-
-
-void
-__pthread_creset(struct sysent *callp)
-{
-
-       unsigned int cancel_enable;
-       thread_t thread;
-       struct uthread * uthread; 
-
-       thread = current_thread();
-       uthread = get_bsdthread_info(thread);
-       
-       cancel_enable = callp->sy_cancel;
-       if (!cancel_enable) 
-               uthread->uu_flag &= ~UT_NOTCANCELPT;

 
 

+       default:
+               return(FALSE);
+       }
+   
+       return(TRUE);

 }
 
 }