• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Common header file for probe-based Dynamic events.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16  *
17  * This code was copied from kernel/trace/trace_kprobe.h written by
18  * Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
19  *
20  * Updates to make this generic:
21  * Copyright (C) IBM Corporation, 2010-2011
22  * Author:     Srikar Dronamraju
23  */
24 
25 #include <linux/seq_file.h>
26 #include <linux/slab.h>
27 #include <linux/smp.h>
28 #include <linux/tracefs.h>
29 #include <linux/types.h>
30 #include <linux/string.h>
31 #include <linux/ctype.h>
32 #include <linux/ptrace.h>
33 #include <linux/perf_event.h>
34 #include <linux/kprobes.h>
35 #include <linux/stringify.h>
36 #include <linux/limits.h>
37 #include <linux/uaccess.h>
38 #include <asm/bitsperlong.h>
39 
40 #include "trace.h"
41 #include "trace_output.h"
42 
43 #define MAX_TRACE_ARGS		128
44 #define MAX_ARGSTR_LEN		63
45 #define MAX_EVENT_NAME_LEN	64
46 #define MAX_STRING_SIZE		PATH_MAX
47 
48 /* Reserved field names */
49 #define FIELD_STRING_IP		"__probe_ip"
50 #define FIELD_STRING_RETIP	"__probe_ret_ip"
51 #define FIELD_STRING_FUNC	"__probe_func"
52 
53 #undef DEFINE_FIELD
54 #define DEFINE_FIELD(type, item, name, is_signed)			\
55 	do {								\
56 		ret = trace_define_field(event_call, #type, name,	\
57 					 offsetof(typeof(field), item),	\
58 					 sizeof(field.item), is_signed, \
59 					 FILTER_OTHER);			\
60 		if (ret)						\
61 			return ret;					\
62 	} while (0)
63 
64 
65 /* Flags for trace_probe */
66 #define TP_FLAG_TRACE		1
67 #define TP_FLAG_PROFILE		2
68 #define TP_FLAG_REGISTERED	4
69 
70 
71 /* data_rloc: data relative location, compatible with u32 */
72 #define make_data_rloc(len, roffs)	\
73 	(((u32)(len) << 16) | ((u32)(roffs) & 0xffff))
74 #define get_rloc_len(dl)		((u32)(dl) >> 16)
75 #define get_rloc_offs(dl)		((u32)(dl) & 0xffff)
76 
77 /*
78  * Convert data_rloc to data_loc:
79  *  data_rloc stores the offset from data_rloc itself, but data_loc
80  *  stores the offset from event entry.
81  */
82 #define convert_rloc_to_loc(dl, offs)	((u32)(dl) + (offs))
83 
get_rloc_data(u32 * dl)84 static nokprobe_inline void *get_rloc_data(u32 *dl)
85 {
86 	return (u8 *)dl + get_rloc_offs(*dl);
87 }
88 
89 /* For data_loc conversion */
get_loc_data(u32 * dl,void * ent)90 static nokprobe_inline void *get_loc_data(u32 *dl, void *ent)
91 {
92 	return (u8 *)ent + get_rloc_offs(*dl);
93 }
94 
95 /* Data fetch function type */
96 typedef	void (*fetch_func_t)(struct pt_regs *, void *, void *);
97 /* Printing function type */
98 typedef int (*print_type_func_t)(struct trace_seq *, const char *, void *, void *);
99 
100 /* Fetch types */
101 enum {
102 	FETCH_MTD_reg = 0,
103 	FETCH_MTD_stack,
104 	FETCH_MTD_retval,
105 	FETCH_MTD_memory,
106 	FETCH_MTD_symbol,
107 	FETCH_MTD_deref,
108 	FETCH_MTD_bitfield,
109 	FETCH_MTD_file_offset,
110 	FETCH_MTD_END,
111 };
112 
113 /* Fetch type information table */
114 struct fetch_type {
115 	const char		*name;		/* Name of type */
116 	size_t			size;		/* Byte size of type */
117 	int			is_signed;	/* Signed flag */
118 	print_type_func_t	print;		/* Print functions */
119 	const char		*fmt;		/* Fromat string */
120 	const char		*fmttype;	/* Name in format file */
121 	/* Fetch functions */
122 	fetch_func_t		fetch[FETCH_MTD_END];
123 };
124 
125 struct fetch_param {
126 	fetch_func_t		fn;
127 	void 			*data;
128 };
129 
130 /* For defining macros, define string/string_size types */
131 typedef u32 string;
132 typedef u32 string_size;
133 
134 #define PRINT_TYPE_FUNC_NAME(type)	print_type_##type
135 #define PRINT_TYPE_FMT_NAME(type)	print_type_format_##type
136 
137 /* Printing  in basic type function template */
138 #define DECLARE_BASIC_PRINT_TYPE_FUNC(type)				\
139 int PRINT_TYPE_FUNC_NAME(type)(struct trace_seq *s, const char *name,	\
140 				void *data, void *ent);			\
141 extern const char PRINT_TYPE_FMT_NAME(type)[]
142 
143 DECLARE_BASIC_PRINT_TYPE_FUNC(u8);
144 DECLARE_BASIC_PRINT_TYPE_FUNC(u16);
145 DECLARE_BASIC_PRINT_TYPE_FUNC(u32);
146 DECLARE_BASIC_PRINT_TYPE_FUNC(u64);
147 DECLARE_BASIC_PRINT_TYPE_FUNC(s8);
148 DECLARE_BASIC_PRINT_TYPE_FUNC(s16);
149 DECLARE_BASIC_PRINT_TYPE_FUNC(s32);
150 DECLARE_BASIC_PRINT_TYPE_FUNC(s64);
151 DECLARE_BASIC_PRINT_TYPE_FUNC(string);
152 
153 #define FETCH_FUNC_NAME(method, type)	fetch_##method##_##type
154 
155 /* Declare macro for basic types */
156 #define DECLARE_FETCH_FUNC(method, type)				\
157 extern void FETCH_FUNC_NAME(method, type)(struct pt_regs *regs, 	\
158 					  void *data, void *dest)
159 
160 #define DECLARE_BASIC_FETCH_FUNCS(method) 	\
161 DECLARE_FETCH_FUNC(method, u8);			\
162 DECLARE_FETCH_FUNC(method, u16);		\
163 DECLARE_FETCH_FUNC(method, u32);		\
164 DECLARE_FETCH_FUNC(method, u64)
165 
166 DECLARE_BASIC_FETCH_FUNCS(reg);
167 #define fetch_reg_string			NULL
168 #define fetch_reg_string_size			NULL
169 
170 DECLARE_BASIC_FETCH_FUNCS(retval);
171 #define fetch_retval_string			NULL
172 #define fetch_retval_string_size		NULL
173 
174 DECLARE_BASIC_FETCH_FUNCS(symbol);
175 DECLARE_FETCH_FUNC(symbol, string);
176 DECLARE_FETCH_FUNC(symbol, string_size);
177 
178 DECLARE_BASIC_FETCH_FUNCS(deref);
179 DECLARE_FETCH_FUNC(deref, string);
180 DECLARE_FETCH_FUNC(deref, string_size);
181 
182 DECLARE_BASIC_FETCH_FUNCS(bitfield);
183 #define fetch_bitfield_string			NULL
184 #define fetch_bitfield_string_size		NULL
185 
186 /*
187  * Define macro for basic types - we don't need to define s* types, because
188  * we have to care only about bitwidth at recording time.
189  */
190 #define DEFINE_BASIC_FETCH_FUNCS(method) \
191 DEFINE_FETCH_##method(u8)		\
192 DEFINE_FETCH_##method(u16)		\
193 DEFINE_FETCH_##method(u32)		\
194 DEFINE_FETCH_##method(u64)
195 
196 /* Default (unsigned long) fetch type */
197 #define __DEFAULT_FETCH_TYPE(t) u##t
198 #define _DEFAULT_FETCH_TYPE(t) __DEFAULT_FETCH_TYPE(t)
199 #define DEFAULT_FETCH_TYPE _DEFAULT_FETCH_TYPE(BITS_PER_LONG)
200 #define DEFAULT_FETCH_TYPE_STR __stringify(DEFAULT_FETCH_TYPE)
201 
202 #define ASSIGN_FETCH_FUNC(method, type)	\
203 	[FETCH_MTD_##method] = FETCH_FUNC_NAME(method, type)
204 
205 #define __ASSIGN_FETCH_TYPE(_name, ptype, ftype, _size, sign, _fmttype)	\
206 	{.name = _name,				\
207 	 .size = _size,					\
208 	 .is_signed = sign,				\
209 	 .print = PRINT_TYPE_FUNC_NAME(ptype),		\
210 	 .fmt = PRINT_TYPE_FMT_NAME(ptype),		\
211 	 .fmttype = _fmttype,				\
212 	 .fetch = {					\
213 ASSIGN_FETCH_FUNC(reg, ftype),				\
214 ASSIGN_FETCH_FUNC(stack, ftype),			\
215 ASSIGN_FETCH_FUNC(retval, ftype),			\
216 ASSIGN_FETCH_FUNC(memory, ftype),			\
217 ASSIGN_FETCH_FUNC(symbol, ftype),			\
218 ASSIGN_FETCH_FUNC(deref, ftype),			\
219 ASSIGN_FETCH_FUNC(bitfield, ftype),			\
220 ASSIGN_FETCH_FUNC(file_offset, ftype),			\
221 	  }						\
222 	}
223 
224 #define ASSIGN_FETCH_TYPE(ptype, ftype, sign)			\
225 	__ASSIGN_FETCH_TYPE(#ptype, ptype, ftype, sizeof(ftype), sign, #ptype)
226 
227 #define ASSIGN_FETCH_TYPE_END {}
228 
229 #define FETCH_TYPE_STRING	0
230 #define FETCH_TYPE_STRSIZE	1
231 
232 #ifdef CONFIG_KPROBE_EVENT
233 struct symbol_cache;
234 unsigned long update_symbol_cache(struct symbol_cache *sc);
235 void free_symbol_cache(struct symbol_cache *sc);
236 struct symbol_cache *alloc_symbol_cache(const char *sym, long offset);
237 #else
238 /* uprobes do not support symbol fetch methods */
239 #define fetch_symbol_u8			NULL
240 #define fetch_symbol_u16		NULL
241 #define fetch_symbol_u32		NULL
242 #define fetch_symbol_u64		NULL
243 #define fetch_symbol_string		NULL
244 #define fetch_symbol_string_size	NULL
245 
246 struct symbol_cache {
247 };
update_symbol_cache(struct symbol_cache * sc)248 static inline unsigned long __used update_symbol_cache(struct symbol_cache *sc)
249 {
250 	return 0;
251 }
252 
free_symbol_cache(struct symbol_cache * sc)253 static inline void __used free_symbol_cache(struct symbol_cache *sc)
254 {
255 }
256 
257 static inline struct symbol_cache * __used
alloc_symbol_cache(const char * sym,long offset)258 alloc_symbol_cache(const char *sym, long offset)
259 {
260 	return NULL;
261 }
262 #endif /* CONFIG_KPROBE_EVENT */
263 
264 struct probe_arg {
265 	struct fetch_param	fetch;
266 	struct fetch_param	fetch_size;
267 	unsigned int		offset;	/* Offset from argument entry */
268 	const char		*name;	/* Name of this argument */
269 	const char		*comm;	/* Command of this argument */
270 	const struct fetch_type	*type;	/* Type of this argument */
271 };
272 
273 struct trace_probe {
274 	unsigned int			flags;	/* For TP_FLAG_* */
275 	struct trace_event_class	class;
276 	struct trace_event_call		call;
277 	struct list_head 		files;
278 	ssize_t				size;	/* trace entry size */
279 	unsigned int			nr_args;
280 	struct probe_arg		args[];
281 };
282 
283 struct event_file_link {
284 	struct trace_event_file		*file;
285 	struct list_head		list;
286 };
287 
trace_probe_is_enabled(struct trace_probe * tp)288 static inline bool trace_probe_is_enabled(struct trace_probe *tp)
289 {
290 	return !!(tp->flags & (TP_FLAG_TRACE | TP_FLAG_PROFILE));
291 }
292 
trace_probe_is_registered(struct trace_probe * tp)293 static inline bool trace_probe_is_registered(struct trace_probe *tp)
294 {
295 	return !!(tp->flags & TP_FLAG_REGISTERED);
296 }
297 
call_fetch(struct fetch_param * fprm,struct pt_regs * regs,void * dest)298 static nokprobe_inline void call_fetch(struct fetch_param *fprm,
299 				 struct pt_regs *regs, void *dest)
300 {
301 	return fprm->fn(regs, fprm->data, dest);
302 }
303 
304 /* Check the name is good for event/group/fields */
is_good_name(const char * name)305 static inline bool is_good_name(const char *name)
306 {
307 	if (!isalpha(*name) && *name != '_')
308 		return false;
309 	while (*++name != '\0') {
310 		if (!isalpha(*name) && !isdigit(*name) && *name != '_')
311 			return false;
312 	}
313 	return true;
314 }
315 
316 static inline struct event_file_link *
find_event_file_link(struct trace_probe * tp,struct trace_event_file * file)317 find_event_file_link(struct trace_probe *tp, struct trace_event_file *file)
318 {
319 	struct event_file_link *link;
320 
321 	list_for_each_entry(link, &tp->files, list)
322 		if (link->file == file)
323 			return link;
324 
325 	return NULL;
326 }
327 
328 extern int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
329 		   struct probe_arg *parg, bool is_return, bool is_kprobe,
330 		   const struct fetch_type *ftbl);
331 
332 extern int traceprobe_conflict_field_name(const char *name,
333 			       struct probe_arg *args, int narg);
334 
335 extern void traceprobe_update_arg(struct probe_arg *arg);
336 extern void traceprobe_free_probe_arg(struct probe_arg *arg);
337 
338 extern int traceprobe_split_symbol_offset(char *symbol, long *offset);
339 
340 extern ssize_t traceprobe_probes_write(struct file *file,
341 		const char __user *buffer, size_t count, loff_t *ppos,
342 		int (*createfn)(int, char**));
343 
344 extern int traceprobe_command(const char *buf, int (*createfn)(int, char**));
345 
346 /* Sum up total data length for dynamic arraies (strings) */
347 static nokprobe_inline int
__get_data_size(struct trace_probe * tp,struct pt_regs * regs)348 __get_data_size(struct trace_probe *tp, struct pt_regs *regs)
349 {
350 	int i, ret = 0;
351 	u32 len;
352 
353 	for (i = 0; i < tp->nr_args; i++)
354 		if (unlikely(tp->args[i].fetch_size.fn)) {
355 			call_fetch(&tp->args[i].fetch_size, regs, &len);
356 			ret += len;
357 		}
358 
359 	return ret;
360 }
361 
362 /* Store the value of each argument */
363 static nokprobe_inline void
store_trace_args(int ent_size,struct trace_probe * tp,struct pt_regs * regs,u8 * data,int maxlen)364 store_trace_args(int ent_size, struct trace_probe *tp, struct pt_regs *regs,
365 		 u8 *data, int maxlen)
366 {
367 	int i;
368 	u32 end = tp->size;
369 	u32 *dl;	/* Data (relative) location */
370 
371 	for (i = 0; i < tp->nr_args; i++) {
372 		if (unlikely(tp->args[i].fetch_size.fn)) {
373 			/*
374 			 * First, we set the relative location and
375 			 * maximum data length to *dl
376 			 */
377 			dl = (u32 *)(data + tp->args[i].offset);
378 			*dl = make_data_rloc(maxlen, end - tp->args[i].offset);
379 			/* Then try to fetch string or dynamic array data */
380 			call_fetch(&tp->args[i].fetch, regs, dl);
381 			/* Reduce maximum length */
382 			end += get_rloc_len(*dl);
383 			maxlen -= get_rloc_len(*dl);
384 			/* Trick here, convert data_rloc to data_loc */
385 			*dl = convert_rloc_to_loc(*dl,
386 				 ent_size + tp->args[i].offset);
387 		} else
388 			/* Just fetching data normally */
389 			call_fetch(&tp->args[i].fetch, regs,
390 				   data + tp->args[i].offset);
391 	}
392 }
393 
394 extern int set_print_fmt(struct trace_probe *tp, bool is_return);
395