17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5ab9a77c7Sahl * Common Development and Distribution License (the "License"). 6ab9a77c7Sahl * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21ab9a77c7Sahl 227c478bd9Sstevel@tonic-gate /* 23ae115bc7Smrj * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate #include <sys/dtrace_impl.h> 307c478bd9Sstevel@tonic-gate #include <sys/stack.h> 317c478bd9Sstevel@tonic-gate #include <sys/frame.h> 327c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 337c478bd9Sstevel@tonic-gate #include <sys/privregs.h> 347c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 357c478bd9Sstevel@tonic-gate 367c478bd9Sstevel@tonic-gate extern uintptr_t kernelbase; 377c478bd9Sstevel@tonic-gate 38*b8fac8e1Sjhaslam int dtrace_ustackdepth_max = 2048; 39*b8fac8e1Sjhaslam 407c478bd9Sstevel@tonic-gate void 417c478bd9Sstevel@tonic-gate dtrace_getpcstack(pc_t *pcstack, int pcstack_limit, int aframes, 427c478bd9Sstevel@tonic-gate uint32_t *intrpc) 437c478bd9Sstevel@tonic-gate { 447c478bd9Sstevel@tonic-gate struct frame *fp = (struct frame *)dtrace_getfp(); 457c478bd9Sstevel@tonic-gate struct frame *nextfp, *minfp, *stacktop; 467c478bd9Sstevel@tonic-gate int depth = 0; 477c478bd9Sstevel@tonic-gate int on_intr, last = 0; 487c478bd9Sstevel@tonic-gate uintptr_t pc; 497c478bd9Sstevel@tonic-gate uintptr_t caller = CPU->cpu_dtrace_caller; 507c478bd9Sstevel@tonic-gate 517c478bd9Sstevel@tonic-gate if ((on_intr = CPU_ON_INTR(CPU)) != 0) 527c478bd9Sstevel@tonic-gate stacktop = (struct frame *)(CPU->cpu_intr_stack + SA(MINFRAME)); 537c478bd9Sstevel@tonic-gate else 547c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 557c478bd9Sstevel@tonic-gate minfp = fp; 567c478bd9Sstevel@tonic-gate 577c478bd9Sstevel@tonic-gate aframes++; 587c478bd9Sstevel@tonic-gate 597c478bd9Sstevel@tonic-gate if (intrpc != NULL && depth < pcstack_limit) 607c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)intrpc; 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate while (depth < pcstack_limit) { 637c478bd9Sstevel@tonic-gate nextfp = (struct frame *)fp->fr_savfp; 647c478bd9Sstevel@tonic-gate pc = fp->fr_savpc; 657c478bd9Sstevel@tonic-gate 667c478bd9Sstevel@tonic-gate if (nextfp <= minfp || nextfp >= stacktop) { 677c478bd9Sstevel@tonic-gate if (on_intr) { 687c478bd9Sstevel@tonic-gate /* 697c478bd9Sstevel@tonic-gate * Hop from interrupt stack to thread stack. 707c478bd9Sstevel@tonic-gate */ 717c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 727c478bd9Sstevel@tonic-gate minfp = (struct frame *)curthread->t_stkbase; 737c478bd9Sstevel@tonic-gate on_intr = 0; 747c478bd9Sstevel@tonic-gate continue; 757c478bd9Sstevel@tonic-gate } 767c478bd9Sstevel@tonic-gate 777c478bd9Sstevel@tonic-gate /* 787c478bd9Sstevel@tonic-gate * This is the last frame we can process; indicate 797c478bd9Sstevel@tonic-gate * that we should return after processing this frame. 807c478bd9Sstevel@tonic-gate */ 817c478bd9Sstevel@tonic-gate last = 1; 827c478bd9Sstevel@tonic-gate } 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate if (aframes > 0) { 857c478bd9Sstevel@tonic-gate if (--aframes == 0 && caller != NULL) { 867c478bd9Sstevel@tonic-gate /* 877c478bd9Sstevel@tonic-gate * We've just run out of artificial frames, 887c478bd9Sstevel@tonic-gate * and we have a valid caller -- fill it in 897c478bd9Sstevel@tonic-gate * now. 907c478bd9Sstevel@tonic-gate */ 917c478bd9Sstevel@tonic-gate ASSERT(depth < pcstack_limit); 927c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)caller; 937c478bd9Sstevel@tonic-gate caller = NULL; 947c478bd9Sstevel@tonic-gate } 957c478bd9Sstevel@tonic-gate } else { 967c478bd9Sstevel@tonic-gate if (depth < pcstack_limit) 977c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)pc; 987c478bd9Sstevel@tonic-gate } 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate if (last) { 1017c478bd9Sstevel@tonic-gate while (depth < pcstack_limit) 1027c478bd9Sstevel@tonic-gate pcstack[depth++] = NULL; 1037c478bd9Sstevel@tonic-gate return; 1047c478bd9Sstevel@tonic-gate } 1057c478bd9Sstevel@tonic-gate 1067c478bd9Sstevel@tonic-gate fp = nextfp; 1077c478bd9Sstevel@tonic-gate minfp = fp; 1087c478bd9Sstevel@tonic-gate } 1097c478bd9Sstevel@tonic-gate } 1107c478bd9Sstevel@tonic-gate 1110b38a8bdSahl static int 1120b38a8bdSahl dtrace_getustack_common(uint64_t *pcstack, int pcstack_limit, uintptr_t pc, 1130b38a8bdSahl uintptr_t sp) 1147c478bd9Sstevel@tonic-gate { 1157c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread); 1160b38a8bdSahl proc_t *p = curproc; 1170b38a8bdSahl uintptr_t oldcontext = lwp->lwp_oldcontext; 118*b8fac8e1Sjhaslam uintptr_t oldsp; 1190b38a8bdSahl volatile uint16_t *flags = 1200b38a8bdSahl (volatile uint16_t *)&cpu_core[CPU->cpu_id].cpuc_dtrace_flags; 1217c478bd9Sstevel@tonic-gate size_t s1, s2; 1220b38a8bdSahl int ret = 0; 1237c478bd9Sstevel@tonic-gate 1240b38a8bdSahl ASSERT(pcstack == NULL || pcstack_limit > 0); 125*b8fac8e1Sjhaslam ASSERT(dtrace_ustackdepth_max > 0); 1267c478bd9Sstevel@tonic-gate 1277c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 1287c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame) + 2 * sizeof (long); 1297c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo_t); 1307c478bd9Sstevel@tonic-gate } else { 1317c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame32) + 3 * sizeof (int); 1327c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo32_t); 1337c478bd9Sstevel@tonic-gate } 1347c478bd9Sstevel@tonic-gate 135ab9a77c7Sahl while (pc != 0) { 136*b8fac8e1Sjhaslam /* 137*b8fac8e1Sjhaslam * We limit the number of times we can go around this 138*b8fac8e1Sjhaslam * loop to account for a circular stack. 139*b8fac8e1Sjhaslam */ 140*b8fac8e1Sjhaslam if (ret++ >= dtrace_ustackdepth_max) { 141*b8fac8e1Sjhaslam *flags |= CPU_DTRACE_BADSTACK; 142*b8fac8e1Sjhaslam cpu_core[CPU->cpu_id].cpuc_dtrace_illval = sp; 143*b8fac8e1Sjhaslam break; 144*b8fac8e1Sjhaslam } 145*b8fac8e1Sjhaslam 1460b38a8bdSahl if (pcstack != NULL) { 1477c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)pc; 1487c478bd9Sstevel@tonic-gate pcstack_limit--; 1497c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 1507c478bd9Sstevel@tonic-gate break; 1510b38a8bdSahl } 1527c478bd9Sstevel@tonic-gate 153ab9a77c7Sahl if (sp == 0) 154ab9a77c7Sahl break; 155ab9a77c7Sahl 156*b8fac8e1Sjhaslam oldsp = sp; 157*b8fac8e1Sjhaslam 1587c478bd9Sstevel@tonic-gate if (oldcontext == sp + s1 || oldcontext == sp + s2) { 1597c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 1607c478bd9Sstevel@tonic-gate ucontext_t *ucp = (ucontext_t *)oldcontext; 1617c478bd9Sstevel@tonic-gate greg_t *gregs = ucp->uc_mcontext.gregs; 1627c478bd9Sstevel@tonic-gate 1637c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&gregs[REG_FP]); 1647c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&gregs[REG_PC]); 1657c478bd9Sstevel@tonic-gate 1667c478bd9Sstevel@tonic-gate oldcontext = dtrace_fulword(&ucp->uc_link); 1677c478bd9Sstevel@tonic-gate } else { 1687c478bd9Sstevel@tonic-gate ucontext32_t *ucp = (ucontext32_t *)oldcontext; 1697c478bd9Sstevel@tonic-gate greg32_t *gregs = ucp->uc_mcontext.gregs; 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&gregs[EBP]); 1727c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&gregs[EIP]); 1737c478bd9Sstevel@tonic-gate 1747c478bd9Sstevel@tonic-gate oldcontext = dtrace_fuword32(&ucp->uc_link); 1757c478bd9Sstevel@tonic-gate } 1767c478bd9Sstevel@tonic-gate } else { 1777c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 1787c478bd9Sstevel@tonic-gate struct frame *fr = (struct frame *)sp; 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&fr->fr_savpc); 1817c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&fr->fr_savfp); 1827c478bd9Sstevel@tonic-gate } else { 1837c478bd9Sstevel@tonic-gate struct frame32 *fr = (struct frame32 *)sp; 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&fr->fr_savpc); 1867c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&fr->fr_savfp); 1877c478bd9Sstevel@tonic-gate } 1887c478bd9Sstevel@tonic-gate } 1897c478bd9Sstevel@tonic-gate 190*b8fac8e1Sjhaslam if (sp == oldsp) { 191*b8fac8e1Sjhaslam *flags |= CPU_DTRACE_BADSTACK; 192*b8fac8e1Sjhaslam cpu_core[CPU->cpu_id].cpuc_dtrace_illval = sp; 193*b8fac8e1Sjhaslam break; 194*b8fac8e1Sjhaslam } 195*b8fac8e1Sjhaslam 1967c478bd9Sstevel@tonic-gate /* 1977c478bd9Sstevel@tonic-gate * This is totally bogus: if we faulted, we're going to clear 1987c478bd9Sstevel@tonic-gate * the fault and break. This is to deal with the apparently 1997c478bd9Sstevel@tonic-gate * broken Java stacks on x86. 2007c478bd9Sstevel@tonic-gate */ 2017c478bd9Sstevel@tonic-gate if (*flags & CPU_DTRACE_FAULT) { 2027c478bd9Sstevel@tonic-gate *flags &= ~CPU_DTRACE_FAULT; 2037c478bd9Sstevel@tonic-gate break; 2047c478bd9Sstevel@tonic-gate } 2057c478bd9Sstevel@tonic-gate } 2067c478bd9Sstevel@tonic-gate 2070b38a8bdSahl return (ret); 2080b38a8bdSahl } 2090b38a8bdSahl 2100b38a8bdSahl void 2110b38a8bdSahl dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit) 2120b38a8bdSahl { 2130b38a8bdSahl klwp_t *lwp = ttolwp(curthread); 2140b38a8bdSahl proc_t *p = curproc; 2150b38a8bdSahl struct regs *rp; 2160b38a8bdSahl uintptr_t pc, sp; 2170b38a8bdSahl volatile uint16_t *flags = 2180b38a8bdSahl (volatile uint16_t *)&cpu_core[CPU->cpu_id].cpuc_dtrace_flags; 2190b38a8bdSahl int n; 2200b38a8bdSahl 2210b38a8bdSahl if (*flags & CPU_DTRACE_FAULT) 2220b38a8bdSahl return; 2230b38a8bdSahl 2240b38a8bdSahl if (pcstack_limit <= 0) 2250b38a8bdSahl return; 2260b38a8bdSahl 22735b7f6ccSahl /* 22835b7f6ccSahl * If there's no user context we still need to zero the stack. 22935b7f6ccSahl */ 23035b7f6ccSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL) 23135b7f6ccSahl goto zero; 23235b7f6ccSahl 2330b38a8bdSahl *pcstack++ = (uint64_t)p->p_pid; 2340b38a8bdSahl pcstack_limit--; 2350b38a8bdSahl 2360b38a8bdSahl if (pcstack_limit <= 0) 2370b38a8bdSahl return; 2380b38a8bdSahl 2390b38a8bdSahl pc = rp->r_pc; 2400b38a8bdSahl sp = rp->r_fp; 2410b38a8bdSahl 2420b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) { 2430b38a8bdSahl *pcstack++ = (uint64_t)pc; 2440b38a8bdSahl pcstack_limit--; 2450b38a8bdSahl if (pcstack_limit <= 0) 2460b38a8bdSahl return; 2470b38a8bdSahl 2480b38a8bdSahl if (p->p_model == DATAMODEL_NATIVE) 2490b38a8bdSahl pc = dtrace_fulword((void *)rp->r_sp); 2500b38a8bdSahl else 2510b38a8bdSahl pc = dtrace_fuword32((void *)rp->r_sp); 2520b38a8bdSahl } 2530b38a8bdSahl 2540b38a8bdSahl n = dtrace_getustack_common(pcstack, pcstack_limit, pc, sp); 2550b38a8bdSahl ASSERT(n >= 0); 2560b38a8bdSahl ASSERT(n <= pcstack_limit); 2570b38a8bdSahl 2580b38a8bdSahl pcstack += n; 2590b38a8bdSahl pcstack_limit -= n; 2600b38a8bdSahl 26135b7f6ccSahl zero: 2627c478bd9Sstevel@tonic-gate while (pcstack_limit-- > 0) 2637c478bd9Sstevel@tonic-gate *pcstack++ = NULL; 2647c478bd9Sstevel@tonic-gate } 2657c478bd9Sstevel@tonic-gate 2660b38a8bdSahl int 2670b38a8bdSahl dtrace_getustackdepth(void) 2680b38a8bdSahl { 2690b38a8bdSahl klwp_t *lwp = ttolwp(curthread); 2700b38a8bdSahl proc_t *p = curproc; 2710b38a8bdSahl struct regs *rp; 2720b38a8bdSahl uintptr_t pc, sp; 2730b38a8bdSahl int n = 0; 2740b38a8bdSahl 2750b38a8bdSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL) 2760b38a8bdSahl return (0); 2770b38a8bdSahl 2780b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAULT)) 2790b38a8bdSahl return (-1); 2800b38a8bdSahl 2810b38a8bdSahl pc = rp->r_pc; 2820b38a8bdSahl sp = rp->r_fp; 2830b38a8bdSahl 2840b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) { 2850b38a8bdSahl n++; 2860b38a8bdSahl 2870b38a8bdSahl if (p->p_model == DATAMODEL_NATIVE) 2880b38a8bdSahl pc = dtrace_fulword((void *)rp->r_sp); 2890b38a8bdSahl else 2900b38a8bdSahl pc = dtrace_fuword32((void *)rp->r_sp); 2910b38a8bdSahl } 2920b38a8bdSahl 2930b38a8bdSahl n += dtrace_getustack_common(NULL, 0, pc, sp); 2940b38a8bdSahl 2950b38a8bdSahl return (n); 2960b38a8bdSahl } 2970b38a8bdSahl 2987c478bd9Sstevel@tonic-gate void 2997c478bd9Sstevel@tonic-gate dtrace_getufpstack(uint64_t *pcstack, uint64_t *fpstack, int pcstack_limit) 3007c478bd9Sstevel@tonic-gate { 3017c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread); 3020b38a8bdSahl proc_t *p = curproc; 3037c478bd9Sstevel@tonic-gate struct regs *rp; 3047c478bd9Sstevel@tonic-gate uintptr_t pc, sp, oldcontext; 3050b38a8bdSahl volatile uint16_t *flags = 3060b38a8bdSahl (volatile uint16_t *)&cpu_core[CPU->cpu_id].cpuc_dtrace_flags; 3077c478bd9Sstevel@tonic-gate size_t s1, s2; 3087c478bd9Sstevel@tonic-gate 3097c478bd9Sstevel@tonic-gate if (*flags & CPU_DTRACE_FAULT) 3107c478bd9Sstevel@tonic-gate return; 3117c478bd9Sstevel@tonic-gate 3127c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 3137c478bd9Sstevel@tonic-gate return; 3147c478bd9Sstevel@tonic-gate 31535b7f6ccSahl /* 31635b7f6ccSahl * If there's no user context we still need to zero the stack. 31735b7f6ccSahl */ 31835b7f6ccSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL) 31935b7f6ccSahl goto zero; 32035b7f6ccSahl 3217c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)p->p_pid; 3227c478bd9Sstevel@tonic-gate pcstack_limit--; 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 3257c478bd9Sstevel@tonic-gate return; 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate pc = rp->r_pc; 3287c478bd9Sstevel@tonic-gate sp = rp->r_fp; 3297c478bd9Sstevel@tonic-gate oldcontext = lwp->lwp_oldcontext; 3307c478bd9Sstevel@tonic-gate 3317c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 3327c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame) + 2 * sizeof (long); 3337c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo_t); 3347c478bd9Sstevel@tonic-gate } else { 3357c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame32) + 3 * sizeof (int); 3367c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo32_t); 3377c478bd9Sstevel@tonic-gate } 3387c478bd9Sstevel@tonic-gate 3397c478bd9Sstevel@tonic-gate if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) { 3407c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)pc; 3417c478bd9Sstevel@tonic-gate *fpstack++ = 0; 3427c478bd9Sstevel@tonic-gate pcstack_limit--; 3437c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 3447c478bd9Sstevel@tonic-gate return; 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) 3477c478bd9Sstevel@tonic-gate pc = dtrace_fulword((void *)rp->r_sp); 3487c478bd9Sstevel@tonic-gate else 3497c478bd9Sstevel@tonic-gate pc = dtrace_fuword32((void *)rp->r_sp); 3507c478bd9Sstevel@tonic-gate } 3517c478bd9Sstevel@tonic-gate 352ab9a77c7Sahl while (pc != 0) { 3537c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)pc; 3547c478bd9Sstevel@tonic-gate *fpstack++ = sp; 3557c478bd9Sstevel@tonic-gate pcstack_limit--; 3567c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 3577c478bd9Sstevel@tonic-gate break; 3587c478bd9Sstevel@tonic-gate 359ab9a77c7Sahl if (sp == 0) 360ab9a77c7Sahl break; 361ab9a77c7Sahl 3627c478bd9Sstevel@tonic-gate if (oldcontext == sp + s1 || oldcontext == sp + s2) { 3637c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 3647c478bd9Sstevel@tonic-gate ucontext_t *ucp = (ucontext_t *)oldcontext; 3657c478bd9Sstevel@tonic-gate greg_t *gregs = ucp->uc_mcontext.gregs; 3667c478bd9Sstevel@tonic-gate 3677c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&gregs[REG_FP]); 3687c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&gregs[REG_PC]); 3697c478bd9Sstevel@tonic-gate 3707c478bd9Sstevel@tonic-gate oldcontext = dtrace_fulword(&ucp->uc_link); 3717c478bd9Sstevel@tonic-gate } else { 3727c478bd9Sstevel@tonic-gate ucontext_t *ucp = (ucontext_t *)oldcontext; 3737c478bd9Sstevel@tonic-gate greg_t *gregs = ucp->uc_mcontext.gregs; 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&gregs[EBP]); 3767c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&gregs[EIP]); 3777c478bd9Sstevel@tonic-gate 3787c478bd9Sstevel@tonic-gate oldcontext = dtrace_fuword32(&ucp->uc_link); 3797c478bd9Sstevel@tonic-gate } 3807c478bd9Sstevel@tonic-gate } else { 3817c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 3827c478bd9Sstevel@tonic-gate struct frame *fr = (struct frame *)sp; 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&fr->fr_savpc); 3857c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&fr->fr_savfp); 3867c478bd9Sstevel@tonic-gate } else { 3877c478bd9Sstevel@tonic-gate struct frame32 *fr = (struct frame32 *)sp; 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&fr->fr_savpc); 3907c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&fr->fr_savfp); 3917c478bd9Sstevel@tonic-gate } 3927c478bd9Sstevel@tonic-gate } 3937c478bd9Sstevel@tonic-gate 3947c478bd9Sstevel@tonic-gate /* 3957c478bd9Sstevel@tonic-gate * This is totally bogus: if we faulted, we're going to clear 3967c478bd9Sstevel@tonic-gate * the fault and break. This is to deal with the apparently 3977c478bd9Sstevel@tonic-gate * broken Java stacks on x86. 3987c478bd9Sstevel@tonic-gate */ 3997c478bd9Sstevel@tonic-gate if (*flags & CPU_DTRACE_FAULT) { 4007c478bd9Sstevel@tonic-gate *flags &= ~CPU_DTRACE_FAULT; 4017c478bd9Sstevel@tonic-gate break; 4027c478bd9Sstevel@tonic-gate } 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate 40535b7f6ccSahl zero: 4067c478bd9Sstevel@tonic-gate while (pcstack_limit-- > 0) 4077c478bd9Sstevel@tonic-gate *pcstack++ = NULL; 4087c478bd9Sstevel@tonic-gate } 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4117c478bd9Sstevel@tonic-gate uint64_t 4127c478bd9Sstevel@tonic-gate dtrace_getarg(int arg, int aframes) 4137c478bd9Sstevel@tonic-gate { 4147c478bd9Sstevel@tonic-gate uintptr_t val; 4157c478bd9Sstevel@tonic-gate struct frame *fp = (struct frame *)dtrace_getfp(); 4167c478bd9Sstevel@tonic-gate uintptr_t *stack; 4177c478bd9Sstevel@tonic-gate int i; 4187c478bd9Sstevel@tonic-gate #if defined(__amd64) 4197c478bd9Sstevel@tonic-gate /* 4207c478bd9Sstevel@tonic-gate * A total of 6 arguments are passed via registers; any argument with 4217c478bd9Sstevel@tonic-gate * index of 5 or lower is therefore in a register. 4227c478bd9Sstevel@tonic-gate */ 4237c478bd9Sstevel@tonic-gate int inreg = 5; 4247c478bd9Sstevel@tonic-gate #endif 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate for (i = 1; i <= aframes; i++) { 4277c478bd9Sstevel@tonic-gate fp = (struct frame *)(fp->fr_savfp); 4287c478bd9Sstevel@tonic-gate 4297c478bd9Sstevel@tonic-gate if (fp->fr_savpc == (pc_t)dtrace_invop_callsite) { 4307c478bd9Sstevel@tonic-gate #if !defined(__amd64) 4317c478bd9Sstevel@tonic-gate /* 4327c478bd9Sstevel@tonic-gate * If we pass through the invalid op handler, we will 4337c478bd9Sstevel@tonic-gate * use the pointer that it passed to the stack as the 4347c478bd9Sstevel@tonic-gate * second argument to dtrace_invop() as the pointer to 4357c478bd9Sstevel@tonic-gate * the stack. When using this stack, we must step 4367c478bd9Sstevel@tonic-gate * beyond the EIP/RIP that was pushed when the trap was 4377c478bd9Sstevel@tonic-gate * taken -- hence the "+ 1" below. 4387c478bd9Sstevel@tonic-gate */ 4397c478bd9Sstevel@tonic-gate stack = ((uintptr_t **)&fp[1])[1] + 1; 4407c478bd9Sstevel@tonic-gate #else 4417c478bd9Sstevel@tonic-gate /* 4427c478bd9Sstevel@tonic-gate * In the case of amd64, we will use the pointer to the 4437c478bd9Sstevel@tonic-gate * regs structure that was pushed when we took the 4447c478bd9Sstevel@tonic-gate * trap. To get this structure, we must increment 4457c478bd9Sstevel@tonic-gate * beyond the frame structure, and then again beyond 4467c478bd9Sstevel@tonic-gate * the calling RIP stored in dtrace_invop(). If the 4477c478bd9Sstevel@tonic-gate * argument that we're seeking is passed on the stack, 4487c478bd9Sstevel@tonic-gate * we'll pull the true stack pointer out of the saved 4497c478bd9Sstevel@tonic-gate * registers and decrement our argument by the number 4507c478bd9Sstevel@tonic-gate * of arguments passed in registers; if the argument 4517c478bd9Sstevel@tonic-gate * we're seeking is passed in regsiters, we can just 4527c478bd9Sstevel@tonic-gate * load it directly. 4537c478bd9Sstevel@tonic-gate */ 4547c478bd9Sstevel@tonic-gate struct regs *rp = (struct regs *)((uintptr_t)&fp[1] + 4557c478bd9Sstevel@tonic-gate sizeof (uintptr_t)); 4567c478bd9Sstevel@tonic-gate 4577c478bd9Sstevel@tonic-gate if (arg <= inreg) { 4587c478bd9Sstevel@tonic-gate stack = (uintptr_t *)&rp->r_rdi; 4597c478bd9Sstevel@tonic-gate } else { 4607c478bd9Sstevel@tonic-gate stack = (uintptr_t *)(rp->r_rsp); 4617c478bd9Sstevel@tonic-gate arg -= inreg; 4627c478bd9Sstevel@tonic-gate } 4637c478bd9Sstevel@tonic-gate #endif 4647c478bd9Sstevel@tonic-gate goto load; 4657c478bd9Sstevel@tonic-gate } 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate } 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate /* 4707c478bd9Sstevel@tonic-gate * We know that we did not come through a trap to get into 4717c478bd9Sstevel@tonic-gate * dtrace_probe() -- the provider simply called dtrace_probe() 4727c478bd9Sstevel@tonic-gate * directly. As this is the case, we need to shift the argument 4737c478bd9Sstevel@tonic-gate * that we're looking for: the probe ID is the first argument to 4747c478bd9Sstevel@tonic-gate * dtrace_probe(), so the argument n will actually be found where 4757c478bd9Sstevel@tonic-gate * one would expect to find argument (n + 1). 4767c478bd9Sstevel@tonic-gate */ 4777c478bd9Sstevel@tonic-gate arg++; 4787c478bd9Sstevel@tonic-gate 4797c478bd9Sstevel@tonic-gate #if defined(__amd64) 4807c478bd9Sstevel@tonic-gate if (arg <= inreg) { 4817c478bd9Sstevel@tonic-gate /* 4827c478bd9Sstevel@tonic-gate * This shouldn't happen. If the argument is passed in a 4837c478bd9Sstevel@tonic-gate * register then it should have been, well, passed in a 4847c478bd9Sstevel@tonic-gate * register... 4857c478bd9Sstevel@tonic-gate */ 4867c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP); 4877c478bd9Sstevel@tonic-gate return (0); 4887c478bd9Sstevel@tonic-gate } 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate arg -= (inreg + 1); 4917c478bd9Sstevel@tonic-gate #endif 4927c478bd9Sstevel@tonic-gate stack = (uintptr_t *)&fp[1]; 4937c478bd9Sstevel@tonic-gate 4947c478bd9Sstevel@tonic-gate load: 4957c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 4967c478bd9Sstevel@tonic-gate val = stack[arg]; 4977c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 4987c478bd9Sstevel@tonic-gate 4997c478bd9Sstevel@tonic-gate return (val); 5007c478bd9Sstevel@tonic-gate } 5017c478bd9Sstevel@tonic-gate 5027c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 5037c478bd9Sstevel@tonic-gate int 5047c478bd9Sstevel@tonic-gate dtrace_getstackdepth(int aframes) 5057c478bd9Sstevel@tonic-gate { 5067c478bd9Sstevel@tonic-gate struct frame *fp = (struct frame *)dtrace_getfp(); 5077c478bd9Sstevel@tonic-gate struct frame *nextfp, *minfp, *stacktop; 5087c478bd9Sstevel@tonic-gate int depth = 0; 5097c478bd9Sstevel@tonic-gate int on_intr; 5107c478bd9Sstevel@tonic-gate 5117c478bd9Sstevel@tonic-gate if ((on_intr = CPU_ON_INTR(CPU)) != 0) 5127c478bd9Sstevel@tonic-gate stacktop = (struct frame *)(CPU->cpu_intr_stack + SA(MINFRAME)); 5137c478bd9Sstevel@tonic-gate else 5147c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 5157c478bd9Sstevel@tonic-gate minfp = fp; 5167c478bd9Sstevel@tonic-gate 5177c478bd9Sstevel@tonic-gate aframes++; 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate for (;;) { 5207c478bd9Sstevel@tonic-gate depth++; 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate nextfp = (struct frame *)fp->fr_savfp; 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate if (nextfp <= minfp || nextfp >= stacktop) { 5257c478bd9Sstevel@tonic-gate if (on_intr) { 5267c478bd9Sstevel@tonic-gate /* 5277c478bd9Sstevel@tonic-gate * Hop from interrupt stack to thread stack. 5287c478bd9Sstevel@tonic-gate */ 5297c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 5307c478bd9Sstevel@tonic-gate minfp = (struct frame *)curthread->t_stkbase; 5317c478bd9Sstevel@tonic-gate on_intr = 0; 5327c478bd9Sstevel@tonic-gate continue; 5337c478bd9Sstevel@tonic-gate } 5347c478bd9Sstevel@tonic-gate break; 5357c478bd9Sstevel@tonic-gate } 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate fp = nextfp; 5387c478bd9Sstevel@tonic-gate minfp = fp; 5397c478bd9Sstevel@tonic-gate } 5407c478bd9Sstevel@tonic-gate 5417c478bd9Sstevel@tonic-gate if (depth <= aframes) 5427c478bd9Sstevel@tonic-gate return (0); 5437c478bd9Sstevel@tonic-gate 5447c478bd9Sstevel@tonic-gate return (depth - aframes); 5457c478bd9Sstevel@tonic-gate } 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate ulong_t 5487c478bd9Sstevel@tonic-gate dtrace_getreg(struct regs *rp, uint_t reg) 5497c478bd9Sstevel@tonic-gate { 5507c478bd9Sstevel@tonic-gate #if defined(__amd64) 5517c478bd9Sstevel@tonic-gate int regmap[] = { 5527c478bd9Sstevel@tonic-gate REG_GS, /* GS */ 5537c478bd9Sstevel@tonic-gate REG_FS, /* FS */ 5547c478bd9Sstevel@tonic-gate REG_ES, /* ES */ 5557c478bd9Sstevel@tonic-gate REG_DS, /* DS */ 5567c478bd9Sstevel@tonic-gate REG_RDI, /* EDI */ 5577c478bd9Sstevel@tonic-gate REG_RSI, /* ESI */ 5587c478bd9Sstevel@tonic-gate REG_RBP, /* EBP */ 5597c478bd9Sstevel@tonic-gate REG_RSP, /* ESP */ 5607c478bd9Sstevel@tonic-gate REG_RBX, /* EBX */ 5617c478bd9Sstevel@tonic-gate REG_RDX, /* EDX */ 5627c478bd9Sstevel@tonic-gate REG_RCX, /* ECX */ 5637c478bd9Sstevel@tonic-gate REG_RAX, /* EAX */ 5647c478bd9Sstevel@tonic-gate REG_TRAPNO, /* TRAPNO */ 5657c478bd9Sstevel@tonic-gate REG_ERR, /* ERR */ 5667c478bd9Sstevel@tonic-gate REG_RIP, /* EIP */ 5677c478bd9Sstevel@tonic-gate REG_CS, /* CS */ 5687c478bd9Sstevel@tonic-gate REG_RFL, /* EFL */ 5697c478bd9Sstevel@tonic-gate REG_RSP, /* UESP */ 5707c478bd9Sstevel@tonic-gate REG_SS /* SS */ 5717c478bd9Sstevel@tonic-gate }; 5727c478bd9Sstevel@tonic-gate 5737c478bd9Sstevel@tonic-gate if (reg <= SS) { 5747c478bd9Sstevel@tonic-gate if (reg >= sizeof (regmap) / sizeof (int)) { 5757c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP); 5767c478bd9Sstevel@tonic-gate return (0); 5777c478bd9Sstevel@tonic-gate } 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate reg = regmap[reg]; 5807c478bd9Sstevel@tonic-gate } else { 5817c478bd9Sstevel@tonic-gate reg -= SS + 1; 5827c478bd9Sstevel@tonic-gate } 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate switch (reg) { 5857c478bd9Sstevel@tonic-gate case REG_RDI: 5867c478bd9Sstevel@tonic-gate return (rp->r_rdi); 5877c478bd9Sstevel@tonic-gate case REG_RSI: 5887c478bd9Sstevel@tonic-gate return (rp->r_rsi); 5897c478bd9Sstevel@tonic-gate case REG_RDX: 5907c478bd9Sstevel@tonic-gate return (rp->r_rdx); 5917c478bd9Sstevel@tonic-gate case REG_RCX: 5927c478bd9Sstevel@tonic-gate return (rp->r_rcx); 5937c478bd9Sstevel@tonic-gate case REG_R8: 5947c478bd9Sstevel@tonic-gate return (rp->r_r8); 5957c478bd9Sstevel@tonic-gate case REG_R9: 5967c478bd9Sstevel@tonic-gate return (rp->r_r9); 5977c478bd9Sstevel@tonic-gate case REG_RAX: 5987c478bd9Sstevel@tonic-gate return (rp->r_rax); 5997c478bd9Sstevel@tonic-gate case REG_RBX: 6007c478bd9Sstevel@tonic-gate return (rp->r_rbx); 6017c478bd9Sstevel@tonic-gate case REG_RBP: 6027c478bd9Sstevel@tonic-gate return (rp->r_rbp); 6037c478bd9Sstevel@tonic-gate case REG_R10: 6047c478bd9Sstevel@tonic-gate return (rp->r_r10); 6057c478bd9Sstevel@tonic-gate case REG_R11: 6067c478bd9Sstevel@tonic-gate return (rp->r_r11); 6077c478bd9Sstevel@tonic-gate case REG_R12: 6087c478bd9Sstevel@tonic-gate return (rp->r_r12); 6097c478bd9Sstevel@tonic-gate case REG_R13: 6107c478bd9Sstevel@tonic-gate return (rp->r_r13); 6117c478bd9Sstevel@tonic-gate case REG_R14: 6127c478bd9Sstevel@tonic-gate return (rp->r_r14); 6137c478bd9Sstevel@tonic-gate case REG_R15: 6147c478bd9Sstevel@tonic-gate return (rp->r_r15); 6157c478bd9Sstevel@tonic-gate case REG_DS: 6167c478bd9Sstevel@tonic-gate return (rp->r_ds); 6177c478bd9Sstevel@tonic-gate case REG_ES: 6187c478bd9Sstevel@tonic-gate return (rp->r_es); 6197c478bd9Sstevel@tonic-gate case REG_FS: 6207c478bd9Sstevel@tonic-gate return (rp->r_fs); 6217c478bd9Sstevel@tonic-gate case REG_GS: 6227c478bd9Sstevel@tonic-gate return (rp->r_gs); 6237c478bd9Sstevel@tonic-gate case REG_TRAPNO: 6247c478bd9Sstevel@tonic-gate return (rp->r_trapno); 6257c478bd9Sstevel@tonic-gate case REG_ERR: 6267c478bd9Sstevel@tonic-gate return (rp->r_err); 6277c478bd9Sstevel@tonic-gate case REG_RIP: 6287c478bd9Sstevel@tonic-gate return (rp->r_rip); 6297c478bd9Sstevel@tonic-gate case REG_CS: 6307c478bd9Sstevel@tonic-gate return (rp->r_cs); 6317c478bd9Sstevel@tonic-gate case REG_SS: 6327c478bd9Sstevel@tonic-gate return (rp->r_ss); 6337c478bd9Sstevel@tonic-gate case REG_RFL: 6347c478bd9Sstevel@tonic-gate return (rp->r_rfl); 6357c478bd9Sstevel@tonic-gate case REG_RSP: 6367c478bd9Sstevel@tonic-gate return (rp->r_rsp); 6377c478bd9Sstevel@tonic-gate default: 6387c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP); 6397c478bd9Sstevel@tonic-gate return (0); 6407c478bd9Sstevel@tonic-gate } 6417c478bd9Sstevel@tonic-gate 6427c478bd9Sstevel@tonic-gate #else 6437c478bd9Sstevel@tonic-gate if (reg > SS) { 6447c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP); 6457c478bd9Sstevel@tonic-gate return (0); 6467c478bd9Sstevel@tonic-gate } 6477c478bd9Sstevel@tonic-gate 6487c478bd9Sstevel@tonic-gate return ((&rp->r_gs)[reg]); 6497c478bd9Sstevel@tonic-gate #endif 6507c478bd9Sstevel@tonic-gate } 6517c478bd9Sstevel@tonic-gate 6527c478bd9Sstevel@tonic-gate static int 6537c478bd9Sstevel@tonic-gate dtrace_copycheck(uintptr_t uaddr, uintptr_t kaddr, size_t size) 6547c478bd9Sstevel@tonic-gate { 6557c478bd9Sstevel@tonic-gate ASSERT(kaddr >= kernelbase && kaddr + size >= kaddr); 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate if (uaddr + size >= kernelbase || uaddr + size < uaddr) { 6587c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR); 6597c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = uaddr; 6607c478bd9Sstevel@tonic-gate return (0); 6617c478bd9Sstevel@tonic-gate } 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate return (1); 6647c478bd9Sstevel@tonic-gate } 6657c478bd9Sstevel@tonic-gate 66628406508Ssudheer /*ARGSUSED*/ 6677c478bd9Sstevel@tonic-gate void 66828406508Ssudheer dtrace_copyin(uintptr_t uaddr, uintptr_t kaddr, size_t size, 66928406508Ssudheer volatile uint16_t *flags) 6707c478bd9Sstevel@tonic-gate { 6717c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size)) 6727c478bd9Sstevel@tonic-gate dtrace_copy(uaddr, kaddr, size); 6737c478bd9Sstevel@tonic-gate } 6747c478bd9Sstevel@tonic-gate 67528406508Ssudheer /*ARGSUSED*/ 6767c478bd9Sstevel@tonic-gate void 67728406508Ssudheer dtrace_copyout(uintptr_t kaddr, uintptr_t uaddr, size_t size, 67828406508Ssudheer volatile uint16_t *flags) 6797c478bd9Sstevel@tonic-gate { 6807c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size)) 6817c478bd9Sstevel@tonic-gate dtrace_copy(kaddr, uaddr, size); 6827c478bd9Sstevel@tonic-gate } 6837c478bd9Sstevel@tonic-gate 6847c478bd9Sstevel@tonic-gate void 68528406508Ssudheer dtrace_copyinstr(uintptr_t uaddr, uintptr_t kaddr, size_t size, 68628406508Ssudheer volatile uint16_t *flags) 6877c478bd9Sstevel@tonic-gate { 6887c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size)) 68928406508Ssudheer dtrace_copystr(uaddr, kaddr, size, flags); 6907c478bd9Sstevel@tonic-gate } 6917c478bd9Sstevel@tonic-gate 6927c478bd9Sstevel@tonic-gate void 69328406508Ssudheer dtrace_copyoutstr(uintptr_t kaddr, uintptr_t uaddr, size_t size, 69428406508Ssudheer volatile uint16_t *flags) 6957c478bd9Sstevel@tonic-gate { 6967c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size)) 69728406508Ssudheer dtrace_copystr(kaddr, uaddr, size, flags); 6987c478bd9Sstevel@tonic-gate } 6997c478bd9Sstevel@tonic-gate 7007c478bd9Sstevel@tonic-gate uint8_t 7017c478bd9Sstevel@tonic-gate dtrace_fuword8(void *uaddr) 7027c478bd9Sstevel@tonic-gate { 7037c478bd9Sstevel@tonic-gate extern uint8_t dtrace_fuword8_nocheck(void *); 7047c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) { 7057c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR); 7067c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr; 7077c478bd9Sstevel@tonic-gate return (0); 7087c478bd9Sstevel@tonic-gate } 7097c478bd9Sstevel@tonic-gate return (dtrace_fuword8_nocheck(uaddr)); 7107c478bd9Sstevel@tonic-gate } 7117c478bd9Sstevel@tonic-gate 7127c478bd9Sstevel@tonic-gate uint16_t 7137c478bd9Sstevel@tonic-gate dtrace_fuword16(void *uaddr) 7147c478bd9Sstevel@tonic-gate { 7157c478bd9Sstevel@tonic-gate extern uint16_t dtrace_fuword16_nocheck(void *); 7167c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) { 7177c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR); 7187c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr; 7197c478bd9Sstevel@tonic-gate return (0); 7207c478bd9Sstevel@tonic-gate } 7217c478bd9Sstevel@tonic-gate return (dtrace_fuword16_nocheck(uaddr)); 7227c478bd9Sstevel@tonic-gate } 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate uint32_t 7257c478bd9Sstevel@tonic-gate dtrace_fuword32(void *uaddr) 7267c478bd9Sstevel@tonic-gate { 7277c478bd9Sstevel@tonic-gate extern uint32_t dtrace_fuword32_nocheck(void *); 7287c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) { 7297c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR); 7307c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr; 7317c478bd9Sstevel@tonic-gate return (0); 7327c478bd9Sstevel@tonic-gate } 7337c478bd9Sstevel@tonic-gate return (dtrace_fuword32_nocheck(uaddr)); 7347c478bd9Sstevel@tonic-gate } 7357c478bd9Sstevel@tonic-gate 7367c478bd9Sstevel@tonic-gate uint64_t 7377c478bd9Sstevel@tonic-gate dtrace_fuword64(void *uaddr) 7387c478bd9Sstevel@tonic-gate { 7397c478bd9Sstevel@tonic-gate extern uint64_t dtrace_fuword64_nocheck(void *); 7407c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) { 7417c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR); 7427c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr; 7437c478bd9Sstevel@tonic-gate return (0); 7447c478bd9Sstevel@tonic-gate } 7457c478bd9Sstevel@tonic-gate return (dtrace_fuword64_nocheck(uaddr)); 7467c478bd9Sstevel@tonic-gate } 747