xref: /freebsd/sys/cddl/dev/fbt/powerpc/fbt_isa.c (revision a0ee8cc636cd5c2374ec44ca71226564ea0bca95)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  *
21  * Portions Copyright 2006-2008 John Birrell jb@freebsd.org
22  * Portions Copyright 2013 Justin Hibbits jhibbits@freebsd.org
23  *
24  * $FreeBSD$
25  *
26  */
27 
28 /*
29  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
30  * Use is subject to license terms.
31  */
32 
33 #include <sys/cdefs.h>
34 #include <sys/param.h>
35 #include <sys/dtrace.h>
36 #include <machine/md_var.h>
37 
38 #include "fbt.h"
39 
40 #define FBT_PATCHVAL		0x7c810808
41 #define FBT_MFLR_R0		0x7c0802a6
42 #define FBT_MTLR_R0		0x7c0803a6
43 #define FBT_BLR			0x4e800020
44 #define FBT_BCTR		0x4e800030
45 #define FBT_BRANCH		0x48000000
46 #define FBT_BR_MASK		0x03fffffc
47 #define FBT_IS_JUMP(instr)	((instr & ~FBT_BR_MASK) == FBT_BRANCH)
48 
49 #define	FBT_ENTRY	"entry"
50 #define	FBT_RETURN	"return"
51 #define	FBT_AFRAMES	7
52 
53 int
54 fbt_invop(uintptr_t addr, uintptr_t *stack, uintptr_t rval)
55 {
56 	struct trapframe *frame = (struct trapframe *)stack;
57 	solaris_cpu_t *cpu = &solaris_cpu[curcpu];
58 	fbt_probe_t *fbt = fbt_probetab[FBT_ADDR2NDX(addr)];
59 	uintptr_t tmp;
60 
61 	for (; fbt != NULL; fbt = fbt->fbtp_hashnext) {
62 		if ((uintptr_t)fbt->fbtp_patchpoint == addr) {
63 			if (fbt->fbtp_roffset == 0) {
64 				cpu->cpu_dtrace_caller = addr;
65 
66 				dtrace_probe(fbt->fbtp_id, frame->fixreg[3],
67 				    frame->fixreg[4], frame->fixreg[5],
68 				    frame->fixreg[6], frame->fixreg[7]);
69 
70 				cpu->cpu_dtrace_caller = 0;
71 			} else {
72 
73 				dtrace_probe(fbt->fbtp_id, fbt->fbtp_roffset,
74 				    rval, 0, 0, 0);
75 				/*
76 				 * The caller doesn't have the fbt item, so
77 				 * fixup tail calls here.
78 				 */
79 				if (fbt->fbtp_rval == DTRACE_INVOP_JUMP) {
80 					frame->srr0 = (uintptr_t)fbt->fbtp_patchpoint;
81 					tmp = fbt->fbtp_savedval & FBT_BR_MASK;
82 					/* Sign extend. */
83 					if (tmp & 0x02000000)
84 #ifdef __powerpc64__
85 						tmp |= 0xfffffffffc000000ULL;
86 #else
87 						tmp |= 0xfc000000UL;
88 #endif
89 					frame->srr0 += tmp;
90 				}
91 				cpu->cpu_dtrace_caller = 0;
92 			}
93 
94 			return (fbt->fbtp_rval);
95 		}
96 	}
97 
98 	return (0);
99 }
100 
101 void
102 fbt_patch_tracepoint(fbt_probe_t *fbt, fbt_patchval_t val)
103 {
104 
105 	*fbt->fbtp_patchpoint = val;
106 	__syncicache(fbt->fbtp_patchpoint, 4);
107 }
108 
109 int
110 fbt_provide_module_function(linker_file_t lf, int symindx,
111     linker_symval_t *symval, void *opaque)
112 {
113 	char *modname = opaque;
114 	const char *name = symval->name;
115 	fbt_probe_t *fbt, *retfbt;
116 	int j;
117 	uint32_t *instr, *limit;
118 
119 #ifdef __powerpc64__
120 	/*
121 	 * PowerPC64 uses '.' prefixes on symbol names, ignore it, but only
122 	 * allow symbols with the '.' prefix, so that we don't get the function
123 	 * descriptor instead.
124 	 */
125 	if (name[0] == '.')
126 		name++;
127 	else
128 		return (0);
129 #endif
130 
131 	if (strncmp(name, "dtrace_", 7) == 0 &&
132 	    strncmp(name, "dtrace_safe_", 12) != 0) {
133 		/*
134 		 * Anything beginning with "dtrace_" may be called
135 		 * from probe context unless it explicitly indicates
136 		 * that it won't be called from probe context by
137 		 * using the prefix "dtrace_safe_".
138 		 */
139 		return (0);
140 	}
141 
142 	if (name[0] == '_' && name[1] == '_')
143 		return (0);
144 
145 	instr = (uint32_t *) symval->value;
146 	limit = (uint32_t *) (symval->value + symval->size);
147 
148 	for (; instr < limit; instr++)
149 		if (*instr == FBT_MFLR_R0)
150 			break;
151 
152 	if (*instr != FBT_MFLR_R0)
153 		return (0);
154 
155 	fbt = malloc(sizeof (fbt_probe_t), M_FBT, M_WAITOK | M_ZERO);
156 	fbt->fbtp_name = name;
157 	fbt->fbtp_id = dtrace_probe_create(fbt_id, modname,
158 	    name, FBT_ENTRY, FBT_AFRAMES, fbt);
159 	fbt->fbtp_patchpoint = instr;
160 	fbt->fbtp_ctl = lf;
161 	fbt->fbtp_loadcnt = lf->loadcnt;
162 	fbt->fbtp_savedval = *instr;
163 	fbt->fbtp_patchval = FBT_PATCHVAL;
164 	fbt->fbtp_rval = DTRACE_INVOP_MFLR_R0;
165 	fbt->fbtp_symindx = symindx;
166 
167 	fbt->fbtp_hashnext = fbt_probetab[FBT_ADDR2NDX(instr)];
168 	fbt_probetab[FBT_ADDR2NDX(instr)] = fbt;
169 
170 	lf->fbt_nentries++;
171 
172 	retfbt = NULL;
173 again:
174 	if (instr >= limit)
175 		return (0);
176 
177 	/*
178 	 * We (desperately) want to avoid erroneously instrumenting a
179 	 * jump table. To determine if we're looking at a true instruction
180 	 * sequence or an inline jump table that happens to contain the same
181 	 * byte sequences, we resort to some heuristic sleeze:  we treat this
182 	 * instruction as being contained within a pointer, and see if that
183 	 * pointer points to within the body of the function.  If it does, we
184 	 * refuse to instrument it.
185 	 */
186 	{
187 		uint32_t *ptr;
188 
189 		ptr = *(uint32_t **)instr;
190 
191 		if (ptr >= (uint32_t *) symval->value && ptr < limit) {
192 			instr++;
193 			goto again;
194 		}
195 	}
196 
197 	if (*instr != FBT_MTLR_R0) {
198 		instr++;
199 		goto again;
200 	}
201 
202 	instr++;
203 
204 	for (j = 0; j < 12 && instr < limit; j++, instr++) {
205 		if ((*instr == FBT_BCTR) || (*instr == FBT_BLR) ||
206 		    FBT_IS_JUMP(*instr))
207 			break;
208 	}
209 
210 	if (!(*instr == FBT_BCTR || *instr == FBT_BLR || FBT_IS_JUMP(*instr)))
211 		goto again;
212 
213 	/*
214 	 * We have a winner!
215 	 */
216 	fbt = malloc(sizeof (fbt_probe_t), M_FBT, M_WAITOK | M_ZERO);
217 	fbt->fbtp_name = name;
218 
219 	if (retfbt == NULL) {
220 		fbt->fbtp_id = dtrace_probe_create(fbt_id, modname,
221 		    name, FBT_RETURN, FBT_AFRAMES, fbt);
222 	} else {
223 		retfbt->fbtp_next = fbt;
224 		fbt->fbtp_id = retfbt->fbtp_id;
225 	}
226 
227 	retfbt = fbt;
228 	fbt->fbtp_patchpoint = instr;
229 	fbt->fbtp_ctl = lf;
230 	fbt->fbtp_loadcnt = lf->loadcnt;
231 	fbt->fbtp_symindx = symindx;
232 
233 	if (*instr == FBT_BCTR)
234 		fbt->fbtp_rval = DTRACE_INVOP_BCTR;
235 	else if (*instr == FBT_BLR)
236 		fbt->fbtp_rval = DTRACE_INVOP_RET;
237 	else
238 		fbt->fbtp_rval = DTRACE_INVOP_JUMP;
239 
240 	fbt->fbtp_roffset =
241 	    (uintptr_t)((uint8_t *)instr - (uint8_t *)symval->value);
242 
243 	fbt->fbtp_savedval = *instr;
244 	fbt->fbtp_patchval = FBT_PATCHVAL;
245 	fbt->fbtp_hashnext = fbt_probetab[FBT_ADDR2NDX(instr)];
246 	fbt_probetab[FBT_ADDR2NDX(instr)] = fbt;
247 
248 	lf->fbt_nentries++;
249 
250 	instr += 4;
251 	goto again;
252 }
253