2 # Architectures that offer an FUNCTION_TRACER implementation should
3 # select HAVE_FUNCTION_TRACER:
6 config USER_STACKTRACE_SUPPORT
12 config HAVE_FTRACE_NMI_ENTER
15 config HAVE_FUNCTION_TRACER
18 config HAVE_FUNCTION_GRAPH_TRACER
21 config HAVE_FUNCTION_GRAPH_FP_TEST
24 An arch may pass in a unique value (frame pointer) to both the
25 entering and exiting of a function. On exit, the value is compared
26 and if it does not match, then it will panic the kernel.
28 config HAVE_FUNCTION_TRACE_MCOUNT_TEST
31 This gets selected when the arch tests the function_trace_stop
32 variable at the mcount call site. Otherwise, this variable
33 is tested by the called function.
35 config HAVE_DYNAMIC_FTRACE
38 config HAVE_FTRACE_MCOUNT_RECORD
41 config HAVE_HW_BRANCH_TRACER
44 config HAVE_FTRACE_SYSCALLS
47 config TRACER_MAX_TRACE
53 config FTRACE_NMI_ENTER
55 depends on HAVE_FTRACE_NMI_ENTER
59 select CONTEXT_SWITCH_TRACER
62 config CONTEXT_SWITCH_TRACER
66 # All tracer options should select GENERIC_TRACER. For those options that are
67 # enabled by all tracers (context switch and event tracer) they select TRACING.
68 # This allows those options to appear when no other tracer is selected. But the
69 # options do not appear when something else selects it. We need the two options
70 # GENERIC_TRACER and TRACING to avoid circular dependencies to accomplish the
71 # hidding of the automatic options options.
77 select STACKTRACE if STACKTRACE_SUPPORT
88 # Minimum requirements an architecture has to meet for us to
89 # be able to offer generic tracing facilities:
91 config TRACING_SUPPORT
93 # PPC32 has no irqflags tracing support, but it can use most of the
94 # tracers anyway, they were tested to build and work. Note that new
95 # exceptions to this list aren't welcomed, better implement the
96 # irqflags tracing for your architecture.
97 depends on TRACE_IRQFLAGS_SUPPORT || PPC32
98 depends on STACKTRACE_SUPPORT
105 default y if DEBUG_KERNEL
107 Enable the kernel tracing infrastructure.
111 config FUNCTION_TRACER
112 bool "Kernel Function Tracer"
113 depends on HAVE_FUNCTION_TRACER
116 select GENERIC_TRACER
117 select CONTEXT_SWITCH_TRACER
119 Enable the kernel to trace every kernel function. This is done
120 by using a compiler feature to insert a small, 5-byte No-Operation
121 instruction to the beginning of every kernel function, which NOP
122 sequence is then dynamically patched into a tracer call when
123 tracing is enabled by the administrator. If it's runtime disabled
124 (the bootup default), then the overhead of the instructions is very
125 small and not measurable even in micro-benchmarks.
127 config FUNCTION_GRAPH_TRACER
128 bool "Kernel Function Graph Tracer"
129 depends on HAVE_FUNCTION_GRAPH_TRACER
130 depends on FUNCTION_TRACER
131 depends on !X86_32 || !CC_OPTIMIZE_FOR_SIZE
134 Enable the kernel to trace a function at both its return
136 Its first purpose is to trace the duration of functions and
137 draw a call graph for each thread with some information like
138 the return value. This is done by setting the current return
139 address on the current task structure into a stack of calls.
142 config IRQSOFF_TRACER
143 bool "Interrupts-off Latency Tracer"
145 depends on TRACE_IRQFLAGS_SUPPORT
146 depends on GENERIC_TIME
147 select TRACE_IRQFLAGS
148 select GENERIC_TRACER
149 select TRACER_MAX_TRACE
151 This option measures the time spent in irqs-off critical
152 sections, with microsecond accuracy.
154 The default measurement method is a maximum search, which is
155 disabled by default and can be runtime (re-)started
158 echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
160 (Note that kernel size and overhead increases with this option
161 enabled. This option and the preempt-off timing option can be
162 used together or separately.)
164 config PREEMPT_TRACER
165 bool "Preemption-off Latency Tracer"
167 depends on GENERIC_TIME
169 select GENERIC_TRACER
170 select TRACER_MAX_TRACE
172 This option measures the time spent in preemption off critical
173 sections, with microsecond accuracy.
175 The default measurement method is a maximum search, which is
176 disabled by default and can be runtime (re-)started
179 echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
181 (Note that kernel size and overhead increases with this option
182 enabled. This option and the irqs-off timing option can be
183 used together or separately.)
185 config SYSPROF_TRACER
186 bool "Sysprof Tracer"
188 select GENERIC_TRACER
189 select CONTEXT_SWITCH_TRACER
191 This tracer provides the trace needed by the 'Sysprof' userspace
195 bool "Scheduling Latency Tracer"
196 select GENERIC_TRACER
197 select CONTEXT_SWITCH_TRACER
198 select TRACER_MAX_TRACE
200 This tracer tracks the latency of the highest priority task
201 to be scheduled in, starting from the point it has woken up.
203 config ENABLE_DEFAULT_TRACERS
204 bool "Trace process context switches and events"
205 depends on !GENERIC_TRACER
208 This tracer hooks to various trace points in the kernel
209 allowing the user to pick and choose which trace point they
210 want to trace. It also includes the sched_switch tracer plugin.
212 config FTRACE_SYSCALLS
213 bool "Trace syscalls"
214 depends on HAVE_FTRACE_SYSCALLS
215 select GENERIC_TRACER
218 Basic tracer to catch the syscall entry and exit events.
221 bool "Trace boot initcalls"
222 select GENERIC_TRACER
223 select CONTEXT_SWITCH_TRACER
225 This tracer helps developers to optimize boot times: it records
226 the timings of the initcalls and traces key events and the identity
227 of tasks that can cause boot delays, such as context-switches.
229 Its aim is to be parsed by the scripts/bootgraph.pl tool to
230 produce pretty graphics about boot inefficiencies, giving a visual
231 representation of the delays during initcalls - but the raw
232 /debug/tracing/trace text output is readable too.
234 You must pass in initcall_debug and ftrace=initcall to the kernel
235 command line to enable this on bootup.
237 config SKB_SOURCES_TRACER
238 bool "Trace skb source information"
240 select GENERIC_TRACER
242 This tracer helps developers/sysadmins correlate skb allocation and
243 consumption. The idea being that some processes will primarily consume data
244 that was allocated on certain numa nodes. By being able to visualize which
245 nodes the data was allocated on, a sysadmin or developer can optimize the
246 scheduling of those processes to cut back on cross node chatter.
248 config TRACE_BRANCH_PROFILING
250 select GENERIC_TRACER
253 prompt "Branch Profiling"
254 default BRANCH_PROFILE_NONE
256 The branch profiling is a software profiler. It will add hooks
257 into the C conditionals to test which path a branch takes.
259 The likely/unlikely profiler only looks at the conditions that
260 are annotated with a likely or unlikely macro.
262 The "all branch" profiler will profile every if statement in the
263 kernel. This profiler will also enable the likely/unlikely
266 Either of the above profilers add a bit of overhead to the system.
267 If unsure choose "No branch profiling".
269 config BRANCH_PROFILE_NONE
270 bool "No branch profiling"
272 No branch profiling. Branch profiling adds a bit of overhead.
273 Only enable it if you want to analyse the branching behavior.
274 Otherwise keep it disabled.
276 config PROFILE_ANNOTATED_BRANCHES
277 bool "Trace likely/unlikely profiler"
278 select TRACE_BRANCH_PROFILING
280 This tracer profiles all the the likely and unlikely macros
281 in the kernel. It will display the results in:
283 /sys/kernel/debug/tracing/profile_annotated_branch
285 Note: this will add a significant overhead, only turn this
286 on if you need to profile the system's use of these macros.
288 config PROFILE_ALL_BRANCHES
289 bool "Profile all if conditionals"
290 select TRACE_BRANCH_PROFILING
292 This tracer profiles all branch conditions. Every if ()
293 taken in the kernel is recorded whether it hit or miss.
294 The results will be displayed in:
296 /sys/kernel/debug/tracing/profile_branch
298 This option also enables the likely/unlikely profiler.
300 This configuration, when enabled, will impose a great overhead
301 on the system. This should only be enabled when the system
305 config TRACING_BRANCHES
308 Selected by tracers that will trace the likely and unlikely
309 conditions. This prevents the tracers themselves from being
310 profiled. Profiling the tracing infrastructure can only happen
311 when the likelys and unlikelys are not being traced.
314 bool "Trace likely/unlikely instances"
315 depends on TRACE_BRANCH_PROFILING
316 select TRACING_BRANCHES
318 This traces the events of likely and unlikely condition
319 calls in the kernel. The difference between this and the
320 "Trace likely/unlikely profiler" is that this is not a
321 histogram of the callers, but actually places the calling
322 events into a running trace buffer to see when and where the
323 events happened, as well as their results.
328 bool "Trace power consumption behavior"
330 select GENERIC_TRACER
332 This tracer helps developers to analyze and optimize the kernels
333 power management decisions, specifically the C-state and P-state
338 bool "Trace max stack"
339 depends on HAVE_FUNCTION_TRACER
340 select FUNCTION_TRACER
344 This special tracer records the maximum stack footprint of the
345 kernel and displays it in /sys/kernel/debug/tracing/stack_trace.
347 This tracer works by hooking into every function call that the
348 kernel executes, and keeping a maximum stack depth value and
349 stack-trace saved. If this is configured with DYNAMIC_FTRACE
350 then it will not have any overhead while the stack tracer
353 To enable the stack tracer on bootup, pass in 'stacktrace'
354 on the kernel command line.
356 The stack tracer can also be enabled or disabled via the
357 sysctl kernel.stack_tracer_enabled
361 config HW_BRANCH_TRACER
362 depends on HAVE_HW_BRANCH_TRACER
363 bool "Trace hw branches"
364 select GENERIC_TRACER
366 This tracer records all branches on the system in a circular
367 buffer giving access to the last N branches for each cpu.
370 bool "Trace SLAB allocations"
371 select GENERIC_TRACER
373 kmemtrace provides tracing for slab allocator functions, such as
374 kmalloc, kfree, kmem_cache_alloc, kmem_cache_free etc.. Collected
375 data is then fed to the userspace application in order to analyse
376 allocation hotspots, internal fragmentation and so on, making it
377 possible to see how well an allocator performs, as well as debug
378 and profile kernel code.
380 This requires an userspace application to use. See
381 Documentation/trace/kmemtrace.txt for more information.
383 Saying Y will make the kernel somewhat larger and slower. However,
384 if you disable kmemtrace at run-time or boot-time, the performance
385 impact is minimal (depending on the arch the kernel is built for).
389 config WORKQUEUE_TRACER
390 bool "Trace workqueues"
391 select GENERIC_TRACER
393 The workqueue tracer provides some statistical informations
394 about each cpu workqueue thread such as the number of the
395 works inserted and executed since their creation. It can help
396 to evaluate the amount of work each of them have to perform.
397 For example it can help a developer to decide whether he should
398 choose a per cpu workqueue instead of a singlethreaded one.
400 config BLK_DEV_IO_TRACE
401 bool "Support for tracing block io actions"
407 select GENERIC_TRACER
410 Say Y here if you want to be able to trace the block layer actions
411 on a given queue. Tracing allows you to see any traffic happening
412 on a block device queue. For more information (and the userspace
413 support tools needed), fetch the blktrace tools from:
415 git://git.kernel.dk/blktrace.git
417 Tracing also is possible using the ftrace interface, e.g.:
419 echo 1 > /sys/block/sda/sda1/trace/enable
420 echo blk > /sys/kernel/debug/tracing/current_tracer
421 cat /sys/kernel/debug/tracing/trace_pipe
425 config DYNAMIC_FTRACE
426 bool "enable/disable ftrace tracepoints dynamically"
427 depends on FUNCTION_TRACER
428 depends on HAVE_DYNAMIC_FTRACE
431 This option will modify all the calls to ftrace dynamically
432 (will patch them out of the binary image and replaces them
433 with a No-Op instruction) as they are called. A table is
434 created to dynamically enable them again.
436 This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but otherwise
437 has native performance as long as no tracing is active.
439 The changes to the code are done by a kernel thread that
440 wakes up once a second and checks to see if any ftrace calls
441 were made. If so, it runs stop_machine (stops all CPUS)
442 and modifies the code to jump over the call to ftrace.
444 config FUNCTION_PROFILER
445 bool "Kernel function profiler"
446 depends on FUNCTION_TRACER
449 This option enables the kernel function profiler. A file is created
450 in debugfs called function_profile_enabled which defaults to zero.
451 When a 1 is echoed into this file profiling begins, and when a
452 zero is entered, profiling stops. A file in the trace_stats
453 directory called functions, that show the list of functions that
454 have been hit and their counters.
458 config FTRACE_MCOUNT_RECORD
460 depends on DYNAMIC_FTRACE
461 depends on HAVE_FTRACE_MCOUNT_RECORD
463 config FTRACE_SELFTEST
466 config FTRACE_STARTUP_TEST
467 bool "Perform a startup test on ftrace"
468 depends on GENERIC_TRACER
469 select FTRACE_SELFTEST
471 This option performs a series of startup tests on ftrace. On bootup
472 a series of tests are made to verify that the tracer is
473 functioning properly. It will do tests on all the configured
477 bool "Memory mapped IO tracing"
478 depends on HAVE_MMIOTRACE_SUPPORT && PCI
479 select GENERIC_TRACER
481 Mmiotrace traces Memory Mapped I/O access and is meant for
482 debugging and reverse engineering. It is called from the ioremap
483 implementation and works via page faults. Tracing is disabled by
484 default and can be enabled at run-time.
486 See Documentation/trace/mmiotrace.txt.
487 If you are not helping to develop drivers, say N.
489 config MMIOTRACE_TEST
490 tristate "Test module for mmiotrace"
491 depends on MMIOTRACE && m
493 This is a dumb module for testing mmiotrace. It is very dangerous
494 as it will write garbage to IO memory starting at a given address.
495 However, it should be safe to use on e.g. unused portion of VRAM.
497 Say N, unless you absolutely know what you are doing.
499 config RING_BUFFER_BENCHMARK
500 tristate "Ring buffer benchmark stress tester"
501 depends on RING_BUFFER
503 This option creates a test to stress the ring buffer and bench mark it.
504 It creates its own ring buffer such that it will not interfer with
505 any other users of the ring buffer (such as ftrace). It then creates
506 a producer and consumer that will run for 10 seconds and sleep for
507 10 seconds. Each interval it will print out the number of events
508 it recorded and give a rough estimate of how long each iteration took.
510 It does not disable interrupts or raise its priority, so it may be
511 affected by processes that are running.
517 endif # TRACING_SUPPORT