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
278e50396aSAdam H. Leventhal /*
288e50396aSAdam H. Leventhal * Copyright (c) 2013, 2014 by Delphix. All rights reserved.
2956a20711SPatrick Mooney * Copyright (c) 2017 Joyent, Inc.
308e50396aSAdam H. Leventhal */
317c478bd9Sstevel@tonic-gate
327c478bd9Sstevel@tonic-gate #include <sys/dtrace_impl.h>
337c478bd9Sstevel@tonic-gate #include <sys/stack.h>
347c478bd9Sstevel@tonic-gate #include <sys/frame.h>
357c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
367c478bd9Sstevel@tonic-gate #include <sys/privregs.h>
377c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
387c478bd9Sstevel@tonic-gate
397c478bd9Sstevel@tonic-gate extern uintptr_t kernelbase;
407c478bd9Sstevel@tonic-gate
41b8fac8e1Sjhaslam int dtrace_ustackdepth_max = 2048;
42b8fac8e1Sjhaslam
437c478bd9Sstevel@tonic-gate void
dtrace_getpcstack(pc_t * pcstack,int pcstack_limit,int aframes,uint32_t * intrpc)447c478bd9Sstevel@tonic-gate dtrace_getpcstack(pc_t *pcstack, int pcstack_limit, int aframes,
457c478bd9Sstevel@tonic-gate uint32_t *intrpc)
467c478bd9Sstevel@tonic-gate {
477c478bd9Sstevel@tonic-gate struct frame *fp = (struct frame *)dtrace_getfp();
487c478bd9Sstevel@tonic-gate struct frame *nextfp, *minfp, *stacktop;
497c478bd9Sstevel@tonic-gate int depth = 0;
507c478bd9Sstevel@tonic-gate int on_intr, last = 0;
517c478bd9Sstevel@tonic-gate uintptr_t pc;
527c478bd9Sstevel@tonic-gate uintptr_t caller = CPU->cpu_dtrace_caller;
537c478bd9Sstevel@tonic-gate
547c478bd9Sstevel@tonic-gate if ((on_intr = CPU_ON_INTR(CPU)) != 0)
557c478bd9Sstevel@tonic-gate stacktop = (struct frame *)(CPU->cpu_intr_stack + SA(MINFRAME));
567c478bd9Sstevel@tonic-gate else
577c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk;
587c478bd9Sstevel@tonic-gate minfp = fp;
597c478bd9Sstevel@tonic-gate
607c478bd9Sstevel@tonic-gate aframes++;
617c478bd9Sstevel@tonic-gate
627c478bd9Sstevel@tonic-gate if (intrpc != NULL && depth < pcstack_limit)
637c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)intrpc;
647c478bd9Sstevel@tonic-gate
657c478bd9Sstevel@tonic-gate while (depth < pcstack_limit) {
667c478bd9Sstevel@tonic-gate nextfp = (struct frame *)fp->fr_savfp;
677c478bd9Sstevel@tonic-gate pc = fp->fr_savpc;
687c478bd9Sstevel@tonic-gate
697c478bd9Sstevel@tonic-gate if (nextfp <= minfp || nextfp >= stacktop) {
707c478bd9Sstevel@tonic-gate if (on_intr) {
717c478bd9Sstevel@tonic-gate /*
727c478bd9Sstevel@tonic-gate * Hop from interrupt stack to thread stack.
737c478bd9Sstevel@tonic-gate */
747c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk;
757c478bd9Sstevel@tonic-gate minfp = (struct frame *)curthread->t_stkbase;
767c478bd9Sstevel@tonic-gate on_intr = 0;
777c478bd9Sstevel@tonic-gate continue;
787c478bd9Sstevel@tonic-gate }
797c478bd9Sstevel@tonic-gate
807c478bd9Sstevel@tonic-gate /*
817c478bd9Sstevel@tonic-gate * This is the last frame we can process; indicate
827c478bd9Sstevel@tonic-gate * that we should return after processing this frame.
837c478bd9Sstevel@tonic-gate */
847c478bd9Sstevel@tonic-gate last = 1;
857c478bd9Sstevel@tonic-gate }
867c478bd9Sstevel@tonic-gate
877c478bd9Sstevel@tonic-gate if (aframes > 0) {
88*f7ecc608SToomas Soome if (--aframes == 0 && caller != 0) {
897c478bd9Sstevel@tonic-gate /*
907c478bd9Sstevel@tonic-gate * We've just run out of artificial frames,
917c478bd9Sstevel@tonic-gate * and we have a valid caller -- fill it in
927c478bd9Sstevel@tonic-gate * now.
937c478bd9Sstevel@tonic-gate */
947c478bd9Sstevel@tonic-gate ASSERT(depth < pcstack_limit);
957c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)caller;
96*f7ecc608SToomas Soome caller = 0;
977c478bd9Sstevel@tonic-gate }
987c478bd9Sstevel@tonic-gate } else {
997c478bd9Sstevel@tonic-gate if (depth < pcstack_limit)
1007c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)pc;
1017c478bd9Sstevel@tonic-gate }
1027c478bd9Sstevel@tonic-gate
1037c478bd9Sstevel@tonic-gate if (last) {
1047c478bd9Sstevel@tonic-gate while (depth < pcstack_limit)
105*f7ecc608SToomas Soome pcstack[depth++] = 0;
1067c478bd9Sstevel@tonic-gate return;
1077c478bd9Sstevel@tonic-gate }
1087c478bd9Sstevel@tonic-gate
1097c478bd9Sstevel@tonic-gate fp = nextfp;
1107c478bd9Sstevel@tonic-gate minfp = fp;
1117c478bd9Sstevel@tonic-gate }
1127c478bd9Sstevel@tonic-gate }
1137c478bd9Sstevel@tonic-gate
1140b38a8bdSahl static int
dtrace_getustack_common(uint64_t * pcstack,int pcstack_limit,uintptr_t pc,uintptr_t sp)1150b38a8bdSahl dtrace_getustack_common(uint64_t *pcstack, int pcstack_limit, uintptr_t pc,
1160b38a8bdSahl uintptr_t sp)
1177c478bd9Sstevel@tonic-gate {
1187c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread);
1190b38a8bdSahl proc_t *p = curproc;
1200b38a8bdSahl uintptr_t oldcontext = lwp->lwp_oldcontext;
121b8fac8e1Sjhaslam uintptr_t oldsp;
1220b38a8bdSahl volatile uint16_t *flags =
1230b38a8bdSahl (volatile uint16_t *)&cpu_core[CPU->cpu_id].cpuc_dtrace_flags;
1247c478bd9Sstevel@tonic-gate size_t s1, s2;
1250b38a8bdSahl int ret = 0;
1267c478bd9Sstevel@tonic-gate
1270b38a8bdSahl ASSERT(pcstack == NULL || pcstack_limit > 0);
128b8fac8e1Sjhaslam ASSERT(dtrace_ustackdepth_max > 0);
1297c478bd9Sstevel@tonic-gate
1307c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) {
1317c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame) + 2 * sizeof (long);
1327c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo_t);
1337c478bd9Sstevel@tonic-gate } else {
1347c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame32) + 3 * sizeof (int);
1357c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo32_t);
1367c478bd9Sstevel@tonic-gate }
1377c478bd9Sstevel@tonic-gate
138ab9a77c7Sahl while (pc != 0) {
139b8fac8e1Sjhaslam /*
140b8fac8e1Sjhaslam * We limit the number of times we can go around this
141b8fac8e1Sjhaslam * loop to account for a circular stack.
142b8fac8e1Sjhaslam */
143b8fac8e1Sjhaslam if (ret++ >= dtrace_ustackdepth_max) {
144b8fac8e1Sjhaslam *flags |= CPU_DTRACE_BADSTACK;
145b8fac8e1Sjhaslam cpu_core[CPU->cpu_id].cpuc_dtrace_illval = sp;
146b8fac8e1Sjhaslam break;
147b8fac8e1Sjhaslam }
148b8fac8e1Sjhaslam
1490b38a8bdSahl if (pcstack != NULL) {
1500b38a8bdSahl *pcstack++ = (uint64_t)pc;
1510b38a8bdSahl pcstack_limit--;
1520b38a8bdSahl if (pcstack_limit <= 0)
1530b38a8bdSahl break;
1540b38a8bdSahl }
1557c478bd9Sstevel@tonic-gate
156ab9a77c7Sahl if (sp == 0)
157ab9a77c7Sahl break;
158ab9a77c7Sahl
159b8fac8e1Sjhaslam oldsp = sp;
160b8fac8e1Sjhaslam
1617c478bd9Sstevel@tonic-gate if (oldcontext == sp + s1 || oldcontext == sp + s2) {
1627c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) {
1637c478bd9Sstevel@tonic-gate ucontext_t *ucp = (ucontext_t *)oldcontext;
1647c478bd9Sstevel@tonic-gate greg_t *gregs = ucp->uc_mcontext.gregs;
1657c478bd9Sstevel@tonic-gate
1667c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&gregs[REG_FP]);
1677c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&gregs[REG_PC]);
1687c478bd9Sstevel@tonic-gate
1697c478bd9Sstevel@tonic-gate oldcontext = dtrace_fulword(&ucp->uc_link);
1707c478bd9Sstevel@tonic-gate } else {
1717c478bd9Sstevel@tonic-gate ucontext32_t *ucp = (ucontext32_t *)oldcontext;
1727c478bd9Sstevel@tonic-gate greg32_t *gregs = ucp->uc_mcontext.gregs;
1737c478bd9Sstevel@tonic-gate
1747c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&gregs[EBP]);
1757c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&gregs[EIP]);
1767c478bd9Sstevel@tonic-gate
1777c478bd9Sstevel@tonic-gate oldcontext = dtrace_fuword32(&ucp->uc_link);
1787c478bd9Sstevel@tonic-gate }
1797c478bd9Sstevel@tonic-gate } else {
1807c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) {
1817c478bd9Sstevel@tonic-gate struct frame *fr = (struct frame *)sp;
1827c478bd9Sstevel@tonic-gate
1837c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&fr->fr_savpc);
1847c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&fr->fr_savfp);
1857c478bd9Sstevel@tonic-gate } else {
1867c478bd9Sstevel@tonic-gate struct frame32 *fr = (struct frame32 *)sp;
1877c478bd9Sstevel@tonic-gate
1887c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&fr->fr_savpc);
1897c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&fr->fr_savfp);
1907c478bd9Sstevel@tonic-gate }
1917c478bd9Sstevel@tonic-gate }
1927c478bd9Sstevel@tonic-gate
193b8fac8e1Sjhaslam if (sp == oldsp) {
194b8fac8e1Sjhaslam *flags |= CPU_DTRACE_BADSTACK;
195b8fac8e1Sjhaslam cpu_core[CPU->cpu_id].cpuc_dtrace_illval = sp;
196b8fac8e1Sjhaslam break;
197b8fac8e1Sjhaslam }
198b8fac8e1Sjhaslam
1997c478bd9Sstevel@tonic-gate /*
2007c478bd9Sstevel@tonic-gate * This is totally bogus: if we faulted, we're going to clear
2017c478bd9Sstevel@tonic-gate * the fault and break. This is to deal with the apparently
2027c478bd9Sstevel@tonic-gate * broken Java stacks on x86.
2037c478bd9Sstevel@tonic-gate */
2047c478bd9Sstevel@tonic-gate if (*flags & CPU_DTRACE_FAULT) {
2057c478bd9Sstevel@tonic-gate *flags &= ~CPU_DTRACE_FAULT;
2067c478bd9Sstevel@tonic-gate break;
2077c478bd9Sstevel@tonic-gate }
2087c478bd9Sstevel@tonic-gate }
2097c478bd9Sstevel@tonic-gate
2100b38a8bdSahl return (ret);
2110b38a8bdSahl }
2120b38a8bdSahl
2130b38a8bdSahl void
dtrace_getupcstack(uint64_t * pcstack,int pcstack_limit)2140b38a8bdSahl dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit)
2150b38a8bdSahl {
2160b38a8bdSahl klwp_t *lwp = ttolwp(curthread);
2170b38a8bdSahl proc_t *p = curproc;
2180b38a8bdSahl struct regs *rp;
2190b38a8bdSahl uintptr_t pc, sp;
2200b38a8bdSahl int n;
2210b38a8bdSahl
2226c9596d4Sahl ASSERT(DTRACE_CPUFLAG_ISSET(CPU_DTRACE_NOFAULT));
2236c9596d4Sahl
2246c9596d4Sahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAULT))
2250b38a8bdSahl return;
2260b38a8bdSahl
2270b38a8bdSahl if (pcstack_limit <= 0)
2280b38a8bdSahl return;
2290b38a8bdSahl
23035b7f6ccSahl /*
23135b7f6ccSahl * If there's no user context we still need to zero the stack.
23235b7f6ccSahl */
23335b7f6ccSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL)
23435b7f6ccSahl goto zero;
23535b7f6ccSahl
2360b38a8bdSahl *pcstack++ = (uint64_t)p->p_pid;
2370b38a8bdSahl pcstack_limit--;
2380b38a8bdSahl
2390b38a8bdSahl if (pcstack_limit <= 0)
2400b38a8bdSahl return;
2410b38a8bdSahl
2420b38a8bdSahl pc = rp->r_pc;
2430b38a8bdSahl sp = rp->r_fp;
2440b38a8bdSahl
2450b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
2460b38a8bdSahl *pcstack++ = (uint64_t)pc;
2470b38a8bdSahl pcstack_limit--;
2480b38a8bdSahl if (pcstack_limit <= 0)
2490b38a8bdSahl return;
2500b38a8bdSahl
2510b38a8bdSahl if (p->p_model == DATAMODEL_NATIVE)
2520b38a8bdSahl pc = dtrace_fulword((void *)rp->r_sp);
2530b38a8bdSahl else
2540b38a8bdSahl pc = dtrace_fuword32((void *)rp->r_sp);
2550b38a8bdSahl }
2560b38a8bdSahl
2570b38a8bdSahl n = dtrace_getustack_common(pcstack, pcstack_limit, pc, sp);
2580b38a8bdSahl ASSERT(n >= 0);
2590b38a8bdSahl ASSERT(n <= pcstack_limit);
2600b38a8bdSahl
2610b38a8bdSahl pcstack += n;
2620b38a8bdSahl pcstack_limit -= n;
2630b38a8bdSahl
26435b7f6ccSahl zero:
2657c478bd9Sstevel@tonic-gate while (pcstack_limit-- > 0)
266*f7ecc608SToomas Soome *pcstack++ = 0;
2677c478bd9Sstevel@tonic-gate }
2687c478bd9Sstevel@tonic-gate
2690b38a8bdSahl int
dtrace_getustackdepth(void)2700b38a8bdSahl dtrace_getustackdepth(void)
2710b38a8bdSahl {
2720b38a8bdSahl klwp_t *lwp = ttolwp(curthread);
2730b38a8bdSahl proc_t *p = curproc;
2740b38a8bdSahl struct regs *rp;
2750b38a8bdSahl uintptr_t pc, sp;
2760b38a8bdSahl int n = 0;
2770b38a8bdSahl
2780b38a8bdSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL)
2790b38a8bdSahl return (0);
2800b38a8bdSahl
2810b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAULT))
2820b38a8bdSahl return (-1);
2830b38a8bdSahl
2840b38a8bdSahl pc = rp->r_pc;
2850b38a8bdSahl sp = rp->r_fp;
2860b38a8bdSahl
2870b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
2880b38a8bdSahl n++;
2890b38a8bdSahl
2900b38a8bdSahl if (p->p_model == DATAMODEL_NATIVE)
2910b38a8bdSahl pc = dtrace_fulword((void *)rp->r_sp);
2920b38a8bdSahl else
2930b38a8bdSahl pc = dtrace_fuword32((void *)rp->r_sp);
2940b38a8bdSahl }
2950b38a8bdSahl
2960b38a8bdSahl n += dtrace_getustack_common(NULL, 0, pc, sp);
2970b38a8bdSahl
2980b38a8bdSahl return (n);
2990b38a8bdSahl }
3000b38a8bdSahl
3017c478bd9Sstevel@tonic-gate void
dtrace_getufpstack(uint64_t * pcstack,uint64_t * fpstack,int pcstack_limit)3027c478bd9Sstevel@tonic-gate dtrace_getufpstack(uint64_t *pcstack, uint64_t *fpstack, int pcstack_limit)
3037c478bd9Sstevel@tonic-gate {
3047c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread);
3050b38a8bdSahl proc_t *p = curproc;
3067c478bd9Sstevel@tonic-gate struct regs *rp;
3077c478bd9Sstevel@tonic-gate uintptr_t pc, sp, oldcontext;
3080b38a8bdSahl volatile uint16_t *flags =
3090b38a8bdSahl (volatile uint16_t *)&cpu_core[CPU->cpu_id].cpuc_dtrace_flags;
3107c478bd9Sstevel@tonic-gate size_t s1, s2;
3117c478bd9Sstevel@tonic-gate
3127c478bd9Sstevel@tonic-gate if (*flags & CPU_DTRACE_FAULT)
3137c478bd9Sstevel@tonic-gate return;
3147c478bd9Sstevel@tonic-gate
3157c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0)
3167c478bd9Sstevel@tonic-gate return;
3177c478bd9Sstevel@tonic-gate
31835b7f6ccSahl /*
31935b7f6ccSahl * If there's no user context we still need to zero the stack.
32035b7f6ccSahl */
32135b7f6ccSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL)
32235b7f6ccSahl goto zero;
32335b7f6ccSahl
3247c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)p->p_pid;
3257c478bd9Sstevel@tonic-gate pcstack_limit--;
3267c478bd9Sstevel@tonic-gate
3277c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0)
3287c478bd9Sstevel@tonic-gate return;
3297c478bd9Sstevel@tonic-gate
3307c478bd9Sstevel@tonic-gate pc = rp->r_pc;
3317c478bd9Sstevel@tonic-gate sp = rp->r_fp;
3327c478bd9Sstevel@tonic-gate oldcontext = lwp->lwp_oldcontext;
3337c478bd9Sstevel@tonic-gate
3347c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) {
3357c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame) + 2 * sizeof (long);
3367c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo_t);
3377c478bd9Sstevel@tonic-gate } else {
3387c478bd9Sstevel@tonic-gate s1 = sizeof (struct frame32) + 3 * sizeof (int);
3397c478bd9Sstevel@tonic-gate s2 = s1 + sizeof (siginfo32_t);
3407c478bd9Sstevel@tonic-gate }
3417c478bd9Sstevel@tonic-gate
3427c478bd9Sstevel@tonic-gate if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) {
3437c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)pc;
3447c478bd9Sstevel@tonic-gate *fpstack++ = 0;
3457c478bd9Sstevel@tonic-gate pcstack_limit--;
3467c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0)
3477c478bd9Sstevel@tonic-gate return;
3487c478bd9Sstevel@tonic-gate
3497c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE)
3507c478bd9Sstevel@tonic-gate pc = dtrace_fulword((void *)rp->r_sp);
3517c478bd9Sstevel@tonic-gate else
3527c478bd9Sstevel@tonic-gate pc = dtrace_fuword32((void *)rp->r_sp);
3537c478bd9Sstevel@tonic-gate }
3547c478bd9Sstevel@tonic-gate
355ab9a77c7Sahl while (pc != 0) {
3567c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)pc;
3577c478bd9Sstevel@tonic-gate *fpstack++ = sp;
3587c478bd9Sstevel@tonic-gate pcstack_limit--;
3597c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0)
3607c478bd9Sstevel@tonic-gate break;
3617c478bd9Sstevel@tonic-gate
362ab9a77c7Sahl if (sp == 0)
363ab9a77c7Sahl break;
364ab9a77c7Sahl
3657c478bd9Sstevel@tonic-gate if (oldcontext == sp + s1 || oldcontext == sp + s2) {
3667c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) {
3677c478bd9Sstevel@tonic-gate ucontext_t *ucp = (ucontext_t *)oldcontext;
3687c478bd9Sstevel@tonic-gate greg_t *gregs = ucp->uc_mcontext.gregs;
3697c478bd9Sstevel@tonic-gate
3707c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&gregs[REG_FP]);
3717c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&gregs[REG_PC]);
3727c478bd9Sstevel@tonic-gate
3737c478bd9Sstevel@tonic-gate oldcontext = dtrace_fulword(&ucp->uc_link);
3747c478bd9Sstevel@tonic-gate } else {
3757c478bd9Sstevel@tonic-gate ucontext_t *ucp = (ucontext_t *)oldcontext;
3767c478bd9Sstevel@tonic-gate greg_t *gregs = ucp->uc_mcontext.gregs;
3777c478bd9Sstevel@tonic-gate
3787c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&gregs[EBP]);
3797c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&gregs[EIP]);
3807c478bd9Sstevel@tonic-gate
3817c478bd9Sstevel@tonic-gate oldcontext = dtrace_fuword32(&ucp->uc_link);
3827c478bd9Sstevel@tonic-gate }
3837c478bd9Sstevel@tonic-gate } else {
3847c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) {
3857c478bd9Sstevel@tonic-gate struct frame *fr = (struct frame *)sp;
3867c478bd9Sstevel@tonic-gate
3877c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&fr->fr_savpc);
3887c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&fr->fr_savfp);
3897c478bd9Sstevel@tonic-gate } else {
3907c478bd9Sstevel@tonic-gate struct frame32 *fr = (struct frame32 *)sp;
3917c478bd9Sstevel@tonic-gate
3927c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&fr->fr_savpc);
3937c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&fr->fr_savfp);
3947c478bd9Sstevel@tonic-gate }
3957c478bd9Sstevel@tonic-gate }
3967c478bd9Sstevel@tonic-gate
3977c478bd9Sstevel@tonic-gate /*
3987c478bd9Sstevel@tonic-gate * This is totally bogus: if we faulted, we're going to clear
3997c478bd9Sstevel@tonic-gate * the fault and break. This is to deal with the apparently
4007c478bd9Sstevel@tonic-gate * broken Java stacks on x86.
4017c478bd9Sstevel@tonic-gate */
4027c478bd9Sstevel@tonic-gate if (*flags & CPU_DTRACE_FAULT) {
4037c478bd9Sstevel@tonic-gate *flags &= ~CPU_DTRACE_FAULT;
4047c478bd9Sstevel@tonic-gate break;
4057c478bd9Sstevel@tonic-gate }
4067c478bd9Sstevel@tonic-gate }
4077c478bd9Sstevel@tonic-gate
40835b7f6ccSahl zero:
4097c478bd9Sstevel@tonic-gate while (pcstack_limit-- > 0)
410*f7ecc608SToomas Soome *pcstack++ = 0;
4117c478bd9Sstevel@tonic-gate }
4127c478bd9Sstevel@tonic-gate
4137c478bd9Sstevel@tonic-gate /*ARGSUSED*/
4147c478bd9Sstevel@tonic-gate uint64_t
dtrace_getarg(int arg,int aframes)4157c478bd9Sstevel@tonic-gate dtrace_getarg(int arg, int aframes)
4167c478bd9Sstevel@tonic-gate {
4177c478bd9Sstevel@tonic-gate uintptr_t val;
4187c478bd9Sstevel@tonic-gate struct frame *fp = (struct frame *)dtrace_getfp();
4197c478bd9Sstevel@tonic-gate uintptr_t *stack;
4207c478bd9Sstevel@tonic-gate int i;
4217c478bd9Sstevel@tonic-gate /*
4227c478bd9Sstevel@tonic-gate * A total of 6 arguments are passed via registers; any argument with
4237c478bd9Sstevel@tonic-gate * index of 5 or lower is therefore in a register.
4247c478bd9Sstevel@tonic-gate */
4257c478bd9Sstevel@tonic-gate int inreg = 5;
4267c478bd9Sstevel@tonic-gate
4277c478bd9Sstevel@tonic-gate for (i = 1; i <= aframes; i++) {
4287c478bd9Sstevel@tonic-gate fp = (struct frame *)(fp->fr_savfp);
4297c478bd9Sstevel@tonic-gate
4307c478bd9Sstevel@tonic-gate if (fp->fr_savpc == (pc_t)dtrace_invop_callsite) {
4317c478bd9Sstevel@tonic-gate /*
4327c478bd9Sstevel@tonic-gate * In the case of amd64, we will use the pointer to the
4337c478bd9Sstevel@tonic-gate * regs structure that was pushed when we took the
4347c478bd9Sstevel@tonic-gate * trap. To get this structure, we must increment
4358e50396aSAdam H. Leventhal * beyond the frame structure, the calling RIP, and
4368e50396aSAdam H. Leventhal * padding stored in dtrace_invop(). If the argument
4378e50396aSAdam H. Leventhal * that we're seeking is passed on the stack, we'll
4388e50396aSAdam H. Leventhal * pull the true stack pointer out of the saved
4397c478bd9Sstevel@tonic-gate * registers and decrement our argument by the number
4407c478bd9Sstevel@tonic-gate * of arguments passed in registers; if the argument
4417c478bd9Sstevel@tonic-gate * we're seeking is passed in regsiters, we can just
4427c478bd9Sstevel@tonic-gate * load it directly.
4437c478bd9Sstevel@tonic-gate */
4447c478bd9Sstevel@tonic-gate struct regs *rp = (struct regs *)((uintptr_t)&fp[1] +
4458e50396aSAdam H. Leventhal sizeof (uintptr_t) * 2);
4467c478bd9Sstevel@tonic-gate
4477c478bd9Sstevel@tonic-gate if (arg <= inreg) {
4487c478bd9Sstevel@tonic-gate stack = (uintptr_t *)&rp->r_rdi;
4497c478bd9Sstevel@tonic-gate } else {
4507c478bd9Sstevel@tonic-gate stack = (uintptr_t *)(rp->r_rsp);
4517c478bd9Sstevel@tonic-gate arg -= inreg;
4527c478bd9Sstevel@tonic-gate }
4537c478bd9Sstevel@tonic-gate goto load;
4547c478bd9Sstevel@tonic-gate }
4557c478bd9Sstevel@tonic-gate
4567c478bd9Sstevel@tonic-gate }
4577c478bd9Sstevel@tonic-gate
4587c478bd9Sstevel@tonic-gate /*
4597c478bd9Sstevel@tonic-gate * We know that we did not come through a trap to get into
4607c478bd9Sstevel@tonic-gate * dtrace_probe() -- the provider simply called dtrace_probe()
4617c478bd9Sstevel@tonic-gate * directly. As this is the case, we need to shift the argument
4627c478bd9Sstevel@tonic-gate * that we're looking for: the probe ID is the first argument to
4637c478bd9Sstevel@tonic-gate * dtrace_probe(), so the argument n will actually be found where
4647c478bd9Sstevel@tonic-gate * one would expect to find argument (n + 1).
4657c478bd9Sstevel@tonic-gate */
4667c478bd9Sstevel@tonic-gate arg++;
4677c478bd9Sstevel@tonic-gate
4687c478bd9Sstevel@tonic-gate if (arg <= inreg) {
4697c478bd9Sstevel@tonic-gate /*
4707c478bd9Sstevel@tonic-gate * This shouldn't happen. If the argument is passed in a
4717c478bd9Sstevel@tonic-gate * register then it should have been, well, passed in a
4727c478bd9Sstevel@tonic-gate * register...
4737c478bd9Sstevel@tonic-gate */
4747c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
4757c478bd9Sstevel@tonic-gate return (0);
4767c478bd9Sstevel@tonic-gate }
4777c478bd9Sstevel@tonic-gate
4787c478bd9Sstevel@tonic-gate arg -= (inreg + 1);
4797c478bd9Sstevel@tonic-gate stack = (uintptr_t *)&fp[1];
4807c478bd9Sstevel@tonic-gate
4817c478bd9Sstevel@tonic-gate load:
4827c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT);
4837c478bd9Sstevel@tonic-gate val = stack[arg];
4847c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT);
4857c478bd9Sstevel@tonic-gate
4867c478bd9Sstevel@tonic-gate return (val);
4877c478bd9Sstevel@tonic-gate }
4887c478bd9Sstevel@tonic-gate
4897c478bd9Sstevel@tonic-gate /*ARGSUSED*/
4907c478bd9Sstevel@tonic-gate int
dtrace_getstackdepth(int aframes)4917c478bd9Sstevel@tonic-gate dtrace_getstackdepth(int aframes)
4927c478bd9Sstevel@tonic-gate {
4937c478bd9Sstevel@tonic-gate struct frame *fp = (struct frame *)dtrace_getfp();
4947c478bd9Sstevel@tonic-gate struct frame *nextfp, *minfp, *stacktop;
4957c478bd9Sstevel@tonic-gate int depth = 0;
4967c478bd9Sstevel@tonic-gate int on_intr;
4977c478bd9Sstevel@tonic-gate
4987c478bd9Sstevel@tonic-gate if ((on_intr = CPU_ON_INTR(CPU)) != 0)
4997c478bd9Sstevel@tonic-gate stacktop = (struct frame *)(CPU->cpu_intr_stack + SA(MINFRAME));
5007c478bd9Sstevel@tonic-gate else
5017c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk;
5027c478bd9Sstevel@tonic-gate minfp = fp;
5037c478bd9Sstevel@tonic-gate
5047c478bd9Sstevel@tonic-gate aframes++;
5057c478bd9Sstevel@tonic-gate
5067c478bd9Sstevel@tonic-gate for (;;) {
5077c478bd9Sstevel@tonic-gate depth++;
5087c478bd9Sstevel@tonic-gate
5097c478bd9Sstevel@tonic-gate nextfp = (struct frame *)fp->fr_savfp;
5107c478bd9Sstevel@tonic-gate
5117c478bd9Sstevel@tonic-gate if (nextfp <= minfp || nextfp >= stacktop) {
5127c478bd9Sstevel@tonic-gate if (on_intr) {
5137c478bd9Sstevel@tonic-gate /*
5147c478bd9Sstevel@tonic-gate * Hop from interrupt stack to thread stack.
5157c478bd9Sstevel@tonic-gate */
5167c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk;
5177c478bd9Sstevel@tonic-gate minfp = (struct frame *)curthread->t_stkbase;
5187c478bd9Sstevel@tonic-gate on_intr = 0;
5197c478bd9Sstevel@tonic-gate continue;
5207c478bd9Sstevel@tonic-gate }
5217c478bd9Sstevel@tonic-gate break;
5227c478bd9Sstevel@tonic-gate }
5237c478bd9Sstevel@tonic-gate
5247c478bd9Sstevel@tonic-gate fp = nextfp;
5257c478bd9Sstevel@tonic-gate minfp = fp;
5267c478bd9Sstevel@tonic-gate }
5277c478bd9Sstevel@tonic-gate
5287c478bd9Sstevel@tonic-gate if (depth <= aframes)
5297c478bd9Sstevel@tonic-gate return (0);
5307c478bd9Sstevel@tonic-gate
5317c478bd9Sstevel@tonic-gate return (depth - aframes);
5327c478bd9Sstevel@tonic-gate }
5337c478bd9Sstevel@tonic-gate
53456a20711SPatrick Mooney static const int dtrace_regmap[] = {
53556a20711SPatrick Mooney REG_GS, /* GS */
53656a20711SPatrick Mooney REG_FS, /* FS */
53756a20711SPatrick Mooney REG_ES, /* ES */
53856a20711SPatrick Mooney REG_DS, /* DS */
53956a20711SPatrick Mooney REG_RDI, /* EDI */
54056a20711SPatrick Mooney REG_RSI, /* ESI */
54156a20711SPatrick Mooney REG_RBP, /* EBP */
54256a20711SPatrick Mooney REG_RSP, /* ESP */
54356a20711SPatrick Mooney REG_RBX, /* EBX */
54456a20711SPatrick Mooney REG_RDX, /* EDX */
54556a20711SPatrick Mooney REG_RCX, /* ECX */
54656a20711SPatrick Mooney REG_RAX, /* EAX */
54756a20711SPatrick Mooney REG_TRAPNO, /* TRAPNO */
54856a20711SPatrick Mooney REG_ERR, /* ERR */
54956a20711SPatrick Mooney REG_RIP, /* EIP */
55056a20711SPatrick Mooney REG_CS, /* CS */
55156a20711SPatrick Mooney REG_RFL, /* EFL */
55256a20711SPatrick Mooney REG_RSP, /* UESP */
55356a20711SPatrick Mooney REG_SS /* SS */
55456a20711SPatrick Mooney };
55556a20711SPatrick Mooney
55656a20711SPatrick Mooney
5577c478bd9Sstevel@tonic-gate ulong_t
dtrace_getreg(struct regs * rp,uint_t reg)5587c478bd9Sstevel@tonic-gate dtrace_getreg(struct regs *rp, uint_t reg)
5597c478bd9Sstevel@tonic-gate {
5607c478bd9Sstevel@tonic-gate if (reg <= SS) {
56156a20711SPatrick Mooney if (reg >= sizeof (dtrace_regmap) / sizeof (int)) {
5627c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
5637c478bd9Sstevel@tonic-gate return (0);
5647c478bd9Sstevel@tonic-gate }
5657c478bd9Sstevel@tonic-gate
56656a20711SPatrick Mooney reg = dtrace_regmap[reg];
5677c478bd9Sstevel@tonic-gate } else {
5687c478bd9Sstevel@tonic-gate reg -= SS + 1;
5697c478bd9Sstevel@tonic-gate }
5707c478bd9Sstevel@tonic-gate
5717c478bd9Sstevel@tonic-gate switch (reg) {
5727c478bd9Sstevel@tonic-gate case REG_RDI:
5737c478bd9Sstevel@tonic-gate return (rp->r_rdi);
5747c478bd9Sstevel@tonic-gate case REG_RSI:
5757c478bd9Sstevel@tonic-gate return (rp->r_rsi);
5767c478bd9Sstevel@tonic-gate case REG_RDX:
5777c478bd9Sstevel@tonic-gate return (rp->r_rdx);
5787c478bd9Sstevel@tonic-gate case REG_RCX:
5797c478bd9Sstevel@tonic-gate return (rp->r_rcx);
5807c478bd9Sstevel@tonic-gate case REG_R8:
5817c478bd9Sstevel@tonic-gate return (rp->r_r8);
5827c478bd9Sstevel@tonic-gate case REG_R9:
5837c478bd9Sstevel@tonic-gate return (rp->r_r9);
5847c478bd9Sstevel@tonic-gate case REG_RAX:
5857c478bd9Sstevel@tonic-gate return (rp->r_rax);
5867c478bd9Sstevel@tonic-gate case REG_RBX:
5877c478bd9Sstevel@tonic-gate return (rp->r_rbx);
5887c478bd9Sstevel@tonic-gate case REG_RBP:
5897c478bd9Sstevel@tonic-gate return (rp->r_rbp);
5907c478bd9Sstevel@tonic-gate case REG_R10:
5917c478bd9Sstevel@tonic-gate return (rp->r_r10);
5927c478bd9Sstevel@tonic-gate case REG_R11:
5937c478bd9Sstevel@tonic-gate return (rp->r_r11);
5947c478bd9Sstevel@tonic-gate case REG_R12:
5957c478bd9Sstevel@tonic-gate return (rp->r_r12);
5967c478bd9Sstevel@tonic-gate case REG_R13:
5977c478bd9Sstevel@tonic-gate return (rp->r_r13);
5987c478bd9Sstevel@tonic-gate case REG_R14:
5997c478bd9Sstevel@tonic-gate return (rp->r_r14);
6007c478bd9Sstevel@tonic-gate case REG_R15:
6017c478bd9Sstevel@tonic-gate return (rp->r_r15);
6027c478bd9Sstevel@tonic-gate case REG_DS:
6037c478bd9Sstevel@tonic-gate return (rp->r_ds);
6047c478bd9Sstevel@tonic-gate case REG_ES:
6057c478bd9Sstevel@tonic-gate return (rp->r_es);
6067c478bd9Sstevel@tonic-gate case REG_FS:
6077c478bd9Sstevel@tonic-gate return (rp->r_fs);
6087c478bd9Sstevel@tonic-gate case REG_GS:
6097c478bd9Sstevel@tonic-gate return (rp->r_gs);
6107c478bd9Sstevel@tonic-gate case REG_TRAPNO:
6117c478bd9Sstevel@tonic-gate return (rp->r_trapno);
6127c478bd9Sstevel@tonic-gate case REG_ERR:
6137c478bd9Sstevel@tonic-gate return (rp->r_err);
6147c478bd9Sstevel@tonic-gate case REG_RIP:
6157c478bd9Sstevel@tonic-gate return (rp->r_rip);
6167c478bd9Sstevel@tonic-gate case REG_CS:
6177c478bd9Sstevel@tonic-gate return (rp->r_cs);
6187c478bd9Sstevel@tonic-gate case REG_SS:
6197c478bd9Sstevel@tonic-gate return (rp->r_ss);
6207c478bd9Sstevel@tonic-gate case REG_RFL:
6217c478bd9Sstevel@tonic-gate return (rp->r_rfl);
6227c478bd9Sstevel@tonic-gate case REG_RSP:
6237c478bd9Sstevel@tonic-gate return (rp->r_rsp);
6247c478bd9Sstevel@tonic-gate default:
6257c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
6267c478bd9Sstevel@tonic-gate return (0);
6277c478bd9Sstevel@tonic-gate }
6287c478bd9Sstevel@tonic-gate
6297c478bd9Sstevel@tonic-gate }
6307c478bd9Sstevel@tonic-gate
63156a20711SPatrick Mooney void
dtrace_setreg(struct regs * rp,uint_t reg,ulong_t val)63256a20711SPatrick Mooney dtrace_setreg(struct regs *rp, uint_t reg, ulong_t val)
63356a20711SPatrick Mooney {
63456a20711SPatrick Mooney if (reg <= SS) {
63556a20711SPatrick Mooney ASSERT(reg < (sizeof (dtrace_regmap) / sizeof (int)));
63656a20711SPatrick Mooney
63756a20711SPatrick Mooney reg = dtrace_regmap[reg];
63856a20711SPatrick Mooney } else {
63956a20711SPatrick Mooney reg -= SS + 1;
64056a20711SPatrick Mooney }
64156a20711SPatrick Mooney
64256a20711SPatrick Mooney switch (reg) {
64356a20711SPatrick Mooney case REG_RDI:
64456a20711SPatrick Mooney rp->r_rdi = val;
64556a20711SPatrick Mooney break;
64656a20711SPatrick Mooney case REG_RSI:
64756a20711SPatrick Mooney rp->r_rsi = val;
64856a20711SPatrick Mooney break;
64956a20711SPatrick Mooney case REG_RDX:
65056a20711SPatrick Mooney rp->r_rdx = val;
65156a20711SPatrick Mooney break;
65256a20711SPatrick Mooney case REG_RCX:
65356a20711SPatrick Mooney rp->r_rcx = val;
65456a20711SPatrick Mooney break;
65556a20711SPatrick Mooney case REG_R8:
65656a20711SPatrick Mooney rp->r_r8 = val;
65756a20711SPatrick Mooney break;
65856a20711SPatrick Mooney case REG_R9:
65956a20711SPatrick Mooney rp->r_r9 = val;
66056a20711SPatrick Mooney break;
66156a20711SPatrick Mooney case REG_RAX:
66256a20711SPatrick Mooney rp->r_rax = val;
66356a20711SPatrick Mooney break;
66456a20711SPatrick Mooney case REG_RBX:
66556a20711SPatrick Mooney rp->r_rbx = val;
66656a20711SPatrick Mooney break;
66756a20711SPatrick Mooney case REG_RBP:
66856a20711SPatrick Mooney rp->r_rbp = val;
66956a20711SPatrick Mooney break;
67056a20711SPatrick Mooney case REG_R10:
67156a20711SPatrick Mooney rp->r_r10 = val;
67256a20711SPatrick Mooney break;
67356a20711SPatrick Mooney case REG_R11:
67456a20711SPatrick Mooney rp->r_r11 = val;
67556a20711SPatrick Mooney break;
67656a20711SPatrick Mooney case REG_R12:
67756a20711SPatrick Mooney rp->r_r12 = val;
67856a20711SPatrick Mooney break;
67956a20711SPatrick Mooney case REG_R13:
68056a20711SPatrick Mooney rp->r_r13 = val;
68156a20711SPatrick Mooney break;
68256a20711SPatrick Mooney case REG_R14:
68356a20711SPatrick Mooney rp->r_r14 = val;
68456a20711SPatrick Mooney break;
68556a20711SPatrick Mooney case REG_R15:
68656a20711SPatrick Mooney rp->r_r15 = val;
68756a20711SPatrick Mooney break;
68856a20711SPatrick Mooney case REG_RSP:
68956a20711SPatrick Mooney rp->r_rsp = val;
69056a20711SPatrick Mooney break;
69156a20711SPatrick Mooney default:
69256a20711SPatrick Mooney DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
69356a20711SPatrick Mooney return;
69456a20711SPatrick Mooney }
69556a20711SPatrick Mooney
69656a20711SPatrick Mooney }
69756a20711SPatrick Mooney
6987c478bd9Sstevel@tonic-gate static int
dtrace_copycheck(uintptr_t uaddr,uintptr_t kaddr,size_t size)6997c478bd9Sstevel@tonic-gate dtrace_copycheck(uintptr_t uaddr, uintptr_t kaddr, size_t size)
7007c478bd9Sstevel@tonic-gate {
7017c478bd9Sstevel@tonic-gate ASSERT(kaddr >= kernelbase && kaddr + size >= kaddr);
7027c478bd9Sstevel@tonic-gate
7037c478bd9Sstevel@tonic-gate if (uaddr + size >= kernelbase || uaddr + size < uaddr) {
7047c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
7057c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = uaddr;
7067c478bd9Sstevel@tonic-gate return (0);
7077c478bd9Sstevel@tonic-gate }
7087c478bd9Sstevel@tonic-gate
7097c478bd9Sstevel@tonic-gate return (1);
7107c478bd9Sstevel@tonic-gate }
7117c478bd9Sstevel@tonic-gate
71228406508Ssudheer /*ARGSUSED*/
7137c478bd9Sstevel@tonic-gate void
dtrace_copyin(uintptr_t uaddr,uintptr_t kaddr,size_t size,volatile uint16_t * flags)71428406508Ssudheer dtrace_copyin(uintptr_t uaddr, uintptr_t kaddr, size_t size,
71528406508Ssudheer volatile uint16_t *flags)
7167c478bd9Sstevel@tonic-gate {
7177c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size))
7187c478bd9Sstevel@tonic-gate dtrace_copy(uaddr, kaddr, size);
7197c478bd9Sstevel@tonic-gate }
7207c478bd9Sstevel@tonic-gate
72128406508Ssudheer /*ARGSUSED*/
7227c478bd9Sstevel@tonic-gate void
dtrace_copyout(uintptr_t kaddr,uintptr_t uaddr,size_t size,volatile uint16_t * flags)72328406508Ssudheer dtrace_copyout(uintptr_t kaddr, uintptr_t uaddr, size_t size,
72428406508Ssudheer volatile uint16_t *flags)
7257c478bd9Sstevel@tonic-gate {
7267c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size))
7277c478bd9Sstevel@tonic-gate dtrace_copy(kaddr, uaddr, size);
7287c478bd9Sstevel@tonic-gate }
7297c478bd9Sstevel@tonic-gate
7307c478bd9Sstevel@tonic-gate void
dtrace_copyinstr(uintptr_t uaddr,uintptr_t kaddr,size_t size,volatile uint16_t * flags)73128406508Ssudheer dtrace_copyinstr(uintptr_t uaddr, uintptr_t kaddr, size_t size,
73228406508Ssudheer volatile uint16_t *flags)
7337c478bd9Sstevel@tonic-gate {
7347c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size))
73528406508Ssudheer dtrace_copystr(uaddr, kaddr, size, flags);
7367c478bd9Sstevel@tonic-gate }
7377c478bd9Sstevel@tonic-gate
7387c478bd9Sstevel@tonic-gate void
dtrace_copyoutstr(uintptr_t kaddr,uintptr_t uaddr,size_t size,volatile uint16_t * flags)73928406508Ssudheer dtrace_copyoutstr(uintptr_t kaddr, uintptr_t uaddr, size_t size,
74028406508Ssudheer volatile uint16_t *flags)
7417c478bd9Sstevel@tonic-gate {
7427c478bd9Sstevel@tonic-gate if (dtrace_copycheck(uaddr, kaddr, size))
74328406508Ssudheer dtrace_copystr(kaddr, uaddr, size, flags);
7447c478bd9Sstevel@tonic-gate }
7457c478bd9Sstevel@tonic-gate
7467c478bd9Sstevel@tonic-gate uint8_t
dtrace_fuword8(void * uaddr)7477c478bd9Sstevel@tonic-gate dtrace_fuword8(void *uaddr)
7487c478bd9Sstevel@tonic-gate {
7497c478bd9Sstevel@tonic-gate extern uint8_t dtrace_fuword8_nocheck(void *);
7507c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) {
7517c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
7527c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr;
7537c478bd9Sstevel@tonic-gate return (0);
7547c478bd9Sstevel@tonic-gate }
7557c478bd9Sstevel@tonic-gate return (dtrace_fuword8_nocheck(uaddr));
7567c478bd9Sstevel@tonic-gate }
7577c478bd9Sstevel@tonic-gate
7587c478bd9Sstevel@tonic-gate uint16_t
dtrace_fuword16(void * uaddr)7597c478bd9Sstevel@tonic-gate dtrace_fuword16(void *uaddr)
7607c478bd9Sstevel@tonic-gate {
7617c478bd9Sstevel@tonic-gate extern uint16_t dtrace_fuword16_nocheck(void *);
7627c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) {
7637c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
7647c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr;
7657c478bd9Sstevel@tonic-gate return (0);
7667c478bd9Sstevel@tonic-gate }
7677c478bd9Sstevel@tonic-gate return (dtrace_fuword16_nocheck(uaddr));
7687c478bd9Sstevel@tonic-gate }
7697c478bd9Sstevel@tonic-gate
7707c478bd9Sstevel@tonic-gate uint32_t
dtrace_fuword32(void * uaddr)7717c478bd9Sstevel@tonic-gate dtrace_fuword32(void *uaddr)
7727c478bd9Sstevel@tonic-gate {
7737c478bd9Sstevel@tonic-gate extern uint32_t dtrace_fuword32_nocheck(void *);
7747c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) {
7757c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
7767c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr;
7777c478bd9Sstevel@tonic-gate return (0);
7787c478bd9Sstevel@tonic-gate }
7797c478bd9Sstevel@tonic-gate return (dtrace_fuword32_nocheck(uaddr));
7807c478bd9Sstevel@tonic-gate }
7817c478bd9Sstevel@tonic-gate
7827c478bd9Sstevel@tonic-gate uint64_t
dtrace_fuword64(void * uaddr)7837c478bd9Sstevel@tonic-gate dtrace_fuword64(void *uaddr)
7847c478bd9Sstevel@tonic-gate {
7857c478bd9Sstevel@tonic-gate extern uint64_t dtrace_fuword64_nocheck(void *);
7867c478bd9Sstevel@tonic-gate if ((uintptr_t)uaddr >= _userlimit) {
7877c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
7887c478bd9Sstevel@tonic-gate cpu_core[CPU->cpu_id].cpuc_dtrace_illval = (uintptr_t)uaddr;
7897c478bd9Sstevel@tonic-gate return (0);
7907c478bd9Sstevel@tonic-gate }
7917c478bd9Sstevel@tonic-gate return (dtrace_fuword64_nocheck(uaddr));
7927c478bd9Sstevel@tonic-gate }
793