tracing/documentation: Cover new frame pointer semantics
[linux-2.6.git] / kernel / trace / Kconfig
1 #
2 # Architectures that offer an FUNCTION_TRACER implementation should
3 #  select HAVE_FUNCTION_TRACER:
4 #
5
6 config USER_STACKTRACE_SUPPORT
7         bool
8
9 config NOP_TRACER
10         bool
11
12 config HAVE_FTRACE_NMI_ENTER
13         bool
14         help
15           See Documentation/trace/ftrace-design.txt
16
17 config HAVE_FUNCTION_TRACER
18         bool
19         help
20           See Documentation/trace/ftrace-design.txt
21
22 config HAVE_FUNCTION_GRAPH_TRACER
23         bool
24         help
25           See Documentation/trace/ftrace-design.txt
26
27 config HAVE_FUNCTION_GRAPH_FP_TEST
28         bool
29         help
30           See Documentation/trace/ftrace-design.txt
31
32 config HAVE_FUNCTION_TRACE_MCOUNT_TEST
33         bool
34         help
35           See Documentation/trace/ftrace-design.txt
36
37 config HAVE_DYNAMIC_FTRACE
38         bool
39         help
40           See Documentation/trace/ftrace-design.txt
41
42 config HAVE_FTRACE_MCOUNT_RECORD
43         bool
44         help
45           See Documentation/trace/ftrace-design.txt
46
47 config HAVE_HW_BRANCH_TRACER
48         bool
49
50 config HAVE_SYSCALL_TRACEPOINTS
51         bool
52         help
53           See Documentation/trace/ftrace-design.txt
54
55 config TRACER_MAX_TRACE
56         bool
57
58 config RING_BUFFER
59         bool
60
61 config FTRACE_NMI_ENTER
62        bool
63        depends on HAVE_FTRACE_NMI_ENTER
64        default y
65
66 config EVENT_TRACING
67         select CONTEXT_SWITCH_TRACER
68         bool
69
70 config CONTEXT_SWITCH_TRACER
71         bool
72
73 config RING_BUFFER_ALLOW_SWAP
74         bool
75         help
76          Allow the use of ring_buffer_swap_cpu.
77          Adds a very slight overhead to tracing when enabled.
78
79 # All tracer options should select GENERIC_TRACER. For those options that are
80 # enabled by all tracers (context switch and event tracer) they select TRACING.
81 # This allows those options to appear when no other tracer is selected. But the
82 # options do not appear when something else selects it. We need the two options
83 # GENERIC_TRACER and TRACING to avoid circular dependencies to accomplish the
84 # hiding of the automatic options.
85
86 config TRACING
87         bool
88         select DEBUG_FS
89         select RING_BUFFER
90         select STACKTRACE if STACKTRACE_SUPPORT
91         select TRACEPOINTS
92         select NOP_TRACER
93         select BINARY_PRINTF
94         select EVENT_TRACING
95
96 config GENERIC_TRACER
97         bool
98         select TRACING
99
100 #
101 # Minimum requirements an architecture has to meet for us to
102 # be able to offer generic tracing facilities:
103 #
104 config TRACING_SUPPORT
105         bool
106         # PPC32 has no irqflags tracing support, but it can use most of the
107         # tracers anyway, they were tested to build and work. Note that new
108         # exceptions to this list aren't welcomed, better implement the
109         # irqflags tracing for your architecture.
110         depends on TRACE_IRQFLAGS_SUPPORT || PPC32
111         depends on STACKTRACE_SUPPORT
112         default y
113
114 if TRACING_SUPPORT
115
116 menuconfig FTRACE
117         bool "Tracers"
118         default y if DEBUG_KERNEL
119         help
120           Enable the kernel tracing infrastructure.
121
122 if FTRACE
123
124 config FUNCTION_TRACER
125         bool "Kernel Function Tracer"
126         depends on HAVE_FUNCTION_TRACER
127         select FRAME_POINTER
128         select KALLSYMS
129         select GENERIC_TRACER
130         select CONTEXT_SWITCH_TRACER
131         help
132           Enable the kernel to trace every kernel function. This is done
133           by using a compiler feature to insert a small, 5-byte No-Operation
134           instruction at the beginning of every kernel function, which NOP
135           sequence is then dynamically patched into a tracer call when
136           tracing is enabled by the administrator. If it's runtime disabled
137           (the bootup default), then the overhead of the instructions is very
138           small and not measurable even in micro-benchmarks.
139
140 config FUNCTION_GRAPH_TRACER
141         bool "Kernel Function Graph Tracer"
142         depends on HAVE_FUNCTION_GRAPH_TRACER
143         depends on FUNCTION_TRACER
144         depends on !X86_32 || !CC_OPTIMIZE_FOR_SIZE
145         default y
146         help
147           Enable the kernel to trace a function at both its return
148           and its entry.
149           Its first purpose is to trace the duration of functions and
150           draw a call graph for each thread with some information like
151           the return value. This is done by setting the current return
152           address on the current task structure into a stack of calls.
153
154
155 config IRQSOFF_TRACER
156         bool "Interrupts-off Latency Tracer"
157         default n
158         depends on TRACE_IRQFLAGS_SUPPORT
159         depends on GENERIC_TIME
160         select TRACE_IRQFLAGS
161         select GENERIC_TRACER
162         select TRACER_MAX_TRACE
163         select RING_BUFFER_ALLOW_SWAP
164         help
165           This option measures the time spent in irqs-off critical
166           sections, with microsecond accuracy.
167
168           The default measurement method is a maximum search, which is
169           disabled by default and can be runtime (re-)started
170           via:
171
172               echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
173
174           (Note that kernel size and overhead increase with this option
175           enabled. This option and the preempt-off timing option can be
176           used together or separately.)
177
178 config PREEMPT_TRACER
179         bool "Preemption-off Latency Tracer"
180         default n
181         depends on GENERIC_TIME
182         depends on PREEMPT
183         select GENERIC_TRACER
184         select TRACER_MAX_TRACE
185         select RING_BUFFER_ALLOW_SWAP
186         help
187           This option measures the time spent in preemption-off critical
188           sections, with microsecond accuracy.
189
190           The default measurement method is a maximum search, which is
191           disabled by default and can be runtime (re-)started
192           via:
193
194               echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
195
196           (Note that kernel size and overhead increase with this option
197           enabled. This option and the irqs-off timing option can be
198           used together or separately.)
199
200 config SYSPROF_TRACER
201         bool "Sysprof Tracer"
202         depends on X86
203         select GENERIC_TRACER
204         select CONTEXT_SWITCH_TRACER
205         help
206           This tracer provides the trace needed by the 'Sysprof' userspace
207           tool.
208
209 config SCHED_TRACER
210         bool "Scheduling Latency Tracer"
211         select GENERIC_TRACER
212         select CONTEXT_SWITCH_TRACER
213         select TRACER_MAX_TRACE
214         help
215           This tracer tracks the latency of the highest priority task
216           to be scheduled in, starting from the point it has woken up.
217
218 config ENABLE_DEFAULT_TRACERS
219         bool "Trace process context switches and events"
220         depends on !GENERIC_TRACER
221         select TRACING
222         help
223           This tracer hooks to various trace points in the kernel,
224           allowing the user to pick and choose which trace point they
225           want to trace. It also includes the sched_switch tracer plugin.
226
227 config FTRACE_SYSCALLS
228         bool "Trace syscalls"
229         depends on HAVE_SYSCALL_TRACEPOINTS
230         select GENERIC_TRACER
231         select KALLSYMS
232         help
233           Basic tracer to catch the syscall entry and exit events.
234
235 config BOOT_TRACER
236         bool "Trace boot initcalls"
237         select GENERIC_TRACER
238         select CONTEXT_SWITCH_TRACER
239         help
240           This tracer helps developers to optimize boot times: it records
241           the timings of the initcalls and traces key events and the identity
242           of tasks that can cause boot delays, such as context-switches.
243
244           Its aim is to be parsed by the scripts/bootgraph.pl tool to
245           produce pretty graphics about boot inefficiencies, giving a visual
246           representation of the delays during initcalls - but the raw
247           /debug/tracing/trace text output is readable too.
248
249           You must pass in initcall_debug and ftrace=initcall to the kernel
250           command line to enable this on bootup.
251
252 config TRACE_BRANCH_PROFILING
253         bool
254         select GENERIC_TRACER
255
256 choice
257         prompt "Branch Profiling"
258         default BRANCH_PROFILE_NONE
259         help
260          The branch profiling is a software profiler. It will add hooks
261          into the C conditionals to test which path a branch takes.
262
263          The likely/unlikely profiler only looks at the conditions that
264          are annotated with a likely or unlikely macro.
265
266          The "all branch" profiler will profile every if-statement in the
267          kernel. This profiler will also enable the likely/unlikely
268          profiler.
269
270          Either of the above profilers adds a bit of overhead to the system.
271          If unsure, choose "No branch profiling".
272
273 config BRANCH_PROFILE_NONE
274         bool "No branch profiling"
275         help
276           No branch profiling. Branch profiling adds a bit of overhead.
277           Only enable it if you want to analyse the branching behavior.
278           Otherwise keep it disabled.
279
280 config PROFILE_ANNOTATED_BRANCHES
281         bool "Trace likely/unlikely profiler"
282         select TRACE_BRANCH_PROFILING
283         help
284           This tracer profiles all the the likely and unlikely macros
285           in the kernel. It will display the results in:
286
287           /sys/kernel/debug/tracing/profile_annotated_branch
288
289           Note: this will add a significant overhead; only turn this
290           on if you need to profile the system's use of these macros.
291
292 config PROFILE_ALL_BRANCHES
293         bool "Profile all if conditionals"
294         select TRACE_BRANCH_PROFILING
295         help
296           This tracer profiles all branch conditions. Every if ()
297           taken in the kernel is recorded whether it hit or miss.
298           The results will be displayed in:
299
300           /sys/kernel/debug/tracing/profile_branch
301
302           This option also enables the likely/unlikely profiler.
303
304           This configuration, when enabled, will impose a great overhead
305           on the system. This should only be enabled when the system
306           is to be analyzed in much detail.
307 endchoice
308
309 config TRACING_BRANCHES
310         bool
311         help
312           Selected by tracers that will trace the likely and unlikely
313           conditions. This prevents the tracers themselves from being
314           profiled. Profiling the tracing infrastructure can only happen
315           when the likelys and unlikelys are not being traced.
316
317 config BRANCH_TRACER
318         bool "Trace likely/unlikely instances"
319         depends on TRACE_BRANCH_PROFILING
320         select TRACING_BRANCHES
321         help
322           This traces the events of likely and unlikely condition
323           calls in the kernel.  The difference between this and the
324           "Trace likely/unlikely profiler" is that this is not a
325           histogram of the callers, but actually places the calling
326           events into a running trace buffer to see when and where the
327           events happened, as well as their results.
328
329           Say N if unsure.
330
331 config POWER_TRACER
332         bool "Trace power consumption behavior"
333         depends on X86
334         select GENERIC_TRACER
335         help
336           This tracer helps developers to analyze and optimize the kernel's
337           power management decisions, specifically the C-state and P-state
338           behavior.
339
340 config KSYM_TRACER
341         bool "Trace read and write access on kernel memory locations"
342         depends on HAVE_HW_BREAKPOINT
343         select TRACING
344         help
345           This tracer helps find read and write operations on any given kernel
346           symbol i.e. /proc/kallsyms.
347
348 config PROFILE_KSYM_TRACER
349         bool "Profile all kernel memory accesses on 'watched' variables"
350         depends on KSYM_TRACER
351         help
352           This tracer profiles kernel accesses on variables watched through the
353           ksym tracer ftrace plugin. Depending upon the hardware, all read
354           and write operations on kernel variables can be monitored for
355           accesses.
356
357           The results will be displayed in:
358           /debugfs/tracing/profile_ksym
359
360           Say N if unsure.
361
362 config STACK_TRACER
363         bool "Trace max stack"
364         depends on HAVE_FUNCTION_TRACER
365         select FUNCTION_TRACER
366         select STACKTRACE
367         select KALLSYMS
368         help
369           This special tracer records the maximum stack footprint of the
370           kernel and displays it in /sys/kernel/debug/tracing/stack_trace.
371
372           This tracer works by hooking into every function call that the
373           kernel executes, and keeping a maximum stack depth value and
374           stack-trace saved.  If this is configured with DYNAMIC_FTRACE
375           then it will not have any overhead while the stack tracer
376           is disabled.
377
378           To enable the stack tracer on bootup, pass in 'stacktrace'
379           on the kernel command line.
380
381           The stack tracer can also be enabled or disabled via the
382           sysctl kernel.stack_tracer_enabled
383
384           Say N if unsure.
385
386 config HW_BRANCH_TRACER
387         depends on HAVE_HW_BRANCH_TRACER
388         bool "Trace hw branches"
389         select GENERIC_TRACER
390         help
391           This tracer records all branches on the system in a circular
392           buffer, giving access to the last N branches for each cpu.
393
394 config KMEMTRACE
395         bool "Trace SLAB allocations"
396         select GENERIC_TRACER
397         help
398           kmemtrace provides tracing for slab allocator functions, such as
399           kmalloc, kfree, kmem_cache_alloc, kmem_cache_free, etc. Collected
400           data is then fed to the userspace application in order to analyse
401           allocation hotspots, internal fragmentation and so on, making it
402           possible to see how well an allocator performs, as well as debug
403           and profile kernel code.
404
405           This requires an userspace application to use. See
406           Documentation/trace/kmemtrace.txt for more information.
407
408           Saying Y will make the kernel somewhat larger and slower. However,
409           if you disable kmemtrace at run-time or boot-time, the performance
410           impact is minimal (depending on the arch the kernel is built for).
411
412           If unsure, say N.
413
414 config WORKQUEUE_TRACER
415         bool "Trace workqueues"
416         select GENERIC_TRACER
417         help
418           The workqueue tracer provides some statistical information
419           about each cpu workqueue thread such as the number of the
420           works inserted and executed since their creation. It can help
421           to evaluate the amount of work each of them has to perform.
422           For example it can help a developer to decide whether he should
423           choose a per-cpu workqueue instead of a singlethreaded one.
424
425 config BLK_DEV_IO_TRACE
426         bool "Support for tracing block IO actions"
427         depends on SYSFS
428         depends on BLOCK
429         select RELAY
430         select DEBUG_FS
431         select TRACEPOINTS
432         select GENERIC_TRACER
433         select STACKTRACE
434         help
435           Say Y here if you want to be able to trace the block layer actions
436           on a given queue. Tracing allows you to see any traffic happening
437           on a block device queue. For more information (and the userspace
438           support tools needed), fetch the blktrace tools from:
439
440           git://git.kernel.dk/blktrace.git
441
442           Tracing also is possible using the ftrace interface, e.g.:
443
444             echo 1 > /sys/block/sda/sda1/trace/enable
445             echo blk > /sys/kernel/debug/tracing/current_tracer
446             cat /sys/kernel/debug/tracing/trace_pipe
447
448           If unsure, say N.
449
450 config KPROBE_EVENT
451         depends on KPROBES
452         depends on X86
453         bool "Enable kprobes-based dynamic events"
454         select TRACING
455         default y
456         help
457           This allows the user to add tracing events (similar to tracepoints)
458           on the fly via the ftrace interface. See
459           Documentation/trace/kprobetrace.txt for more details.
460
461           Those events can be inserted wherever kprobes can probe, and record
462           various register and memory values.
463
464           This option is also required by perf-probe subcommand of perf tools.
465           If you want to use perf tools, this option is strongly recommended.
466
467 config DYNAMIC_FTRACE
468         bool "enable/disable ftrace tracepoints dynamically"
469         depends on FUNCTION_TRACER
470         depends on HAVE_DYNAMIC_FTRACE
471         default y
472         help
473           This option will modify all the calls to ftrace dynamically
474           (will patch them out of the binary image and replace them
475           with a No-Op instruction) as they are called. A table is
476           created to dynamically enable them again.
477
478           This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but
479           otherwise has native performance as long as no tracing is active.
480
481           The changes to the code are done by a kernel thread that
482           wakes up once a second and checks to see if any ftrace calls
483           were made. If so, it runs stop_machine (stops all CPUS)
484           and modifies the code to jump over the call to ftrace.
485
486 config FUNCTION_PROFILER
487         bool "Kernel function profiler"
488         depends on FUNCTION_TRACER
489         default n
490         help
491           This option enables the kernel function profiler. A file is created
492           in debugfs called function_profile_enabled which defaults to zero.
493           When a 1 is echoed into this file profiling begins, and when a
494           zero is entered, profiling stops. A "functions" file is created in
495           the trace_stats directory; this file shows the list of functions that
496           have been hit and their counters.
497
498           If in doubt, say N.
499
500 config FTRACE_MCOUNT_RECORD
501         def_bool y
502         depends on DYNAMIC_FTRACE
503         depends on HAVE_FTRACE_MCOUNT_RECORD
504
505 config FTRACE_SELFTEST
506         bool
507
508 config FTRACE_STARTUP_TEST
509         bool "Perform a startup test on ftrace"
510         depends on GENERIC_TRACER
511         select FTRACE_SELFTEST
512         help
513           This option performs a series of startup tests on ftrace. On bootup
514           a series of tests are made to verify that the tracer is
515           functioning properly. It will do tests on all the configured
516           tracers of ftrace.
517
518 config EVENT_TRACE_TEST_SYSCALLS
519         bool "Run selftest on syscall events"
520         depends on FTRACE_STARTUP_TEST
521         help
522          This option will also enable testing every syscall event.
523          It only enables the event and disables it and runs various loads
524          with the event enabled. This adds a bit more time for kernel boot
525          up since it runs this on every system call defined.
526
527          TBD - enable a way to actually call the syscalls as we test their
528                events
529
530 config MMIOTRACE
531         bool "Memory mapped IO tracing"
532         depends on HAVE_MMIOTRACE_SUPPORT && PCI
533         select GENERIC_TRACER
534         help
535           Mmiotrace traces Memory Mapped I/O access and is meant for
536           debugging and reverse engineering. It is called from the ioremap
537           implementation and works via page faults. Tracing is disabled by
538           default and can be enabled at run-time.
539
540           See Documentation/trace/mmiotrace.txt.
541           If you are not helping to develop drivers, say N.
542
543 config MMIOTRACE_TEST
544         tristate "Test module for mmiotrace"
545         depends on MMIOTRACE && m
546         help
547           This is a dumb module for testing mmiotrace. It is very dangerous
548           as it will write garbage to IO memory starting at a given address.
549           However, it should be safe to use on e.g. unused portion of VRAM.
550
551           Say N, unless you absolutely know what you are doing.
552
553 config RING_BUFFER_BENCHMARK
554         tristate "Ring buffer benchmark stress tester"
555         depends on RING_BUFFER
556         help
557           This option creates a test to stress the ring buffer and benchmark it.
558           It creates its own ring buffer such that it will not interfere with
559           any other users of the ring buffer (such as ftrace). It then creates
560           a producer and consumer that will run for 10 seconds and sleep for
561           10 seconds. Each interval it will print out the number of events
562           it recorded and give a rough estimate of how long each iteration took.
563
564           It does not disable interrupts or raise its priority, so it may be
565           affected by processes that are running.
566
567           If unsure, say N.
568
569 endif # FTRACE
570
571 endif # TRACING_SUPPORT
572