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