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 .wait_pipe = poll_wait_pipe,
256 .flags = &func_flags,
257 .set_flag = func_set_flag,
258 .allow_instances = true,
259 #ifdef CONFIG_FTRACE_SELFTEST
260 .selftest = trace_selftest_startup_function,
264 #ifdef CONFIG_DYNAMIC_FTRACE
265 static int update_count(void **data)
267 unsigned long *count = (long *)data;
279 ftrace_traceon_count(unsigned long ip, unsigned long parent_ip, void **data)
284 if (update_count(data))
289 ftrace_traceoff_count(unsigned long ip, unsigned long parent_ip, void **data)
291 if (!tracing_is_on())
294 if (update_count(data))
299 ftrace_traceon(unsigned long ip, unsigned long parent_ip, void **data)
308 ftrace_traceoff(unsigned long ip, unsigned long parent_ip, void **data)
310 if (!tracing_is_on())
318 * ftrace_stacktrace()
319 * function_trace_probe_call()
320 * ftrace_ops_list_func()
326 ftrace_stacktrace(unsigned long ip, unsigned long parent_ip, void **data)
328 trace_dump_stack(STACK_SKIP);
332 ftrace_stacktrace_count(unsigned long ip, unsigned long parent_ip, void **data)
334 if (!tracing_is_on())
337 if (update_count(data))
338 trace_dump_stack(STACK_SKIP);
342 ftrace_dump_probe(unsigned long ip, unsigned long parent_ip, void **data)
344 if (update_count(data))
345 ftrace_dump(DUMP_ALL);
348 /* Only dump the current CPU buffer. */
350 ftrace_cpudump_probe(unsigned long ip, unsigned long parent_ip, void **data)
352 if (update_count(data))
353 ftrace_dump(DUMP_ORIG);
357 ftrace_probe_print(const char *name, struct seq_file *m,
358 unsigned long ip, void *data)
360 long count = (long)data;
362 seq_printf(m, "%ps:%s", (void *)ip, name);
365 seq_printf(m, ":unlimited\n");
367 seq_printf(m, ":count=%ld\n", count);
373 ftrace_traceon_print(struct seq_file *m, unsigned long ip,
374 struct ftrace_probe_ops *ops, void *data)
376 return ftrace_probe_print("traceon", m, ip, data);
380 ftrace_traceoff_print(struct seq_file *m, unsigned long ip,
381 struct ftrace_probe_ops *ops, void *data)
383 return ftrace_probe_print("traceoff", m, ip, data);
387 ftrace_stacktrace_print(struct seq_file *m, unsigned long ip,
388 struct ftrace_probe_ops *ops, void *data)
390 return ftrace_probe_print("stacktrace", m, ip, data);
394 ftrace_dump_print(struct seq_file *m, unsigned long ip,
395 struct ftrace_probe_ops *ops, void *data)
397 return ftrace_probe_print("dump", m, ip, data);
401 ftrace_cpudump_print(struct seq_file *m, unsigned long ip,
402 struct ftrace_probe_ops *ops, void *data)
404 return ftrace_probe_print("cpudump", m, ip, data);
407 static struct ftrace_probe_ops traceon_count_probe_ops = {
408 .func = ftrace_traceon_count,
409 .print = ftrace_traceon_print,
412 static struct ftrace_probe_ops traceoff_count_probe_ops = {
413 .func = ftrace_traceoff_count,
414 .print = ftrace_traceoff_print,
417 static struct ftrace_probe_ops stacktrace_count_probe_ops = {
418 .func = ftrace_stacktrace_count,
419 .print = ftrace_stacktrace_print,
422 static struct ftrace_probe_ops dump_probe_ops = {
423 .func = ftrace_dump_probe,
424 .print = ftrace_dump_print,
427 static struct ftrace_probe_ops cpudump_probe_ops = {
428 .func = ftrace_cpudump_probe,
429 .print = ftrace_cpudump_print,
432 static struct ftrace_probe_ops traceon_probe_ops = {
433 .func = ftrace_traceon,
434 .print = ftrace_traceon_print,
437 static struct ftrace_probe_ops traceoff_probe_ops = {
438 .func = ftrace_traceoff,
439 .print = ftrace_traceoff_print,
442 static struct ftrace_probe_ops stacktrace_probe_ops = {
443 .func = ftrace_stacktrace,
444 .print = ftrace_stacktrace_print,
448 ftrace_trace_probe_callback(struct ftrace_probe_ops *ops,
449 struct ftrace_hash *hash, char *glob,
450 char *cmd, char *param, int enable)
452 void *count = (void *)-1;
456 /* hash funcs only work with set_ftrace_filter */
460 if (glob[0] == '!') {
461 unregister_ftrace_function_probe_func(glob+1, ops);
468 number = strsep(¶m, ":");
474 * We use the callback data field (which is a pointer)
477 ret = kstrtoul(number, 0, (unsigned long *)&count);
482 ret = register_ftrace_function_probe(glob, ops, count);
484 return ret < 0 ? ret : 0;
488 ftrace_trace_onoff_callback(struct ftrace_hash *hash,
489 char *glob, char *cmd, char *param, int enable)
491 struct ftrace_probe_ops *ops;
493 /* we register both traceon and traceoff to this callback */
494 if (strcmp(cmd, "traceon") == 0)
495 ops = param ? &traceon_count_probe_ops : &traceon_probe_ops;
497 ops = param ? &traceoff_count_probe_ops : &traceoff_probe_ops;
499 return ftrace_trace_probe_callback(ops, hash, glob, cmd,
504 ftrace_stacktrace_callback(struct ftrace_hash *hash,
505 char *glob, char *cmd, char *param, int enable)
507 struct ftrace_probe_ops *ops;
509 ops = param ? &stacktrace_count_probe_ops : &stacktrace_probe_ops;
511 return ftrace_trace_probe_callback(ops, hash, glob, cmd,
516 ftrace_dump_callback(struct ftrace_hash *hash,
517 char *glob, char *cmd, char *param, int enable)
519 struct ftrace_probe_ops *ops;
521 ops = &dump_probe_ops;
523 /* Only dump once. */
524 return ftrace_trace_probe_callback(ops, hash, glob, cmd,
529 ftrace_cpudump_callback(struct ftrace_hash *hash,
530 char *glob, char *cmd, char *param, int enable)
532 struct ftrace_probe_ops *ops;
534 ops = &cpudump_probe_ops;
536 /* Only dump once. */
537 return ftrace_trace_probe_callback(ops, hash, glob, cmd,
541 static struct ftrace_func_command ftrace_traceon_cmd = {
543 .func = ftrace_trace_onoff_callback,
546 static struct ftrace_func_command ftrace_traceoff_cmd = {
548 .func = ftrace_trace_onoff_callback,
551 static struct ftrace_func_command ftrace_stacktrace_cmd = {
552 .name = "stacktrace",
553 .func = ftrace_stacktrace_callback,
556 static struct ftrace_func_command ftrace_dump_cmd = {
558 .func = ftrace_dump_callback,
561 static struct ftrace_func_command ftrace_cpudump_cmd = {
563 .func = ftrace_cpudump_callback,
566 static int __init init_func_cmd_traceon(void)
570 ret = register_ftrace_command(&ftrace_traceoff_cmd);
574 ret = register_ftrace_command(&ftrace_traceon_cmd);
576 goto out_free_traceoff;
578 ret = register_ftrace_command(&ftrace_stacktrace_cmd);
580 goto out_free_traceon;
582 ret = register_ftrace_command(&ftrace_dump_cmd);
584 goto out_free_stacktrace;
586 ret = register_ftrace_command(&ftrace_cpudump_cmd);
593 unregister_ftrace_command(&ftrace_dump_cmd);
595 unregister_ftrace_command(&ftrace_stacktrace_cmd);
597 unregister_ftrace_command(&ftrace_traceon_cmd);
599 unregister_ftrace_command(&ftrace_traceoff_cmd);
604 static inline int init_func_cmd_traceon(void)
608 #endif /* CONFIG_DYNAMIC_FTRACE */
610 static __init int init_function_trace(void)
612 init_func_cmd_traceon();
613 return register_tracer(&function_trace);
615 core_initcall(init_function_trace);