2 * ring buffer based function tracer
4 * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
5 * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
7 * Based on code from the latency_tracer, that is:
9 * Copyright (C) 2004-2006 Ingo Molnar
10 * Copyright (C) 2004 Nadia Yvette Chambers
12 #include <linux/ring_buffer.h>
13 #include <linux/debugfs.h>
14 #include <linux/uaccess.h>
15 #include <linux/ftrace.h>
16 #include <linux/slab.h>
21 static void tracing_start_function_trace(struct trace_array
*tr
);
22 static void tracing_stop_function_trace(struct trace_array
*tr
);
24 function_trace_call(unsigned long ip
, unsigned long parent_ip
,
25 struct ftrace_ops
*op
, struct pt_regs
*pt_regs
);
27 function_stack_trace_call(unsigned long ip
, unsigned long parent_ip
,
28 struct ftrace_ops
*op
, struct pt_regs
*pt_regs
);
29 static struct tracer_flags func_flags
;
33 TRACE_FUNC_OPT_STACK
= 0x1,
36 static int allocate_ftrace_ops(struct trace_array
*tr
)
38 struct ftrace_ops
*ops
;
40 ops
= kzalloc(sizeof(*ops
), GFP_KERNEL
);
44 /* Currently only the non stack verision is supported */
45 ops
->func
= function_trace_call
;
46 ops
->flags
= FTRACE_OPS_FL_RECURSION_SAFE
;
54 int ftrace_create_function_files(struct trace_array
*tr
,
55 struct dentry
*parent
)
60 * The top level array uses the "global_ops", and the files are
63 if (tr
->flags
& TRACE_ARRAY_FL_GLOBAL
)
66 ret
= allocate_ftrace_ops(tr
);
70 ftrace_create_filter_files(tr
->ops
, parent
);
75 void ftrace_destroy_function_files(struct trace_array
*tr
)
77 ftrace_destroy_filter_files(tr
->ops
);
82 static int function_trace_init(struct trace_array
*tr
)
87 * Instance trace_arrays get their ops allocated
88 * at instance creation. Unless it failed
94 /* Currently only the global instance can do stack tracing */
95 if (tr
->flags
& TRACE_ARRAY_FL_GLOBAL
&&
96 func_flags
.val
& TRACE_FUNC_OPT_STACK
)
97 func
= function_stack_trace_call
;
99 func
= function_trace_call
;
101 ftrace_init_array_ops(tr
, func
);
103 tr
->trace_buffer
.cpu
= get_cpu();
106 tracing_start_cmdline_record();
107 tracing_start_function_trace(tr
);
111 static void function_trace_reset(struct trace_array
*tr
)
113 tracing_stop_function_trace(tr
);
114 tracing_stop_cmdline_record();
115 ftrace_reset_array_ops(tr
);
118 static void function_trace_start(struct trace_array
*tr
)
120 tracing_reset_online_cpus(&tr
->trace_buffer
);
124 function_trace_call(unsigned long ip
, unsigned long parent_ip
,
125 struct ftrace_ops
*op
, struct pt_regs
*pt_regs
)
127 struct trace_array
*tr
= op
->private;
128 struct trace_array_cpu
*data
;
134 if (unlikely(!tr
->function_enabled
))
137 pc
= preempt_count();
138 preempt_disable_notrace();
140 bit
= trace_test_and_set_recursion(TRACE_FTRACE_START
, TRACE_FTRACE_MAX
);
144 cpu
= smp_processor_id();
145 data
= per_cpu_ptr(tr
->trace_buffer
.data
, cpu
);
146 if (!atomic_read(&data
->disabled
)) {
147 local_save_flags(flags
);
148 trace_function(tr
, ip
, parent_ip
, flags
, pc
);
150 trace_clear_recursion(bit
);
153 preempt_enable_notrace();
157 function_stack_trace_call(unsigned long ip
, unsigned long parent_ip
,
158 struct ftrace_ops
*op
, struct pt_regs
*pt_regs
)
160 struct trace_array
*tr
= op
->private;
161 struct trace_array_cpu
*data
;
167 if (unlikely(!tr
->function_enabled
))
171 * Need to use raw, since this must be called before the
172 * recursive protection is performed.
174 local_irq_save(flags
);
175 cpu
= raw_smp_processor_id();
176 data
= per_cpu_ptr(tr
->trace_buffer
.data
, cpu
);
177 disabled
= atomic_inc_return(&data
->disabled
);
179 if (likely(disabled
== 1)) {
180 pc
= preempt_count();
181 trace_function(tr
, ip
, parent_ip
, flags
, pc
);
184 * __ftrace_trace_stack,
186 * function_stack_trace_call
190 __trace_stack(tr
, flags
, 5, pc
);
193 atomic_dec(&data
->disabled
);
194 local_irq_restore(flags
);
197 static struct tracer_opt func_opts
[] = {
198 #ifdef CONFIG_STACKTRACE
199 { TRACER_OPT(func_stack_trace
, TRACE_FUNC_OPT_STACK
) },
201 { } /* Always set a last empty entry */
204 static struct tracer_flags func_flags
= {
205 .val
= 0, /* By default: all flags disabled */
209 static void tracing_start_function_trace(struct trace_array
*tr
)
211 tr
->function_enabled
= 0;
212 register_ftrace_function(tr
->ops
);
213 tr
->function_enabled
= 1;
216 static void tracing_stop_function_trace(struct trace_array
*tr
)
218 tr
->function_enabled
= 0;
219 unregister_ftrace_function(tr
->ops
);
223 func_set_flag(struct trace_array
*tr
, u32 old_flags
, u32 bit
, int set
)
226 case TRACE_FUNC_OPT_STACK
:
227 /* do nothing if already set */
228 if (!!set
== !!(func_flags
.val
& TRACE_FUNC_OPT_STACK
))
231 unregister_ftrace_function(tr
->ops
);
234 tr
->ops
->func
= function_stack_trace_call
;
235 register_ftrace_function(tr
->ops
);
237 tr
->ops
->func
= function_trace_call
;
238 register_ftrace_function(tr
->ops
);
249 static struct tracer function_trace __tracer_data
=
252 .init
= function_trace_init
,
253 .reset
= function_trace_reset
,
254 .start
= function_trace_start
,
255 .flags
= &func_flags
,
256 .set_flag
= func_set_flag
,
257 .allow_instances
= true,
258 #ifdef CONFIG_FTRACE_SELFTEST
259 .selftest
= trace_selftest_startup_function
,
263 #ifdef CONFIG_DYNAMIC_FTRACE
264 static int update_count(void **data
)
266 unsigned long *count
= (long *)data
;
278 ftrace_traceon_count(unsigned long ip
, unsigned long parent_ip
, void **data
)
283 if (update_count(data
))
288 ftrace_traceoff_count(unsigned long ip
, unsigned long parent_ip
, void **data
)
290 if (!tracing_is_on())
293 if (update_count(data
))
298 ftrace_traceon(unsigned long ip
, unsigned long parent_ip
, void **data
)
307 ftrace_traceoff(unsigned long ip
, unsigned long parent_ip
, void **data
)
309 if (!tracing_is_on())
317 * ftrace_stacktrace()
318 * function_trace_probe_call()
319 * ftrace_ops_list_func()
325 ftrace_stacktrace(unsigned long ip
, unsigned long parent_ip
, void **data
)
327 trace_dump_stack(STACK_SKIP
);
331 ftrace_stacktrace_count(unsigned long ip
, unsigned long parent_ip
, void **data
)
333 if (!tracing_is_on())
336 if (update_count(data
))
337 trace_dump_stack(STACK_SKIP
);
341 ftrace_dump_probe(unsigned long ip
, unsigned long parent_ip
, void **data
)
343 if (update_count(data
))
344 ftrace_dump(DUMP_ALL
);
347 /* Only dump the current CPU buffer. */
349 ftrace_cpudump_probe(unsigned long ip
, unsigned long parent_ip
, void **data
)
351 if (update_count(data
))
352 ftrace_dump(DUMP_ORIG
);
356 ftrace_probe_print(const char *name
, struct seq_file
*m
,
357 unsigned long ip
, void *data
)
359 long count
= (long)data
;
361 seq_printf(m
, "%ps:%s", (void *)ip
, name
);
364 seq_printf(m
, ":unlimited\n");
366 seq_printf(m
, ":count=%ld\n", count
);
372 ftrace_traceon_print(struct seq_file
*m
, unsigned long ip
,
373 struct ftrace_probe_ops
*ops
, void *data
)
375 return ftrace_probe_print("traceon", m
, ip
, data
);
379 ftrace_traceoff_print(struct seq_file
*m
, unsigned long ip
,
380 struct ftrace_probe_ops
*ops
, void *data
)
382 return ftrace_probe_print("traceoff", m
, ip
, data
);
386 ftrace_stacktrace_print(struct seq_file
*m
, unsigned long ip
,
387 struct ftrace_probe_ops
*ops
, void *data
)
389 return ftrace_probe_print("stacktrace", m
, ip
, data
);
393 ftrace_dump_print(struct seq_file
*m
, unsigned long ip
,
394 struct ftrace_probe_ops
*ops
, void *data
)
396 return ftrace_probe_print("dump", m
, ip
, data
);
400 ftrace_cpudump_print(struct seq_file
*m
, unsigned long ip
,
401 struct ftrace_probe_ops
*ops
, void *data
)
403 return ftrace_probe_print("cpudump", m
, ip
, data
);
406 static struct ftrace_probe_ops traceon_count_probe_ops
= {
407 .func
= ftrace_traceon_count
,
408 .print
= ftrace_traceon_print
,
411 static struct ftrace_probe_ops traceoff_count_probe_ops
= {
412 .func
= ftrace_traceoff_count
,
413 .print
= ftrace_traceoff_print
,
416 static struct ftrace_probe_ops stacktrace_count_probe_ops
= {
417 .func
= ftrace_stacktrace_count
,
418 .print
= ftrace_stacktrace_print
,
421 static struct ftrace_probe_ops dump_probe_ops
= {
422 .func
= ftrace_dump_probe
,
423 .print
= ftrace_dump_print
,
426 static struct ftrace_probe_ops cpudump_probe_ops
= {
427 .func
= ftrace_cpudump_probe
,
428 .print
= ftrace_cpudump_print
,
431 static struct ftrace_probe_ops traceon_probe_ops
= {
432 .func
= ftrace_traceon
,
433 .print
= ftrace_traceon_print
,
436 static struct ftrace_probe_ops traceoff_probe_ops
= {
437 .func
= ftrace_traceoff
,
438 .print
= ftrace_traceoff_print
,
441 static struct ftrace_probe_ops stacktrace_probe_ops
= {
442 .func
= ftrace_stacktrace
,
443 .print
= ftrace_stacktrace_print
,
447 ftrace_trace_probe_callback(struct ftrace_probe_ops
*ops
,
448 struct ftrace_hash
*hash
, char *glob
,
449 char *cmd
, char *param
, int enable
)
451 void *count
= (void *)-1;
455 /* hash funcs only work with set_ftrace_filter */
459 if (glob
[0] == '!') {
460 unregister_ftrace_function_probe_func(glob
+1, ops
);
467 number
= strsep(¶m
, ":");
473 * We use the callback data field (which is a pointer)
476 ret
= kstrtoul(number
, 0, (unsigned long *)&count
);
481 ret
= register_ftrace_function_probe(glob
, ops
, count
);
483 return ret
< 0 ? ret
: 0;
487 ftrace_trace_onoff_callback(struct ftrace_hash
*hash
,
488 char *glob
, char *cmd
, char *param
, int enable
)
490 struct ftrace_probe_ops
*ops
;
492 /* we register both traceon and traceoff to this callback */
493 if (strcmp(cmd
, "traceon") == 0)
494 ops
= param
? &traceon_count_probe_ops
: &traceon_probe_ops
;
496 ops
= param
? &traceoff_count_probe_ops
: &traceoff_probe_ops
;
498 return ftrace_trace_probe_callback(ops
, hash
, glob
, cmd
,
503 ftrace_stacktrace_callback(struct ftrace_hash
*hash
,
504 char *glob
, char *cmd
, char *param
, int enable
)
506 struct ftrace_probe_ops
*ops
;
508 ops
= param
? &stacktrace_count_probe_ops
: &stacktrace_probe_ops
;
510 return ftrace_trace_probe_callback(ops
, hash
, glob
, cmd
,
515 ftrace_dump_callback(struct ftrace_hash
*hash
,
516 char *glob
, char *cmd
, char *param
, int enable
)
518 struct ftrace_probe_ops
*ops
;
520 ops
= &dump_probe_ops
;
522 /* Only dump once. */
523 return ftrace_trace_probe_callback(ops
, hash
, glob
, cmd
,
528 ftrace_cpudump_callback(struct ftrace_hash
*hash
,
529 char *glob
, char *cmd
, char *param
, int enable
)
531 struct ftrace_probe_ops
*ops
;
533 ops
= &cpudump_probe_ops
;
535 /* Only dump once. */
536 return ftrace_trace_probe_callback(ops
, hash
, glob
, cmd
,
540 static struct ftrace_func_command ftrace_traceon_cmd
= {
542 .func
= ftrace_trace_onoff_callback
,
545 static struct ftrace_func_command ftrace_traceoff_cmd
= {
547 .func
= ftrace_trace_onoff_callback
,
550 static struct ftrace_func_command ftrace_stacktrace_cmd
= {
551 .name
= "stacktrace",
552 .func
= ftrace_stacktrace_callback
,
555 static struct ftrace_func_command ftrace_dump_cmd
= {
557 .func
= ftrace_dump_callback
,
560 static struct ftrace_func_command ftrace_cpudump_cmd
= {
562 .func
= ftrace_cpudump_callback
,
565 static int __init
init_func_cmd_traceon(void)
569 ret
= register_ftrace_command(&ftrace_traceoff_cmd
);
573 ret
= register_ftrace_command(&ftrace_traceon_cmd
);
575 goto out_free_traceoff
;
577 ret
= register_ftrace_command(&ftrace_stacktrace_cmd
);
579 goto out_free_traceon
;
581 ret
= register_ftrace_command(&ftrace_dump_cmd
);
583 goto out_free_stacktrace
;
585 ret
= register_ftrace_command(&ftrace_cpudump_cmd
);
592 unregister_ftrace_command(&ftrace_dump_cmd
);
594 unregister_ftrace_command(&ftrace_stacktrace_cmd
);
596 unregister_ftrace_command(&ftrace_traceon_cmd
);
598 unregister_ftrace_command(&ftrace_traceoff_cmd
);
603 static inline int init_func_cmd_traceon(void)
607 #endif /* CONFIG_DYNAMIC_FTRACE */
609 static __init
int init_function_trace(void)
611 init_func_cmd_traceon();
612 return register_tracer(&function_trace
);
614 core_initcall(init_function_trace
);