Merge tag 'm68k-for-v4.9-tag1' of git://git.kernel.org/pub/scm/linux/kernel/git/geert...
[platform/kernel/linux-exynos.git] / kernel / trace / trace_probe.h
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
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 */
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_comm,
106         FETCH_MTD_memory,
107         FETCH_MTD_symbol,
108         FETCH_MTD_deref,
109         FETCH_MTD_bitfield,
110         FETCH_MTD_file_offset,
111         FETCH_MTD_END,
112 };
113
114 /* Fetch type information table */
115 struct fetch_type {
116         const char              *name;          /* Name of type */
117         size_t                  size;           /* Byte size of type */
118         int                     is_signed;      /* Signed flag */
119         print_type_func_t       print;          /* Print functions */
120         const char              *fmt;           /* Fromat string */
121         const char              *fmttype;       /* Name in format file */
122         /* Fetch functions */
123         fetch_func_t            fetch[FETCH_MTD_END];
124 };
125
126 struct fetch_param {
127         fetch_func_t            fn;
128         void                    *data;
129 };
130
131 /* For defining macros, define string/string_size types */
132 typedef u32 string;
133 typedef u32 string_size;
134
135 #define PRINT_TYPE_FUNC_NAME(type)      print_type_##type
136 #define PRINT_TYPE_FMT_NAME(type)       print_type_format_##type
137
138 /* Printing  in basic type function template */
139 #define DECLARE_BASIC_PRINT_TYPE_FUNC(type)                             \
140 int PRINT_TYPE_FUNC_NAME(type)(struct trace_seq *s, const char *name,   \
141                                 void *data, void *ent);                 \
142 extern const char PRINT_TYPE_FMT_NAME(type)[]
143
144 DECLARE_BASIC_PRINT_TYPE_FUNC(u8);
145 DECLARE_BASIC_PRINT_TYPE_FUNC(u16);
146 DECLARE_BASIC_PRINT_TYPE_FUNC(u32);
147 DECLARE_BASIC_PRINT_TYPE_FUNC(u64);
148 DECLARE_BASIC_PRINT_TYPE_FUNC(s8);
149 DECLARE_BASIC_PRINT_TYPE_FUNC(s16);
150 DECLARE_BASIC_PRINT_TYPE_FUNC(s32);
151 DECLARE_BASIC_PRINT_TYPE_FUNC(s64);
152 DECLARE_BASIC_PRINT_TYPE_FUNC(x8);
153 DECLARE_BASIC_PRINT_TYPE_FUNC(x16);
154 DECLARE_BASIC_PRINT_TYPE_FUNC(x32);
155 DECLARE_BASIC_PRINT_TYPE_FUNC(x64);
156
157 DECLARE_BASIC_PRINT_TYPE_FUNC(string);
158
159 #define FETCH_FUNC_NAME(method, type)   fetch_##method##_##type
160
161 /* Declare macro for basic types */
162 #define DECLARE_FETCH_FUNC(method, type)                                \
163 extern void FETCH_FUNC_NAME(method, type)(struct pt_regs *regs,         \
164                                           void *data, void *dest)
165
166 #define DECLARE_BASIC_FETCH_FUNCS(method)       \
167 DECLARE_FETCH_FUNC(method, u8);                 \
168 DECLARE_FETCH_FUNC(method, u16);                \
169 DECLARE_FETCH_FUNC(method, u32);                \
170 DECLARE_FETCH_FUNC(method, u64)
171
172 DECLARE_BASIC_FETCH_FUNCS(reg);
173 #define fetch_reg_string                        NULL
174 #define fetch_reg_string_size                   NULL
175
176 DECLARE_BASIC_FETCH_FUNCS(retval);
177 #define fetch_retval_string                     NULL
178 #define fetch_retval_string_size                NULL
179
180 DECLARE_BASIC_FETCH_FUNCS(symbol);
181 DECLARE_FETCH_FUNC(symbol, string);
182 DECLARE_FETCH_FUNC(symbol, string_size);
183
184 DECLARE_BASIC_FETCH_FUNCS(deref);
185 DECLARE_FETCH_FUNC(deref, string);
186 DECLARE_FETCH_FUNC(deref, string_size);
187
188 DECLARE_BASIC_FETCH_FUNCS(bitfield);
189 #define fetch_bitfield_string                   NULL
190 #define fetch_bitfield_string_size              NULL
191
192 /* comm only makes sense as a string */
193 #define fetch_comm_u8           NULL
194 #define fetch_comm_u16          NULL
195 #define fetch_comm_u32          NULL
196 #define fetch_comm_u64          NULL
197 DECLARE_FETCH_FUNC(comm, string);
198 DECLARE_FETCH_FUNC(comm, string_size);
199
200 /*
201  * Define macro for basic types - we don't need to define s* types, because
202  * we have to care only about bitwidth at recording time.
203  */
204 #define DEFINE_BASIC_FETCH_FUNCS(method) \
205 DEFINE_FETCH_##method(u8)               \
206 DEFINE_FETCH_##method(u16)              \
207 DEFINE_FETCH_##method(u32)              \
208 DEFINE_FETCH_##method(u64)
209
210 /* Default (unsigned long) fetch type */
211 #define __DEFAULT_FETCH_TYPE(t) x##t
212 #define _DEFAULT_FETCH_TYPE(t) __DEFAULT_FETCH_TYPE(t)
213 #define DEFAULT_FETCH_TYPE _DEFAULT_FETCH_TYPE(BITS_PER_LONG)
214 #define DEFAULT_FETCH_TYPE_STR __stringify(DEFAULT_FETCH_TYPE)
215
216 #define ASSIGN_FETCH_FUNC(method, type) \
217         [FETCH_MTD_##method] = FETCH_FUNC_NAME(method, type)
218
219 #define __ASSIGN_FETCH_TYPE(_name, ptype, ftype, _size, sign, _fmttype) \
220         {.name = _name,                         \
221          .size = _size,                                 \
222          .is_signed = sign,                             \
223          .print = PRINT_TYPE_FUNC_NAME(ptype),          \
224          .fmt = PRINT_TYPE_FMT_NAME(ptype),             \
225          .fmttype = _fmttype,                           \
226          .fetch = {                                     \
227 ASSIGN_FETCH_FUNC(reg, ftype),                          \
228 ASSIGN_FETCH_FUNC(stack, ftype),                        \
229 ASSIGN_FETCH_FUNC(retval, ftype),                       \
230 ASSIGN_FETCH_FUNC(comm, ftype),                         \
231 ASSIGN_FETCH_FUNC(memory, ftype),                       \
232 ASSIGN_FETCH_FUNC(symbol, ftype),                       \
233 ASSIGN_FETCH_FUNC(deref, ftype),                        \
234 ASSIGN_FETCH_FUNC(bitfield, ftype),                     \
235 ASSIGN_FETCH_FUNC(file_offset, ftype),                  \
236           }                                             \
237         }
238
239 #define ASSIGN_FETCH_TYPE(ptype, ftype, sign)                   \
240         __ASSIGN_FETCH_TYPE(#ptype, ptype, ftype, sizeof(ftype), sign, #ptype)
241
242 /* If ptype is an alias of atype, use this macro (show atype in format) */
243 #define ASSIGN_FETCH_TYPE_ALIAS(ptype, atype, ftype, sign)              \
244         __ASSIGN_FETCH_TYPE(#ptype, ptype, ftype, sizeof(ftype), sign, #atype)
245
246 #define ASSIGN_FETCH_TYPE_END {}
247
248 #define FETCH_TYPE_STRING       0
249 #define FETCH_TYPE_STRSIZE      1
250
251 #ifdef CONFIG_KPROBE_EVENT
252 struct symbol_cache;
253 unsigned long update_symbol_cache(struct symbol_cache *sc);
254 void free_symbol_cache(struct symbol_cache *sc);
255 struct symbol_cache *alloc_symbol_cache(const char *sym, long offset);
256 #else
257 /* uprobes do not support symbol fetch methods */
258 #define fetch_symbol_u8                 NULL
259 #define fetch_symbol_u16                NULL
260 #define fetch_symbol_u32                NULL
261 #define fetch_symbol_u64                NULL
262 #define fetch_symbol_string             NULL
263 #define fetch_symbol_string_size        NULL
264
265 struct symbol_cache {
266 };
267 static inline unsigned long __used update_symbol_cache(struct symbol_cache *sc)
268 {
269         return 0;
270 }
271
272 static inline void __used free_symbol_cache(struct symbol_cache *sc)
273 {
274 }
275
276 static inline struct symbol_cache * __used
277 alloc_symbol_cache(const char *sym, long offset)
278 {
279         return NULL;
280 }
281 #endif /* CONFIG_KPROBE_EVENT */
282
283 struct probe_arg {
284         struct fetch_param      fetch;
285         struct fetch_param      fetch_size;
286         unsigned int            offset; /* Offset from argument entry */
287         const char              *name;  /* Name of this argument */
288         const char              *comm;  /* Command of this argument */
289         const struct fetch_type *type;  /* Type of this argument */
290 };
291
292 struct trace_probe {
293         unsigned int                    flags;  /* For TP_FLAG_* */
294         struct trace_event_class        class;
295         struct trace_event_call         call;
296         struct list_head                files;
297         ssize_t                         size;   /* trace entry size */
298         unsigned int                    nr_args;
299         struct probe_arg                args[];
300 };
301
302 struct event_file_link {
303         struct trace_event_file         *file;
304         struct list_head                list;
305 };
306
307 static inline bool trace_probe_is_enabled(struct trace_probe *tp)
308 {
309         return !!(tp->flags & (TP_FLAG_TRACE | TP_FLAG_PROFILE));
310 }
311
312 static inline bool trace_probe_is_registered(struct trace_probe *tp)
313 {
314         return !!(tp->flags & TP_FLAG_REGISTERED);
315 }
316
317 static nokprobe_inline void call_fetch(struct fetch_param *fprm,
318                                  struct pt_regs *regs, void *dest)
319 {
320         return fprm->fn(regs, fprm->data, dest);
321 }
322
323 /* Check the name is good for event/group/fields */
324 static inline bool is_good_name(const char *name)
325 {
326         if (!isalpha(*name) && *name != '_')
327                 return false;
328         while (*++name != '\0') {
329                 if (!isalpha(*name) && !isdigit(*name) && *name != '_')
330                         return false;
331         }
332         return true;
333 }
334
335 static inline struct event_file_link *
336 find_event_file_link(struct trace_probe *tp, struct trace_event_file *file)
337 {
338         struct event_file_link *link;
339
340         list_for_each_entry(link, &tp->files, list)
341                 if (link->file == file)
342                         return link;
343
344         return NULL;
345 }
346
347 extern int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
348                    struct probe_arg *parg, bool is_return, bool is_kprobe,
349                    const struct fetch_type *ftbl);
350
351 extern int traceprobe_conflict_field_name(const char *name,
352                                struct probe_arg *args, int narg);
353
354 extern void traceprobe_update_arg(struct probe_arg *arg);
355 extern void traceprobe_free_probe_arg(struct probe_arg *arg);
356
357 extern int traceprobe_split_symbol_offset(char *symbol, unsigned long *offset);
358
359 extern ssize_t traceprobe_probes_write(struct file *file,
360                 const char __user *buffer, size_t count, loff_t *ppos,
361                 int (*createfn)(int, char**));
362
363 extern int traceprobe_command(const char *buf, int (*createfn)(int, char**));
364
365 /* Sum up total data length for dynamic arraies (strings) */
366 static nokprobe_inline int
367 __get_data_size(struct trace_probe *tp, struct pt_regs *regs)
368 {
369         int i, ret = 0;
370         u32 len;
371
372         for (i = 0; i < tp->nr_args; i++)
373                 if (unlikely(tp->args[i].fetch_size.fn)) {
374                         call_fetch(&tp->args[i].fetch_size, regs, &len);
375                         ret += len;
376                 }
377
378         return ret;
379 }
380
381 /* Store the value of each argument */
382 static nokprobe_inline void
383 store_trace_args(int ent_size, struct trace_probe *tp, struct pt_regs *regs,
384                  u8 *data, int maxlen)
385 {
386         int i;
387         u32 end = tp->size;
388         u32 *dl;        /* Data (relative) location */
389
390         for (i = 0; i < tp->nr_args; i++) {
391                 if (unlikely(tp->args[i].fetch_size.fn)) {
392                         /*
393                          * First, we set the relative location and
394                          * maximum data length to *dl
395                          */
396                         dl = (u32 *)(data + tp->args[i].offset);
397                         *dl = make_data_rloc(maxlen, end - tp->args[i].offset);
398                         /* Then try to fetch string or dynamic array data */
399                         call_fetch(&tp->args[i].fetch, regs, dl);
400                         /* Reduce maximum length */
401                         end += get_rloc_len(*dl);
402                         maxlen -= get_rloc_len(*dl);
403                         /* Trick here, convert data_rloc to data_loc */
404                         *dl = convert_rloc_to_loc(*dl,
405                                  ent_size + tp->args[i].offset);
406                 } else
407                         /* Just fetching data normally */
408                         call_fetch(&tp->args[i].fetch, regs,
409                                    data + tp->args[i].offset);
410         }
411 }
412
413 extern int set_print_fmt(struct trace_probe *tp, bool is_return);