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/atomic.h> 317c478bd9Sstevel@tonic-gate #include <sys/model.h> 327c478bd9Sstevel@tonic-gate #include <sys/frame.h> 337c478bd9Sstevel@tonic-gate #include <sys/stack.h> 347c478bd9Sstevel@tonic-gate #include <sys/machpcb.h> 357c478bd9Sstevel@tonic-gate #include <sys/procfs_isa.h> 367c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 370b38a8bdSahl #include <sys/sysmacros.h> 387c478bd9Sstevel@tonic-gate 397c478bd9Sstevel@tonic-gate #define DTRACE_FMT3OP3_MASK 0x81000000 407c478bd9Sstevel@tonic-gate #define DTRACE_FMT3OP3 0x80000000 417c478bd9Sstevel@tonic-gate #define DTRACE_FMT3RS1_SHIFT 14 427c478bd9Sstevel@tonic-gate #define DTRACE_FMT3RD_SHIFT 25 43*a1b5e537Sbmc #define DTRACE_DISP22_SHIFT 10 447c478bd9Sstevel@tonic-gate #define DTRACE_RMASK 0x1f 457c478bd9Sstevel@tonic-gate #define DTRACE_REG_L0 16 467c478bd9Sstevel@tonic-gate #define DTRACE_REG_O7 15 477c478bd9Sstevel@tonic-gate #define DTRACE_REG_I0 24 487c478bd9Sstevel@tonic-gate #define DTRACE_REG_I6 30 497c478bd9Sstevel@tonic-gate #define DTRACE_RET 0x81c7e008 507c478bd9Sstevel@tonic-gate #define DTRACE_RETL 0x81c3e008 517c478bd9Sstevel@tonic-gate #define DTRACE_SAVE_MASK 0xc1f80000 527c478bd9Sstevel@tonic-gate #define DTRACE_SAVE 0x81e00000 537c478bd9Sstevel@tonic-gate #define DTRACE_RESTORE 0x81e80000 547c478bd9Sstevel@tonic-gate #define DTRACE_CALL_MASK 0xc0000000 557c478bd9Sstevel@tonic-gate #define DTRACE_CALL 0x40000000 567c478bd9Sstevel@tonic-gate #define DTRACE_JMPL_MASK 0x81f10000 577c478bd9Sstevel@tonic-gate #define DTRACE_JMPL 0x81c00000 58*a1b5e537Sbmc #define DTRACE_BA_MASK 0xdfc00000 59*a1b5e537Sbmc #define DTRACE_BA 0x10800000 60*a1b5e537Sbmc #define DTRACE_BA_MAX 10 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate extern int dtrace_getupcstack_top(uint64_t *, int, uintptr_t *); 630b38a8bdSahl extern int dtrace_getustackdepth_top(uintptr_t *); 647c478bd9Sstevel@tonic-gate extern ulong_t dtrace_getreg_win(uint_t, uint_t); 657c478bd9Sstevel@tonic-gate extern void dtrace_putreg_win(uint_t, ulong_t); 667c478bd9Sstevel@tonic-gate extern int dtrace_fish(int, int, uintptr_t *); 677c478bd9Sstevel@tonic-gate 687c478bd9Sstevel@tonic-gate /* 697c478bd9Sstevel@tonic-gate * This is similar in principle to getpcstack(), but there are several marked 707c478bd9Sstevel@tonic-gate * differences in implementation: 717c478bd9Sstevel@tonic-gate * 727c478bd9Sstevel@tonic-gate * (a) dtrace_getpcstack() is called from probe context. Thus, the call 737c478bd9Sstevel@tonic-gate * to flush_windows() from getpcstack() is a call to the probe-safe 747c478bd9Sstevel@tonic-gate * equivalent here. 757c478bd9Sstevel@tonic-gate * 767c478bd9Sstevel@tonic-gate * (b) dtrace_getpcstack() is willing to sacrifice some performance to get 777c478bd9Sstevel@tonic-gate * a correct stack. While consumers of getpcstack() are largely 787c478bd9Sstevel@tonic-gate * subsystem-specific in-kernel debugging facilities, DTrace consumers 797c478bd9Sstevel@tonic-gate * are arbitrary user-level analysis tools; dtrace_getpcstack() must 807c478bd9Sstevel@tonic-gate * deliver as correct a stack as possible. Details on the issues 817c478bd9Sstevel@tonic-gate * surrounding stack correctness are found below. 827c478bd9Sstevel@tonic-gate * 830b38a8bdSahl * (c) dtrace_getpcstack() _always_ fills in pcstack_limit pc_t's -- filling 840b38a8bdSahl * in the difference between the stack depth and pcstack_limit with NULLs. 857c478bd9Sstevel@tonic-gate * Due to this behavior dtrace_getpcstack() returns void. 867c478bd9Sstevel@tonic-gate * 877c478bd9Sstevel@tonic-gate * (d) dtrace_getpcstack() takes a third parameter, aframes, that 887c478bd9Sstevel@tonic-gate * denotes the number of _artificial frames_ on the bottom of the 897c478bd9Sstevel@tonic-gate * stack. An artificial frame is one induced by the provider; all 907c478bd9Sstevel@tonic-gate * artificial frames are stripped off before frames are stored to 917c478bd9Sstevel@tonic-gate * pcstack. 927c478bd9Sstevel@tonic-gate * 937c478bd9Sstevel@tonic-gate * (e) dtrace_getpcstack() takes a fourth parameter, pc, that indicates 947c478bd9Sstevel@tonic-gate * an interrupted program counter (if any). This should be a non-NULL 957c478bd9Sstevel@tonic-gate * value if and only if the hit probe is unanchored. (Anchored probes 967c478bd9Sstevel@tonic-gate * don't fire through an interrupt source.) This parameter is used to 977c478bd9Sstevel@tonic-gate * assure (b), above. 987c478bd9Sstevel@tonic-gate */ 997c478bd9Sstevel@tonic-gate void 1007c478bd9Sstevel@tonic-gate dtrace_getpcstack(pc_t *pcstack, int pcstack_limit, int aframes, uint32_t *pc) 1017c478bd9Sstevel@tonic-gate { 1027c478bd9Sstevel@tonic-gate struct frame *fp, *nextfp, *minfp, *stacktop; 1037c478bd9Sstevel@tonic-gate int depth = 0; 1047c478bd9Sstevel@tonic-gate int on_intr, j = 0; 1057c478bd9Sstevel@tonic-gate uint32_t i, r; 1067c478bd9Sstevel@tonic-gate 1077c478bd9Sstevel@tonic-gate fp = (struct frame *)((caddr_t)dtrace_getfp() + STACK_BIAS); 1087c478bd9Sstevel@tonic-gate dtrace_flush_windows(); 1097c478bd9Sstevel@tonic-gate 1107c478bd9Sstevel@tonic-gate if (pc != NULL) { 1117c478bd9Sstevel@tonic-gate /* 1127c478bd9Sstevel@tonic-gate * If we've been passed a non-NULL pc, we need to determine 1137c478bd9Sstevel@tonic-gate * whether or not the specified program counter falls in a leaf 1147c478bd9Sstevel@tonic-gate * function. If it falls within a leaf function, we know that 1157c478bd9Sstevel@tonic-gate * %o7 is valid in its frame (and we can just drive on). If 1167c478bd9Sstevel@tonic-gate * it's a non-leaf, however, we know that %o7 is garbage in the 1177c478bd9Sstevel@tonic-gate * bottom frame. To trim this frame, we simply increment 1187c478bd9Sstevel@tonic-gate * aframes and drop into the stack-walking loop. 1197c478bd9Sstevel@tonic-gate * 1207c478bd9Sstevel@tonic-gate * To quickly determine if the specified program counter is in 1217c478bd9Sstevel@tonic-gate * a leaf function, we exploit the fact that leaf functions 1227c478bd9Sstevel@tonic-gate * tend to be short and non-leaf functions tend to frequently 1237c478bd9Sstevel@tonic-gate * perform operations that are only permitted in a non-leaf 1247c478bd9Sstevel@tonic-gate * function (e.g., using the %i's or %l's; calling a function; 1257c478bd9Sstevel@tonic-gate * performing a restore). We exploit these tendencies by 1267c478bd9Sstevel@tonic-gate * simply scanning forward from the specified %pc -- if we see 1277c478bd9Sstevel@tonic-gate * an operation only permitted in a non-leaf, we know we're in 1287c478bd9Sstevel@tonic-gate * a non-leaf; if we see a retl, we know we're in a leaf. 1297c478bd9Sstevel@tonic-gate * Fortunately, one need not perform anywhere near full 1307c478bd9Sstevel@tonic-gate * disassembly to effectively determine the former: determining 1317c478bd9Sstevel@tonic-gate * that an instruction is a format-3 instruction and decoding 1327c478bd9Sstevel@tonic-gate * its rd and rs1 fields, for example, requires very little 1337c478bd9Sstevel@tonic-gate * manipulation. Overall, this method of leaf determination 1347c478bd9Sstevel@tonic-gate * performs quite well: on average, we only examine between 1357c478bd9Sstevel@tonic-gate * 1.5 and 2.5 instructions before making the determination. 1367c478bd9Sstevel@tonic-gate * (Outliers do exist, however; of note is the non-leaf 1377c478bd9Sstevel@tonic-gate * function ip_sioctl_not_ours() which -- as of this writing -- 1387c478bd9Sstevel@tonic-gate * has a whopping 455 straight instructions that manipulate 1397c478bd9Sstevel@tonic-gate * only %g's and %o's.) 1407c478bd9Sstevel@tonic-gate */ 141*a1b5e537Sbmc int delay = 0, branches = 0, taken = 0; 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate if (depth < pcstack_limit) 1447c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)pc; 1457c478bd9Sstevel@tonic-gate 146*a1b5e537Sbmc /* 147*a1b5e537Sbmc * Our heuristic is exactly that -- a heuristic -- and there 148*a1b5e537Sbmc * exists a possibility that we could be either be vectored 149*a1b5e537Sbmc * off into the weeds (by following a bogus branch) or could 150*a1b5e537Sbmc * wander off the end of the function and off the end of a 151*a1b5e537Sbmc * text mapping (by not following a conditional branch at the 152*a1b5e537Sbmc * end of the function that is effectively always taken). So 153*a1b5e537Sbmc * as a precautionary measure, we set the NOFAULT flag. 154*a1b5e537Sbmc */ 155*a1b5e537Sbmc DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 156*a1b5e537Sbmc 1577c478bd9Sstevel@tonic-gate for (;;) { 1587c478bd9Sstevel@tonic-gate i = pc[j++]; 1597c478bd9Sstevel@tonic-gate 1607c478bd9Sstevel@tonic-gate if ((i & DTRACE_FMT3OP3_MASK) == DTRACE_FMT3OP3) { 1617c478bd9Sstevel@tonic-gate /* 1627c478bd9Sstevel@tonic-gate * This is a format-3 instruction. We can 1637c478bd9Sstevel@tonic-gate * look at rd and rs1. 1647c478bd9Sstevel@tonic-gate */ 1657c478bd9Sstevel@tonic-gate r = (i >> DTRACE_FMT3RS1_SHIFT) & DTRACE_RMASK; 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate if (r >= DTRACE_REG_L0) 1687c478bd9Sstevel@tonic-gate goto nonleaf; 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate r = (i >> DTRACE_FMT3RD_SHIFT) & DTRACE_RMASK; 1717c478bd9Sstevel@tonic-gate 1727c478bd9Sstevel@tonic-gate if (r >= DTRACE_REG_L0) 1737c478bd9Sstevel@tonic-gate goto nonleaf; 1747c478bd9Sstevel@tonic-gate 1757c478bd9Sstevel@tonic-gate if ((i & DTRACE_JMPL_MASK) == DTRACE_JMPL) { 1767c478bd9Sstevel@tonic-gate delay = 1; 1777c478bd9Sstevel@tonic-gate continue; 1787c478bd9Sstevel@tonic-gate } 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate /* 1817c478bd9Sstevel@tonic-gate * If we see explicit manipulation with %o7 1827c478bd9Sstevel@tonic-gate * as a destination register, we know that 1837c478bd9Sstevel@tonic-gate * %o7 is likely bogus -- and we treat this 1847c478bd9Sstevel@tonic-gate * function as a non-leaf. 1857c478bd9Sstevel@tonic-gate */ 1867c478bd9Sstevel@tonic-gate if (r == DTRACE_REG_O7) { 1877c478bd9Sstevel@tonic-gate if (delay) 1887c478bd9Sstevel@tonic-gate goto leaf; 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate i &= DTRACE_JMPL_MASK; 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate if (i == DTRACE_JMPL) { 1937c478bd9Sstevel@tonic-gate delay = 1; 1947c478bd9Sstevel@tonic-gate continue; 1957c478bd9Sstevel@tonic-gate } 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate goto nonleaf; 1987c478bd9Sstevel@tonic-gate } 1997c478bd9Sstevel@tonic-gate } else { 2007c478bd9Sstevel@tonic-gate /* 2017c478bd9Sstevel@tonic-gate * If this is a call, it may or may not be 2027c478bd9Sstevel@tonic-gate * a leaf; we need to check the delay slot. 2037c478bd9Sstevel@tonic-gate */ 2047c478bd9Sstevel@tonic-gate if ((i & DTRACE_CALL_MASK) == DTRACE_CALL) { 2057c478bd9Sstevel@tonic-gate delay = 1; 2067c478bd9Sstevel@tonic-gate continue; 2077c478bd9Sstevel@tonic-gate } 2087c478bd9Sstevel@tonic-gate 2097c478bd9Sstevel@tonic-gate /* 2107c478bd9Sstevel@tonic-gate * If we see a ret it's not a leaf; if we 2117c478bd9Sstevel@tonic-gate * see a retl, it is a leaf. 2127c478bd9Sstevel@tonic-gate */ 2137c478bd9Sstevel@tonic-gate if (i == DTRACE_RET) 2147c478bd9Sstevel@tonic-gate goto nonleaf; 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate if (i == DTRACE_RETL) 2177c478bd9Sstevel@tonic-gate goto leaf; 2187c478bd9Sstevel@tonic-gate 219*a1b5e537Sbmc /* 220*a1b5e537Sbmc * If this is a ba (annulled or not), then we 221*a1b5e537Sbmc * need to actually follow the branch. No, we 222*a1b5e537Sbmc * don't look at the delay slot -- hopefully 223*a1b5e537Sbmc * anything that can be gleaned from the delay 224*a1b5e537Sbmc * slot can also be gleaned from the branch 225*a1b5e537Sbmc * target. To prevent ourselves from iterating 226*a1b5e537Sbmc * infinitely, we clamp the number of branches 227*a1b5e537Sbmc * that we'll follow, and we refuse to follow 228*a1b5e537Sbmc * the same branch twice consecutively. In 229*a1b5e537Sbmc * both cases, we abort by deciding that we're 230*a1b5e537Sbmc * looking at a leaf. While in theory this 231*a1b5e537Sbmc * could be wrong (we could be in the middle of 232*a1b5e537Sbmc * a loop in a non-leaf that ends with a ba and 233*a1b5e537Sbmc * only manipulates outputs and globals in the 234*a1b5e537Sbmc * body of the loop -- therefore leading us to 235*a1b5e537Sbmc * the wrong conclusion), this doesn't seem to 236*a1b5e537Sbmc * crop up in practice. (Or rather, this 237*a1b5e537Sbmc * condition could not be deliberately induced, 238*a1b5e537Sbmc * despite concerted effort.) 239*a1b5e537Sbmc */ 240*a1b5e537Sbmc if ((i & DTRACE_BA_MASK) == DTRACE_BA) { 241*a1b5e537Sbmc if (++branches == DTRACE_BA_MAX || 242*a1b5e537Sbmc taken == j) 243*a1b5e537Sbmc goto nonleaf; 244*a1b5e537Sbmc 245*a1b5e537Sbmc taken = j; 246*a1b5e537Sbmc j += ((int)(i << DTRACE_DISP22_SHIFT) >> 247*a1b5e537Sbmc DTRACE_DISP22_SHIFT) - 1; 248*a1b5e537Sbmc continue; 249*a1b5e537Sbmc } 250*a1b5e537Sbmc 2517c478bd9Sstevel@tonic-gate /* 2527c478bd9Sstevel@tonic-gate * Finally, if it's a save, it should be 2537c478bd9Sstevel@tonic-gate * treated as a leaf; if it's a restore it 2547c478bd9Sstevel@tonic-gate * should not be treated as a leaf. 2557c478bd9Sstevel@tonic-gate */ 2567c478bd9Sstevel@tonic-gate if ((i & DTRACE_SAVE_MASK) == DTRACE_SAVE) 2577c478bd9Sstevel@tonic-gate goto leaf; 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate if ((i & DTRACE_SAVE_MASK) == DTRACE_RESTORE) 2607c478bd9Sstevel@tonic-gate goto nonleaf; 2617c478bd9Sstevel@tonic-gate } 2627c478bd9Sstevel@tonic-gate 2637c478bd9Sstevel@tonic-gate if (delay) { 2647c478bd9Sstevel@tonic-gate /* 2657c478bd9Sstevel@tonic-gate * If this was a delay slot instruction and 2667c478bd9Sstevel@tonic-gate * we didn't pick it up elsewhere, this is a 2677c478bd9Sstevel@tonic-gate * non-leaf. 2687c478bd9Sstevel@tonic-gate */ 2697c478bd9Sstevel@tonic-gate goto nonleaf; 2707c478bd9Sstevel@tonic-gate } 2717c478bd9Sstevel@tonic-gate } 2727c478bd9Sstevel@tonic-gate nonleaf: 2737c478bd9Sstevel@tonic-gate aframes++; 2747c478bd9Sstevel@tonic-gate leaf: 275*a1b5e537Sbmc DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 2767c478bd9Sstevel@tonic-gate } 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate if ((on_intr = CPU_ON_INTR(CPU)) != 0) 2797c478bd9Sstevel@tonic-gate stacktop = (struct frame *)(CPU->cpu_intr_stack + SA(MINFRAME)); 2807c478bd9Sstevel@tonic-gate else 2817c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 2827c478bd9Sstevel@tonic-gate minfp = fp; 2837c478bd9Sstevel@tonic-gate 2847c478bd9Sstevel@tonic-gate while (depth < pcstack_limit) { 2857c478bd9Sstevel@tonic-gate nextfp = (struct frame *)((caddr_t)fp->fr_savfp + STACK_BIAS); 2867c478bd9Sstevel@tonic-gate if (nextfp <= minfp || nextfp >= stacktop) { 2877c478bd9Sstevel@tonic-gate if (!on_intr && nextfp == stacktop && aframes != 0) { 2887c478bd9Sstevel@tonic-gate /* 2897c478bd9Sstevel@tonic-gate * If we are exactly at the top of the stack 2907c478bd9Sstevel@tonic-gate * with a non-zero number of artificial frames, 2917c478bd9Sstevel@tonic-gate * it must be that the stack is filled with 2927c478bd9Sstevel@tonic-gate * nothing _but_ artificial frames. In this 2937c478bd9Sstevel@tonic-gate * case, we assert that this is so, zero 2947c478bd9Sstevel@tonic-gate * pcstack, and return. 2957c478bd9Sstevel@tonic-gate */ 2967c478bd9Sstevel@tonic-gate ASSERT(aframes == 1); 2977c478bd9Sstevel@tonic-gate ASSERT(depth == 0); 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate while (depth < pcstack_limit) 3007c478bd9Sstevel@tonic-gate pcstack[depth++] = NULL; 3017c478bd9Sstevel@tonic-gate return; 3027c478bd9Sstevel@tonic-gate } 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate if (on_intr) { 3057c478bd9Sstevel@tonic-gate /* 3067c478bd9Sstevel@tonic-gate * Hop from interrupt stack to thread stack. 3077c478bd9Sstevel@tonic-gate */ 3087c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 3097c478bd9Sstevel@tonic-gate minfp = (struct frame *)curthread->t_stkbase; 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate on_intr = 0; 3127c478bd9Sstevel@tonic-gate 3137c478bd9Sstevel@tonic-gate if (nextfp > minfp && nextfp < stacktop) 3147c478bd9Sstevel@tonic-gate continue; 3157c478bd9Sstevel@tonic-gate } else { 3167c478bd9Sstevel@tonic-gate /* 3177c478bd9Sstevel@tonic-gate * High-level interrupts may occur when %sp is 3187c478bd9Sstevel@tonic-gate * not necessarily contained in the stack 3197c478bd9Sstevel@tonic-gate * bounds implied by %g7 -- interrupt thread 3207c478bd9Sstevel@tonic-gate * management runs with %pil at DISP_LEVEL, 3217c478bd9Sstevel@tonic-gate * and high-level interrupts may thus occur 3227c478bd9Sstevel@tonic-gate * in windows when %sp and %g7 are not self- 3237c478bd9Sstevel@tonic-gate * consistent. If we call dtrace_getpcstack() 3247c478bd9Sstevel@tonic-gate * from a high-level interrupt that has occurred 3257c478bd9Sstevel@tonic-gate * in such a window, we will fail the above test 3267c478bd9Sstevel@tonic-gate * of nextfp against minfp/stacktop. If the 3277c478bd9Sstevel@tonic-gate * high-level interrupt has in turn interrupted 3287c478bd9Sstevel@tonic-gate * a non-passivated interrupt thread, we 3297c478bd9Sstevel@tonic-gate * will execute the below code with non-zero 3307c478bd9Sstevel@tonic-gate * aframes. We therefore want to assert that 3317c478bd9Sstevel@tonic-gate * aframes is zero _or_ we are in a high-level 3327c478bd9Sstevel@tonic-gate * interrupt -- but because cpu_intr_actv is 3337c478bd9Sstevel@tonic-gate * updated with high-level interrupts enabled, 3347c478bd9Sstevel@tonic-gate * we must reduce this to only asserting that 3357c478bd9Sstevel@tonic-gate * %pil is greater than DISP_LEVEL. 3367c478bd9Sstevel@tonic-gate */ 3377c478bd9Sstevel@tonic-gate ASSERT(aframes == 0 || 3387c478bd9Sstevel@tonic-gate dtrace_getipl() > DISP_LEVEL); 3397c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)fp->fr_savpc; 3407c478bd9Sstevel@tonic-gate } 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate while (depth < pcstack_limit) 3437c478bd9Sstevel@tonic-gate pcstack[depth++] = NULL; 3447c478bd9Sstevel@tonic-gate return; 3457c478bd9Sstevel@tonic-gate } 3467c478bd9Sstevel@tonic-gate 3477c478bd9Sstevel@tonic-gate if (aframes > 0) { 3487c478bd9Sstevel@tonic-gate aframes--; 3497c478bd9Sstevel@tonic-gate } else { 3507c478bd9Sstevel@tonic-gate pcstack[depth++] = (pc_t)fp->fr_savpc; 3517c478bd9Sstevel@tonic-gate } 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate fp = nextfp; 3547c478bd9Sstevel@tonic-gate minfp = fp; 3557c478bd9Sstevel@tonic-gate } 3567c478bd9Sstevel@tonic-gate } 3577c478bd9Sstevel@tonic-gate 3580b38a8bdSahl static int 3590b38a8bdSahl dtrace_getustack_common(uint64_t *pcstack, int pcstack_limit, uintptr_t sp) 3600b38a8bdSahl { 3610b38a8bdSahl proc_t *p = curproc; 3620b38a8bdSahl int ret = 0; 3630b38a8bdSahl 3640b38a8bdSahl ASSERT(pcstack == NULL || pcstack_limit > 0); 3650b38a8bdSahl 3660b38a8bdSahl if (p->p_model == DATAMODEL_NATIVE) { 3670b38a8bdSahl for (;;) { 3680b38a8bdSahl struct frame *fr = (struct frame *)(sp + STACK_BIAS); 3690b38a8bdSahl uintptr_t pc; 3700b38a8bdSahl 3710b38a8bdSahl if (sp == 0 || fr == NULL || 3720b38a8bdSahl !IS_P2ALIGNED((uintptr_t)fr, STACK_ALIGN)) 3730b38a8bdSahl break; 3740b38a8bdSahl 3750b38a8bdSahl pc = dtrace_fulword(&fr->fr_savpc); 3760b38a8bdSahl sp = dtrace_fulword(&fr->fr_savfp); 3770b38a8bdSahl 3780b38a8bdSahl if (pc == 0) 3790b38a8bdSahl break; 3800b38a8bdSahl 3810b38a8bdSahl ret++; 3820b38a8bdSahl 3830b38a8bdSahl if (pcstack != NULL) { 3840b38a8bdSahl *pcstack++ = pc; 3850b38a8bdSahl pcstack_limit--; 3860b38a8bdSahl if (pcstack_limit == 0) 3870b38a8bdSahl break; 3880b38a8bdSahl } 3890b38a8bdSahl } 3900b38a8bdSahl } else { 3910b38a8bdSahl for (;;) { 3920b38a8bdSahl struct frame32 *fr = (struct frame32 *)sp; 3930b38a8bdSahl uint32_t pc; 3940b38a8bdSahl 3950b38a8bdSahl if (sp == 0 || 3960b38a8bdSahl !IS_P2ALIGNED((uintptr_t)fr, STACK_ALIGN32)) 3970b38a8bdSahl break; 3980b38a8bdSahl 3990b38a8bdSahl pc = dtrace_fuword32(&fr->fr_savpc); 4000b38a8bdSahl sp = dtrace_fuword32(&fr->fr_savfp); 4010b38a8bdSahl 4020b38a8bdSahl if (pc == 0) 4030b38a8bdSahl break; 4040b38a8bdSahl 4050b38a8bdSahl ret++; 4060b38a8bdSahl 4070b38a8bdSahl if (pcstack != NULL) { 4080b38a8bdSahl *pcstack++ = pc; 4090b38a8bdSahl pcstack_limit--; 4100b38a8bdSahl if (pcstack_limit == 0) 4110b38a8bdSahl break; 4120b38a8bdSahl } 4130b38a8bdSahl } 4140b38a8bdSahl } 4150b38a8bdSahl 4160b38a8bdSahl return (ret); 4170b38a8bdSahl } 4180b38a8bdSahl 4197c478bd9Sstevel@tonic-gate void 4207c478bd9Sstevel@tonic-gate dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit) 4217c478bd9Sstevel@tonic-gate { 4227c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread); 4230b38a8bdSahl proc_t *p = curproc; 4247c478bd9Sstevel@tonic-gate struct regs *rp; 4257c478bd9Sstevel@tonic-gate uintptr_t sp; 4267c478bd9Sstevel@tonic-gate int n; 4277c478bd9Sstevel@tonic-gate 4280b38a8bdSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL) 4297c478bd9Sstevel@tonic-gate return; 4307c478bd9Sstevel@tonic-gate 4317c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 4327c478bd9Sstevel@tonic-gate return; 4337c478bd9Sstevel@tonic-gate 4347c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)p->p_pid; 4357c478bd9Sstevel@tonic-gate pcstack_limit--; 4367c478bd9Sstevel@tonic-gate 4377c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 4387c478bd9Sstevel@tonic-gate return; 4397c478bd9Sstevel@tonic-gate 4407c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)rp->r_pc; 4417c478bd9Sstevel@tonic-gate pcstack_limit--; 4427c478bd9Sstevel@tonic-gate 4437c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 4447c478bd9Sstevel@tonic-gate return; 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) { 4477c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)rp->r_o7; 4487c478bd9Sstevel@tonic-gate pcstack_limit--; 4497c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 4507c478bd9Sstevel@tonic-gate return; 4517c478bd9Sstevel@tonic-gate } 4527c478bd9Sstevel@tonic-gate 4537c478bd9Sstevel@tonic-gate sp = rp->r_sp; 4547c478bd9Sstevel@tonic-gate 4557c478bd9Sstevel@tonic-gate n = dtrace_getupcstack_top(pcstack, pcstack_limit, &sp); 4567c478bd9Sstevel@tonic-gate ASSERT(n >= 0); 4577c478bd9Sstevel@tonic-gate ASSERT(n <= pcstack_limit); 4587c478bd9Sstevel@tonic-gate 4597c478bd9Sstevel@tonic-gate pcstack += n; 4607c478bd9Sstevel@tonic-gate pcstack_limit -= n; 4610b38a8bdSahl if (pcstack_limit <= 0) 4620b38a8bdSahl return; 4637c478bd9Sstevel@tonic-gate 4640b38a8bdSahl n = dtrace_getustack_common(pcstack, pcstack_limit, sp); 4650b38a8bdSahl ASSERT(n >= 0); 4660b38a8bdSahl ASSERT(n <= pcstack_limit); 4677c478bd9Sstevel@tonic-gate 4680b38a8bdSahl pcstack += n; 4690b38a8bdSahl pcstack_limit -= n; 4707c478bd9Sstevel@tonic-gate 4710b38a8bdSahl while (pcstack_limit-- > 0) 4720b38a8bdSahl *pcstack++ = NULL; 4730b38a8bdSahl } 4747c478bd9Sstevel@tonic-gate 4750b38a8bdSahl int 4760b38a8bdSahl dtrace_getustackdepth(void) 4770b38a8bdSahl { 4780b38a8bdSahl klwp_t *lwp = ttolwp(curthread); 4790b38a8bdSahl proc_t *p = curproc; 4800b38a8bdSahl struct regs *rp; 4810b38a8bdSahl uintptr_t sp; 4820b38a8bdSahl int n = 1; 4837c478bd9Sstevel@tonic-gate 4840b38a8bdSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL) 4850b38a8bdSahl return (0); 4867c478bd9Sstevel@tonic-gate 4870b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAULT)) 4880b38a8bdSahl return (-1); 4897c478bd9Sstevel@tonic-gate 4900b38a8bdSahl if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) 4910b38a8bdSahl n++; 4927c478bd9Sstevel@tonic-gate 4930b38a8bdSahl sp = rp->r_sp; 4947c478bd9Sstevel@tonic-gate 4950b38a8bdSahl n += dtrace_getustackdepth_top(&sp); 4960b38a8bdSahl n += dtrace_getustack_common(NULL, 0, sp); 4970b38a8bdSahl 4980b38a8bdSahl return (n); 4997c478bd9Sstevel@tonic-gate } 5007c478bd9Sstevel@tonic-gate 5017c478bd9Sstevel@tonic-gate void 5027c478bd9Sstevel@tonic-gate dtrace_getufpstack(uint64_t *pcstack, uint64_t *fpstack, int pcstack_limit) 5037c478bd9Sstevel@tonic-gate { 5047c478bd9Sstevel@tonic-gate klwp_t *lwp = ttolwp(curthread); 5057c478bd9Sstevel@tonic-gate proc_t *p = ttoproc(curthread); 5067c478bd9Sstevel@tonic-gate struct regs *rp; 5077c478bd9Sstevel@tonic-gate uintptr_t sp; 5087c478bd9Sstevel@tonic-gate 5090b38a8bdSahl if (lwp == NULL || p == NULL || (rp = lwp->lwp_regs) == NULL) 5107c478bd9Sstevel@tonic-gate return; 5117c478bd9Sstevel@tonic-gate 5127c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 5137c478bd9Sstevel@tonic-gate return; 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)p->p_pid; 5167c478bd9Sstevel@tonic-gate pcstack_limit--; 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 5197c478bd9Sstevel@tonic-gate return; 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_ENTRY)) { 5227c478bd9Sstevel@tonic-gate *fpstack++ = 0; 5237c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)rp->r_pc; 5247c478bd9Sstevel@tonic-gate pcstack_limit--; 5257c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 5267c478bd9Sstevel@tonic-gate return; 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate *fpstack++ = (uint64_t)rp->r_sp; 5297c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)rp->r_o7; 5307c478bd9Sstevel@tonic-gate pcstack_limit--; 5317c478bd9Sstevel@tonic-gate } else { 5327c478bd9Sstevel@tonic-gate *fpstack++ = (uint64_t)rp->r_sp; 5337c478bd9Sstevel@tonic-gate *pcstack++ = (uint64_t)rp->r_pc; 5347c478bd9Sstevel@tonic-gate pcstack_limit--; 5357c478bd9Sstevel@tonic-gate } 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate if (pcstack_limit <= 0) 5387c478bd9Sstevel@tonic-gate return; 5397c478bd9Sstevel@tonic-gate 5407c478bd9Sstevel@tonic-gate sp = rp->r_sp; 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate dtrace_flush_user_windows(); 5437c478bd9Sstevel@tonic-gate 5447c478bd9Sstevel@tonic-gate if (p->p_model == DATAMODEL_NATIVE) { 5457c478bd9Sstevel@tonic-gate while (pcstack_limit > 0) { 5467c478bd9Sstevel@tonic-gate struct frame *fr = (struct frame *)(sp + STACK_BIAS); 5477c478bd9Sstevel@tonic-gate uintptr_t pc; 5487c478bd9Sstevel@tonic-gate 5497c478bd9Sstevel@tonic-gate if (sp == 0 || fr == NULL || 5507c478bd9Sstevel@tonic-gate ((uintptr_t)&fr->fr_savpc & 3) != 0 || 5517c478bd9Sstevel@tonic-gate ((uintptr_t)&fr->fr_savfp & 3) != 0) 5527c478bd9Sstevel@tonic-gate break; 5537c478bd9Sstevel@tonic-gate 5547c478bd9Sstevel@tonic-gate pc = dtrace_fulword(&fr->fr_savpc); 5557c478bd9Sstevel@tonic-gate sp = dtrace_fulword(&fr->fr_savfp); 5567c478bd9Sstevel@tonic-gate 5577c478bd9Sstevel@tonic-gate if (pc == 0) 5587c478bd9Sstevel@tonic-gate break; 5597c478bd9Sstevel@tonic-gate 5607c478bd9Sstevel@tonic-gate *fpstack++ = sp; 5617c478bd9Sstevel@tonic-gate *pcstack++ = pc; 5627c478bd9Sstevel@tonic-gate pcstack_limit--; 5637c478bd9Sstevel@tonic-gate } 5647c478bd9Sstevel@tonic-gate } else { 5657c478bd9Sstevel@tonic-gate while (pcstack_limit > 0) { 5667c478bd9Sstevel@tonic-gate struct frame32 *fr = (struct frame32 *)sp; 5677c478bd9Sstevel@tonic-gate uint32_t pc; 5687c478bd9Sstevel@tonic-gate 5697c478bd9Sstevel@tonic-gate if (sp == 0 || 5707c478bd9Sstevel@tonic-gate ((uintptr_t)&fr->fr_savpc & 3) != 0 || 5717c478bd9Sstevel@tonic-gate ((uintptr_t)&fr->fr_savfp & 3) != 0) 5727c478bd9Sstevel@tonic-gate break; 5737c478bd9Sstevel@tonic-gate 5747c478bd9Sstevel@tonic-gate pc = dtrace_fuword32(&fr->fr_savpc); 5757c478bd9Sstevel@tonic-gate sp = dtrace_fuword32(&fr->fr_savfp); 5767c478bd9Sstevel@tonic-gate 5770b38a8bdSahl if (pc == 0) 5780b38a8bdSahl break; 5790b38a8bdSahl 5807c478bd9Sstevel@tonic-gate *fpstack++ = sp; 5817c478bd9Sstevel@tonic-gate *pcstack++ = pc; 5827c478bd9Sstevel@tonic-gate pcstack_limit--; 5837c478bd9Sstevel@tonic-gate } 5847c478bd9Sstevel@tonic-gate } 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate while (pcstack_limit-- > 0) 5877c478bd9Sstevel@tonic-gate *pcstack++ = NULL; 5887c478bd9Sstevel@tonic-gate } 5897c478bd9Sstevel@tonic-gate 5907c478bd9Sstevel@tonic-gate uint64_t 5917c478bd9Sstevel@tonic-gate dtrace_getarg(int arg, int aframes) 5927c478bd9Sstevel@tonic-gate { 5937c478bd9Sstevel@tonic-gate uintptr_t val; 5947c478bd9Sstevel@tonic-gate struct frame *fp; 5957c478bd9Sstevel@tonic-gate uint64_t rval; 5967c478bd9Sstevel@tonic-gate 5977c478bd9Sstevel@tonic-gate /* 5987c478bd9Sstevel@tonic-gate * Account for the fact that dtrace_getarg() consumes an additional 5997c478bd9Sstevel@tonic-gate * stack frame. 6007c478bd9Sstevel@tonic-gate */ 6017c478bd9Sstevel@tonic-gate aframes++; 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate if (arg < 6) { 6047c478bd9Sstevel@tonic-gate if (dtrace_fish(aframes, DTRACE_REG_I0 + arg, &val) == 0) 6057c478bd9Sstevel@tonic-gate return (val); 6067c478bd9Sstevel@tonic-gate } else { 6077c478bd9Sstevel@tonic-gate if (dtrace_fish(aframes, DTRACE_REG_I6, &val) == 0) { 6087c478bd9Sstevel@tonic-gate /* 6097c478bd9Sstevel@tonic-gate * We have a stack pointer; grab the argument. 6107c478bd9Sstevel@tonic-gate */ 6117c478bd9Sstevel@tonic-gate fp = (struct frame *)(val + STACK_BIAS); 6127c478bd9Sstevel@tonic-gate 6137c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 6147c478bd9Sstevel@tonic-gate rval = fp->fr_argx[arg - 6]; 6157c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 6167c478bd9Sstevel@tonic-gate 6177c478bd9Sstevel@tonic-gate return (rval); 6187c478bd9Sstevel@tonic-gate } 6197c478bd9Sstevel@tonic-gate } 6207c478bd9Sstevel@tonic-gate 6217c478bd9Sstevel@tonic-gate /* 6227c478bd9Sstevel@tonic-gate * There are other ways to do this. But the slow, painful way works 6237c478bd9Sstevel@tonic-gate * just fine. Because this requires some loads, we need to set 6247c478bd9Sstevel@tonic-gate * CPU_DTRACE_NOFAULT to protect against looking for an argument that 6257c478bd9Sstevel@tonic-gate * isn't there. 6267c478bd9Sstevel@tonic-gate */ 6277c478bd9Sstevel@tonic-gate fp = (struct frame *)((caddr_t)dtrace_getfp() + STACK_BIAS); 6287c478bd9Sstevel@tonic-gate dtrace_flush_windows(); 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 6317c478bd9Sstevel@tonic-gate 6327c478bd9Sstevel@tonic-gate for (aframes -= 1; aframes; aframes--) 6337c478bd9Sstevel@tonic-gate fp = (struct frame *)((caddr_t)fp->fr_savfp + STACK_BIAS); 6347c478bd9Sstevel@tonic-gate 6357c478bd9Sstevel@tonic-gate if (arg < 6) { 6367c478bd9Sstevel@tonic-gate rval = fp->fr_arg[arg]; 6377c478bd9Sstevel@tonic-gate } else { 6387c478bd9Sstevel@tonic-gate fp = (struct frame *)((caddr_t)fp->fr_savfp + STACK_BIAS); 6397c478bd9Sstevel@tonic-gate rval = fp->fr_argx[arg - 6]; 6407c478bd9Sstevel@tonic-gate } 6417c478bd9Sstevel@tonic-gate 6427c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 6437c478bd9Sstevel@tonic-gate 6447c478bd9Sstevel@tonic-gate return (rval); 6457c478bd9Sstevel@tonic-gate } 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate int 6487c478bd9Sstevel@tonic-gate dtrace_getstackdepth(int aframes) 6497c478bd9Sstevel@tonic-gate { 6507c478bd9Sstevel@tonic-gate struct frame *fp, *nextfp, *minfp, *stacktop; 6517c478bd9Sstevel@tonic-gate int depth = 0; 6527c478bd9Sstevel@tonic-gate int on_intr; 6537c478bd9Sstevel@tonic-gate 6547c478bd9Sstevel@tonic-gate fp = (struct frame *)((caddr_t)dtrace_getfp() + STACK_BIAS); 6557c478bd9Sstevel@tonic-gate dtrace_flush_windows(); 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate if ((on_intr = CPU_ON_INTR(CPU)) != 0) 6587c478bd9Sstevel@tonic-gate stacktop = (struct frame *)CPU->cpu_intr_stack + SA(MINFRAME); 6597c478bd9Sstevel@tonic-gate else 6607c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 6617c478bd9Sstevel@tonic-gate minfp = fp; 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate for (;;) { 6647c478bd9Sstevel@tonic-gate nextfp = (struct frame *)((caddr_t)fp->fr_savfp + STACK_BIAS); 6657c478bd9Sstevel@tonic-gate if (nextfp <= minfp || nextfp >= stacktop) { 6667c478bd9Sstevel@tonic-gate if (on_intr) { 6677c478bd9Sstevel@tonic-gate /* 6687c478bd9Sstevel@tonic-gate * Hop from interrupt stack to thread stack. 6697c478bd9Sstevel@tonic-gate */ 6707c478bd9Sstevel@tonic-gate stacktop = (struct frame *)curthread->t_stk; 6717c478bd9Sstevel@tonic-gate minfp = (struct frame *)curthread->t_stkbase; 6727c478bd9Sstevel@tonic-gate on_intr = 0; 6737c478bd9Sstevel@tonic-gate continue; 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate return (++depth); 6777c478bd9Sstevel@tonic-gate } 6787c478bd9Sstevel@tonic-gate 6797c478bd9Sstevel@tonic-gate if (aframes > 0) { 6807c478bd9Sstevel@tonic-gate aframes--; 6817c478bd9Sstevel@tonic-gate } else { 6827c478bd9Sstevel@tonic-gate depth++; 6837c478bd9Sstevel@tonic-gate } 6847c478bd9Sstevel@tonic-gate 6857c478bd9Sstevel@tonic-gate fp = nextfp; 6867c478bd9Sstevel@tonic-gate minfp = fp; 6877c478bd9Sstevel@tonic-gate } 6887c478bd9Sstevel@tonic-gate } 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate /* 6917c478bd9Sstevel@tonic-gate * This uses the same register numbering scheme as in sys/procfs_isa.h. 6927c478bd9Sstevel@tonic-gate */ 6937c478bd9Sstevel@tonic-gate ulong_t 6947c478bd9Sstevel@tonic-gate dtrace_getreg(struct regs *rp, uint_t reg) 6957c478bd9Sstevel@tonic-gate { 6967c478bd9Sstevel@tonic-gate ulong_t value; 6977c478bd9Sstevel@tonic-gate uintptr_t fp; 6987c478bd9Sstevel@tonic-gate struct machpcb *mpcb; 6997c478bd9Sstevel@tonic-gate 7007c478bd9Sstevel@tonic-gate if (reg == R_G0) 7017c478bd9Sstevel@tonic-gate return (0); 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate if (reg <= R_G7) 7047c478bd9Sstevel@tonic-gate return ((&rp->r_g1)[reg - 1]); 7057c478bd9Sstevel@tonic-gate 7067c478bd9Sstevel@tonic-gate if (reg > R_I7) { 7077c478bd9Sstevel@tonic-gate switch (reg) { 7087c478bd9Sstevel@tonic-gate case R_CCR: 7097c478bd9Sstevel@tonic-gate return ((rp->r_tstate >> TSTATE_CCR_SHIFT) & 7107c478bd9Sstevel@tonic-gate TSTATE_CCR_MASK); 7117c478bd9Sstevel@tonic-gate case R_PC: 7127c478bd9Sstevel@tonic-gate return (rp->r_pc); 7137c478bd9Sstevel@tonic-gate case R_nPC: 7147c478bd9Sstevel@tonic-gate return (rp->r_npc); 7157c478bd9Sstevel@tonic-gate case R_Y: 7167c478bd9Sstevel@tonic-gate return (rp->r_y); 7177c478bd9Sstevel@tonic-gate case R_ASI: 7187c478bd9Sstevel@tonic-gate return ((rp->r_tstate >> TSTATE_ASI_SHIFT) & 7197c478bd9Sstevel@tonic-gate TSTATE_ASI_MASK); 7207c478bd9Sstevel@tonic-gate case R_FPRS: 7217c478bd9Sstevel@tonic-gate return (dtrace_getfprs()); 7227c478bd9Sstevel@tonic-gate default: 7237c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP); 7247c478bd9Sstevel@tonic-gate return (0); 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate } 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate /* 7297c478bd9Sstevel@tonic-gate * We reach go to the fake restore case if the probe we hit was a pid 7307c478bd9Sstevel@tonic-gate * return probe on a restore instruction. We partially emulate the 7317c478bd9Sstevel@tonic-gate * restore in the kernel and then execute a simple restore 7327c478bd9Sstevel@tonic-gate * instruction that we've secreted away to do the actual register 7337c478bd9Sstevel@tonic-gate * window manipulation. We need to go one register window further 7347c478bd9Sstevel@tonic-gate * down to get at the %ls, and %is and we need to treat %os like %is 7357c478bd9Sstevel@tonic-gate * to pull them out of the topmost user frame. 7367c478bd9Sstevel@tonic-gate */ 7377c478bd9Sstevel@tonic-gate if (DTRACE_CPUFLAG_ISSET(CPU_DTRACE_FAKERESTORE)) { 7387c478bd9Sstevel@tonic-gate if (reg > R_O7) 7397c478bd9Sstevel@tonic-gate goto fake_restore; 7407c478bd9Sstevel@tonic-gate else 7417c478bd9Sstevel@tonic-gate reg += R_I0 - R_O0; 7427c478bd9Sstevel@tonic-gate 7437c478bd9Sstevel@tonic-gate } else if (reg <= R_O7) { 7447c478bd9Sstevel@tonic-gate return ((&rp->r_g1)[reg - 1]); 7457c478bd9Sstevel@tonic-gate } 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate if (dtrace_getotherwin() > 0) 7487c478bd9Sstevel@tonic-gate return (dtrace_getreg_win(reg, 1)); 7497c478bd9Sstevel@tonic-gate 7507c478bd9Sstevel@tonic-gate mpcb = (struct machpcb *)((caddr_t)rp - REGOFF); 7517c478bd9Sstevel@tonic-gate 7527c478bd9Sstevel@tonic-gate if (curproc->p_model == DATAMODEL_NATIVE) { 7537c478bd9Sstevel@tonic-gate struct frame *fr = (void *)(rp->r_sp + STACK_BIAS); 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate if (mpcb->mpcb_wbcnt > 0) { 7567c478bd9Sstevel@tonic-gate struct rwindow *rwin = (void *)mpcb->mpcb_wbuf; 7577c478bd9Sstevel@tonic-gate int i = mpcb->mpcb_wbcnt; 7587c478bd9Sstevel@tonic-gate do { 7597c478bd9Sstevel@tonic-gate i--; 7607c478bd9Sstevel@tonic-gate if ((long)mpcb->mpcb_spbuf[i] == rp->r_sp) 7617c478bd9Sstevel@tonic-gate return (rwin[i].rw_local[reg - 16]); 7627c478bd9Sstevel@tonic-gate } while (i > 0); 7637c478bd9Sstevel@tonic-gate } 7647c478bd9Sstevel@tonic-gate 7657c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 7667c478bd9Sstevel@tonic-gate value = dtrace_fulword(&fr->fr_local[reg - 16]); 7677c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 7687c478bd9Sstevel@tonic-gate } else { 7697c478bd9Sstevel@tonic-gate struct frame32 *fr = (void *)(caddr32_t)rp->r_sp; 7707c478bd9Sstevel@tonic-gate 7717c478bd9Sstevel@tonic-gate if (mpcb->mpcb_wbcnt > 0) { 7727c478bd9Sstevel@tonic-gate struct rwindow32 *rwin = (void *)mpcb->mpcb_wbuf; 7737c478bd9Sstevel@tonic-gate int i = mpcb->mpcb_wbcnt; 7747c478bd9Sstevel@tonic-gate do { 7757c478bd9Sstevel@tonic-gate i--; 7767c478bd9Sstevel@tonic-gate if ((long)mpcb->mpcb_spbuf[i] == rp->r_sp) 7777c478bd9Sstevel@tonic-gate return (rwin[i].rw_local[reg - 16]); 7787c478bd9Sstevel@tonic-gate } while (i > 0); 7797c478bd9Sstevel@tonic-gate } 7807c478bd9Sstevel@tonic-gate 7817c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 7827c478bd9Sstevel@tonic-gate value = dtrace_fuword32(&fr->fr_local[reg - 16]); 7837c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 7847c478bd9Sstevel@tonic-gate } 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate return (value); 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate fake_restore: 7897c478bd9Sstevel@tonic-gate ASSERT(R_L0 <= reg && reg <= R_I7); 7907c478bd9Sstevel@tonic-gate 7917c478bd9Sstevel@tonic-gate /* 7927c478bd9Sstevel@tonic-gate * We first look two user windows down to see if we can dig out 7937c478bd9Sstevel@tonic-gate * the register we're looking for. 7947c478bd9Sstevel@tonic-gate */ 7957c478bd9Sstevel@tonic-gate if (dtrace_getotherwin() > 1) 7967c478bd9Sstevel@tonic-gate return (dtrace_getreg_win(reg, 2)); 7977c478bd9Sstevel@tonic-gate 7987c478bd9Sstevel@tonic-gate /* 7997c478bd9Sstevel@tonic-gate * First we need to get the frame pointer and then we perform 8007c478bd9Sstevel@tonic-gate * the same computation as in the non-fake-o-restore case. 8017c478bd9Sstevel@tonic-gate */ 8027c478bd9Sstevel@tonic-gate 8037c478bd9Sstevel@tonic-gate mpcb = (struct machpcb *)((caddr_t)rp - REGOFF); 8047c478bd9Sstevel@tonic-gate 8057c478bd9Sstevel@tonic-gate if (dtrace_getotherwin() > 0) { 8067c478bd9Sstevel@tonic-gate fp = dtrace_getreg_win(R_FP, 1); 8077c478bd9Sstevel@tonic-gate goto got_fp; 8087c478bd9Sstevel@tonic-gate } 8097c478bd9Sstevel@tonic-gate 8107c478bd9Sstevel@tonic-gate if (curproc->p_model == DATAMODEL_NATIVE) { 8117c478bd9Sstevel@tonic-gate struct frame *fr = (void *)(rp->r_sp + STACK_BIAS); 8127c478bd9Sstevel@tonic-gate 8137c478bd9Sstevel@tonic-gate if (mpcb->mpcb_wbcnt > 0) { 8147c478bd9Sstevel@tonic-gate struct rwindow *rwin = (void *)mpcb->mpcb_wbuf; 8157c478bd9Sstevel@tonic-gate int i = mpcb->mpcb_wbcnt; 8167c478bd9Sstevel@tonic-gate do { 8177c478bd9Sstevel@tonic-gate i--; 8187c478bd9Sstevel@tonic-gate if ((long)mpcb->mpcb_spbuf[i] == rp->r_sp) { 8197c478bd9Sstevel@tonic-gate fp = rwin[i].rw_fp; 8207c478bd9Sstevel@tonic-gate goto got_fp; 8217c478bd9Sstevel@tonic-gate } 8227c478bd9Sstevel@tonic-gate } while (i > 0); 8237c478bd9Sstevel@tonic-gate } 8247c478bd9Sstevel@tonic-gate 8257c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 8267c478bd9Sstevel@tonic-gate fp = dtrace_fulword(&fr->fr_savfp); 8277c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 8287c478bd9Sstevel@tonic-gate if (cpu_core[CPU->cpu_id].cpuc_dtrace_flags & CPU_DTRACE_FAULT) 8297c478bd9Sstevel@tonic-gate return (0); 8307c478bd9Sstevel@tonic-gate } else { 8317c478bd9Sstevel@tonic-gate struct frame32 *fr = (void *)(caddr32_t)rp->r_sp; 8327c478bd9Sstevel@tonic-gate 8337c478bd9Sstevel@tonic-gate if (mpcb->mpcb_wbcnt > 0) { 8347c478bd9Sstevel@tonic-gate struct rwindow32 *rwin = (void *)mpcb->mpcb_wbuf; 8357c478bd9Sstevel@tonic-gate int i = mpcb->mpcb_wbcnt; 8367c478bd9Sstevel@tonic-gate do { 8377c478bd9Sstevel@tonic-gate i--; 8387c478bd9Sstevel@tonic-gate if ((long)mpcb->mpcb_spbuf[i] == rp->r_sp) { 8397c478bd9Sstevel@tonic-gate fp = rwin[i].rw_fp; 8407c478bd9Sstevel@tonic-gate goto got_fp; 8417c478bd9Sstevel@tonic-gate } 8427c478bd9Sstevel@tonic-gate } while (i > 0); 8437c478bd9Sstevel@tonic-gate } 8447c478bd9Sstevel@tonic-gate 8457c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 8467c478bd9Sstevel@tonic-gate fp = dtrace_fuword32(&fr->fr_savfp); 8477c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 8487c478bd9Sstevel@tonic-gate if (cpu_core[CPU->cpu_id].cpuc_dtrace_flags & CPU_DTRACE_FAULT) 8497c478bd9Sstevel@tonic-gate return (0); 8507c478bd9Sstevel@tonic-gate } 8517c478bd9Sstevel@tonic-gate got_fp: 8527c478bd9Sstevel@tonic-gate 8537c478bd9Sstevel@tonic-gate if (curproc->p_model == DATAMODEL_NATIVE) { 8547c478bd9Sstevel@tonic-gate struct frame *fr = (void *)(fp + STACK_BIAS); 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate if (mpcb->mpcb_wbcnt > 0) { 8577c478bd9Sstevel@tonic-gate struct rwindow *rwin = (void *)mpcb->mpcb_wbuf; 8587c478bd9Sstevel@tonic-gate int i = mpcb->mpcb_wbcnt; 8597c478bd9Sstevel@tonic-gate do { 8607c478bd9Sstevel@tonic-gate i--; 8617c478bd9Sstevel@tonic-gate if ((long)mpcb->mpcb_spbuf[i] == fp) 8627c478bd9Sstevel@tonic-gate return (rwin[i].rw_local[reg - 16]); 8637c478bd9Sstevel@tonic-gate } while (i > 0); 8647c478bd9Sstevel@tonic-gate } 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 8677c478bd9Sstevel@tonic-gate value = dtrace_fulword(&fr->fr_local[reg - 16]); 8687c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 8697c478bd9Sstevel@tonic-gate } else { 8707c478bd9Sstevel@tonic-gate struct frame32 *fr = (void *)(caddr32_t)fp; 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate if (mpcb->mpcb_wbcnt > 0) { 8737c478bd9Sstevel@tonic-gate struct rwindow32 *rwin = (void *)mpcb->mpcb_wbuf; 8747c478bd9Sstevel@tonic-gate int i = mpcb->mpcb_wbcnt; 8757c478bd9Sstevel@tonic-gate do { 8767c478bd9Sstevel@tonic-gate i--; 8777c478bd9Sstevel@tonic-gate if ((long)mpcb->mpcb_spbuf[i] == fp) 8787c478bd9Sstevel@tonic-gate return (rwin[i].rw_local[reg - 16]); 8797c478bd9Sstevel@tonic-gate } while (i > 0); 8807c478bd9Sstevel@tonic-gate } 8817c478bd9Sstevel@tonic-gate 8827c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_SET(CPU_DTRACE_NOFAULT); 8837c478bd9Sstevel@tonic-gate value = dtrace_fuword32(&fr->fr_local[reg - 16]); 8847c478bd9Sstevel@tonic-gate DTRACE_CPUFLAG_CLEAR(CPU_DTRACE_NOFAULT); 8857c478bd9Sstevel@tonic-gate } 8867c478bd9Sstevel@tonic-gate 8877c478bd9Sstevel@tonic-gate return (value); 8887c478bd9Sstevel@tonic-gate } 889