Branch data Line data Source code
1 : :
2 : : #ifndef _LINUX_FTRACE_EVENT_H
3 : : #define _LINUX_FTRACE_EVENT_H
4 : :
5 : : #include <linux/ring_buffer.h>
6 : : #include <linux/trace_seq.h>
7 : : #include <linux/percpu.h>
8 : : #include <linux/hardirq.h>
9 : : #include <linux/perf_event.h>
10 : :
11 : : struct trace_array;
12 : : struct trace_buffer;
13 : : struct tracer;
14 : : struct dentry;
15 : :
16 : : struct trace_print_flags {
17 : : unsigned long mask;
18 : : const char *name;
19 : : };
20 : :
21 : : struct trace_print_flags_u64 {
22 : : unsigned long long mask;
23 : : const char *name;
24 : : };
25 : :
26 : : const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
27 : : unsigned long flags,
28 : : const struct trace_print_flags *flag_array);
29 : :
30 : : const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
31 : : const struct trace_print_flags *symbol_array);
32 : :
33 : : #if BITS_PER_LONG == 32
34 : : const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
35 : : unsigned long long val,
36 : : const struct trace_print_flags_u64
37 : : *symbol_array);
38 : : #endif
39 : :
40 : : const char *ftrace_print_hex_seq(struct trace_seq *p,
41 : : const unsigned char *buf, int len);
42 : :
43 : : struct trace_iterator;
44 : : struct trace_event;
45 : :
46 : : int ftrace_raw_output_prep(struct trace_iterator *iter,
47 : : struct trace_event *event);
48 : :
49 : : /*
50 : : * The trace entry - the most basic unit of tracing. This is what
51 : : * is printed in the end as a single line in the trace output, such as:
52 : : *
53 : : * bash-15816 [01] 235.197585: idle_cpu <- irq_enter
54 : : */
55 : : struct trace_entry {
56 : : unsigned short type;
57 : : unsigned char flags;
58 : : unsigned char preempt_count;
59 : : int pid;
60 : : };
61 : :
62 : : #define FTRACE_MAX_EVENT \
63 : : ((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1)
64 : :
65 : : /*
66 : : * Trace iterator - used by printout routines who present trace
67 : : * results to users and which routines might sleep, etc:
68 : : */
69 : : struct trace_iterator {
70 : : struct trace_array *tr;
71 : : struct tracer *trace;
72 : : struct trace_buffer *trace_buffer;
73 : : void *private;
74 : : int cpu_file;
75 : : struct mutex mutex;
76 : : struct ring_buffer_iter **buffer_iter;
77 : : unsigned long iter_flags;
78 : :
79 : : /* trace_seq for __print_flags() and __print_symbolic() etc. */
80 : : struct trace_seq tmp_seq;
81 : :
82 : : cpumask_var_t started;
83 : :
84 : : /* it's true when current open file is snapshot */
85 : : bool snapshot;
86 : :
87 : : /* The below is zeroed out in pipe_read */
88 : : struct trace_seq seq;
89 : : struct trace_entry *ent;
90 : : unsigned long lost_events;
91 : : int leftover;
92 : : int ent_size;
93 : : int cpu;
94 : : u64 ts;
95 : :
96 : : loff_t pos;
97 : : long idx;
98 : :
99 : : /* All new field here will be zeroed out in pipe_read */
100 : : };
101 : :
102 : : enum trace_iter_flags {
103 : : TRACE_FILE_LAT_FMT = 1,
104 : : TRACE_FILE_ANNOTATE = 2,
105 : : TRACE_FILE_TIME_IN_NS = 4,
106 : : };
107 : :
108 : :
109 : : typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter,
110 : : int flags, struct trace_event *event);
111 : :
112 : : struct trace_event_functions {
113 : : trace_print_func trace;
114 : : trace_print_func raw;
115 : : trace_print_func hex;
116 : : trace_print_func binary;
117 : : };
118 : :
119 : : struct trace_event {
120 : : struct hlist_node node;
121 : : struct list_head list;
122 : : int type;
123 : : struct trace_event_functions *funcs;
124 : : };
125 : :
126 : : extern int register_ftrace_event(struct trace_event *event);
127 : : extern int unregister_ftrace_event(struct trace_event *event);
128 : :
129 : : /* Return values for print_line callback */
130 : : enum print_line_t {
131 : : TRACE_TYPE_PARTIAL_LINE = 0, /* Retry after flushing the seq */
132 : : TRACE_TYPE_HANDLED = 1,
133 : : TRACE_TYPE_UNHANDLED = 2, /* Relay to other output functions */
134 : : TRACE_TYPE_NO_CONSUME = 3 /* Handled but ask to not consume */
135 : : };
136 : :
137 : : void tracing_generic_entry_update(struct trace_entry *entry,
138 : : unsigned long flags,
139 : : int pc);
140 : : struct ftrace_event_file;
141 : :
142 : : struct ring_buffer_event *
143 : : trace_event_buffer_lock_reserve(struct ring_buffer **current_buffer,
144 : : struct ftrace_event_file *ftrace_file,
145 : : int type, unsigned long len,
146 : : unsigned long flags, int pc);
147 : : struct ring_buffer_event *
148 : : trace_current_buffer_lock_reserve(struct ring_buffer **current_buffer,
149 : : int type, unsigned long len,
150 : : unsigned long flags, int pc);
151 : : void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
152 : : struct ring_buffer_event *event,
153 : : unsigned long flags, int pc);
154 : : void trace_buffer_unlock_commit(struct ring_buffer *buffer,
155 : : struct ring_buffer_event *event,
156 : : unsigned long flags, int pc);
157 : : void trace_buffer_unlock_commit_regs(struct ring_buffer *buffer,
158 : : struct ring_buffer_event *event,
159 : : unsigned long flags, int pc,
160 : : struct pt_regs *regs);
161 : : void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
162 : : struct ring_buffer_event *event);
163 : :
164 : : void tracing_record_cmdline(struct task_struct *tsk);
165 : :
166 : : struct event_filter;
167 : :
168 : : enum trace_reg {
169 : : TRACE_REG_REGISTER,
170 : : TRACE_REG_UNREGISTER,
171 : : #ifdef CONFIG_PERF_EVENTS
172 : : TRACE_REG_PERF_REGISTER,
173 : : TRACE_REG_PERF_UNREGISTER,
174 : : TRACE_REG_PERF_OPEN,
175 : : TRACE_REG_PERF_CLOSE,
176 : : TRACE_REG_PERF_ADD,
177 : : TRACE_REG_PERF_DEL,
178 : : #endif
179 : : };
180 : :
181 : : struct ftrace_event_call;
182 : :
183 : : struct ftrace_event_class {
184 : : char *system;
185 : : void *probe;
186 : : #ifdef CONFIG_PERF_EVENTS
187 : : void *perf_probe;
188 : : #endif
189 : : int (*reg)(struct ftrace_event_call *event,
190 : : enum trace_reg type, void *data);
191 : : int (*define_fields)(struct ftrace_event_call *);
192 : : struct list_head *(*get_fields)(struct ftrace_event_call *);
193 : : struct list_head fields;
194 : : int (*raw_init)(struct ftrace_event_call *);
195 : : };
196 : :
197 : : extern int ftrace_event_reg(struct ftrace_event_call *event,
198 : : enum trace_reg type, void *data);
199 : :
200 : : enum {
201 : : TRACE_EVENT_FL_FILTERED_BIT,
202 : : TRACE_EVENT_FL_CAP_ANY_BIT,
203 : : TRACE_EVENT_FL_NO_SET_FILTER_BIT,
204 : : TRACE_EVENT_FL_IGNORE_ENABLE_BIT,
205 : : TRACE_EVENT_FL_WAS_ENABLED_BIT,
206 : : TRACE_EVENT_FL_USE_CALL_FILTER_BIT,
207 : : };
208 : :
209 : : /*
210 : : * Event flags:
211 : : * FILTERED - The event has a filter attached
212 : : * CAP_ANY - Any user can enable for perf
213 : : * NO_SET_FILTER - Set when filter has error and is to be ignored
214 : : * IGNORE_ENABLE - For ftrace internal events, do not enable with debugfs file
215 : : * WAS_ENABLED - Set and stays set when an event was ever enabled
216 : : * (used for module unloading, if a module event is enabled,
217 : : * it is best to clear the buffers that used it).
218 : : * USE_CALL_FILTER - For ftrace internal events, don't use file filter
219 : : */
220 : : enum {
221 : : TRACE_EVENT_FL_FILTERED = (1 << TRACE_EVENT_FL_FILTERED_BIT),
222 : : TRACE_EVENT_FL_CAP_ANY = (1 << TRACE_EVENT_FL_CAP_ANY_BIT),
223 : : TRACE_EVENT_FL_NO_SET_FILTER = (1 << TRACE_EVENT_FL_NO_SET_FILTER_BIT),
224 : : TRACE_EVENT_FL_IGNORE_ENABLE = (1 << TRACE_EVENT_FL_IGNORE_ENABLE_BIT),
225 : : TRACE_EVENT_FL_WAS_ENABLED = (1 << TRACE_EVENT_FL_WAS_ENABLED_BIT),
226 : : TRACE_EVENT_FL_USE_CALL_FILTER = (1 << TRACE_EVENT_FL_USE_CALL_FILTER_BIT),
227 : : };
228 : :
229 : : struct ftrace_event_call {
230 : : struct list_head list;
231 : : struct ftrace_event_class *class;
232 : : char *name;
233 : : struct trace_event event;
234 : : const char *print_fmt;
235 : : struct event_filter *filter;
236 : : struct list_head *files;
237 : : void *mod;
238 : : void *data;
239 : : /*
240 : : * bit 0: filter_active
241 : : * bit 1: allow trace by non root (cap any)
242 : : * bit 2: failed to apply filter
243 : : * bit 3: ftrace internal event (do not enable)
244 : : * bit 4: Event was enabled by module
245 : : * bit 5: use call filter rather than file filter
246 : : */
247 : : int flags; /* static flags of different events */
248 : :
249 : : #ifdef CONFIG_PERF_EVENTS
250 : : int perf_refcount;
251 : : struct hlist_head __percpu *perf_events;
252 : :
253 : : int (*perf_perm)(struct ftrace_event_call *,
254 : : struct perf_event *);
255 : : #endif
256 : : };
257 : :
258 : : struct trace_array;
259 : : struct ftrace_subsystem_dir;
260 : :
261 : : enum {
262 : : FTRACE_EVENT_FL_ENABLED_BIT,
263 : : FTRACE_EVENT_FL_RECORDED_CMD_BIT,
264 : : FTRACE_EVENT_FL_FILTERED_BIT,
265 : : FTRACE_EVENT_FL_NO_SET_FILTER_BIT,
266 : : FTRACE_EVENT_FL_SOFT_MODE_BIT,
267 : : FTRACE_EVENT_FL_SOFT_DISABLED_BIT,
268 : : FTRACE_EVENT_FL_TRIGGER_MODE_BIT,
269 : : FTRACE_EVENT_FL_TRIGGER_COND_BIT,
270 : : };
271 : :
272 : : /*
273 : : * Ftrace event file flags:
274 : : * ENABLED - The event is enabled
275 : : * RECORDED_CMD - The comms should be recorded at sched_switch
276 : : * FILTERED - The event has a filter attached
277 : : * NO_SET_FILTER - Set when filter has error and is to be ignored
278 : : * SOFT_MODE - The event is enabled/disabled by SOFT_DISABLED
279 : : * SOFT_DISABLED - When set, do not trace the event (even though its
280 : : * tracepoint may be enabled)
281 : : * TRIGGER_MODE - When set, invoke the triggers associated with the event
282 : : * TRIGGER_COND - When set, one or more triggers has an associated filter
283 : : */
284 : : enum {
285 : : FTRACE_EVENT_FL_ENABLED = (1 << FTRACE_EVENT_FL_ENABLED_BIT),
286 : : FTRACE_EVENT_FL_RECORDED_CMD = (1 << FTRACE_EVENT_FL_RECORDED_CMD_BIT),
287 : : FTRACE_EVENT_FL_FILTERED = (1 << FTRACE_EVENT_FL_FILTERED_BIT),
288 : : FTRACE_EVENT_FL_NO_SET_FILTER = (1 << FTRACE_EVENT_FL_NO_SET_FILTER_BIT),
289 : : FTRACE_EVENT_FL_SOFT_MODE = (1 << FTRACE_EVENT_FL_SOFT_MODE_BIT),
290 : : FTRACE_EVENT_FL_SOFT_DISABLED = (1 << FTRACE_EVENT_FL_SOFT_DISABLED_BIT),
291 : : FTRACE_EVENT_FL_TRIGGER_MODE = (1 << FTRACE_EVENT_FL_TRIGGER_MODE_BIT),
292 : : FTRACE_EVENT_FL_TRIGGER_COND = (1 << FTRACE_EVENT_FL_TRIGGER_COND_BIT),
293 : : };
294 : :
295 : : struct ftrace_event_file {
296 : : struct list_head list;
297 : : struct ftrace_event_call *event_call;
298 : : struct event_filter *filter;
299 : : struct dentry *dir;
300 : : struct trace_array *tr;
301 : : struct ftrace_subsystem_dir *system;
302 : : struct list_head triggers;
303 : :
304 : : /*
305 : : * 32 bit flags:
306 : : * bit 0: enabled
307 : : * bit 1: enabled cmd record
308 : : * bit 2: enable/disable with the soft disable bit
309 : : * bit 3: soft disabled
310 : : * bit 4: trigger enabled
311 : : *
312 : : * Note: The bits must be set atomically to prevent races
313 : : * from other writers. Reads of flags do not need to be in
314 : : * sync as they occur in critical sections. But the way flags
315 : : * is currently used, these changes do not affect the code
316 : : * except that when a change is made, it may have a slight
317 : : * delay in propagating the changes to other CPUs due to
318 : : * caching and such. Which is mostly OK ;-)
319 : : */
320 : : unsigned long flags;
321 : : atomic_t sm_ref; /* soft-mode reference counter */
322 : : atomic_t tm_ref; /* trigger-mode reference counter */
323 : : };
324 : :
325 : : #define __TRACE_EVENT_FLAGS(name, value) \
326 : : static int __init trace_init_flags_##name(void) \
327 : : { \
328 : : event_##name.flags = value; \
329 : : return 0; \
330 : : } \
331 : : early_initcall(trace_init_flags_##name);
332 : :
333 : : #define __TRACE_EVENT_PERF_PERM(name, expr...) \
334 : : static int perf_perm_##name(struct ftrace_event_call *tp_event, \
335 : : struct perf_event *p_event) \
336 : : { \
337 : : return ({ expr; }); \
338 : : } \
339 : : static int __init trace_init_perf_perm_##name(void) \
340 : : { \
341 : : event_##name.perf_perm = &perf_perm_##name; \
342 : : return 0; \
343 : : } \
344 : : early_initcall(trace_init_perf_perm_##name);
345 : :
346 : : #define PERF_MAX_TRACE_SIZE 2048
347 : :
348 : : #define MAX_FILTER_STR_VAL 256 /* Should handle KSYM_SYMBOL_LEN */
349 : :
350 : : enum event_trigger_type {
351 : : ETT_NONE = (0),
352 : : ETT_TRACE_ONOFF = (1 << 0),
353 : : ETT_SNAPSHOT = (1 << 1),
354 : : ETT_STACKTRACE = (1 << 2),
355 : : ETT_EVENT_ENABLE = (1 << 3),
356 : : };
357 : :
358 : : extern void destroy_preds(struct ftrace_event_file *file);
359 : : extern void destroy_call_preds(struct ftrace_event_call *call);
360 : : extern int filter_match_preds(struct event_filter *filter, void *rec);
361 : :
362 : : extern int filter_check_discard(struct ftrace_event_file *file, void *rec,
363 : : struct ring_buffer *buffer,
364 : : struct ring_buffer_event *event);
365 : : extern int call_filter_check_discard(struct ftrace_event_call *call, void *rec,
366 : : struct ring_buffer *buffer,
367 : : struct ring_buffer_event *event);
368 : : extern enum event_trigger_type event_triggers_call(struct ftrace_event_file *file,
369 : : void *rec);
370 : : extern void event_triggers_post_call(struct ftrace_event_file *file,
371 : : enum event_trigger_type tt);
372 : :
373 : : /**
374 : : * ftrace_trigger_soft_disabled - do triggers and test if soft disabled
375 : : * @file: The file pointer of the event to test
376 : : *
377 : : * If any triggers without filters are attached to this event, they
378 : : * will be called here. If the event is soft disabled and has no
379 : : * triggers that require testing the fields, it will return true,
380 : : * otherwise false.
381 : : */
382 : : static inline bool
383 : : ftrace_trigger_soft_disabled(struct ftrace_event_file *file)
384 : : {
385 : 0 : unsigned long eflags = file->flags;
386 : :
387 [ # # ][ # # ]: 0 : if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
388 [ # # ][ # # ]: 0 : if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
389 : 0 : event_triggers_call(file, NULL);
390 [ # # ][ # # ]: 0 : if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
391 : : return true;
392 : : }
393 : : return false;
394 : : }
395 : :
396 : : /*
397 : : * Helper function for event_trigger_unlock_commit{_regs}().
398 : : * If there are event triggers attached to this event that requires
399 : : * filtering against its fields, then they wil be called as the
400 : : * entry already holds the field information of the current event.
401 : : *
402 : : * It also checks if the event should be discarded or not.
403 : : * It is to be discarded if the event is soft disabled and the
404 : : * event was only recorded to process triggers, or if the event
405 : : * filter is active and this event did not match the filters.
406 : : *
407 : : * Returns true if the event is discarded, false otherwise.
408 : : */
409 : : static inline bool
410 : : __event_trigger_test_discard(struct ftrace_event_file *file,
411 : : struct ring_buffer *buffer,
412 : : struct ring_buffer_event *event,
413 : : void *entry,
414 : : enum event_trigger_type *tt)
415 : : {
416 : 0 : unsigned long eflags = file->flags;
417 : :
418 [ # # # # ]: 0 : if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)
[ # # ]
[ # # # # ]
[ # # ][ # # ]
[ # # ]
[ # # # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
[ # # # # ]
[ # # ]
[ # # # # ]
[ # # ][ # #
# # # # #
# # # ]
[ # # ][ # # ]
[ # # # #
# # # # #
# # # # #
# # ][ # # ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ][ # # ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ][ #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
[ # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # #
# # ][ # # ]
[ # # ][ # #
# # # # ]
[ # # # #
# # # # #
# ]
[ # # # # ]
[ # # # # ]
419 : 0 : *tt = event_triggers_call(file, entry);
420 : :
421 [ # # ][ # # ]: 0 : if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags))
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
422 : 0 : ring_buffer_discard_commit(buffer, event);
423 [ # # ][ # # ]: 0 : else if (!filter_check_discard(file, entry, buffer, event))
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
424 : : return false;
425 : :
426 : : return true;
427 : : }
428 : :
429 : : /**
430 : : * event_trigger_unlock_commit - handle triggers and finish event commit
431 : : * @file: The file pointer assoctiated to the event
432 : : * @buffer: The ring buffer that the event is being written to
433 : : * @event: The event meta data in the ring buffer
434 : : * @entry: The event itself
435 : : * @irq_flags: The state of the interrupts at the start of the event
436 : : * @pc: The state of the preempt count at the start of the event.
437 : : *
438 : : * This is a helper function to handle triggers that require data
439 : : * from the event itself. It also tests the event against filters and
440 : : * if the event is soft disabled and should be discarded.
441 : : */
442 : : static inline void
443 : : event_trigger_unlock_commit(struct ftrace_event_file *file,
444 : : struct ring_buffer *buffer,
445 : : struct ring_buffer_event *event,
446 : : void *entry, unsigned long irq_flags, int pc)
447 : : {
448 : : enum event_trigger_type tt = ETT_NONE;
449 : :
450 [ # # ][ # # ]: 0 : if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
451 : 0 : trace_buffer_unlock_commit(buffer, event, irq_flags, pc);
452 : :
453 [ # # ][ # # ]: 0 : if (tt)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
454 : 0 : event_triggers_post_call(file, tt);
455 : : }
456 : :
457 : : /**
458 : : * event_trigger_unlock_commit_regs - handle triggers and finish event commit
459 : : * @file: The file pointer assoctiated to the event
460 : : * @buffer: The ring buffer that the event is being written to
461 : : * @event: The event meta data in the ring buffer
462 : : * @entry: The event itself
463 : : * @irq_flags: The state of the interrupts at the start of the event
464 : : * @pc: The state of the preempt count at the start of the event.
465 : : *
466 : : * This is a helper function to handle triggers that require data
467 : : * from the event itself. It also tests the event against filters and
468 : : * if the event is soft disabled and should be discarded.
469 : : *
470 : : * Same as event_trigger_unlock_commit() but calls
471 : : * trace_buffer_unlock_commit_regs() instead of trace_buffer_unlock_commit().
472 : : */
473 : : static inline void
474 : : event_trigger_unlock_commit_regs(struct ftrace_event_file *file,
475 : : struct ring_buffer *buffer,
476 : : struct ring_buffer_event *event,
477 : : void *entry, unsigned long irq_flags, int pc,
478 : : struct pt_regs *regs)
479 : : {
480 : : enum event_trigger_type tt = ETT_NONE;
481 : :
482 [ # # ][ # # ]: 0 : if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
483 : 0 : trace_buffer_unlock_commit_regs(buffer, event,
484 : : irq_flags, pc, regs);
485 : :
486 [ # # ][ # # ]: 0 : if (tt)
487 : 0 : event_triggers_post_call(file, tt);
488 : : }
489 : :
490 : : enum {
491 : : FILTER_OTHER = 0,
492 : : FILTER_STATIC_STRING,
493 : : FILTER_DYN_STRING,
494 : : FILTER_PTR_STRING,
495 : : FILTER_TRACE_FN,
496 : : };
497 : :
498 : : extern int trace_event_raw_init(struct ftrace_event_call *call);
499 : : extern int trace_define_field(struct ftrace_event_call *call, const char *type,
500 : : const char *name, int offset, int size,
501 : : int is_signed, int filter_type);
502 : : extern int trace_add_event_call(struct ftrace_event_call *call);
503 : : extern int trace_remove_event_call(struct ftrace_event_call *call);
504 : :
505 : : #define is_signed_type(type) (((type)(-1)) < (type)1)
506 : :
507 : : int trace_set_clr_event(const char *system, const char *event, int set);
508 : :
509 : : /*
510 : : * The double __builtin_constant_p is because gcc will give us an error
511 : : * if we try to allocate the static variable to fmt if it is not a
512 : : * constant. Even with the outer if statement optimizing out.
513 : : */
514 : : #define event_trace_printk(ip, fmt, args...) \
515 : : do { \
516 : : __trace_printk_check_format(fmt, ##args); \
517 : : tracing_record_cmdline(current); \
518 : : if (__builtin_constant_p(fmt)) { \
519 : : static const char *trace_printk_fmt \
520 : : __attribute__((section("__trace_printk_fmt"))) = \
521 : : __builtin_constant_p(fmt) ? fmt : NULL; \
522 : : \
523 : : __trace_bprintk(ip, trace_printk_fmt, ##args); \
524 : : } else \
525 : : __trace_printk(ip, fmt, ##args); \
526 : : } while (0)
527 : :
528 : : /**
529 : : * tracepoint_string - register constant persistent string to trace system
530 : : * @str - a constant persistent string that will be referenced in tracepoints
531 : : *
532 : : * If constant strings are being used in tracepoints, it is faster and
533 : : * more efficient to just save the pointer to the string and reference
534 : : * that with a printf "%s" instead of saving the string in the ring buffer
535 : : * and wasting space and time.
536 : : *
537 : : * The problem with the above approach is that userspace tools that read
538 : : * the binary output of the trace buffers do not have access to the string.
539 : : * Instead they just show the address of the string which is not very
540 : : * useful to users.
541 : : *
542 : : * With tracepoint_string(), the string will be registered to the tracing
543 : : * system and exported to userspace via the debugfs/tracing/printk_formats
544 : : * file that maps the string address to the string text. This way userspace
545 : : * tools that read the binary buffers have a way to map the pointers to
546 : : * the ASCII strings they represent.
547 : : *
548 : : * The @str used must be a constant string and persistent as it would not
549 : : * make sense to show a string that no longer exists. But it is still fine
550 : : * to be used with modules, because when modules are unloaded, if they
551 : : * had tracepoints, the ring buffers are cleared too. As long as the string
552 : : * does not change during the life of the module, it is fine to use
553 : : * tracepoint_string() within a module.
554 : : */
555 : : #define tracepoint_string(str) \
556 : : ({ \
557 : : static const char *___tp_str __tracepoint_string = str; \
558 : : ___tp_str; \
559 : : })
560 : : #define __tracepoint_string __attribute__((section("__tracepoint_str")))
561 : :
562 : : #ifdef CONFIG_PERF_EVENTS
563 : : struct perf_event;
564 : :
565 : : DECLARE_PER_CPU(struct pt_regs, perf_trace_regs);
566 : :
567 : : extern int perf_trace_init(struct perf_event *event);
568 : : extern void perf_trace_destroy(struct perf_event *event);
569 : : extern int perf_trace_add(struct perf_event *event, int flags);
570 : : extern void perf_trace_del(struct perf_event *event, int flags);
571 : : extern int ftrace_profile_set_filter(struct perf_event *event, int event_id,
572 : : char *filter_str);
573 : : extern void ftrace_profile_free_filter(struct perf_event *event);
574 : : extern void *perf_trace_buf_prepare(int size, unsigned short type,
575 : : struct pt_regs *regs, int *rctxp);
576 : :
577 : : static inline void
578 : : perf_trace_buf_submit(void *raw_data, int size, int rctx, u64 addr,
579 : : u64 count, struct pt_regs *regs, void *head,
580 : : struct task_struct *task)
581 : : {
582 : 0 : perf_tp_event(addr, count, raw_data, size, regs, head, rctx, task);
583 : : }
584 : : #endif
585 : :
586 : : #endif /* _LINUX_FTRACE_EVENT_H */
|
