xnu-3789.70.16.tar.gz

[apple/xnu.git] / osfmk / i386 / trap.c

diff --git a/osfmk/i386/trap.c b/osfmk/i386/trap.c
index a07b1b8cb470d6fb89725c92197862898e3e799b..7924f4f7dd5f0ce543e13640e96759c0de1fe40d 100644 (file)
--- a/osfmk/i386/trap.c
+++ b/osfmk/i386/trap.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2000-2010 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2016 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 


@@ -60,8 +60,6 @@
 * Hardware trap/fault handler.
  */
 
 * Hardware trap/fault handler.
  */
 

-#include <mach_kdb.h>
-#include <mach_kgdb.h>

 #include <mach_kdp.h>
 #include <mach_ldebug.h>
 
 #include <mach_kdp.h>
 #include <mach_ldebug.h>
 


@@ -91,20 +89,11 @@
 #include <kern/spl.h>
 #include <kern/misc_protos.h>
 #include <kern/debug.h>
 #include <kern/spl.h>
 #include <kern/misc_protos.h>
 #include <kern/debug.h>

-
+#if CONFIG_TELEMETRY
+#include <kern/telemetry.h>
+#endif

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

-
-#if    MACH_KGDB
-#include <kgdb/kgdb_defs.h>
-#endif /* MACH_KGDB */
-
-#if    MACH_KDB
-#include <debug.h>
-#include <ddb/db_watch.h>
-#include <ddb/db_run.h>
-#include <ddb/db_break.h>
-#include <ddb/db_trap.h>
-#endif /* MACH_KDB */
+#include <prng/random.h>

 
 #include <string.h>
 
 
 #include <string.h>
 


@@ -117,7 +106,7 @@
 #include <mach/i386/syscall_sw.h>
 
 #include <libkern/OSDebug.h>
 #include <mach/i386/syscall_sw.h>
 
 #include <libkern/OSDebug.h>

-
+#include <i386/cpu_threads.h>

 #include <machine/pal_routines.h>
 
 extern void throttle_lowpri_io(int);
 #include <machine/pal_routines.h>
 
 extern void throttle_lowpri_io(int);


@@ -127,14 +116,8 @@ extern void kprint_state(x86_saved_state64_t *saved_state);
  * Forward declarations
  */
 static void user_page_fault_continue(kern_return_t kret);
  * Forward declarations
  */
 static void user_page_fault_continue(kern_return_t kret);

-#ifdef __i386__
-static void panic_trap(x86_saved_state32_t *saved_state);
-static void set_recovery_ip(x86_saved_state32_t *saved_state, vm_offset_t ip);
-extern void panic_64(x86_saved_state_t *, int, const char *, boolean_t);
-#else
-static void panic_trap(x86_saved_state64_t *saved_state);
+static void panic_trap(x86_saved_state64_t *saved_state, uint32_t pl, kern_return_t fault_result);

 static void set_recovery_ip(x86_saved_state64_t *saved_state, vm_offset_t ip);
 static void set_recovery_ip(x86_saved_state64_t *saved_state, vm_offset_t ip);

-#endif

 
 volatile perfCallback perfTrapHook = NULL; /* Pointer to CHUD trap hook routine */
 
 
 volatile perfCallback perfTrapHook = NULL; /* Pointer to CHUD trap hook routine */
 


@@ -145,7 +128,10 @@ perfCallback tempDTraceTrapHook = NULL; /* Pointer to DTrace fbt trap hook routi
 extern boolean_t dtrace_tally_fault(user_addr_t);
 #endif
 
 extern boolean_t dtrace_tally_fault(user_addr_t);
 #endif
 

+extern boolean_t pmap_smep_enabled;
+extern boolean_t pmap_smap_enabled;

 
 

+__attribute__((noreturn))

 void
 thread_syscall_return(
         kern_return_t ret)
 void
 thread_syscall_return(
         kern_return_t ret)


@@ -166,7 +152,7 @@ thread_syscall_return(
                            == (SYSCALL_CLASS_MACH << SYSCALL_CLASS_SHIFT);
                if (kdebug_enable && is_mach) {
                        /* Mach trap */
                            == (SYSCALL_CLASS_MACH << SYSCALL_CLASS_SHIFT);
                if (kdebug_enable && is_mach) {
                        /* Mach trap */

-                       KERNEL_DEBUG_CONSTANT(
+                       KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, 

                              MACHDBG_CODE(DBG_MACH_EXCP_SC,code)|DBG_FUNC_END,
                              ret, 0, 0, 0, 0);
                }
                              MACHDBG_CODE(DBG_MACH_EXCP_SC,code)|DBG_FUNC_END,
                              ret, 0, 0, 0, 0);
                }


@@ -190,7 +176,7 @@ thread_syscall_return(
                is_mach = (code < 0);
                if (kdebug_enable && is_mach) {
                        /* Mach trap */
                is_mach = (code < 0);
                if (kdebug_enable && is_mach) {
                        /* Mach trap */

-                       KERNEL_DEBUG_CONSTANT(
+                       KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, 

                              MACHDBG_CODE(DBG_MACH_EXCP_SC,-code)|DBG_FUNC_END,
                              ret, 0, 0, 0, 0);
                }
                              MACHDBG_CODE(DBG_MACH_EXCP_SC,-code)|DBG_FUNC_END,
                              ret, 0, 0, 0, 0);
                }


@@ -206,51 +192,13 @@ thread_syscall_return(
                                ret);
 #endif
        }
                                ret);
 #endif
        }

-       throttle_lowpri_io(TRUE);
+       throttle_lowpri_io(1);

 
        thread_exception_return();
         /*NOTREACHED*/
 }
 
 
 
        thread_exception_return();
         /*NOTREACHED*/
 }
 
 

-#if    MACH_KDB
-boolean_t      debug_all_traps_with_kdb = FALSE;
-extern struct db_watchpoint *db_watchpoint_list;
-extern boolean_t db_watchpoints_inserted;
-extern boolean_t db_breakpoints_inserted;
-
-void
-thread_kdb_return(void)
-{
-       thread_t                thr_act = current_thread();
-       x86_saved_state_t       *iss = USER_STATE(thr_act);
-
-       pal_register_cache_state(thr_act, DIRTY);
-
-        if (is_saved_state64(iss)) {
-               x86_saved_state64_t     *regs;
-               
-               regs = saved_state64(iss);
-
-               if (kdb_trap(regs->isf.trapno, (int)regs->isf.err, (void *)regs)) {
-                       thread_exception_return();
-                       /*NOTREACHED*/
-               }
-
-       } else {
-               x86_saved_state32_t     *regs;
-               
-               regs = saved_state32(iss);
-
-               if (kdb_trap(regs->trapno, regs->err, (void *)regs)) {
-                       thread_exception_return();
-                       /*NOTREACHED*/
-               }
-       }
-}
-
-#endif /* MACH_KDB */
-

 static inline void
 user_page_fault_continue(
                         kern_return_t  kr)
 static inline void
 user_page_fault_continue(
                         kern_return_t  kr)


