forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-05-10 61598093bbdd283a7edc367d900f223070ead8d2 
 kernel/kernel/trace/trace_probe.h
....@@ -16,13 +16,13 @@
1616 #include <linux/tracefs.h>
1717 #include <linux/types.h>
1818 #include <linux/string.h>
19
-#include <linux/ctype.h>
2019 #include <linux/ptrace.h>
2120 #include <linux/perf_event.h>
2221 #include <linux/kprobes.h>
2322 #include <linux/stringify.h>
2423 #include <linux/limits.h>
2524 #include <linux/uaccess.h>
25
+#include <linux/bitops.h>
2626 #include <asm/bitsperlong.h>
2727 
2828 #include "trace.h"
....@@ -30,6 +30,8 @@
3030 
3131 #define MAX_TRACE_ARGS		128
3232 #define MAX_ARGSTR_LEN		63
33
+#define MAX_ARRAY_LEN		64
34
+#define MAX_ARG_NAME_LEN	32
3335 #define MAX_STRING_SIZE		PATH_MAX
3436 
3537 /* Reserved field names */
....@@ -52,51 +54,79 @@
5254 /* Flags for trace_probe */
5355 #define TP_FLAG_TRACE		1
5456 #define TP_FLAG_PROFILE		2
55
-#define TP_FLAG_REGISTERED	4
5657 
58
+/* data_loc: data location, compatible with u32 */
59
+#define make_data_loc(len, offs)	\
60
+	(((u32)(len) << 16) | ((u32)(offs) & 0xffff))
61
+#define get_loc_len(dl)		((u32)(dl) >> 16)
62
+#define get_loc_offs(dl)	((u32)(dl) & 0xffff)
5763 
58
-/* data_rloc: data relative location, compatible with u32 */
59
-#define make_data_rloc(len, roffs)	\
60
-	(((u32)(len) << 16) | ((u32)(roffs) & 0xffff))
61
-#define get_rloc_len(dl)		((u32)(dl) >> 16)
62
-#define get_rloc_offs(dl)		((u32)(dl) & 0xffff)
63
-
64
-/*
65
- * Convert data_rloc to data_loc:
66
- *  data_rloc stores the offset from data_rloc itself, but data_loc
67
- *  stores the offset from event entry.
68
- */
69
-#define convert_rloc_to_loc(dl, offs)	((u32)(dl) + (offs))
70
-
71
-static nokprobe_inline void *get_rloc_data(u32 *dl)
72
-{
73
-	return (u8 *)dl + get_rloc_offs(*dl);
74
-}
75
-
76
-/* For data_loc conversion */
7764 static nokprobe_inline void *get_loc_data(u32 *dl, void *ent)
7865 {
79
-	return (u8 *)ent + get_rloc_offs(*dl);
66
+	return (u8 *)ent + get_loc_offs(*dl);
8067 }
8168 
82
-/* Data fetch function type */
83
-typedef	void (*fetch_func_t)(struct pt_regs *, void *, void *);
84
-/* Printing function type */
85
-typedef int (*print_type_func_t)(struct trace_seq *, const char *, void *, void *);
69
+static nokprobe_inline u32 update_data_loc(u32 loc, int consumed)
70
+{
71
+	u32 maxlen = get_loc_len(loc);
72
+	u32 offset = get_loc_offs(loc);
8673 
87
-/* Fetch types */
88
-enum {
89
-	FETCH_MTD_reg = 0,
90
-	FETCH_MTD_stack,
91
-	FETCH_MTD_retval,
92
-	FETCH_MTD_comm,
93
-	FETCH_MTD_memory,
94
-	FETCH_MTD_symbol,
95
-	FETCH_MTD_deref,
96
-	FETCH_MTD_bitfield,
97
-	FETCH_MTD_file_offset,
98
-	FETCH_MTD_END,
74
+	return make_data_loc(maxlen - consumed, offset + consumed);
75
+}
76
+
77
+/* Printing function type */
78
+typedef int (*print_type_func_t)(struct trace_seq *, void *, void *);
79
+
80
+enum fetch_op {
81
+	FETCH_OP_NOP = 0,
82
+	// Stage 1 (load) ops
83
+	FETCH_OP_REG,		/* Register : .param = offset */
84
+	FETCH_OP_STACK,		/* Stack : .param = index */
85
+	FETCH_OP_STACKP,	/* Stack pointer */
86
+	FETCH_OP_RETVAL,	/* Return value */
87
+	FETCH_OP_IMM,		/* Immediate : .immediate */
88
+	FETCH_OP_COMM,		/* Current comm */
89
+	FETCH_OP_ARG,		/* Function argument : .param */
90
+	FETCH_OP_FOFFS,		/* File offset: .immediate */
91
+	FETCH_OP_DATA,		/* Allocated data: .data */
92
+	// Stage 2 (dereference) op
93
+	FETCH_OP_DEREF,		/* Dereference: .offset */
94
+	FETCH_OP_UDEREF,	/* User-space Dereference: .offset */
95
+	// Stage 3 (store) ops
96
+	FETCH_OP_ST_RAW,	/* Raw: .size */
97
+	FETCH_OP_ST_MEM,	/* Mem: .offset, .size */
98
+	FETCH_OP_ST_UMEM,	/* Mem: .offset, .size */
99
+	FETCH_OP_ST_STRING,	/* String: .offset, .size */
100
+	FETCH_OP_ST_USTRING,	/* User String: .offset, .size */
101
+	// Stage 4 (modify) op
102
+	FETCH_OP_MOD_BF,	/* Bitfield: .basesize, .lshift, .rshift */
103
+	// Stage 5 (loop) op
104
+	FETCH_OP_LP_ARRAY,	/* Array: .param = loop count */
105
+	FETCH_OP_END,
106
+	FETCH_NOP_SYMBOL,	/* Unresolved Symbol holder */
99107 };
108
+
109
+struct fetch_insn {
110
+	enum fetch_op op;
111
+	union {
112
+		unsigned int param;
113
+		struct {
114
+			unsigned int size;
115
+			int offset;
116
+		};
117
+		struct {
118
+			unsigned char basesize;
119
+			unsigned char lshift;
120
+			unsigned char rshift;
121
+		};
122
+		unsigned long immediate;
123
+		void *data;
124
+	};
125
+};
126
+
127
+/* fetch + deref*N + store + mod + end <= 16, this allows N=12, enough */
128
+#define FETCH_INSN_MAX	16
129
+#define FETCH_TOKEN_COMM	(-ECOMM)
100130 
101131 /* Fetch type information table */
102132 struct fetch_type {
....@@ -106,13 +136,6 @@
106136 	print_type_func_t	print;		/* Print functions */
107137 	const char		*fmt;		/* Fromat string */
108138 	const char		*fmttype;	/* Name in format file */
109
-	/* Fetch functions */
110
-	fetch_func_t		fetch[FETCH_MTD_END];
111
-};
112
-
113
-struct fetch_param {
114
-	fetch_func_t		fn;
115
-	void 			*data;
116139 };
117140 
118141 /* For defining macros, define string/string_size types */
....@@ -124,8 +147,7 @@
124147 
125148 /* Printing  in basic type function template */
126149 #define DECLARE_BASIC_PRINT_TYPE_FUNC(type)				\
127
-int PRINT_TYPE_FUNC_NAME(type)(struct trace_seq *s, const char *name,	\
128
-				void *data, void *ent);			\
150
+int PRINT_TYPE_FUNC_NAME(type)(struct trace_seq *s, void *data, void *ent);\
129151 extern const char PRINT_TYPE_FMT_NAME(type)[]
130152 
131153 DECLARE_BASIC_PRINT_TYPE_FUNC(u8);
....@@ -142,57 +164,7 @@
142164 DECLARE_BASIC_PRINT_TYPE_FUNC(x64);
143165 
144166 DECLARE_BASIC_PRINT_TYPE_FUNC(string);
145
-
146
-#define FETCH_FUNC_NAME(method, type)	fetch_##method##_##type
147
-
148
-/* Declare macro for basic types */
149
-#define DECLARE_FETCH_FUNC(method, type)				\
150
-extern void FETCH_FUNC_NAME(method, type)(struct pt_regs *regs, 	\
151
-					  void *data, void *dest)
152
-
153
-#define DECLARE_BASIC_FETCH_FUNCS(method) 	\
154
-DECLARE_FETCH_FUNC(method, u8);			\
155
-DECLARE_FETCH_FUNC(method, u16);		\
156
-DECLARE_FETCH_FUNC(method, u32);		\
157
-DECLARE_FETCH_FUNC(method, u64)
158
-
159
-DECLARE_BASIC_FETCH_FUNCS(reg);
160
-#define fetch_reg_string			NULL
161
-#define fetch_reg_string_size			NULL
162
-
163
-DECLARE_BASIC_FETCH_FUNCS(retval);
164
-#define fetch_retval_string			NULL
165
-#define fetch_retval_string_size		NULL
166
-
167
-DECLARE_BASIC_FETCH_FUNCS(symbol);
168
-DECLARE_FETCH_FUNC(symbol, string);
169
-DECLARE_FETCH_FUNC(symbol, string_size);
170
-
171
-DECLARE_BASIC_FETCH_FUNCS(deref);
172
-DECLARE_FETCH_FUNC(deref, string);
173
-DECLARE_FETCH_FUNC(deref, string_size);
174
-
175
-DECLARE_BASIC_FETCH_FUNCS(bitfield);
176
-#define fetch_bitfield_string			NULL
177
-#define fetch_bitfield_string_size		NULL
178
-
179
-/* comm only makes sense as a string */
180
-#define fetch_comm_u8		NULL
181
-#define fetch_comm_u16		NULL
182
-#define fetch_comm_u32		NULL
183
-#define fetch_comm_u64		NULL
184
-DECLARE_FETCH_FUNC(comm, string);
185
-DECLARE_FETCH_FUNC(comm, string_size);
186
-
187
-/*
188
- * Define macro for basic types - we don't need to define s* types, because
189
- * we have to care only about bitwidth at recording time.
190
- */
191
-#define DEFINE_BASIC_FETCH_FUNCS(method) \
192
-DEFINE_FETCH_##method(u8)		\
193
-DEFINE_FETCH_##method(u16)		\
194
-DEFINE_FETCH_##method(u32)		\
195
-DEFINE_FETCH_##method(u64)
167
+DECLARE_BASIC_PRINT_TYPE_FUNC(symbol);
196168 
197169 /* Default (unsigned long) fetch type */
198170 #define __DEFAULT_FETCH_TYPE(t) x##t
....@@ -200,8 +172,9 @@
200172 #define DEFAULT_FETCH_TYPE _DEFAULT_FETCH_TYPE(BITS_PER_LONG)
201173 #define DEFAULT_FETCH_TYPE_STR __stringify(DEFAULT_FETCH_TYPE)
202174 
203
-#define ASSIGN_FETCH_FUNC(method, type)	\
204
-	[FETCH_MTD_##method] = FETCH_FUNC_NAME(method, type)
175
+#define __ADDR_FETCH_TYPE(t) u##t
176
+#define _ADDR_FETCH_TYPE(t) __ADDR_FETCH_TYPE(t)
177
+#define ADDR_FETCH_TYPE _ADDR_FETCH_TYPE(BITS_PER_LONG)
205178 
206179 #define __ASSIGN_FETCH_TYPE(_name, ptype, ftype, _size, sign, _fmttype)	\
207180 	{.name = _name,				\
....@@ -210,64 +183,23 @@
210183 	 .print = PRINT_TYPE_FUNC_NAME(ptype),		\
211184 	 .fmt = PRINT_TYPE_FMT_NAME(ptype),		\
212185 	 .fmttype = _fmttype,				\
213
-	 .fetch = {					\
214
-ASSIGN_FETCH_FUNC(reg, ftype),				\
215
-ASSIGN_FETCH_FUNC(stack, ftype),			\
216
-ASSIGN_FETCH_FUNC(retval, ftype),			\
217
-ASSIGN_FETCH_FUNC(comm, ftype),				\
218
-ASSIGN_FETCH_FUNC(memory, ftype),			\
219
-ASSIGN_FETCH_FUNC(symbol, ftype),			\
220
-ASSIGN_FETCH_FUNC(deref, ftype),			\
221
-ASSIGN_FETCH_FUNC(bitfield, ftype),			\
222
-ASSIGN_FETCH_FUNC(file_offset, ftype),			\
223
-	  }						\
224186 	}
225
-
187
+#define _ASSIGN_FETCH_TYPE(_name, ptype, ftype, _size, sign, _fmttype)	\
188
+	__ASSIGN_FETCH_TYPE(_name, ptype, ftype, _size, sign, #_fmttype)
226189 #define ASSIGN_FETCH_TYPE(ptype, ftype, sign)			\
227
-	__ASSIGN_FETCH_TYPE(#ptype, ptype, ftype, sizeof(ftype), sign, #ptype)
190
+	_ASSIGN_FETCH_TYPE(#ptype, ptype, ftype, sizeof(ftype), sign, ptype)
228191 
229192 /* If ptype is an alias of atype, use this macro (show atype in format) */
230193 #define ASSIGN_FETCH_TYPE_ALIAS(ptype, atype, ftype, sign)		\
231
-	__ASSIGN_FETCH_TYPE(#ptype, ptype, ftype, sizeof(ftype), sign, #atype)
194
+	_ASSIGN_FETCH_TYPE(#ptype, ptype, ftype, sizeof(ftype), sign, atype)
232195 
233196 #define ASSIGN_FETCH_TYPE_END {}
234
-
235
-#define FETCH_TYPE_STRING	0
236
-#define FETCH_TYPE_STRSIZE	1
197
+#define MAX_ARRAY_LEN	64
237198 
238199 #ifdef CONFIG_KPROBE_EVENTS
239
-struct symbol_cache;
240
-unsigned long update_symbol_cache(struct symbol_cache *sc);
241
-void free_symbol_cache(struct symbol_cache *sc);
242
-struct symbol_cache *alloc_symbol_cache(const char *sym, long offset);
243200 bool trace_kprobe_on_func_entry(struct trace_event_call *call);
244201 bool trace_kprobe_error_injectable(struct trace_event_call *call);
245202 #else
246
-/* uprobes do not support symbol fetch methods */
247
-#define fetch_symbol_u8			NULL
248
-#define fetch_symbol_u16		NULL
249
-#define fetch_symbol_u32		NULL
250
-#define fetch_symbol_u64		NULL
251
-#define fetch_symbol_string		NULL
252
-#define fetch_symbol_string_size	NULL
253
-
254
-struct symbol_cache {
255
-};
256
-static inline unsigned long __used update_symbol_cache(struct symbol_cache *sc)
257
-{
258
-	return 0;
259
-}
260
-
261
-static inline void __used free_symbol_cache(struct symbol_cache *sc)
262
-{
263
-}
264
-
265
-static inline struct symbol_cache * __used
266
-alloc_symbol_cache(const char *sym, long offset)
267
-{
268
-	return NULL;
269
-}
270
-
271203 static inline bool trace_kprobe_on_func_entry(struct trace_event_call *call)
272204 {
273205 	return false;
....@@ -280,19 +212,35 @@
280212 #endif /* CONFIG_KPROBE_EVENTS */
281213 
282214 struct probe_arg {
283
-	struct fetch_param	fetch;
284
-	struct fetch_param	fetch_size;
215
+	struct fetch_insn	*code;
216
+	bool			dynamic;/* Dynamic array (string) is used */
285217 	unsigned int		offset;	/* Offset from argument entry */
218
+	unsigned int		count;	/* Array count */
286219 	const char		*name;	/* Name of this argument */
287220 	const char		*comm;	/* Command of this argument */
221
+	char			*fmt;	/* Format string if needed */
288222 	const struct fetch_type	*type;	/* Type of this argument */
289223 };
290224 
291
-struct trace_probe {
225
+struct trace_uprobe_filter {
226
+	rwlock_t		rwlock;
227
+	int			nr_systemwide;
228
+	struct list_head	perf_events;
229
+};
230
+
231
+/* Event call and class holder */
232
+struct trace_probe_event {
292233 	unsigned int			flags;	/* For TP_FLAG_* */
293234 	struct trace_event_class	class;
294235 	struct trace_event_call		call;
295236 	struct list_head 		files;
237
+	struct list_head		probes;
238
+	struct trace_uprobe_filter	filter[];
239
+};
240
+
241
+struct trace_probe {
242
+	struct list_head		list;
243
+	struct trace_probe_event	*event;
296244 	ssize_t				size;	/* trace entry size */
297245 	unsigned int			nr_args;
298246 	struct probe_arg		args[];
....@@ -303,107 +251,118 @@
303251 	struct list_head		list;
304252 };
305253 
254
+static inline bool trace_probe_test_flag(struct trace_probe *tp,
255
+					 unsigned int flag)
256
+{
257
+	return !!(tp->event->flags & flag);
258
+}
259
+
260
+static inline void trace_probe_set_flag(struct trace_probe *tp,
261
+					unsigned int flag)
262
+{
263
+	tp->event->flags |= flag;
264
+}
265
+
266
+static inline void trace_probe_clear_flag(struct trace_probe *tp,
267
+					  unsigned int flag)
268
+{
269
+	tp->event->flags &= ~flag;
270
+}
271
+
306272 static inline bool trace_probe_is_enabled(struct trace_probe *tp)
307273 {
308
-	return !!(tp->flags & (TP_FLAG_TRACE | TP_FLAG_PROFILE));
274
+	return trace_probe_test_flag(tp, TP_FLAG_TRACE | TP_FLAG_PROFILE);
309275 }
310276 
311
-static inline bool trace_probe_is_registered(struct trace_probe *tp)
277
+static inline const char *trace_probe_name(struct trace_probe *tp)
312278 {
313
-	return !!(tp->flags & TP_FLAG_REGISTERED);
279
+	return trace_event_name(&tp->event->call);
314280 }
315281 
316
-static nokprobe_inline void call_fetch(struct fetch_param *fprm,
317
-				 struct pt_regs *regs, void *dest)
282
+static inline const char *trace_probe_group_name(struct trace_probe *tp)
318283 {
319
-	return fprm->fn(regs, fprm->data, dest);
284
+	return tp->event->call.class->system;
320285 }
321286 
322
-/* Check the name is good for event/group/fields */
323
-static inline bool is_good_name(const char *name)
287
+static inline struct trace_event_call *
288
+	trace_probe_event_call(struct trace_probe *tp)
324289 {
325
-	if (!isalpha(*name) && *name != '_')
326
-		return false;
327
-	while (*++name != '\0') {
328
-		if (!isalpha(*name) && !isdigit(*name) && *name != '_')
329
-			return false;
330
-	}
331
-	return true;
290
+	return &tp->event->call;
332291 }
333292 
334
-static inline struct event_file_link *
335
-find_event_file_link(struct trace_probe *tp, struct trace_event_file *file)
293
+static inline struct trace_probe_event *
294
+trace_probe_event_from_call(struct trace_event_call *event_call)
336295 {
337
-	struct event_file_link *link;
338
-
339
-	list_for_each_entry(link, &tp->files, list)
340
-		if (link->file == file)
341
-			return link;
342
-
343
-	return NULL;
296
+	return container_of(event_call, struct trace_probe_event, call);
344297 }
345298 
346
-extern int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
347
-		   struct probe_arg *parg, bool is_return, bool is_kprobe,
348
-		   const struct fetch_type *ftbl);
299
+static inline struct trace_probe *
300
+trace_probe_primary_from_call(struct trace_event_call *call)
301
+{
302
+	struct trace_probe_event *tpe = trace_probe_event_from_call(call);
349303 
350
-extern int traceprobe_conflict_field_name(const char *name,
351
-			       struct probe_arg *args, int narg);
304
+	return list_first_entry_or_null(&tpe->probes, struct trace_probe, list);
305
+}
352306 
353
-extern void traceprobe_update_arg(struct probe_arg *arg);
307
+static inline struct list_head *trace_probe_probe_list(struct trace_probe *tp)
308
+{
309
+	return &tp->event->probes;
310
+}
311
+
312
+static inline bool trace_probe_has_sibling(struct trace_probe *tp)
313
+{
314
+	struct list_head *list = trace_probe_probe_list(tp);
315
+
316
+	return !list_empty(list) && !list_is_singular(list);
317
+}
318
+
319
+static inline int trace_probe_unregister_event_call(struct trace_probe *tp)
320
+{
321
+	/* tp->event is unregistered in trace_remove_event_call() */
322
+	return trace_remove_event_call(&tp->event->call);
323
+}
324
+
325
+static inline bool trace_probe_has_single_file(struct trace_probe *tp)
326
+{
327
+	return !!list_is_singular(&tp->event->files);
328
+}
329
+
330
+int trace_probe_init(struct trace_probe *tp, const char *event,
331
+		     const char *group, bool alloc_filter);
332
+void trace_probe_cleanup(struct trace_probe *tp);
333
+int trace_probe_append(struct trace_probe *tp, struct trace_probe *to);
334
+void trace_probe_unlink(struct trace_probe *tp);
335
+int trace_probe_register_event_call(struct trace_probe *tp);
336
+int trace_probe_add_file(struct trace_probe *tp, struct trace_event_file *file);
337
+int trace_probe_remove_file(struct trace_probe *tp,
338
+			    struct trace_event_file *file);
339
+struct event_file_link *trace_probe_get_file_link(struct trace_probe *tp,
340
+						struct trace_event_file *file);
341
+int trace_probe_compare_arg_type(struct trace_probe *a, struct trace_probe *b);
342
+bool trace_probe_match_command_args(struct trace_probe *tp,
343
+				    int argc, const char **argv);
344
+
345
+#define trace_probe_for_each_link(pos, tp)	\
346
+	list_for_each_entry(pos, &(tp)->event->files, list)
347
+#define trace_probe_for_each_link_rcu(pos, tp)	\
348
+	list_for_each_entry_rcu(pos, &(tp)->event->files, list)
349
+
350
+#define TPARG_FL_RETURN BIT(0)
351
+#define TPARG_FL_KERNEL BIT(1)
352
+#define TPARG_FL_FENTRY BIT(2)
353
+#define TPARG_FL_MASK	GENMASK(2, 0)
354
+
355
+extern int traceprobe_parse_probe_arg(struct trace_probe *tp, int i,
356
+				char *arg, unsigned int flags);
357
+
358
+extern int traceprobe_update_arg(struct probe_arg *arg);
354359 extern void traceprobe_free_probe_arg(struct probe_arg *arg);
355360 
356361 extern int traceprobe_split_symbol_offset(char *symbol, long *offset);
362
+int traceprobe_parse_event_name(const char **pevent, const char **pgroup,
363
+				char *buf, int offset);
357364 
358
-/* Sum up total data length for dynamic arraies (strings) */
359
-static nokprobe_inline int
360
-__get_data_size(struct trace_probe *tp, struct pt_regs *regs)
361
-{
362
-	int i, ret = 0;
363
-	u32 len;
364
-
365
-	for (i = 0; i < tp->nr_args; i++)
366
-		if (unlikely(tp->args[i].fetch_size.fn)) {
367
-			call_fetch(&tp->args[i].fetch_size, regs, &len);
368
-			ret += len;
369
-		}
370
-
371
-	return ret;
372
-}
373
-
374
-/* Store the value of each argument */
375
-static nokprobe_inline void
376
-store_trace_args(int ent_size, struct trace_probe *tp, struct pt_regs *regs,
377
-		 u8 *data, int maxlen)
378
-{
379
-	int i;
380
-	u32 end = tp->size;
381
-	u32 *dl;	/* Data (relative) location */
382
-
383
-	for (i = 0; i < tp->nr_args; i++) {
384
-		if (unlikely(tp->args[i].fetch_size.fn)) {
385
-			/*
386
-			 * First, we set the relative location and
387
-			 * maximum data length to *dl
388
-			 */
389
-			dl = (u32 *)(data + tp->args[i].offset);
390
-			*dl = make_data_rloc(maxlen, end - tp->args[i].offset);
391
-			/* Then try to fetch string or dynamic array data */
392
-			call_fetch(&tp->args[i].fetch, regs, dl);
393
-			/* Reduce maximum length */
394
-			end += get_rloc_len(*dl);
395
-			maxlen -= get_rloc_len(*dl);
396
-			/* Trick here, convert data_rloc to data_loc */
397
-			*dl = convert_rloc_to_loc(*dl,
398
-				 ent_size + tp->args[i].offset);
399
-		} else
400
-			/* Just fetching data normally */
401
-			call_fetch(&tp->args[i].fetch, regs,
402
-				   data + tp->args[i].offset);
403
-	}
404
-}
405
-
406
-extern int set_print_fmt(struct trace_probe *tp, bool is_return);
365
+extern int traceprobe_set_print_fmt(struct trace_probe *tp, bool is_return);
407366 
408367 #ifdef CONFIG_PERF_EVENTS
409368 extern struct trace_event_call *
....@@ -412,6 +371,89 @@
412371 extern void destroy_local_trace_kprobe(struct trace_event_call *event_call);
413372 
414373 extern struct trace_event_call *
415
-create_local_trace_uprobe(char *name, unsigned long offs, bool is_return);
374
+create_local_trace_uprobe(char *name, unsigned long offs,
375
+			  unsigned long ref_ctr_offset, bool is_return);
416376 extern void destroy_local_trace_uprobe(struct trace_event_call *event_call);
417377 #endif
378
+extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,
379
+					size_t offset, struct trace_probe *tp);
380
+
381
+#undef ERRORS
382
+#define ERRORS	\
383
+	C(FILE_NOT_FOUND,	"Failed to find the given file"),	\
384
+	C(NO_REGULAR_FILE,	"Not a regular file"),			\
385
+	C(BAD_REFCNT,		"Invalid reference counter offset"),	\
386
+	C(REFCNT_OPEN_BRACE,	"Reference counter brace is not closed"), \
387
+	C(BAD_REFCNT_SUFFIX,	"Reference counter has wrong suffix"),	\
388
+	C(BAD_UPROBE_OFFS,	"Invalid uprobe offset"),		\
389
+	C(MAXACT_NO_KPROBE,	"Maxactive is not for kprobe"),		\
390
+	C(BAD_MAXACT,		"Invalid maxactive number"),		\
391
+	C(MAXACT_TOO_BIG,	"Maxactive is too big"),		\
392
+	C(BAD_PROBE_ADDR,	"Invalid probed address or symbol"),	\
393
+	C(BAD_RETPROBE,		"Retprobe address must be an function entry"), \
394
+	C(BAD_ADDR_SUFFIX,	"Invalid probed address suffix"), \
395
+	C(NO_GROUP_NAME,	"Group name is not specified"),		\
396
+	C(GROUP_TOO_LONG,	"Group name is too long"),		\
397
+	C(BAD_GROUP_NAME,	"Group name must follow the same rules as C identifiers"), \
398
+	C(NO_EVENT_NAME,	"Event name is not specified"),		\
399
+	C(EVENT_TOO_LONG,	"Event name is too long"),		\
400
+	C(BAD_EVENT_NAME,	"Event name must follow the same rules as C identifiers"), \
401
+	C(EVENT_EXIST,		"Given group/event name is already used by another event"), \
402
+	C(RETVAL_ON_PROBE,	"$retval is not available on probe"),	\
403
+	C(BAD_STACK_NUM,	"Invalid stack number"),		\
404
+	C(BAD_ARG_NUM,		"Invalid argument number"),		\
405
+	C(BAD_VAR,		"Invalid $-valiable specified"),	\
406
+	C(BAD_REG_NAME,		"Invalid register name"),		\
407
+	C(BAD_MEM_ADDR,		"Invalid memory address"),		\
408
+	C(BAD_IMM,		"Invalid immediate value"),		\
409
+	C(IMMSTR_NO_CLOSE,	"String is not closed with '\"'"),	\
410
+	C(FILE_ON_KPROBE,	"File offset is not available with kprobe"), \
411
+	C(BAD_FILE_OFFS,	"Invalid file offset value"),		\
412
+	C(SYM_ON_UPROBE,	"Symbol is not available with uprobe"),	\
413
+	C(TOO_MANY_OPS,		"Dereference is too much nested"), 	\
414
+	C(DEREF_NEED_BRACE,	"Dereference needs a brace"),		\
415
+	C(BAD_DEREF_OFFS,	"Invalid dereference offset"),		\
416
+	C(DEREF_OPEN_BRACE,	"Dereference brace is not closed"),	\
417
+	C(COMM_CANT_DEREF,	"$comm can not be dereferenced"),	\
418
+	C(BAD_FETCH_ARG,	"Invalid fetch argument"),		\
419
+	C(ARRAY_NO_CLOSE,	"Array is not closed"),			\
420
+	C(BAD_ARRAY_SUFFIX,	"Array has wrong suffix"),		\
421
+	C(BAD_ARRAY_NUM,	"Invalid array size"),			\
422
+	C(ARRAY_TOO_BIG,	"Array number is too big"),		\
423
+	C(BAD_TYPE,		"Unknown type is specified"),		\
424
+	C(BAD_STRING,		"String accepts only memory argument"),	\
425
+	C(BAD_BITFIELD,		"Invalid bitfield"),			\
426
+	C(ARG_NAME_TOO_LONG,	"Argument name is too long"),		\
427
+	C(NO_ARG_NAME,		"Argument name is not specified"),	\
428
+	C(BAD_ARG_NAME,		"Argument name must follow the same rules as C identifiers"), \
429
+	C(USED_ARG_NAME,	"This argument name is already used"),	\
430
+	C(ARG_TOO_LONG,		"Argument expression is too long"),	\
431
+	C(NO_ARG_BODY,		"No argument expression"),		\
432
+	C(BAD_INSN_BNDRY,	"Probe point is not an instruction boundary"),\
433
+	C(FAIL_REG_PROBE,	"Failed to register probe event"),\
434
+	C(DIFF_PROBE_TYPE,	"Probe type is different from existing probe"),\
435
+	C(DIFF_ARG_TYPE,	"Argument type or name is different from existing probe"),\
436
+	C(SAME_PROBE,		"There is already the exact same probe event"),
437
+
438
+#undef C
439
+#define C(a, b)		TP_ERR_##a
440
+
441
+/* Define TP_ERR_ */
442
+enum { ERRORS };
443
+
444
+/* Error text is defined in trace_probe.c */
445
+
446
+struct trace_probe_log {
447
+	const char	*subsystem;
448
+	const char	**argv;
449
+	int		argc;
450
+	int		index;
451
+};
452
+
453
+void trace_probe_log_init(const char *subsystem, int argc, const char **argv);
454
+void trace_probe_log_set_index(int index);
455
+void trace_probe_log_clear(void);
456
+void __trace_probe_log_err(int offset, int err);
457
+
458
+#define trace_probe_log_err(offs, err)	\
459
+	__trace_probe_log_err(offs, TP_ERR_##err)