xnu-7195.50.7.100.1.tar.gz

[apple/xnu.git] / bsd / dev / arm64 / dtrace_isa.c

diff --git a/bsd/dev/arm64/dtrace_isa.c b/bsd/dev/arm64/dtrace_isa.c
index 56d1729f5614407a79fbdd2e67e0a633854f965f..494bb7fad4501ca023424c94c9111a5249c90062 100644 (file)
--- a/bsd/dev/arm64/dtrace_isa.c
+++ b/bsd/dev/arm64/dtrace_isa.c
@@ -41,6 +41,7 @@
 #include <sys/dtrace.h>
 #include <sys/dtrace_impl.h>
 #include <machine/atomic.h>
+#include <kern/cambria_layout.h>
 #include <kern/simple_lock.h>
 #include <kern/sched_prim.h>            /* for thread_wakeup() */
 #include <kern/thread_call.h>
@@ -70,21 +71,13 @@ struct frame {
 inline void
 dtrace_membar_producer(void)
 {
-#if __ARM_SMP__
        __asm__ volatile ("dmb ish" : : : "memory");
-#else
-       __asm__ volatile ("nop" : : : "memory");
-#endif
 }
 
 inline void
 dtrace_membar_consumer(void)
 {
-#if __ARM_SMP__
        __asm__ volatile ("dmb ish" : : : "memory");
-#else
-       __asm__ volatile ("nop" : : : "memory");
-#endif
 }
 
 /*
@@ -102,7 +95,6 @@ dtrace_getipl(void)
        return ml_at_interrupt_context() ? 1 : 0;
 }
 
-#if __ARM_SMP__
 /*
  * MP coordination
  */
@@ -129,7 +121,6 @@ xcRemote(void *foo)
                thread_wakeup((event_t) &dt_xc_sync);
        }
 }
-#endif
 
 /*
  * dtrace_xcall() is not called from probe context.
@@ -137,7 +128,6 @@ xcRemote(void *foo)
 void
 dtrace_xcall(processorid_t cpu, dtrace_xcall_t f, void *arg)
 {
-#if __ARM_SMP__
        /* Only one dtrace_xcall in flight allowed */
        lck_mtx_lock(&dt_xc_lock);
 
@@ -151,14 +141,6 @@ dtrace_xcall(processorid_t cpu, dtrace_xcall_t f, void *arg)
 
        lck_mtx_unlock(&dt_xc_lock);
        return;
-#else
-#pragma unused(cpu)
-       /* On uniprocessor systems, the cpu should always be either ourselves or all */
-       ASSERT(cpu == CPU->cpu_id || cpu == DTRACE_CPUALL);
-
-       (*f)(arg);
-       return;
-#endif
 }
 
 /*
@@ -202,12 +184,21 @@ dtrace_getreg(struct regs * savearea, uint_t reg)
        return (uint64_t)get_saved_state_reg(regs, reg);
 }
 
+uint64_t
+dtrace_getvmreg(uint_t ndx)
+{
+#pragma unused(ndx)
+       DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
+       return 0;
+}
+
 #define RETURN_OFFSET64 8
 
 static int
 dtrace_getustack_common(uint64_t * pcstack, int pcstack_limit, user_addr_t pc,
     user_addr_t sp)
 {
+       volatile uint16_t *flags = (volatile uint16_t *) &cpu_core[CPU->cpu_id].cpuc_dtrace_flags;
        int ret = 0;
 
        ASSERT(pcstack == NULL || pcstack_limit > 0);
@@ -228,6 +219,12 @@ dtrace_getustack_common(uint64_t * pcstack, int pcstack_limit, user_addr_t pc,
 
                pc = dtrace_fuword64((sp + RETURN_OFFSET64));
                sp = dtrace_fuword64(sp);
+
+               /* Truncate ustack if the iterator causes fault. */
+               if (*flags & CPU_DTRACE_FAULT) {
+                       *flags &= ~CPU_DTRACE_FAULT;
+                       break;
+               }
        }
 
        return ret;
@@ -236,9 +233,9 @@ dtrace_getustack_common(uint64_t * pcstack, int pcstack_limit, user_addr_t pc,
 void
 dtrace_getupcstack(uint64_t * pcstack, int pcstack_limit)
 {
-       thread_t        thread = current_thread();
-       savearea_t     *regs;
-       user_addr_t     pc, sp, fp;
+       thread_t thread = current_thread();
+       savearea_t *regs;
+       user_addr_t pc, sp, fp;
        volatile uint16_t *flags = (volatile uint16_t *) &cpu_core[CPU->cpu_id].cpuc_dtrace_flags;
        int n;
 
@@ -271,7 +268,10 @@ dtrace_getupcstack(uint64_t * pcstack, int pcstack_limit)
 
        pc = get_saved_state_pc(regs);
        sp = get_saved_state_sp(regs);
-       fp = get_saved_state_fp(regs);
+
+       {
+               fp = get_saved_state_fp(regs);
+       }
 
        if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
                *pcstack++ = (uint64_t) pc;
@@ -439,18 +439,11 @@ dtrace_getufpstack(uint64_t * pcstack, uint64_t * fpstack, int pcstack_limit)
                        sp = dtrace_fuword64(sp);
                }
 
-#if 0
-               /* XXX ARMTODO*/
-               /*
-                * This is totally bogus:  if we faulted, we're going to clear
-                * the fault and break.  This is to deal with the apparently
-                * broken Java stacks on x86.
-                */
+               /* Truncate ustack if the iterator causes fault. */
                if (*flags & CPU_DTRACE_FAULT) {
                        *flags &= ~CPU_DTRACE_FAULT;
                        break;
                }
-#endif
        }
 
 zero: