fbt_isa.c revision 286241 
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: head/sys/cddl/dev/fbt/powerpc/fbt_isa.c 286241 2015-08-03 17:39:36Z markj $
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
53int
54fbt_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
101void
102fbt_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
109int
110fbt_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;
173again:
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