@@ -258,61 +206,20 @@ user_page_fault_continue(
        thread_t        thread = current_thread();
        user_addr_t     vaddr;
 
        thread_t        thread = current_thread();
        user_addr_t     vaddr;
 

-#if    MACH_KDB
-       x86_saved_state_t *regs = USER_STATE(thread);
-       int             err;
-       int             trapno;
-
-       assert((is_saved_state32(regs) && !thread_is_64bit(thread)) ||
-              (is_saved_state64(regs) &&  thread_is_64bit(thread)));
-#endif
-
-        if (thread_is_64bit(thread)) {
-               x86_saved_state64_t     *uregs;
+       if (thread_is_64bit(thread)) {
+               x86_saved_state64_t     *uregs;

 
                uregs = USER_REGS64(thread);
 
 
                uregs = USER_REGS64(thread);
 

-#if    MACH_KDB
-               trapno = uregs->isf.trapno;
-               err = (int)uregs->isf.err;
-#endif

                vaddr = (user_addr_t)uregs->cr2;
        } else {
                x86_saved_state32_t     *uregs;
 
                uregs = USER_REGS32(thread);
 
                vaddr = (user_addr_t)uregs->cr2;
        } else {
                x86_saved_state32_t     *uregs;
 
                uregs = USER_REGS32(thread);
 

-#if    MACH_KDB
-               trapno = uregs->trapno;
-               err = uregs->err;
-#endif

                vaddr = uregs->cr2;
        }
 
                vaddr = uregs->cr2;
        }
 

-       if (__probable((kr == KERN_SUCCESS) || (kr == KERN_ABORTED))) {
-#if    MACH_KDB
-               if (!db_breakpoints_inserted) {
-                       db_set_breakpoints();
-               }
-               if (db_watchpoint_list &&
-                   db_watchpoints_inserted &&
-                   (err & T_PF_WRITE) &&
-                   db_find_watchpoint(thread->map,
-                                      (vm_offset_t)vaddr,
-                                      saved_state32(regs)))
-                       kdb_trap(T_WATCHPOINT, 0, saved_state32(regs));
-#endif /* MACH_KDB */
-               thread_exception_return();
-               /*NOTREACHED*/
-       }
-
-#if    MACH_KDB
-       if (debug_all_traps_with_kdb &&
-           kdb_trap(trapno, err, saved_state32(regs))) {
-               thread_exception_return();
-               /*NOTREACHED*/
-       }
-#endif /* MACH_KDB */

 
        /* PAL debug hook */
        pal_dbg_page_fault( thread, vaddr, kr );
 
        /* PAL debug hook */
        pal_dbg_page_fault( thread, vaddr, kr );


@@ -352,9 +259,6 @@ kprint_state(x86_saved_state64_t    *saved_state)
        kprintf("      r10    0x%llx\n", saved_state->r10);
        kprintf("      r8     0x%llx\n", saved_state->r8);
        kprintf("      r9     0x%llx\n", saved_state->r9);     
        kprintf("      r10    0x%llx\n", saved_state->r10);
        kprintf("      r8     0x%llx\n", saved_state->r8);
        kprintf("      r9     0x%llx\n", saved_state->r9);     

-       kprintf("      v_arg6 0x%llx\n", saved_state->v_arg6);
-       kprintf("      v_arg7 0x%llx\n", saved_state->v_arg7);
-       kprintf("      v_arg8 0x%llx\n", saved_state->v_arg8);

 
        kprintf("      cr2    0x%llx\n", saved_state->cr2);
        kprintf("real  cr2    0x%lx\n", get_cr2());
 
        kprintf("      cr2    0x%llx\n", saved_state->cr2);
        kprintf("real  cr2    0x%lx\n", get_cr2());


@@ -427,6 +331,9 @@ void interrupt_populate_latency_stats(char *buf, unsigned bufsize) {
                snprintf(buf, bufsize, "0x%x 0x%x 0x%llx", tcpu, cpu_data_ptr[tcpu]->cpu_max_observed_int_latency_vector, cpu_data_ptr[tcpu]->cpu_max_observed_int_latency);
 }
 
                snprintf(buf, bufsize, "0x%x 0x%x 0x%llx", tcpu, cpu_data_ptr[tcpu]->cpu_max_observed_int_latency_vector, cpu_data_ptr[tcpu]->cpu_max_observed_int_latency);
 }
 

+uint32_t interrupt_timer_coalescing_enabled = 1;
+uint64_t interrupt_coalesced_timers;
+

 /*
  * Handle interrupts:
  *  - local APIC interrupts (IPIs, timers, etc) are handled by the kernel,
 /*
  * Handle interrupts:
  *  - local APIC interrupts (IPIs, timers, etc) are handled by the kernel,


@@ -441,6 +348,8 @@ interrupt(x86_saved_state_t *state)
        boolean_t       user_mode = FALSE;
        int             ipl;
        int             cnum = cpu_number();
        boolean_t       user_mode = FALSE;
        int             ipl;
        int             cnum = cpu_number();

+       cpu_data_t      *cdp = cpu_data_ptr[cnum];
+       int             itype = 0;

 
        if (is_saved_state64(state) == TRUE) {
                x86_saved_state64_t     *state64;
 
        if (is_saved_state64(state) == TRUE) {
                x86_saved_state64_t     *state64;


@@ -464,40 +373,79 @@ interrupt(x86_saved_state_t *state)
                interrupt_num = state32->trapno;
        }
 
                interrupt_num = state32->trapno;
        }
 

-       KERNEL_DEBUG_CONSTANT(
+       if (cpu_data_ptr[cnum]->lcpu.package->num_idle == topoParms.nLThreadsPerPackage)
+               cpu_data_ptr[cnum]->cpu_hwIntpexits[interrupt_num]++;
+
+       if (interrupt_num == (LAPIC_DEFAULT_INTERRUPT_BASE + LAPIC_INTERPROCESSOR_INTERRUPT))
+               itype = 1;
+       else if (interrupt_num == (LAPIC_DEFAULT_INTERRUPT_BASE + LAPIC_TIMER_INTERRUPT))
+               itype = 2;
+       else
+               itype = 3;
+
+       KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, 

                MACHDBG_CODE(DBG_MACH_EXCP_INTR, 0) | DBG_FUNC_START,
                MACHDBG_CODE(DBG_MACH_EXCP_INTR, 0) | DBG_FUNC_START,

-               interrupt_num, rip, user_mode, 0, 0);
+               interrupt_num,
+               (user_mode ? rip : VM_KERNEL_UNSLIDE(rip)),
+               user_mode, itype, 0);

 
        SCHED_STATS_INTERRUPT(current_processor());
 
 
        SCHED_STATS_INTERRUPT(current_processor());
 

-       ipl = get_preemption_level();
+#if CONFIG_TELEMETRY
+       if (telemetry_needs_record) {
+               telemetry_mark_curthread(user_mode);
+       }
+#endif

 
 

+       ipl = get_preemption_level();
+       

        /*
         * Handle local APIC interrupts
         * else call platform expert for devices.
         */
        /*
         * Handle local APIC interrupts
         * else call platform expert for devices.
         */

-       if (!lapic_interrupt(interrupt_num, state))
+       if (!lapic_interrupt(interrupt_num, state)) {

                PE_incoming_interrupt(interrupt_num);
                PE_incoming_interrupt(interrupt_num);

+       }

 
        if (__improbable(get_preemption_level() != ipl)) {
                panic("Preemption level altered by interrupt vector 0x%x: initial 0x%x, final: 0x%x\n", interrupt_num, ipl, get_preemption_level());
        }
 
 
        if (__improbable(get_preemption_level() != ipl)) {
                panic("Preemption level altered by interrupt vector 0x%x: initial 0x%x, final: 0x%x\n", interrupt_num, ipl, get_preemption_level());
        }
 

-       KERNEL_DEBUG_CONSTANT(
-               MACHDBG_CODE(DBG_MACH_EXCP_INTR, 0) | DBG_FUNC_END,
-               interrupt_num, 0, 0, 0, 0);

 
 

-       if (cpu_data_ptr[cnum]->cpu_nested_istack) {
-               cpu_data_ptr[cnum]->cpu_nested_istack_events++;
+       if (__improbable(cdp->cpu_nested_istack)) {
+               cdp->cpu_nested_istack_events++;

        }
        else  {
        }
        else  {

-               uint64_t int_latency = mach_absolute_time() - cpu_data_ptr[cnum]->cpu_int_event_time;
-               if (ilat_assert && (int_latency > interrupt_latency_cap) && !machine_timeout_suspended()) {
-                       panic("Interrupt vector 0x%x exceeded interrupt latency threshold, 0x%llx absolute time delta, prior signals: 0x%x, current signals: 0x%x", interrupt_num, int_latency, cpu_data_ptr[cnum]->cpu_prior_signals, cpu_data_ptr[cnum]->cpu_signals);
+               uint64_t ctime = mach_absolute_time();
+               uint64_t int_latency = ctime - cdp->cpu_int_event_time;
+               uint64_t esdeadline, ehdeadline;
+               /* Attempt to process deferred timers in the context of
+                * this interrupt, unless interrupt time has already exceeded
+                * TCOAL_ILAT_THRESHOLD.
+                */
+#define TCOAL_ILAT_THRESHOLD (30000ULL)
+
+               if ((int_latency < TCOAL_ILAT_THRESHOLD) &&
+                   interrupt_timer_coalescing_enabled) {
+                       esdeadline = cdp->rtclock_timer.queue.earliest_soft_deadline;
+                       ehdeadline = cdp->rtclock_timer.deadline;
+                       if ((ctime >= esdeadline) && (ctime < ehdeadline)) {
+                               interrupt_coalesced_timers++;
+                               TCOAL_DEBUG(0x88880000 | DBG_FUNC_START, ctime, esdeadline, ehdeadline, interrupt_coalesced_timers, 0);
+                               rtclock_intr(state);
+                               TCOAL_DEBUG(0x88880000 | DBG_FUNC_END, ctime, esdeadline, interrupt_coalesced_timers, 0, 0);
+                       } else {
+                               TCOAL_DEBUG(0x77770000, ctime, cdp->rtclock_timer.queue.earliest_soft_deadline, cdp->rtclock_timer.deadline, interrupt_coalesced_timers, 0);
+                       }

                }
                }

-               if (int_latency > cpu_data_ptr[cnum]->cpu_max_observed_int_latency) {
-                       cpu_data_ptr[cnum]->cpu_max_observed_int_latency = int_latency;
-                       cpu_data_ptr[cnum]->cpu_max_observed_int_latency_vector = interrupt_num;
+
+               if (__improbable(ilat_assert && (int_latency > interrupt_latency_cap) && !machine_timeout_suspended())) {
+                       panic("Interrupt vector 0x%x exceeded interrupt latency threshold, 0x%llx absolute time delta, prior signals: 0x%x, current signals: 0x%x", interrupt_num, int_latency, cdp->cpu_prior_signals, cdp->cpu_signals);
+               }
+
+               if (__improbable(int_latency > cdp->cpu_max_observed_int_latency)) {
+                       cdp->cpu_max_observed_int_latency = int_latency;
+                       cdp->cpu_max_observed_int_latency_vector = interrupt_num;

                }
        }
 
                }
        }
 


@@ -505,17 +453,26 @@ interrupt(x86_saved_state_t *state)
         * Having serviced the interrupt first, look at the interrupted stack depth.
         */
        if (!user_mode) {
         * Having serviced the interrupt first, look at the interrupted stack depth.
         */
        if (!user_mode) {

-               uint64_t depth = cpu_data_ptr[cnum]->cpu_kernel_stack
+               uint64_t depth = cdp->cpu_kernel_stack

                                 + sizeof(struct x86_kernel_state)
                                 + sizeof(struct i386_exception_link *)
                                 - rsp;
                                 + sizeof(struct x86_kernel_state)
                                 + sizeof(struct i386_exception_link *)
                                 - rsp;

-               if (depth > kernel_stack_depth_max) {
+               if (__improbable(depth > kernel_stack_depth_max)) {

                        kernel_stack_depth_max = (vm_offset_t)depth;
                        KERNEL_DEBUG_CONSTANT(
                                MACHDBG_CODE(DBG_MACH_SCHED, MACH_STACK_DEPTH),
                        kernel_stack_depth_max = (vm_offset_t)depth;
                        KERNEL_DEBUG_CONSTANT(
                                MACHDBG_CODE(DBG_MACH_SCHED, MACH_STACK_DEPTH),

-                               (long) depth, (long) rip, 0, 0, 0);
+                               (long) depth, (long) VM_KERNEL_UNSLIDE(rip), 0, 0, 0);

                }
        }
                }
        }

+       
+       if (cnum == master_cpu)
+               ml_entropy_collect();
+
+       KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, 
+               MACHDBG_CODE(DBG_MACH_EXCP_INTR, 0) | DBG_FUNC_END,
+               interrupt_num, 0, 0, 0, 0);
+
+       assert(ml_get_interrupts_enabled() == FALSE);

 }
 
 static inline void
 }
 
 static inline void


