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);