void
dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit)
{
proc_t *p = curproc;
struct trapframe *tf;
uintptr_t pc, sp;
volatile uint16_t *flags =
(volatile uint16_t *)&cpu_core[curcpu].cpuc_dtrace_flags;
int n;
if (*flags & CPU_DTRACE_FAULT)
return;
if (pcstack_limit <= 0)
return;
/*
* If there's no user context we still need to zero the stack.
*/
if (p == NULL || (tf = curthread->td_frame) == NULL)
goto zero;
*pcstack++ = (uint64_t)p->p_pid;
pcstack_limit--;
if (pcstack_limit <= 0)
return;
pc = tf->srr0;
sp = tf->fixreg[1];
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
/*
* In an entry probe. The frame pointer has not yet been
* pushed (that happens in the function prologue). The
* best approach is to add the current pc as a missing top
* of stack and back the pc up to the caller, which is stored
* at the current stack pointer address since the call
* instruction puts it there right before the branch.
*/
*pcstack++ = (uint64_t)pc;
pcstack_limit--;
if (pcstack_limit <= 0)
return;
pc = tf->lr;
}
n = dtrace_getustack_common(pcstack, pcstack_limit, pc, sp);
ASSERT(n >= 0);
ASSERT(n <= pcstack_limit);
pcstack += n;
pcstack_limit -= n;
zero:
while (pcstack_limit-- > 0)
*pcstack++ = 0;
}
int
dtrace_getustackdepth(void)
{
thread_t thread = current_thread();
x86_saved_state_t *regs;
user_addr_t pc, sp, fp;
int n = 0;
boolean_t is64Bit = proc_is64bit(current_proc());
if (thread == NULL)
return 0;
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAULT))
return (-1);
pal_register_cache_state(thread, VALID);
regs = (x86_saved_state_t *)find_user_regs(thread);
if (regs == NULL)
return 0;
if (is64Bit) {
pc = regs->ss_64.isf.rip;
sp = regs->ss_64.isf.rsp;
fp = regs->ss_64.rbp;
} else {
pc = regs->ss_32.eip;
sp = regs->ss_32.uesp;
fp = regs->ss_32.ebp;
}
if (dtrace_adjust_stack(NULL, NULL, &pc, sp) == 1) {
/*
* we would have adjusted the stack if we had
* supplied one (that is what rc == 1 means).
* Also, as a side effect, the pc might have
* been fixed up, which is good for calling
* in to dtrace_getustack_common.
*/
n++;
}
/*
* Note that unlike ppc, the x86 code does not use
* CPU_DTRACE_USTACK_FP. This is because x86 always
* traces from the fp, even in syscall/profile/fbt
* providers.
*/
n += dtrace_getustack_common(NULL, 0, pc, fp);
return (n);
}
int
dtrace_getustackdepth(void)
{
proc_t *p = curproc;
struct reg *tf;
uintptr_t pc, fp, sp;
int n = 0;
if (p == NULL || (tf = curthread->tf) == NULL)
return (0);
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAULT))
return (-1);
#ifdef __amd64
if (p->p_model == DATAMODEL_NATIVE) {
CONTEXT ct;
uint64_t pcstack[100];
int pcstack_limit = 100;
winos_reg_to_context(&ct, tf);
n += winos_unwind_user_stack(&ct, pcstack_limit, (uintptr_t) pcstack);
} else {
#endif // i386
pc = tf->r_rip;
fp = tf->r_rbp;
sp = tf->r_rsp;
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
/*
* In an entry probe. The frame pointer has not yet been
* pushed (that happens in the function prologue). The
* best approach is to add the current pc as a missing top
* of stack and back the pc up to the caller, which is stored
* at the current stack pointer address since the call
* instruction puts it there right before the branch.
*/
pc = dtrace_fuword32((void *) sp);
n++;
}
n += dtrace_getustack_common(NULL, 0, pc, fp);
#ifdef __amd64
}
#endif
return (n);
}
int
dtrace_getustackdepth(void)
{
thread_t thread = current_thread();
ppc_saved_state_t *regs;
user_addr_t pc, sp;
int n = 0;
boolean_t is64Bit = proc_is64bit(current_proc());
if (thread == NULL)
return 0;
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAULT))
return (-1);
regs = (ppc_saved_state_t *)find_user_regs(thread);
if (regs == NULL)
return 0;
pc = regs->REGPC;
sp = regs->REGSP;
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
n++;
pc = regs->save_lr;
}
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_USTACK_FP)) {
/*
* If the ustack fp flag is set, the stack frame from sp to
* fp contains no valid call information. Start with the fp.
*/
if (is64Bit)
sp = dtrace_fuword64(sp);
else
sp = (user_addr_t)dtrace_fuword32(sp);
}
n += dtrace_getustack_common(NULL, 0, pc, sp);
return (n);
}
int
dtrace_getustackdepth(void)
{
proc_t *p = curproc;
struct trapframe *tf;
uintptr_t pc, sp;
int n = 0;
if (p == NULL || (tf = curthread->td_frame) == NULL)
return (0);
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAULT))
return (-1);
pc = tf->srr0;
sp = tf->fixreg[1];
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
/*
* In an entry probe. The frame pointer has not yet been
* pushed (that happens in the function prologue). The
* best approach is to add the current pc as a missing top
* of stack and back the pc up to the caller, which is stored
* at the current stack pointer address since the call
* instruction puts it there right before the branch.
*/
if (SV_PROC_FLAG(p, SV_ILP32)) {
pc = dtrace_fuword32((void *) sp);
}
else
pc = dtrace_fuword64((void *) sp);
n++;
}
n += dtrace_getustack_common(NULL, 0, pc, sp);
return (n);
}
int
dtrace_getustackdepth(void)
{
printk("need to do this dtrace_getustackdepth\n");
# if 0
klwp_t *lwp = ttolwp(curthread);
proc_t *p = curproc;
struct regs *rp;
uintptr_t pc, sp;
int n = 0;
if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL)
return (0);
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAULT))
return (-1);
pc = rp->r_pc;
sp = rp->r_fp;
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
n++;
if (dtrace_data_model(p) == DATAMODEL_NATIVE)
pc = dtrace_fulword((void *)rp->r_sp);
else
pc = dtrace_fuword32((void *)rp->r_sp);
}
n += dtrace_getustack_common(NULL, 0, pc, sp);
return (n);
# else
TODO();
return 0;
# endif
}
void
dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit)
{
thread_t thread = current_thread();
x86_saved_state_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;
boolean_t is64Bit = proc_is64bit(current_proc());
if (*flags & CPU_DTRACE_FAULT)
return;
if (pcstack_limit <= 0)
return;
/*
* If there's no user context we still need to zero the stack.
*/
if (thread == NULL)
goto zero;
regs = (x86_saved_state_t *)find_user_regs(thread);
if (regs == NULL)
goto zero;
*pcstack++ = (uint64_t)proc_selfpid();
pcstack_limit--;
if (pcstack_limit <= 0)
return;
if (is64Bit) {
pc = regs->ss_64.isf.rip;
sp = regs->ss_64.isf.rsp;
fp = regs->ss_64.rbp;
} else {
pc = regs->ss_32.eip;
sp = regs->ss_32.uesp;
fp = regs->ss_32.ebp;
}
/*
* The return value indicates if we've modified the stack.
* Since there is nothing else to fix up in either case,
* we can safely ignore it here.
*/
(void)dtrace_adjust_stack(&pcstack, &pcstack_limit, &pc, sp);
if(pcstack_limit <= 0)
return;
/*
* Note that unlike ppc, the x86 code does not use
* CPU_DTRACE_USTACK_FP. This is because x86 always
* traces from the fp, even in syscall/profile/fbt
* providers.
*/
n = dtrace_getustack_common(pcstack, pcstack_limit, pc, fp);
ASSERT(n >= 0);
ASSERT(n <= pcstack_limit);
pcstack += n;
pcstack_limit -= n;
zero:
while (pcstack_limit-- > 0)
*pcstack++ = 0;
}
void
dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit)
{
thread_t thread = current_thread();
ppc_saved_state_t *regs;
user_addr_t pc, sp;
volatile uint16_t *flags =
(volatile uint16_t *)&cpu_core[CPU->cpu_id].cpuc_dtrace_flags;
int n;
boolean_t is64Bit = proc_is64bit(current_proc());
if (*flags & CPU_DTRACE_FAULT)
return;
if (pcstack_limit <= 0)
return;
/*
* If there's no user context we still need to zero the stack.
*/
if (thread == NULL)
goto zero;
regs = (ppc_saved_state_t *)find_user_regs(thread);
if (regs == NULL)
goto zero;
*pcstack++ = (uint64_t)proc_selfpid();
pcstack_limit--;
if (pcstack_limit <= 0)
return;
pc = regs->REGPC;
sp = regs->REGSP;
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
*pcstack++ = (uint64_t)pc;
pcstack_limit--;
if (pcstack_limit <= 0)
return;
pc = regs->save_lr;
}
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_USTACK_FP)) {
/*
* If the ustack fp flag is set, the stack frame from sp to
* fp contains no valid call information. Start with the fp.
*/
if (is64Bit)
sp = dtrace_fuword64(sp);
else
sp = (user_addr_t)dtrace_fuword32(sp);
}
n = dtrace_getustack_common(pcstack, pcstack_limit, pc, sp);
ASSERT(n >= 0);
ASSERT(n <= pcstack_limit);
pcstack += n;
pcstack_limit -= n;
zero:
while (pcstack_limit-- > 0)
*pcstack++ = 0;
}
void
dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit)
{
proc_t *p = curproc;
thread_t *td = curthread;
struct reg *tf;
uintptr_t pc, sp, fp;
volatile uint16_t *flags =
#if defined(sun)
(volatile uint16_t *)&cpu_core[curcpu].cpuc_dtrace_flags;
#else
(volatile uint16_t *)&cpu_core[KeGetCurrentProcessorNumber()].cpuc_dtrace_flags;
#endif
int n = 0;
CONTEXT ct;
if (*flags & CPU_DTRACE_FAULT)
return;
if (pcstack_limit <= 0)
return;
/*
* If there's no user context we still need to zero the stack.
*/
if (p == NULL || (tf = td->tf) == NULL)
goto zero;
*pcstack++ = (uint64_t)p->pid;
pcstack_limit--;
if (pcstack_limit <= 0)
return;
#ifdef __amd64
if (p->p_model == DATAMODEL_NATIVE) {
winos_reg_to_context(&ct, tf);
n = winos_unwind_user_stack(&ct, pcstack_limit, (uintptr_t) pcstack);
pcstack = &pcstack[n];
pcstack_limit -= n;
} else {
#endif // i386
pc = tf->r_rip;
fp = tf->r_rbp;
sp = tf->r_rsp;
if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
/*
* In an entry probe. The frame pointer has not yet been
* pushed (that happens in the function prologue). The
* best approach is to add the current pc as a missing top
* of stack and back the pc up to the caller, which is stored
* at the current stack pointer address since the call
* instruction puts it there right before the branch.
*/
*pcstack++ = (uint64_t)pc;
pcstack_limit--;
if (pcstack_limit <= 0)
return;
pc = dtrace_fuword32((void *) sp);
}
n = dtrace_getustack_common(pcstack, pcstack_limit, pc, fp);
ASSERT(n >= 0);
ASSERT(n <= pcstack_limit);
pcstack += n;
pcstack_limit -= n;
#ifdef __amd64
}
#endif
zero:
while (pcstack_limit-- > 0)
*pcstack++ = 0;
}
