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 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 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 /* 377c478bd9Sstevel@tonic-gate * This is gross knowledge to have to encode here... 387c478bd9Sstevel@tonic-gate */ 397c478bd9Sstevel@tonic-gate extern void _interrupt(); 407c478bd9Sstevel@tonic-gate extern void _cmntrap(); 417c478bd9Sstevel@tonic-gate extern void _allsyscalls(); 427c478bd9Sstevel@tonic-gate 437c478bd9Sstevel@tonic-gate extern size_t _interrupt_size; 447c478bd9Sstevel@tonic-gate extern size_t _cmntrap_size; 457c478bd9Sstevel@tonic-gate extern size_t _allsyscalls_size; 467c478bd9Sstevel@tonic-gate 477c478bd9Sstevel@tonic-gate extern uintptr_t kernelbase; 487c478bd9Sstevel@tonic-gate 497c478bd9Sstevel@tonic-gate void 507c478bd9Sstevel@tonic-gate dtrace_getpcstack(pc_t *pcstack, int pcstack_limit, int aframes, 517c478bd9Sstevel@tonic-gate uint32_t *intrpc) 527c478bd9Sstevel@tonic-gate { 537c478bd9Sstevel@tonic-gate struct frame *fp = (struct frame *)dtrace_getfp(); 547c478bd9Sstevel@tonic-gate struct frame *nextfp, *minfp, *stacktop; 557c478bd9Sstevel@tonic-gate int depth = 0; 567c478bd9Sstevel@tonic-gate int on_intr, last = 0; 577c478bd9Sstevel@tonic-gate uintptr_t pc; 587c478bd9Sstevel@tonic-gate uintptr_t caller = CPU->cpu_dtrace_caller; 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate if ((on_intr = CPU_ON_INTR(CPU)) != 0) 617c478bd9Sstevel@tonic-gate stacktop = (struct frame *)(CPU->cpu_intr_stack + SA(MINFRAME)); 627c478bd9Sstevel@tonic-gate else 637c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 647c478bd9Sstevel@tonic-gate minfp = fp; 657c478bd9Sstevel@tonic-gate 667c478bd9Sstevel@tonic-gate aframes++; 677c478bd9Sstevel@tonic-gate 687c478bd9Sstevel@tonic-gate if (intrpc != NULL && depth < pcstack_limit) 697c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)intrpc; 707c478bd9Sstevel@tonic-gate 717c478bd9Sstevel@tonic-gate while (depth < pcstack_limit) { 727c478bd9Sstevel@tonic-gate nextfp = (struct frame *)fp->fr_savfp; 737c478bd9Sstevel@tonic-gate pc = fp->fr_savpc; 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate if (nextfp <= minfp || nextfp >= stacktop) { 767c478bd9Sstevel@tonic-gate if (on_intr) { 777c478bd9Sstevel@tonic-gate /* 787c478bd9Sstevel@tonic-gate * Hop from interrupt stack to thread stack. 797c478bd9Sstevel@tonic-gate */ 807c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 817c478bd9Sstevel@tonic-gate minfp = (struct frame *)curthread->t_stkbase; 827c478bd9Sstevel@tonic-gate on_intr = 0; 837c478bd9Sstevel@tonic-gate continue; 847c478bd9Sstevel@tonic-gate } 857c478bd9Sstevel@tonic-gate 867c478bd9Sstevel@tonic-gate /* 877c478bd9Sstevel@tonic-gate * This is the last frame we can process; indicate 887c478bd9Sstevel@tonic-gate * that we should return after processing this frame. 897c478bd9Sstevel@tonic-gate */ 907c478bd9Sstevel@tonic-gate last = 1; 917c478bd9Sstevel@tonic-gate } 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate if (aframes > 0) { 947c478bd9Sstevel@tonic-gate if (--aframes == 0 && caller != NULL) { 957c478bd9Sstevel@tonic-gate /* 967c478bd9Sstevel@tonic-gate * We've just run out of artificial frames, 977c478bd9Sstevel@tonic-gate * and we have a valid caller -- fill it in 987c478bd9Sstevel@tonic-gate * now. 997c478bd9Sstevel@tonic-gate */ 1007c478bd9Sstevel@tonic-gate ASSERT(depth < pcstack_limit); 1017c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)caller; 1027c478bd9Sstevel@tonic-gate caller = NULL; 1037c478bd9Sstevel@tonic-gate } 1047c478bd9Sstevel@tonic-gate } else { 1057c478bd9Sstevel@tonic-gate if (depth < pcstack_limit) 1067c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)pc; 1077c478bd9Sstevel@tonic-gate } 1087c478bd9Sstevel@tonic-gate 1097c478bd9Sstevel@tonic-gate if (last) { 1107c478bd9Sstevel@tonic-gate while (depth < pcstack_limit) 1117c478bd9Sstevel@tonic-gate pcstack[depth++] = NULL; 1127c478bd9Sstevel@tonic-gate return; 1137c478bd9Sstevel@tonic-gate } 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate fp = nextfp; 1167c478bd9Sstevel@tonic-gate minfp = fp; 1177c478bd9Sstevel@tonic-gate } 1187c478bd9Sstevel@tonic-gate } 1197c478bd9Sstevel@tonic-gate 1200b38a8bdSahl static int 1210b38a8bdSahl dtrace_getustack_common(uint64_t *pcstack, int pcstack_limit, uintptr_t pc, 1220b38a8bdSahl uintptr_t sp) 1237c478bd9Sstevel@tonic-gate { 1247c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread); 1250b38a8bdSahl proc_t *p = curproc; 1260b38a8bdSahl uintptr_t oldcontext = lwp->lwp_oldcontext; 1270b38a8bdSahl volatile uint16_t *flags = 1280b38a8bdSahl (volatile uint16_t *)&cpu_core[CPU->cpu_id].cpuc_dtrace_flags; 1297c478bd9Sstevel@tonic-gate size_t s1, s2; 1300b38a8bdSahl int ret = 0; 1317c478bd9Sstevel@tonic-gate 1320b38a8bdSahl ASSERT(pcstack == NULL || pcstack_limit > 0); 1337c478bd9Sstevel@tonic-gate 1347c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 1357c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame) + 2 * sizeof (long); 1367c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo_t); 1377c478bd9Sstevel@tonic-gate } else { 1387c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame32) + 3 * sizeof (int); 1397c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo32_t); 1407c478bd9Sstevel@tonic-gate } 1417c478bd9Sstevel@tonic-gate 1427c478bd9Sstevel@tonic-gate while (pc != 0 && sp != 0) { 1430b38a8bdSahl ret++; 1440b38a8bdSahl if (pcstack != NULL) { 1457c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)pc; 1467c478bd9Sstevel@tonic-gate pcstack_limit--; 1477c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 1487c478bd9Sstevel@tonic-gate break; 1490b38a8bdSahl } 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate if (oldcontext == sp + s1 || oldcontext == sp + s2) { 1527c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 1537c478bd9Sstevel@tonic-gate ucontext_t *ucp = (ucontext_t *)oldcontext; 1547c478bd9Sstevel@tonic-gate greg_t *gregs = ucp->uc_mcontext.gregs; 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&gregs[REG_FP]); 1577c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&gregs[REG_PC]); 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate oldcontext = dtrace_fulword(&ucp->uc_link); 1607c478bd9Sstevel@tonic-gate } else { 1617c478bd9Sstevel@tonic-gate ucontext32_t *ucp = (ucontext32_t *)oldcontext; 1627c478bd9Sstevel@tonic-gate greg32_t *gregs = ucp->uc_mcontext.gregs; 1637c478bd9Sstevel@tonic-gate 1647c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&gregs[EBP]); 1657c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&gregs[EIP]); 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate oldcontext = dtrace_fuword32(&ucp->uc_link); 1687c478bd9Sstevel@tonic-gate } 1697c478bd9Sstevel@tonic-gate } else { 1707c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 1717c478bd9Sstevel@tonic-gate struct frame *fr = (struct frame *)sp; 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&fr->fr_savpc); 1747c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&fr->fr_savfp); 1757c478bd9Sstevel@tonic-gate } else { 1767c478bd9Sstevel@tonic-gate struct frame32 *fr = (struct frame32 *)sp; 1777c478bd9Sstevel@tonic-gate 1787c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&fr->fr_savpc); 1797c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&fr->fr_savfp); 1807c478bd9Sstevel@tonic-gate } 1817c478bd9Sstevel@tonic-gate } 1827c478bd9Sstevel@tonic-gate 1837c478bd9Sstevel@tonic-gate /* 1847c478bd9Sstevel@tonic-gate * This is totally bogus: if we faulted, we're going to clear 1857c478bd9Sstevel@tonic-gate * the fault and break. This is to deal with the apparently 1867c478bd9Sstevel@tonic-gate * broken Java stacks on x86. 1877c478bd9Sstevel@tonic-gate */ 1887c478bd9Sstevel@tonic-gate if (*flags & CPU_DTRACE_FAULT) { 1897c478bd9Sstevel@tonic-gate *flags &= ~CPU_DTRACE_FAULT; 1907c478bd9Sstevel@tonic-gate break; 1917c478bd9Sstevel@tonic-gate } 1927c478bd9Sstevel@tonic-gate } 1937c478bd9Sstevel@tonic-gate 1940b38a8bdSahl return (ret); 1950b38a8bdSahl } 1960b38a8bdSahl 1970b38a8bdSahl void 1980b38a8bdSahl dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit) 1990b38a8bdSahl { 2000b38a8bdSahl klwp_t *lwp = ttolwp(curthread); 2010b38a8bdSahl proc_t *p = curproc; 2020b38a8bdSahl struct regs *rp; 2030b38a8bdSahl uintptr_t pc, sp; 2040b38a8bdSahl volatile uint16_t *flags = 2050b38a8bdSahl (volatile uint16_t *)&cpu_core[CPU->cpu_id].cpuc_dtrace_flags; 2060b38a8bdSahl int n; 2070b38a8bdSahl 2080b38a8bdSahl if (*flags & CPU_DTRACE_FAULT) 2090b38a8bdSahl return; 2100b38a8bdSahl 2110b38a8bdSahl if (pcstack_limit <= 0) 2120b38a8bdSahl return; 2130b38a8bdSahl 214*35b7f6ccSahl /* 215*35b7f6ccSahl * If there's no user context we still need to zero the stack. 216*35b7f6ccSahl */ 217*35b7f6ccSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL) 218*35b7f6ccSahl goto zero; 219*35b7f6ccSahl 2200b38a8bdSahl *pcstack++ = (uint64_t)p->p_pid; 2210b38a8bdSahl pcstack_limit--; 2220b38a8bdSahl 2230b38a8bdSahl if (pcstack_limit <= 0) 2240b38a8bdSahl return; 2250b38a8bdSahl 2260b38a8bdSahl pc = rp->r_pc; 2270b38a8bdSahl sp = rp->r_fp; 2280b38a8bdSahl 2290b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) { 2300b38a8bdSahl *pcstack++ = (uint64_t)pc; 2310b38a8bdSahl pcstack_limit--; 2320b38a8bdSahl if (pcstack_limit <= 0) 2330b38a8bdSahl return; 2340b38a8bdSahl 2350b38a8bdSahl if (p->p_model == DATAMODEL_NATIVE) 2360b38a8bdSahl pc = dtrace_fulword((void *)rp->r_sp); 2370b38a8bdSahl else 2380b38a8bdSahl pc = dtrace_fuword32((void *)rp->r_sp); 2390b38a8bdSahl } 2400b38a8bdSahl 2410b38a8bdSahl n = dtrace_getustack_common(pcstack, pcstack_limit, pc, sp); 2420b38a8bdSahl ASSERT(n >= 0); 2430b38a8bdSahl ASSERT(n <= pcstack_limit); 2440b38a8bdSahl 2450b38a8bdSahl pcstack += n; 2460b38a8bdSahl pcstack_limit -= n; 2470b38a8bdSahl 248*35b7f6ccSahl zero: 2497c478bd9Sstevel@tonic-gate while (pcstack_limit-- > 0) 2507c478bd9Sstevel@tonic-gate *pcstack++ = NULL; 2517c478bd9Sstevel@tonic-gate } 2527c478bd9Sstevel@tonic-gate 2530b38a8bdSahl int 2540b38a8bdSahl dtrace_getustackdepth(void) 2550b38a8bdSahl { 2560b38a8bdSahl klwp_t *lwp = ttolwp(curthread); 2570b38a8bdSahl proc_t *p = curproc; 2580b38a8bdSahl struct regs *rp; 2590b38a8bdSahl uintptr_t pc, sp; 2600b38a8bdSahl int n = 0; 2610b38a8bdSahl 2620b38a8bdSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL) 2630b38a8bdSahl return (0); 2640b38a8bdSahl 2650b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAULT)) 2660b38a8bdSahl return (-1); 2670b38a8bdSahl 2680b38a8bdSahl pc = rp->r_pc; 2690b38a8bdSahl sp = rp->r_fp; 2700b38a8bdSahl 2710b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) { 2720b38a8bdSahl n++; 2730b38a8bdSahl 2740b38a8bdSahl if (p->p_model == DATAMODEL_NATIVE) 2750b38a8bdSahl pc = dtrace_fulword((void *)rp->r_sp); 2760b38a8bdSahl else 2770b38a8bdSahl pc = dtrace_fuword32((void *)rp->r_sp); 2780b38a8bdSahl } 2790b38a8bdSahl 2800b38a8bdSahl n += dtrace_getustack_common(NULL, 0, pc, sp); 2810b38a8bdSahl 2820b38a8bdSahl return (n); 2830b38a8bdSahl } 2840b38a8bdSahl 2857c478bd9Sstevel@tonic-gate void 2867c478bd9Sstevel@tonic-gate dtrace_getufpstack(uint64_t *pcstack, uint64_t *fpstack, int pcstack_limit) 2877c478bd9Sstevel@tonic-gate { 2887c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread); 2890b38a8bdSahl proc_t *p = curproc; 2907c478bd9Sstevel@tonic-gate struct regs *rp; 2917c478bd9Sstevel@tonic-gate uintptr_t pc, sp, oldcontext; 2920b38a8bdSahl volatile uint16_t *flags = 2930b38a8bdSahl (volatile uint16_t *)&cpu_core[CPU->cpu_id].cpuc_dtrace_flags; 2947c478bd9Sstevel@tonic-gate size_t s1, s2; 2957c478bd9Sstevel@tonic-gate 2967c478bd9Sstevel@tonic-gate if (*flags & CPU_DTRACE_FAULT) 2977c478bd9Sstevel@tonic-gate return; 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 3007c478bd9Sstevel@tonic-gate return; 3017c478bd9Sstevel@tonic-gate 302*35b7f6ccSahl /* 303*35b7f6ccSahl * If there's no user context we still need to zero the stack. 304*35b7f6ccSahl */ 305*35b7f6ccSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL) 306*35b7f6ccSahl goto zero; 307*35b7f6ccSahl 3087c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)p->p_pid; 3097c478bd9Sstevel@tonic-gate pcstack_limit--; 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 3127c478bd9Sstevel@tonic-gate return; 3137c478bd9Sstevel@tonic-gate 3147c478bd9Sstevel@tonic-gate pc = rp->r_pc; 3157c478bd9Sstevel@tonic-gate sp = rp->r_fp; 3167c478bd9Sstevel@tonic-gate oldcontext = lwp->lwp_oldcontext; 3177c478bd9Sstevel@tonic-gate 3187c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 3197c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame) + 2 * sizeof (long); 3207c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo_t); 3217c478bd9Sstevel@tonic-gate } else { 3227c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame32) + 3 * sizeof (int); 3237c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo32_t); 3247c478bd9Sstevel@tonic-gate } 3257c478bd9Sstevel@tonic-gate 3267c478bd9Sstevel@tonic-gate if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) { 3277c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)pc; 3287c478bd9Sstevel@tonic-gate *fpstack++ = 0; 3297c478bd9Sstevel@tonic-gate pcstack_limit--; 3307c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 3317c478bd9Sstevel@tonic-gate return; 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) 3347c478bd9Sstevel@tonic-gate pc = dtrace_fulword((void *)rp->r_sp); 3357c478bd9Sstevel@tonic-gate else 3367c478bd9Sstevel@tonic-gate pc = dtrace_fuword32((void *)rp->r_sp); 3377c478bd9Sstevel@tonic-gate } 3387c478bd9Sstevel@tonic-gate 3397c478bd9Sstevel@tonic-gate while (pc != 0 && sp != 0) { 3407c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)pc; 3417c478bd9Sstevel@tonic-gate *fpstack++ = sp; 3427c478bd9Sstevel@tonic-gate pcstack_limit--; 3437c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 3447c478bd9Sstevel@tonic-gate break; 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate if (oldcontext == sp + s1 || oldcontext == sp + s2) { 3477c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 3487c478bd9Sstevel@tonic-gate ucontext_t *ucp = (ucontext_t *)oldcontext; 3497c478bd9Sstevel@tonic-gate greg_t *gregs = ucp->uc_mcontext.gregs; 3507c478bd9Sstevel@tonic-gate 3517c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&gregs[REG_FP]); 3527c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&gregs[REG_PC]); 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate oldcontext = dtrace_fulword(&ucp->uc_link); 3557c478bd9Sstevel@tonic-gate } else { 3567c478bd9Sstevel@tonic-gate ucontext_t *ucp = (ucontext_t *)oldcontext; 3577c478bd9Sstevel@tonic-gate greg_t *gregs = ucp->uc_mcontext.gregs; 3587c478bd9Sstevel@tonic-gate 3597c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&gregs[EBP]); 3607c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&gregs[EIP]); 3617c478bd9Sstevel@tonic-gate 3627c478bd9Sstevel@tonic-gate oldcontext = dtrace_fuword32(&ucp->uc_link); 3637c478bd9Sstevel@tonic-gate } 3647c478bd9Sstevel@tonic-gate } else { 3657c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 3667c478bd9Sstevel@tonic-gate struct frame *fr = (struct frame *)sp; 3677c478bd9Sstevel@tonic-gate 3687c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&fr->fr_savpc); 3697c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&fr->fr_savfp); 3707c478bd9Sstevel@tonic-gate } else { 3717c478bd9Sstevel@tonic-gate struct frame32 *fr = (struct frame32 *)sp; 3727c478bd9Sstevel@tonic-gate 3737c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&fr->fr_savpc); 3747c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&fr->fr_savfp); 3757c478bd9Sstevel@tonic-gate } 3767c478bd9Sstevel@tonic-gate } 3777c478bd9Sstevel@tonic-gate 3787c478bd9Sstevel@tonic-gate /* 3797c478bd9Sstevel@tonic-gate * This is totally bogus: if we faulted, we're going to clear 3807c478bd9Sstevel@tonic-gate * the fault and break. This is to deal with the apparently 3817c478bd9Sstevel@tonic-gate * broken Java stacks on x86. 3827c478bd9Sstevel@tonic-gate */ 3837c478bd9Sstevel@tonic-gate if (*flags & CPU_DTRACE_FAULT) { 3847c478bd9Sstevel@tonic-gate *flags &= ~CPU_DTRACE_FAULT; 3857c478bd9Sstevel@tonic-gate break; 3867c478bd9Sstevel@tonic-gate } 3877c478bd9Sstevel@tonic-gate } 3887c478bd9Sstevel@tonic-gate 389*35b7f6ccSahl zero: 3907c478bd9Sstevel@tonic-gate while (pcstack_limit-- > 0) 3917c478bd9Sstevel@tonic-gate *pcstack++ = NULL; 3927c478bd9Sstevel@tonic-gate } 3937c478bd9Sstevel@tonic-gate 3947c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 3957c478bd9Sstevel@tonic-gate uint64_t 3967c478bd9Sstevel@tonic-gate dtrace_getarg(int arg, int aframes) 3977c478bd9Sstevel@tonic-gate { 3987c478bd9Sstevel@tonic-gate uintptr_t val; 3997c478bd9Sstevel@tonic-gate struct frame *fp = (struct frame *)dtrace_getfp(); 4007c478bd9Sstevel@tonic-gate uintptr_t *stack; 4017c478bd9Sstevel@tonic-gate int i; 4027c478bd9Sstevel@tonic-gate #if defined(__amd64) 4037c478bd9Sstevel@tonic-gate /* 4047c478bd9Sstevel@tonic-gate * A total of 6 arguments are passed via registers; any argument with 4057c478bd9Sstevel@tonic-gate * index of 5 or lower is therefore in a register. 4067c478bd9Sstevel@tonic-gate */ 4077c478bd9Sstevel@tonic-gate int inreg = 5; 4087c478bd9Sstevel@tonic-gate #endif 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate for (i = 1; i <= aframes; i++) { 4117c478bd9Sstevel@tonic-gate fp = (struct frame *)(fp->fr_savfp); 4127c478bd9Sstevel@tonic-gate 4137c478bd9Sstevel@tonic-gate if (fp->fr_savpc == (pc_t)dtrace_invop_callsite) { 4147c478bd9Sstevel@tonic-gate #if !defined(__amd64) 4157c478bd9Sstevel@tonic-gate /* 4167c478bd9Sstevel@tonic-gate * If we pass through the invalid op handler, we will 4177c478bd9Sstevel@tonic-gate * use the pointer that it passed to the stack as the 4187c478bd9Sstevel@tonic-gate * second argument to dtrace_invop() as the pointer to 4197c478bd9Sstevel@tonic-gate * the stack. When using this stack, we must step 4207c478bd9Sstevel@tonic-gate * beyond the EIP/RIP that was pushed when the trap was 4217c478bd9Sstevel@tonic-gate * taken -- hence the "+ 1" below. 4227c478bd9Sstevel@tonic-gate */ 4237c478bd9Sstevel@tonic-gate stack = ((uintptr_t **)&fp[1])[1] + 1; 4247c478bd9Sstevel@tonic-gate #else 4257c478bd9Sstevel@tonic-gate /* 4267c478bd9Sstevel@tonic-gate * In the case of amd64, we will use the pointer to the 4277c478bd9Sstevel@tonic-gate * regs structure that was pushed when we took the 4287c478bd9Sstevel@tonic-gate * trap. To get this structure, we must increment 4297c478bd9Sstevel@tonic-gate * beyond the frame structure, and then again beyond 4307c478bd9Sstevel@tonic-gate * the calling RIP stored in dtrace_invop(). If the 4317c478bd9Sstevel@tonic-gate * argument that we're seeking is passed on the stack, 4327c478bd9Sstevel@tonic-gate * we'll pull the true stack pointer out of the saved 4337c478bd9Sstevel@tonic-gate * registers and decrement our argument by the number 4347c478bd9Sstevel@tonic-gate * of arguments passed in registers; if the argument 4357c478bd9Sstevel@tonic-gate * we're seeking is passed in regsiters, we can just 4367c478bd9Sstevel@tonic-gate * load it directly. 4377c478bd9Sstevel@tonic-gate */ 4387c478bd9Sstevel@tonic-gate struct regs *rp = (struct regs *)((uintptr_t)&fp[1] + 4397c478bd9Sstevel@tonic-gate sizeof (uintptr_t)); 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate if (arg <= inreg) { 4427c478bd9Sstevel@tonic-gate stack = (uintptr_t *)&rp->r_rdi; 4437c478bd9Sstevel@tonic-gate } else { 4447c478bd9Sstevel@tonic-gate stack = (uintptr_t *)(rp->r_rsp); 4457c478bd9Sstevel@tonic-gate arg -= inreg; 4467c478bd9Sstevel@tonic-gate } 4477c478bd9Sstevel@tonic-gate #endif 4487c478bd9Sstevel@tonic-gate goto load; 4497c478bd9Sstevel@tonic-gate } 4507c478bd9Sstevel@tonic-gate 4517c478bd9Sstevel@tonic-gate } 4527c478bd9Sstevel@tonic-gate 4537c478bd9Sstevel@tonic-gate /* 4547c478bd9Sstevel@tonic-gate * We know that we did not come through a trap to get into 4557c478bd9Sstevel@tonic-gate * dtrace_probe() -- the provider simply called dtrace_probe() 4567c478bd9Sstevel@tonic-gate * directly. As this is the case, we need to shift the argument 4577c478bd9Sstevel@tonic-gate * that we're looking for: the probe ID is the first argument to 4587c478bd9Sstevel@tonic-gate * dtrace_probe(), so the argument n will actually be found where 4597c478bd9Sstevel@tonic-gate * one would expect to find argument (n + 1). 4607c478bd9Sstevel@tonic-gate */ 4617c478bd9Sstevel@tonic-gate arg++; 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate #if defined(__amd64) 4647c478bd9Sstevel@tonic-gate if (arg <= inreg) { 4657c478bd9Sstevel@tonic-gate /* 4667c478bd9Sstevel@tonic-gate * This shouldn't happen. If the argument is passed in a 4677c478bd9Sstevel@tonic-gate * register then it should have been, well, passed in a 4687c478bd9Sstevel@tonic-gate * register... 4697c478bd9Sstevel@tonic-gate */ 4707c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP); 4717c478bd9Sstevel@tonic-gate return (0); 4727c478bd9Sstevel@tonic-gate } 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate arg -= (inreg + 1); 4757c478bd9Sstevel@tonic-gate #endif 4767c478bd9Sstevel@tonic-gate stack = (uintptr_t *)&fp[1]; 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate load: 4797c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 4807c478bd9Sstevel@tonic-gate val = stack[arg]; 4817c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate return (val); 4847c478bd9Sstevel@tonic-gate } 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4877c478bd9Sstevel@tonic-gate int 4887c478bd9Sstevel@tonic-gate dtrace_getstackdepth(int aframes) 4897c478bd9Sstevel@tonic-gate { 4907c478bd9Sstevel@tonic-gate struct frame *fp = (struct frame *)dtrace_getfp(); 4917c478bd9Sstevel@tonic-gate struct frame *nextfp, *minfp, *stacktop; 4927c478bd9Sstevel@tonic-gate int depth = 0; 4937c478bd9Sstevel@tonic-gate int on_intr; 4947c478bd9Sstevel@tonic-gate 4957c478bd9Sstevel@tonic-gate if ((on_intr = CPU_ON_INTR(CPU)) != 0) 4967c478bd9Sstevel@tonic-gate stacktop = (struct frame *)(CPU->cpu_intr_stack + SA(MINFRAME)); 4977c478bd9Sstevel@tonic-gate else 4987c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 4997c478bd9Sstevel@tonic-gate minfp = fp; 5007c478bd9Sstevel@tonic-gate 5017c478bd9Sstevel@tonic-gate aframes++; 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate for (;;) { 5047c478bd9Sstevel@tonic-gate depth++; 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate nextfp = (struct frame *)fp->fr_savfp; 5077c478bd9Sstevel@tonic-gate 5087c478bd9Sstevel@tonic-gate if (nextfp <= minfp || nextfp >= stacktop) { 5097c478bd9Sstevel@tonic-gate if (on_intr) { 5107c478bd9Sstevel@tonic-gate /* 5117c478bd9Sstevel@tonic-gate * Hop from interrupt stack to thread stack. 5127c478bd9Sstevel@tonic-gate */ 5137c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 5147c478bd9Sstevel@tonic-gate minfp = (struct frame *)curthread->t_stkbase; 5157c478bd9Sstevel@tonic-gate on_intr = 0; 5167c478bd9Sstevel@tonic-gate continue; 5177c478bd9Sstevel@tonic-gate } 5187c478bd9Sstevel@tonic-gate break; 5197c478bd9Sstevel@tonic-gate } 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate fp = nextfp; 5227c478bd9Sstevel@tonic-gate minfp = fp; 5237c478bd9Sstevel@tonic-gate } 5247c478bd9Sstevel@tonic-gate 5257c478bd9Sstevel@tonic-gate if (depth <= aframes) 5267c478bd9Sstevel@tonic-gate return (0); 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate return (depth - aframes); 5297c478bd9Sstevel@tonic-gate } 5307c478bd9Sstevel@tonic-gate 5317c478bd9Sstevel@tonic-gate ulong_t 5327c478bd9Sstevel@tonic-gate dtrace_getreg(struct regs *rp, uint_t reg) 5337c478bd9Sstevel@tonic-gate { 5347c478bd9Sstevel@tonic-gate #if defined(__amd64) 5357c478bd9Sstevel@tonic-gate int regmap[] = { 5367c478bd9Sstevel@tonic-gate REG_GS, /* GS */ 5377c478bd9Sstevel@tonic-gate REG_FS, /* FS */ 5387c478bd9Sstevel@tonic-gate REG_ES, /* ES */ 5397c478bd9Sstevel@tonic-gate REG_DS, /* DS */ 5407c478bd9Sstevel@tonic-gate REG_RDI, /* EDI */ 5417c478bd9Sstevel@tonic-gate REG_RSI, /* ESI */ 5427c478bd9Sstevel@tonic-gate REG_RBP, /* EBP */ 5437c478bd9Sstevel@tonic-gate REG_RSP, /* ESP */ 5447c478bd9Sstevel@tonic-gate REG_RBX, /* EBX */ 5457c478bd9Sstevel@tonic-gate REG_RDX, /* EDX */ 5467c478bd9Sstevel@tonic-gate REG_RCX, /* ECX */ 5477c478bd9Sstevel@tonic-gate REG_RAX, /* EAX */ 5487c478bd9Sstevel@tonic-gate REG_TRAPNO, /* TRAPNO */ 5497c478bd9Sstevel@tonic-gate REG_ERR, /* ERR */ 5507c478bd9Sstevel@tonic-gate REG_RIP, /* EIP */ 5517c478bd9Sstevel@tonic-gate REG_CS, /* CS */ 5527c478bd9Sstevel@tonic-gate REG_RFL, /* EFL */ 5537c478bd9Sstevel@tonic-gate REG_RSP, /* UESP */ 5547c478bd9Sstevel@tonic-gate REG_SS /* SS */ 5557c478bd9Sstevel@tonic-gate }; 5567c478bd9Sstevel@tonic-gate 5577c478bd9Sstevel@tonic-gate if (reg <= SS) { 5587c478bd9Sstevel@tonic-gate if (reg >= sizeof (regmap) / sizeof (int)) { 5597c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP); 5607c478bd9Sstevel@tonic-gate return (0); 5617c478bd9Sstevel@tonic-gate } 5627c478bd9Sstevel@tonic-gate 5637c478bd9Sstevel@tonic-gate reg = regmap[reg]; 5647c478bd9Sstevel@tonic-gate } else { 5657c478bd9Sstevel@tonic-gate reg -= SS + 1; 5667c478bd9Sstevel@tonic-gate } 5677c478bd9Sstevel@tonic-gate 5687c478bd9Sstevel@tonic-gate switch (reg) { 5697c478bd9Sstevel@tonic-gate case REG_RDI: 5707c478bd9Sstevel@tonic-gate return (rp->r_rdi); 5717c478bd9Sstevel@tonic-gate case REG_RSI: 5727c478bd9Sstevel@tonic-gate return (rp->r_rsi); 5737c478bd9Sstevel@tonic-gate case REG_RDX: 5747c478bd9Sstevel@tonic-gate return (rp->r_rdx); 5757c478bd9Sstevel@tonic-gate case REG_RCX: 5767c478bd9Sstevel@tonic-gate return (rp->r_rcx); 5777c478bd9Sstevel@tonic-gate case REG_R8: 5787c478bd9Sstevel@tonic-gate return (rp->r_r8); 5797c478bd9Sstevel@tonic-gate case REG_R9: 5807c478bd9Sstevel@tonic-gate return (rp->r_r9); 5817c478bd9Sstevel@tonic-gate case REG_RAX: 5827c478bd9Sstevel@tonic-gate return (rp->r_rax); 5837c478bd9Sstevel@tonic-gate case REG_RBX: 5847c478bd9Sstevel@tonic-gate return (rp->r_rbx); 5857c478bd9Sstevel@tonic-gate case REG_RBP: 5867c478bd9Sstevel@tonic-gate return (rp->r_rbp); 5877c478bd9Sstevel@tonic-gate case REG_R10: 5887c478bd9Sstevel@tonic-gate return (rp->r_r10); 5897c478bd9Sstevel@tonic-gate case REG_R11: 5907c478bd9Sstevel@tonic-gate return (rp->r_r11); 5917c478bd9Sstevel@tonic-gate case REG_R12: 5927c478bd9Sstevel@tonic-gate return (rp->r_r12); 5937c478bd9Sstevel@tonic-gate case REG_R13: 5947c478bd9Sstevel@tonic-gate return (rp->r_r13); 5957c478bd9Sstevel@tonic-gate case REG_R14: 5967c478bd9Sstevel@tonic-gate return (rp->r_r14); 5977c478bd9Sstevel@tonic-gate case REG_R15: 5987c478bd9Sstevel@tonic-gate return (rp->r_r15); 5997c478bd9Sstevel@tonic-gate case REG_DS: 6007c478bd9Sstevel@tonic-gate return (rp->r_ds); 6017c478bd9Sstevel@tonic-gate case REG_ES: 6027c478bd9Sstevel@tonic-gate return (rp->r_es); 6037c478bd9Sstevel@tonic-gate case REG_FS: 6047c478bd9Sstevel@tonic-gate return (rp->r_fs); 6057c478bd9Sstevel@tonic-gate case REG_GS: 6067c478bd9Sstevel@tonic-gate return (rp->r_gs); 6077c478bd9Sstevel@tonic-gate case REG_TRAPNO: 6087c478bd9Sstevel@tonic-gate return (rp->r_trapno); 6097c478bd9Sstevel@tonic-gate case REG_ERR: 6107c478bd9Sstevel@tonic-gate return (rp->r_err); 6117c478bd9Sstevel@tonic-gate case REG_RIP: 6127c478bd9Sstevel@tonic-gate return (rp->r_rip); 6137c478bd9Sstevel@tonic-gate case REG_CS: 6147c478bd9Sstevel@tonic-gate return (rp->r_cs); 6157c478bd9Sstevel@tonic-gate case REG_SS: 6167c478bd9Sstevel@tonic-gate return (rp->r_ss); 6177c478bd9Sstevel@tonic-gate case REG_RFL: 6187c478bd9Sstevel@tonic-gate return (rp->r_rfl); 6197c478bd9Sstevel@tonic-gate case REG_RSP: 6207c478bd9Sstevel@tonic-gate return (rp->r_rsp); 6217c478bd9Sstevel@tonic-gate default: 6227c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP); 6237c478bd9Sstevel@tonic-gate return (0); 6247c478bd9Sstevel@tonic-gate } 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate #else 6277c478bd9Sstevel@tonic-gate if (reg > SS) { 6287c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP); 6297c478bd9Sstevel@tonic-gate return (0); 6307c478bd9Sstevel@tonic-gate } 6317c478bd9Sstevel@tonic-gate 6327c478bd9Sstevel@tonic-gate return ((&rp->r_gs)[reg]); 6337c478bd9Sstevel@tonic-gate #endif 6347c478bd9Sstevel@tonic-gate } 6357c478bd9Sstevel@tonic-gate 6367c478bd9Sstevel@tonic-gate static int 6377c478bd9Sstevel@tonic-gate dtrace_copycheck(uintptr_t uaddr, uintptr_t kaddr, size_t size) 6387c478bd9Sstevel@tonic-gate { 6397c478bd9Sstevel@tonic-gate ASSERT(kaddr >= kernelbase && kaddr + size >= kaddr); 6407c478bd9Sstevel@tonic-gate 6417c478bd9Sstevel@tonic-gate if (uaddr + size >= kernelbase || uaddr + size < uaddr) { 6427c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR); 6437c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = uaddr; 6447c478bd9Sstevel@tonic-gate return (0); 6457c478bd9Sstevel@tonic-gate } 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate return (1); 6487c478bd9Sstevel@tonic-gate } 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate void 6517c478bd9Sstevel@tonic-gate dtrace_copyin(uintptr_t uaddr, uintptr_t kaddr, size_t size) 6527c478bd9Sstevel@tonic-gate { 6537c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size)) 6547c478bd9Sstevel@tonic-gate dtrace_copy(uaddr, kaddr, size); 6557c478bd9Sstevel@tonic-gate } 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate void 6587c478bd9Sstevel@tonic-gate dtrace_copyout(uintptr_t kaddr, uintptr_t uaddr, size_t size) 6597c478bd9Sstevel@tonic-gate { 6607c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size)) 6617c478bd9Sstevel@tonic-gate dtrace_copy(kaddr, uaddr, size); 6627c478bd9Sstevel@tonic-gate } 6637c478bd9Sstevel@tonic-gate 6647c478bd9Sstevel@tonic-gate void 6657c478bd9Sstevel@tonic-gate dtrace_copyinstr(uintptr_t uaddr, uintptr_t kaddr, size_t size) 6667c478bd9Sstevel@tonic-gate { 6677c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size)) 6687c478bd9Sstevel@tonic-gate dtrace_copystr(uaddr, kaddr, size); 6697c478bd9Sstevel@tonic-gate } 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate void 6727c478bd9Sstevel@tonic-gate dtrace_copyoutstr(uintptr_t kaddr, uintptr_t uaddr, size_t size) 6737c478bd9Sstevel@tonic-gate { 6747c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size)) 6757c478bd9Sstevel@tonic-gate dtrace_copystr(kaddr, uaddr, size); 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate uint8_t 6797c478bd9Sstevel@tonic-gate dtrace_fuword8(void *uaddr) 6807c478bd9Sstevel@tonic-gate { 6817c478bd9Sstevel@tonic-gate extern uint8_t dtrace_fuword8_nocheck(void *); 6827c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) { 6837c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR); 6847c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr; 6857c478bd9Sstevel@tonic-gate return (0); 6867c478bd9Sstevel@tonic-gate } 6877c478bd9Sstevel@tonic-gate return (dtrace_fuword8_nocheck(uaddr)); 6887c478bd9Sstevel@tonic-gate } 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate uint16_t 6917c478bd9Sstevel@tonic-gate dtrace_fuword16(void *uaddr) 6927c478bd9Sstevel@tonic-gate { 6937c478bd9Sstevel@tonic-gate extern uint16_t dtrace_fuword16_nocheck(void *); 6947c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) { 6957c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR); 6967c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr; 6977c478bd9Sstevel@tonic-gate return (0); 6987c478bd9Sstevel@tonic-gate } 6997c478bd9Sstevel@tonic-gate return (dtrace_fuword16_nocheck(uaddr)); 7007c478bd9Sstevel@tonic-gate } 7017c478bd9Sstevel@tonic-gate 7027c478bd9Sstevel@tonic-gate uint32_t 7037c478bd9Sstevel@tonic-gate dtrace_fuword32(void *uaddr) 7047c478bd9Sstevel@tonic-gate { 7057c478bd9Sstevel@tonic-gate extern uint32_t dtrace_fuword32_nocheck(void *); 7067c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) { 7077c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR); 7087c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr; 7097c478bd9Sstevel@tonic-gate return (0); 7107c478bd9Sstevel@tonic-gate } 7117c478bd9Sstevel@tonic-gate return (dtrace_fuword32_nocheck(uaddr)); 7127c478bd9Sstevel@tonic-gate } 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate uint64_t 7157c478bd9Sstevel@tonic-gate dtrace_fuword64(void *uaddr) 7167c478bd9Sstevel@tonic-gate { 7177c478bd9Sstevel@tonic-gate extern uint64_t dtrace_fuword64_nocheck(void *); 7187c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) { 7197c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR); 7207c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr; 7217c478bd9Sstevel@tonic-gate return (0); 7227c478bd9Sstevel@tonic-gate } 7237c478bd9Sstevel@tonic-gate return (dtrace_fuword64_nocheck(uaddr)); 7247c478bd9Sstevel@tonic-gate } 725