@@ -541,16 +498,13 @@ kernel_trap(
        x86_saved_state_t       *state,
        uintptr_t *lo_spp)
 {
        x86_saved_state_t       *state,
        uintptr_t *lo_spp)
 {

-#ifdef __i386__
-       x86_saved_state32_t     *saved_state;
-#else

        x86_saved_state64_t     *saved_state;
        x86_saved_state64_t     *saved_state;

-#endif

        int                     code;
        user_addr_t             vaddr;
        int                     type;
        vm_map_t                map = 0;        /* protected by T_PAGE_FAULT */
        kern_return_t           result = KERN_FAILURE;
        int                     code;
        user_addr_t             vaddr;
        int                     type;
        vm_map_t                map = 0;        /* protected by T_PAGE_FAULT */
        kern_return_t           result = KERN_FAILURE;

+       kern_return_t           fault_result = KERN_SUCCESS;

        thread_t                thread;
        ast_t                   *myast;
        boolean_t               intr;
        thread_t                thread;
        ast_t                   *myast;
        boolean_t               intr;


@@ -560,29 +514,11 @@ kernel_trap(
 #if NCOPY_WINDOWS > 0
        int                     fault_in_copy_window = -1;
 #endif
 #if NCOPY_WINDOWS > 0
        int                     fault_in_copy_window = -1;
 #endif

-       int                     is_user = 0;
-#if MACH_KDB
-       pt_entry_t              *pte;
-#endif /* MACH_KDB */
-       
-       thread = current_thread();
-
-#ifdef __i386__
-       if (__improbable(is_saved_state64(state))) {
-               panic_64(state, 0, "Kernel trap with 64-bit state", FALSE);
-       }
-
-       saved_state = saved_state32(state);
+       int                     is_user;
+       int                     trap_pl = get_preemption_level();

 
 

-       /* Record cpu where state was captured (trampolines don't set this) */
-       saved_state->cpu = cpu_number();
+       thread = current_thread();

 
 

-       vaddr = (user_addr_t)saved_state->cr2;
-       type  = saved_state->trapno;
-       code  = saved_state->err & 0xffff;
-       intr  = (saved_state->efl & EFL_IF) != 0;       /* state of ints at trap */
-       kern_ip = (vm_offset_t)saved_state->eip;
-#else

        if (__improbable(is_saved_state32(state)))
                panic("kernel_trap(%p) with 32-bit state", state);
        saved_state = saved_state64(state);
        if (__improbable(is_saved_state32(state)))
                panic("kernel_trap(%p) with 32-bit state", state);
        saved_state = saved_state64(state);


@@ -595,10 +531,11 @@ kernel_trap(
        code  = (int)(saved_state->isf.err & 0xffff);
        intr  = (saved_state->isf.rflags & EFL_IF) != 0;        /* state of ints at trap */
        kern_ip = (vm_offset_t)saved_state->isf.rip;
        code  = (int)(saved_state->isf.err & 0xffff);
        intr  = (saved_state->isf.rflags & EFL_IF) != 0;        /* state of ints at trap */
        kern_ip = (vm_offset_t)saved_state->isf.rip;

-#endif

 
        myast = ast_pending();
 
 
        myast = ast_pending();
 

+       is_user = (vaddr < VM_MAX_USER_PAGE_ADDRESS);
+

        perfASTCallback astfn = perfASTHook;
        if (__improbable(astfn != NULL)) {
                if (*myast & AST_CHUD_ALL)
        perfASTCallback astfn = perfASTHook;
        if (__improbable(astfn != NULL)) {
                if (*myast & AST_CHUD_ALL)


@@ -606,20 +543,11 @@ kernel_trap(
        } else
                *myast &= ~AST_CHUD_ALL;
 
        } else
                *myast &= ~AST_CHUD_ALL;
 

-       /*
-        * Is there a hook?
-        */
-       perfCallback fn = perfTrapHook;
-       if (__improbable(fn != NULL)) {
-               if (fn(type, NULL, 0, 0) == KERN_SUCCESS) {
-                       /*
-                        * If it succeeds, we are done...
-                        */
-                       return;
-               }
-       }

 
 #if CONFIG_DTRACE
 
 #if CONFIG_DTRACE

+       /*
+        * Is there a DTrace hook?
+        */     

        if (__improbable(tempDTraceTrapHook != NULL)) {
                if (tempDTraceTrapHook(type, state, lo_spp, 0) == KERN_SUCCESS) {
                        /*
        if (__improbable(tempDTraceTrapHook != NULL)) {
                if (tempDTraceTrapHook(type, state, lo_spp, 0) == KERN_SUCCESS) {
                        /*


@@ -638,11 +566,19 @@ kernel_trap(
        if (__improbable(T_PREEMPT == type)) {
                ast_taken(AST_PREEMPTION, FALSE);
 
        if (__improbable(T_PREEMPT == type)) {
                ast_taken(AST_PREEMPTION, FALSE);
 

-               KERNEL_DEBUG_CONSTANT((MACHDBG_CODE(DBG_MACH_EXCP_KTRAP_x86, type)) | DBG_FUNC_NONE,
-                                     0, 0, 0, kern_ip, 0);
+               KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, 
+                       (MACHDBG_CODE(DBG_MACH_EXCP_KTRAP_x86, type)) | DBG_FUNC_NONE,
+                       0, 0, 0, VM_KERNEL_UNSLIDE(kern_ip), 0);

                return;
        }
                return;
        }

-       
+
+       user_addr_t     kd_vaddr = is_user ? vaddr : VM_KERNEL_UNSLIDE(vaddr);
+       KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE,
+               (MACHDBG_CODE(DBG_MACH_EXCP_KTRAP_x86, type)) | DBG_FUNC_NONE,
+               (unsigned)(kd_vaddr >> 32), (unsigned)kd_vaddr, is_user,
+               VM_KERNEL_UNSLIDE(kern_ip), 0);
+
+

        if (T_PAGE_FAULT == type) {
                /*
                 * assume we're faulting in the kernel map
        if (T_PAGE_FAULT == type) {
                /*
                 * assume we're faulting in the kernel map


@@ -677,13 +613,34 @@ kernel_trap(
                                        map = thread->map;
                                        fault_in_copy_window = window_index;
                                }
                                        map = thread->map;
                                        fault_in_copy_window = window_index;
                                }

-                               is_user = -1;

                        }
 #else
                        if (__probable(vaddr < VM_MAX_USER_PAGE_ADDRESS)) {
                                /* fault occurred in userspace */
                                map = thread->map;
                        }
 #else
                        if (__probable(vaddr < VM_MAX_USER_PAGE_ADDRESS)) {
                                /* fault occurred in userspace */
                                map = thread->map;

-                               is_user = -1;
+
+                               /* Intercept a potential Supervisor Mode Execute
+                                * Protection fault. These criteria identify
+                                * both NX faults and SMEP faults, but both
+                                * are fatal. We avoid checking PTEs (racy).
+                                * (The VM could just redrive a SMEP fault, hence
+                                * the intercept).
+                                */
+                               if (__improbable((code == (T_PF_PROT | T_PF_EXECUTE)) &&
+                                       (pmap_smep_enabled) && (saved_state->isf.rip == vaddr))) {
+                                       goto debugger_entry;
+                               }
+
+                               /*
+                                * Additionally check for SMAP faults...
+                                * which are characterized by page-present and
+                                * the AC bit unset (i.e. not from copyin/out path).
+                                */
+                               if (__improbable(code & T_PF_PROT &&
+                                                pmap_smap_enabled &&
+                                                (saved_state->isf.rflags & EFL_AC) == 0)) {
+                                       goto debugger_entry;
+                               }

 
                                /*
                                 * If we're not sharing cr3 with the user
 
                                /*
                                 * If we're not sharing cr3 with the user


@@ -697,16 +654,15 @@ kernel_trap(
                                        set_cr3_raw(map->pmap->pm_cr3);
                                        return;
                                }
                                        set_cr3_raw(map->pmap->pm_cr3);
                                        return;
                                }

+                               if (__improbable(vaddr < PAGE_SIZE) &&
+                                   ((thread->machine.specFlags & CopyIOActive) == 0)) {
+                                       goto debugger_entry;
+                               }

                        }
 #endif
                }
        }
 
                        }
 #endif
                }
        }
 

-       KERNEL_DEBUG_CONSTANT(
-               (MACHDBG_CODE(DBG_MACH_EXCP_KTRAP_x86, type)) | DBG_FUNC_NONE,
-               (unsigned)(vaddr >> 32), (unsigned)vaddr, is_user, kern_ip, 0);
-
-

        (void) ml_set_interrupts_enabled(intr);
 
        switch (type) {
        (void) ml_set_interrupts_enabled(intr);
 
        switch (type) {


@@ -727,11 +683,7 @@ kernel_trap(
                fpSSEexterrflt();
                return;
            case T_DEBUG:
                fpSSEexterrflt();
                return;
            case T_DEBUG:

-#ifdef __i386__
-                   if ((saved_state->efl & EFL_TF) == 0 && NO_WATCHPOINTS)
-#else

                    if ((saved_state->isf.rflags & EFL_TF) == 0 && NO_WATCHPOINTS)
                    if ((saved_state->isf.rflags & EFL_TF) == 0 && NO_WATCHPOINTS)

-#endif

                    {
                            /* We've somehow encountered a debug
                             * register match that does not belong
                    {
                            /* We've somehow encountered a debug
                             * register match that does not belong


@@ -748,24 +700,6 @@ kernel_trap(
 #endif
            case T_PAGE_FAULT:
 
 #endif
            case T_PAGE_FAULT:
 

-#if    MACH_KDB
-               /*
-                * Check for watchpoint on kernel static data.
-                * vm_fault would fail in this case 
-                */
-               if (map == kernel_map && db_watchpoint_list && db_watchpoints_inserted &&
-                   (code & T_PF_WRITE) && vaddr < vm_map_max(map) &&
-                   ((*(pte = pmap_pte(kernel_pmap, (vm_map_offset_t)vaddr))) & INTEL_PTE_WRITE) == 0) {
-                       pmap_store_pte(
-                               pte,
-                               *pte | INTEL_PTE_VALID | INTEL_PTE_WRITE);
-                       /* XXX need invltlb here? */
-
-                       result = KERN_SUCCESS;
-                       goto look_for_watchpoints;
-               }
-#endif /* MACH_KDB */
-

 #if CONFIG_DTRACE
                if (thread != THREAD_NULL && thread->options & TH_OPT_DTRACE) { /* Executing under dtrace_probe? */
                        if (dtrace_tally_fault(vaddr)) { /* Should a fault under dtrace be ignored? */
 #if CONFIG_DTRACE
                if (thread != THREAD_NULL && thread->options & TH_OPT_DTRACE) { /* Executing under dtrace_probe? */
                        if (dtrace_tally_fault(vaddr)) { /* Should a fault under dtrace be ignored? */


@@ -778,35 +712,20 @@ kernel_trap(
                        }
                }
 #endif /* CONFIG_DTRACE */
                        }
                }
 #endif /* CONFIG_DTRACE */

-

                
                prot = VM_PROT_READ;
 
                if (code & T_PF_WRITE)
                        prot |= VM_PROT_WRITE;
                
                prot = VM_PROT_READ;
 
                if (code & T_PF_WRITE)
                        prot |= VM_PROT_WRITE;

-#if     PAE

                if (code & T_PF_EXECUTE)
                        prot |= VM_PROT_EXECUTE;
                if (code & T_PF_EXECUTE)
                        prot |= VM_PROT_EXECUTE;

-#endif

 
 

-               result = vm_fault(map,
-                                 vm_map_trunc_page(vaddr),
+               fault_result = result = vm_fault(map,
+                                 vaddr,

                                  prot,
                                  FALSE, 
                                  THREAD_UNINT, NULL, 0);
 
                                  prot,
                                  FALSE, 
                                  THREAD_UNINT, NULL, 0);
 

-#if    MACH_KDB
-               if (result == KERN_SUCCESS) {
-                       /*
-                        * Look for watchpoints
-                        */
-look_for_watchpoints:
-                       if (map == kernel_map && db_watchpoint_list && db_watchpoints_inserted && (code & T_PF_WRITE) &&
-                           db_find_watchpoint(map, vaddr, saved_state))
-                               kdb_trap(T_WATCHPOINT, 0, saved_state);
-               }
-#endif /* MACH_KDB */
-

                if (result == KERN_SUCCESS) {
 #if NCOPY_WINDOWS > 0
                        if (fault_in_copy_window != -1) {
                if (result == KERN_SUCCESS) {
 #if NCOPY_WINDOWS > 0
                        if (fault_in_copy_window != -1) {


@@ -867,99 +786,32 @@ debugger_entry:
                 * access through the debugger.
                 */
                sync_iss_to_iks(state);
                 * access through the debugger.
                 */
                sync_iss_to_iks(state);

-#if MACH_KDB
-restart_debugger:
-#endif /* MACH_KDB */          

 #if  MACH_KDP
 #if  MACH_KDP

-                if (current_debugger != KDB_CUR_DB) {
-                       if (kdp_i386_trap(type, saved_state, result, (vm_offset_t)vaddr))
-                               return;
-               } else {
-#endif /* MACH_KDP */
-#if MACH_KDB
-                       if (kdb_trap(type, code, saved_state)) {
-                               if (switch_debugger) {
-                                       current_debugger = KDP_CUR_DB;
-                                       switch_debugger = 0;
-                                       goto restart_debugger;
-                               }
-                               return;
-                       }
-#endif /* MACH_KDB */
-#if MACH_KDP
-               }
+               if (kdp_i386_trap(type, saved_state, result, (vm_offset_t)vaddr))
+                       return;

 #endif
        }
 #endif
        }

-       __asm__ volatile("cli":::"cc");
-       panic_trap(saved_state);
+       pal_cli();
+       panic_trap(saved_state, trap_pl, fault_result);

        /*
         * NO RETURN
         */
 }
 
 
        /*
         * NO RETURN
         */
 }
 
 

-#ifdef __i386__
-static void
-set_recovery_ip(x86_saved_state32_t  *saved_state, vm_offset_t ip)
-{
-        saved_state->eip = ip;
-}
-#else

 static void
 set_recovery_ip(x86_saved_state64_t  *saved_state, vm_offset_t ip)
 {
         saved_state->isf.rip = ip;
 }
 static void
 set_recovery_ip(x86_saved_state64_t  *saved_state, vm_offset_t ip)
 {
         saved_state->isf.rip = ip;
 }

-#endif
-
-
-#ifdef __i386__
-static void
-panic_trap(x86_saved_state32_t *regs)
-{
-       const char *trapname = "Unknown";
-       pal_cr_t        cr0, cr2, cr3, cr4;
-
-       pal_get_control_registers( &cr0, &cr2, &cr3, &cr4 );
-
-       /*
-        * Issue an I/O port read if one has been requested - this is an
-        * event logic analyzers can use as a trigger point.
-        */
-       panic_io_port_read();
-
-       kprintf("panic trap number 0x%x, eip 0x%x\n", regs->trapno, regs->eip);
-       kprintf("cr0 0x%08x cr2 0x%08x cr3 0x%08x cr4 0x%08x\n",
-               cr0, cr2, cr3, cr4);
-
-       if (regs->trapno < TRAP_TYPES)
-               trapname = trap_type[regs->trapno];
-#undef panic
-       panic("Kernel trap at 0x%08x, type %d=%s, registers:\n"
-             "CR0: 0x%08x, CR2: 0x%08x, CR3: 0x%08x, CR4: 0x%08x\n"
-             "EAX: 0x%08x, EBX: 0x%08x, ECX: 0x%08x, EDX: 0x%08x\n"
-             "CR2: 0x%08x, EBP: 0x%08x, ESI: 0x%08x, EDI: 0x%08x\n"
-             "EFL: 0x%08x, EIP: 0x%08x, CS:  0x%08x, DS:  0x%08x\n"
-             "Error code: 0x%08x\n",
-             regs->eip, regs->trapno, trapname, cr0, cr2, cr3, cr4,
-             regs->eax,regs->ebx,regs->ecx,regs->edx,
-             regs->cr2,regs->ebp,regs->esi,regs->edi,
-             regs->efl,regs->eip,regs->cs & 0xFFFF, regs->ds & 0xFFFF, regs->err);
-       /*
-        * This next statement is not executed,
-        * but it's needed to stop the compiler using tail call optimization
-        * for the panic call - which confuses the subsequent backtrace.
-        */
-       cr0 = 0;
-}
-#else
-

 
 static void
 
 static void

-panic_trap(x86_saved_state64_t *regs)
+panic_trap(x86_saved_state64_t *regs, uint32_t pl, kern_return_t fault_result)

 {
        const char      *trapname = "Unknown";
        pal_cr_t        cr0, cr2, cr3, cr4;
 {
        const char      *trapname = "Unknown";
        pal_cr_t        cr0, cr2, cr3, cr4;

+       boolean_t       potential_smep_fault = FALSE, potential_kernel_NX_fault = FALSE;
+       boolean_t       potential_smap_fault = FALSE;

 
        pal_get_control_registers( &cr0, &cr2, &cr3, &cr4 );
        assert(ml_get_interrupts_enabled() == FALSE);
 
        pal_get_control_registers( &cr0, &cr2, &cr3, &cr4 );
        assert(ml_get_interrupts_enabled() == FALSE);


@@ -978,6 +830,20 @@ panic_trap(x86_saved_state64_t *regs)
        if (regs->isf.trapno < TRAP_TYPES)
                trapname = trap_type[regs->isf.trapno];
 
        if (regs->isf.trapno < TRAP_TYPES)
                trapname = trap_type[regs->isf.trapno];
 

+       if ((regs->isf.trapno == T_PAGE_FAULT) && (regs->isf.err == (T_PF_PROT | T_PF_EXECUTE)) && (regs->isf.rip == regs->cr2)) {
+               if (pmap_smep_enabled && (regs->isf.rip < VM_MAX_USER_PAGE_ADDRESS)) {
+                       potential_smep_fault = TRUE;
+               } else if (regs->isf.rip >= VM_MIN_KERNEL_AND_KEXT_ADDRESS) {
+                       potential_kernel_NX_fault = TRUE;
+               }
+       } else if (pmap_smap_enabled &&
+                  regs->isf.trapno == T_PAGE_FAULT &&
+                  regs->isf.err & T_PF_PROT &&
+                  regs->cr2 < VM_MAX_USER_PAGE_ADDRESS &&
+                  regs->isf.rip >= VM_MIN_KERNEL_AND_KEXT_ADDRESS) {
+               potential_smap_fault = TRUE;
+       }
+

 #undef panic
        panic("Kernel trap at 0x%016llx, type %d=%s, registers:\n"
              "CR0: 0x%016llx, CR2: 0x%016llx, CR3: 0x%016llx, CR4: 0x%016llx\n"
 #undef panic
        panic("Kernel trap at 0x%016llx, type %d=%s, registers:\n"
              "CR0: 0x%016llx, CR2: 0x%016llx, CR3: 0x%016llx, CR4: 0x%016llx\n"


@@ -986,7 +852,7 @@ panic_trap(x86_saved_state64_t *regs)
              "R8:  0x%016llx, R9:  0x%016llx, R10: 0x%016llx, R11: 0x%016llx\n"
              "R12: 0x%016llx, R13: 0x%016llx, R14: 0x%016llx, R15: 0x%016llx\n"
              "RFL: 0x%016llx, RIP: 0x%016llx, CS:  0x%016llx, SS:  0x%016llx\n"
              "R8:  0x%016llx, R9:  0x%016llx, R10: 0x%016llx, R11: 0x%016llx\n"
              "R12: 0x%016llx, R13: 0x%016llx, R14: 0x%016llx, R15: 0x%016llx\n"
              "RFL: 0x%016llx, RIP: 0x%016llx, CS:  0x%016llx, SS:  0x%016llx\n"

-             "CR2: 0x%016llx, Error code: 0x%016llx, Faulting CPU: 0x%x%s\n",
+             "Fault CR2: 0x%016llx, Error code: 0x%016llx, Fault CPU: 0x%x%s%s%s%s, PL: %d, VF: %d\n",

              regs->isf.rip, regs->isf.trapno, trapname,
              cr0, cr2, cr3, cr4,
              regs->rax, regs->rbx, regs->rcx, regs->rdx,
              regs->isf.rip, regs->isf.trapno, trapname,
              cr0, cr2, cr3, cr4,
              regs->rax, regs->rbx, regs->rcx, regs->rdx,


@@ -995,7 +861,12 @@ panic_trap(x86_saved_state64_t *regs)
              regs->r12, regs->r13, regs->r14, regs->r15,
              regs->isf.rflags, regs->isf.rip, regs->isf.cs & 0xFFFF,
              regs->isf.ss & 0xFFFF,regs->cr2, regs->isf.err, regs->isf.cpu,
              regs->r12, regs->r13, regs->r14, regs->r15,
              regs->isf.rflags, regs->isf.rip, regs->isf.cs & 0xFFFF,
              regs->isf.ss & 0xFFFF,regs->cr2, regs->isf.err, regs->isf.cpu,

-             "");
+             virtualized ? " VMM" : "",
+             potential_kernel_NX_fault ? " Kernel NX fault" : "",
+             potential_smep_fault ? " SMEP/User NX fault" : "",
+             potential_smap_fault ? " SMAP fault" : "",
+             pl,
+             fault_result);

        /*
         * This next statement is not executed,
         * but it's needed to stop the compiler using tail call optimization
        /*
         * This next statement is not executed,
         * but it's needed to stop the compiler using tail call optimization


@@ -1003,7 +874,6 @@ panic_trap(x86_saved_state64_t *regs)
         */
        cr0 = 0;
 }
         */
        cr0 = 0;
 }

-#endif

 
 #if CONFIG_DTRACE
 extern kern_return_t dtrace_user_probe(x86_saved_state_t *);
 
 #if CONFIG_DTRACE
 extern kern_return_t dtrace_user_probe(x86_saved_state_t *);


@@ -1069,7 +939,7 @@ user_trap(
 
        pal_sti();
 
 
        pal_sti();
 

-       KERNEL_DEBUG_CONSTANT(
+       KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, 

                (MACHDBG_CODE(DBG_MACH_EXCP_UTRAP_x86, type)) | DBG_FUNC_NONE,
                (unsigned)(vaddr>>32), (unsigned)vaddr,
                (unsigned)(rip>>32), (unsigned)rip, 0);
                (MACHDBG_CODE(DBG_MACH_EXCP_UTRAP_x86, type)) | DBG_FUNC_NONE,
                (unsigned)(vaddr>>32), (unsigned)vaddr,
                (unsigned)(rip>>32), (unsigned)rip, 0);


@@ -1098,11 +968,14 @@ user_trap(
                        return; /* If it succeeds, we are done... */
        }
 
                        return; /* If it succeeds, we are done... */
        }
 

+#if CONFIG_DTRACE

        /*
         * DTrace does not consume all user traps, only INT_3's for now.
         * Avoid needlessly calling tempDTraceTrapHook here, and let the
         * INT_3 case handle them.
         */
        /*
         * DTrace does not consume all user traps, only INT_3's for now.
         * Avoid needlessly calling tempDTraceTrapHook here, and let the
         * INT_3 case handle them.
         */

+#endif
+       

        DEBUG_KPRINT_SYSCALL_MASK(1,
                "user_trap: type=0x%x(%s) err=0x%x cr2=%p rip=%p\n",
                type, trap_type[type], err, (void *)(long) vaddr, (void *)(long) rip);
        DEBUG_KPRINT_SYSCALL_MASK(1,
                "user_trap: type=0x%x(%s) err=0x%x cr2=%p rip=%p\n",
                type, trap_type[type], err, (void *)(long) vaddr, (void *)(long) rip);


@@ -1212,21 +1085,25 @@ user_trap(
                break;
 
            case T_PAGE_FAULT:
                break;
 
            case T_PAGE_FAULT:

-               prot = VM_PROT_READ;
+           {
+                   prot = VM_PROT_READ;

 
                if (err & T_PF_WRITE)
                        prot |= VM_PROT_WRITE;
 
                if (err & T_PF_WRITE)
                        prot |= VM_PROT_WRITE;

-#if     PAE

                if (__improbable(err & T_PF_EXECUTE))
                        prot |= VM_PROT_EXECUTE;
                if (__improbable(err & T_PF_EXECUTE))
                        prot |= VM_PROT_EXECUTE;

-#endif
-               kret = vm_fault(thread->map, vm_map_trunc_page(vaddr),
-                                prot, FALSE,
-                                THREAD_ABORTSAFE, NULL, 0);
+               kret = vm_fault(thread->map,
+                               vaddr,
+                               prot, FALSE,
+                               THREAD_ABORTSAFE, NULL, 0);
+
+               if (__probable((kret == KERN_SUCCESS) || (kret == KERN_ABORTED))) {
+                       thread_exception_return();
+                       /*NOTREACHED*/
+               }

 
                user_page_fault_continue(kret);
 
                user_page_fault_continue(kret);

-       
-               /* NOTREACHED */
+           }   /* NOTREACHED */

                break;
 
            case T_SSE_FLOAT_ERROR:
                break;
 
            case T_SSE_FLOAT_ERROR:


@@ -1252,14 +1129,6 @@ user_trap(
                break;
 
            default:
                break;
 
            default:

-#if     MACH_KGDB
-               Debugger("Unanticipated user trap");
-               return;
-#endif  /* MACH_KGDB */
-#if    MACH_KDB
-               if (kdb_trap(type, err, saved_state32(saved_state)))
-                   return;
-#endif /* MACH_KDB */

                panic("Unexpected user trap, type %d", type);
                return;
        }
                panic("Unexpected user trap, type %d", type);
                return;
        }


@@ -1320,43 +1189,11 @@ i386_exception(
 }
 
 
 }
 
 

-#if    MACH_KDB
-
-extern void    db_i386_state(x86_saved_state32_t *regs);
-
-#include <ddb/db_output.h>
-
-void 
-db_i386_state(
-       x86_saved_state32_t *regs)
-{
-       db_printf("eip  %8x\n", regs->eip);
-       db_printf("trap %8x\n", regs->trapno);
-       db_printf("err  %8x\n", regs->err);
-       db_printf("efl  %8x\n", regs->efl);
-       db_printf("ebp  %8x\n", regs->ebp);
-       db_printf("esp  %8x\n", regs->cr2);
-       db_printf("uesp %8x\n", regs->uesp);
-       db_printf("cs   %8x\n", regs->cs & 0xff);
-       db_printf("ds   %8x\n", regs->ds & 0xff);
-       db_printf("es   %8x\n", regs->es & 0xff);
-       db_printf("fs   %8x\n", regs->fs & 0xff);
-       db_printf("gs   %8x\n", regs->gs & 0xff);
-       db_printf("ss   %8x\n", regs->ss & 0xff);
-       db_printf("eax  %8x\n", regs->eax);
-       db_printf("ebx  %8x\n", regs->ebx);
-       db_printf("ecx  %8x\n", regs->ecx);
-       db_printf("edx  %8x\n", regs->edx);
-       db_printf("esi  %8x\n", regs->esi);
-       db_printf("edi  %8x\n", regs->edi);
-}
-
-#endif /* MACH_KDB */
-
-/* Synchronize a thread's i386_kernel_state (if any) with the given
- * i386_saved_state_t obtained from the trap/IPI handler; called in
+/* Synchronize a thread's x86_kernel_state (if any) with the given
+ * x86_saved_state_t obtained from the trap/IPI handler; called in

  * kernel_trap() prior to entering the debugger, and when receiving
  * kernel_trap() prior to entering the debugger, and when receiving

- * an "MP_KDP" IPI.
+ * an "MP_KDP" IPI. Called with null saved_state if an incoming IPI
+ * was detected from the kernel while spinning with interrupts masked.

  */
   
 void
  */
   
 void


@@ -1367,32 +1204,17 @@ sync_iss_to_iks(x86_saved_state_t *saved_state)
        boolean_t record_active_regs = FALSE;
 
        /* The PAL may have a special way to sync registers */
        boolean_t record_active_regs = FALSE;
 
        /* The PAL may have a special way to sync registers */

-       if( saved_state->flavor == THREAD_STATE_NONE )
+       if (saved_state && saved_state->flavor == THREAD_STATE_NONE)

                pal_get_kern_regs( saved_state );
 
        if ((kstack = current_thread()->kernel_stack) != 0) {
                pal_get_kern_regs( saved_state );
 
        if ((kstack = current_thread()->kernel_stack) != 0) {

-#ifdef __i386__
-               x86_saved_state32_t     *regs = saved_state32(saved_state);
-#else

                x86_saved_state64_t     *regs = saved_state64(saved_state);
                x86_saved_state64_t     *regs = saved_state64(saved_state);

-#endif

 
                iks = STACK_IKS(kstack);
 
                /* Did we take the trap/interrupt in kernel mode? */
 
                iks = STACK_IKS(kstack);
 
                /* Did we take the trap/interrupt in kernel mode? */

-#ifdef __i386__
-               if (regs == USER_REGS32(current_thread()))
-                       record_active_regs = TRUE;
-               else {
-                       iks->k_ebx = regs->ebx;
-                       iks->k_esp = (int)regs;
-                       iks->k_ebp = regs->ebp;
-                       iks->k_edi = regs->edi;
-                       iks->k_esi = regs->esi;
-                       iks->k_eip = regs->eip;
-               }
-#else
-               if (regs == USER_REGS64(current_thread()))
+               if (saved_state == NULL || /* NULL => polling in kernel */
+                   regs == USER_REGS64(current_thread()))

                        record_active_regs = TRUE;
                else {
                        iks->k_rbx = regs->rbx;
                        record_active_regs = TRUE;
                else {
                        iks->k_rbx = regs->rbx;


@@ -1404,20 +1226,9 @@ sync_iss_to_iks(x86_saved_state_t *saved_state)
                        iks->k_r15 = regs->r15;
                        iks->k_rip = regs->isf.rip;
                }
                        iks->k_r15 = regs->r15;
                        iks->k_rip = regs->isf.rip;
                }

-#endif

        }
 
        if (record_active_regs == TRUE) {
        }
 
        if (record_active_regs == TRUE) {

-#ifdef __i386__
-               /* Show the trap handler path */
-               __asm__ volatile("movl %%ebx, %0" : "=m" (iks->k_ebx));
-               __asm__ volatile("movl %%esp, %0" : "=m" (iks->k_esp));
-               __asm__ volatile("movl %%ebp, %0" : "=m" (iks->k_ebp));
-               __asm__ volatile("movl %%edi, %0" : "=m" (iks->k_edi));
-               __asm__ volatile("movl %%esi, %0" : "=m" (iks->k_esi));
-               /* "Current" instruction pointer */
-               __asm__ volatile("movl $1f, %0\n1:" : "=m" (iks->k_eip));
-#else

                /* Show the trap handler path */
                __asm__ volatile("movq %%rbx, %0" : "=m" (iks->k_rbx));
                __asm__ volatile("movq %%rsp, %0" : "=m" (iks->k_rsp));
                /* Show the trap handler path */
                __asm__ volatile("movq %%rbx, %0" : "=m" (iks->k_rbx));
                __asm__ volatile("movq %%rsp, %0" : "=m" (iks->k_rsp));


@@ -1431,7 +1242,6 @@ sync_iss_to_iks(x86_saved_state_t *saved_state)
                                 : "=m" (iks->k_rip)
                                 :
                                 : "rax");
                                 : "=m" (iks->k_rip)
                                 :
                                 : "rax");

-#endif

        }
 }
 
        }
 }
 


@@ -1448,16 +1258,6 @@ sync_iss_to_iks_unconditionally(__unused x86_saved_state_t *saved_state) {
 
        if ((kstack = current_thread()->kernel_stack) != 0) {
                iks = STACK_IKS(kstack);
 
        if ((kstack = current_thread()->kernel_stack) != 0) {
                iks = STACK_IKS(kstack);

-#ifdef __i386__
-               /* Display the trap handler path */
-               __asm__ volatile("movl %%ebx, %0" : "=m" (iks->k_ebx));
-               __asm__ volatile("movl %%esp, %0" : "=m" (iks->k_esp));
-               __asm__ volatile("movl %%ebp, %0" : "=m" (iks->k_ebp));
-               __asm__ volatile("movl %%edi, %0" : "=m" (iks->k_edi));
-               __asm__ volatile("movl %%esi, %0" : "=m" (iks->k_esi));
-               /* "Current" instruction pointer */
-               __asm__ volatile("movl $1f, %0\n1:" : "=m" (iks->k_eip));
-#else

                /* Display the trap handler path */
                __asm__ volatile("movq %%rbx, %0" : "=m" (iks->k_rbx));
                __asm__ volatile("movq %%rsp, %0" : "=m" (iks->k_rsp));
                /* Display the trap handler path */
                __asm__ volatile("movq %%rbx, %0" : "=m" (iks->k_rbx));
                __asm__ volatile("movq %%rsp, %0" : "=m" (iks->k_rsp));


@@ -1468,6 +1268,29 @@ sync_iss_to_iks_unconditionally(__unused x86_saved_state_t *saved_state) {
                __asm__ volatile("movq %%r15, %0" : "=m" (iks->k_r15));
                /* "Current" instruction pointer */
                __asm__ volatile("leaq 1f(%%rip), %%rax; mov %%rax, %0\n1:" : "=m" (iks->k_rip)::"rax");
                __asm__ volatile("movq %%r15, %0" : "=m" (iks->k_r15));
                /* "Current" instruction pointer */
                __asm__ volatile("leaq 1f(%%rip), %%rax; mov %%rax, %0\n1:" : "=m" (iks->k_rip)::"rax");

-#endif

        }
 }
        }
 }

+
+#if DEBUG
+extern void    thread_exception_return_internal(void) __dead2;
+
+void thread_exception_return(void) {
+       thread_t thread = current_thread();
+       ml_set_interrupts_enabled(FALSE);
+       if (thread_is_64bit(thread) != task_has_64BitAddr(thread->task)) {
+               panic("Task/thread bitness mismatch %p %p, task: %d, thread: %d", thread, thread->task, thread_is_64bit(thread),  task_has_64BitAddr(thread->task));
+       }
+
+       if (thread_is_64bit(thread)) {
+               if ((gdt_desc_p(USER64_CS)->access & ACC_PL_U) == 0) {
+                       panic("64-GDT mismatch %p, descriptor: %p", thread, gdt_desc_p(USER64_CS));
+               }
+       } else {
+                       if ((gdt_desc_p(USER_CS)->access & ACC_PL_U) == 0) {
+                               panic("32-GDT mismatch %p, descriptor: %p", thread, gdt_desc_p(USER_CS));
+
+               }
+       }
+       thread_exception_return_internal();
+}
+#endif