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_TRACE_MCOUNT_TEST
24 This gets selected when the arch tests the function_trace_stop
25 variable at the mcount call site. Otherwise, this variable
26 is tested by the called function.
28 config HAVE_DYNAMIC_FTRACE
31 config HAVE_FTRACE_MCOUNT_RECORD
34 config HAVE_HW_BRANCH_TRACER
37 config HAVE_FTRACE_SYSCALLS
40 config TRACER_MAX_TRACE
46 config FTRACE_NMI_ENTER
48 depends on HAVE_FTRACE_NMI_ENTER
58 select STACKTRACE if STACKTRACE_SUPPORT
65 # Minimum requirements an architecture has to meet for us to
66 # be able to offer generic tracing facilities:
68 config TRACING_SUPPORT
70 # PPC32 has no irqflags tracing support, but it can use most of the
71 # tracers anyway, they were tested to build and work. Note that new
72 # exceptions to this list aren't welcomed, better implement the
73 # irqflags tracing for your architecture.
74 depends on TRACE_IRQFLAGS_SUPPORT || PPC32
75 depends on STACKTRACE_SUPPORT
82 default y if DEBUG_KERNEL
84 Enable the kernel tracing infrastructure.
88 config FUNCTION_TRACER
89 bool "Kernel Function Tracer"
90 depends on HAVE_FUNCTION_TRACER
94 select CONTEXT_SWITCH_TRACER
96 Enable the kernel to trace every kernel function. This is done
97 by using a compiler feature to insert a small, 5-byte No-Operation
98 instruction to the beginning of every kernel function, which NOP
99 sequence is then dynamically patched into a tracer call when
100 tracing is enabled by the administrator. If it's runtime disabled
101 (the bootup default), then the overhead of the instructions is very
102 small and not measurable even in micro-benchmarks.
104 config FUNCTION_GRAPH_TRACER
105 bool "Kernel Function Graph Tracer"
106 depends on HAVE_FUNCTION_GRAPH_TRACER
107 depends on FUNCTION_TRACER
110 Enable the kernel to trace a function at both its return
112 Its first purpose is to trace the duration of functions and
113 draw a call graph for each thread with some information like
114 the return value. This is done by setting the current return
115 address on the current task structure into a stack of calls.
118 config IRQSOFF_TRACER
119 bool "Interrupts-off Latency Tracer"
121 depends on TRACE_IRQFLAGS_SUPPORT
122 depends on GENERIC_TIME
123 select TRACE_IRQFLAGS
125 select TRACER_MAX_TRACE
127 This option measures the time spent in irqs-off critical
128 sections, with microsecond accuracy.
130 The default measurement method is a maximum search, which is
131 disabled by default and can be runtime (re-)started
134 echo 0 > /debugfs/tracing/tracing_max_latency
136 (Note that kernel size and overhead increases with this option
137 enabled. This option and the preempt-off timing option can be
138 used together or separately.)
140 config PREEMPT_TRACER
141 bool "Preemption-off Latency Tracer"
143 depends on GENERIC_TIME
146 select TRACER_MAX_TRACE
148 This option measures the time spent in preemption off critical
149 sections, with microsecond accuracy.
151 The default measurement method is a maximum search, which is
152 disabled by default and can be runtime (re-)started
155 echo 0 > /debugfs/tracing/tracing_max_latency
157 (Note that kernel size and overhead increases with this option
158 enabled. This option and the irqs-off timing option can be
159 used together or separately.)
161 config SYSPROF_TRACER
162 bool "Sysprof Tracer"
165 select CONTEXT_SWITCH_TRACER
167 This tracer provides the trace needed by the 'Sysprof' userspace
171 bool "Scheduling Latency Tracer"
173 select CONTEXT_SWITCH_TRACER
174 select TRACER_MAX_TRACE
176 This tracer tracks the latency of the highest priority task
177 to be scheduled in, starting from the point it has woken up.
179 config CONTEXT_SWITCH_TRACER
180 bool "Trace process context switches"
184 This tracer gets called from the context switch and records
185 all switching of tasks.
187 config ENABLE_EVENT_TRACING
188 bool "Trace various events in the kernel"
191 This tracer hooks to various trace points in the kernel
192 allowing the user to pick and choose which trace point they
195 Note, all tracers enable event tracing. This option is
196 only a convenience to enable event tracing when no other
197 tracers are selected.
199 config FTRACE_SYSCALLS
200 bool "Trace syscalls"
201 depends on HAVE_FTRACE_SYSCALLS
205 Basic tracer to catch the syscall entry and exit events.
208 bool "Trace boot initcalls"
210 select CONTEXT_SWITCH_TRACER
212 This tracer helps developers to optimize boot times: it records
213 the timings of the initcalls and traces key events and the identity
214 of tasks that can cause boot delays, such as context-switches.
216 Its aim is to be parsed by the /scripts/bootgraph.pl tool to
217 produce pretty graphics about boot inefficiencies, giving a visual
218 representation of the delays during initcalls - but the raw
219 /debug/tracing/trace text output is readable too.
221 You must pass in ftrace=initcall to the kernel command line
222 to enable this on bootup.
224 config TRACE_BRANCH_PROFILING
229 prompt "Branch Profiling"
230 default BRANCH_PROFILE_NONE
232 The branch profiling is a software profiler. It will add hooks
233 into the C conditionals to test which path a branch takes.
235 The likely/unlikely profiler only looks at the conditions that
236 are annotated with a likely or unlikely macro.
238 The "all branch" profiler will profile every if statement in the
239 kernel. This profiler will also enable the likely/unlikely
242 Either of the above profilers add a bit of overhead to the system.
243 If unsure choose "No branch profiling".
245 config BRANCH_PROFILE_NONE
246 bool "No branch profiling"
248 No branch profiling. Branch profiling adds a bit of overhead.
249 Only enable it if you want to analyse the branching behavior.
250 Otherwise keep it disabled.
252 config PROFILE_ANNOTATED_BRANCHES
253 bool "Trace likely/unlikely profiler"
254 select TRACE_BRANCH_PROFILING
256 This tracer profiles all the the likely and unlikely macros
257 in the kernel. It will display the results in:
259 /debugfs/tracing/profile_annotated_branch
261 Note: this will add a significant overhead, only turn this
262 on if you need to profile the system's use of these macros.
264 config PROFILE_ALL_BRANCHES
265 bool "Profile all if conditionals"
266 select TRACE_BRANCH_PROFILING
268 This tracer profiles all branch conditions. Every if ()
269 taken in the kernel is recorded whether it hit or miss.
270 The results will be displayed in:
272 /debugfs/tracing/profile_branch
274 This option also enables the likely/unlikely profiler.
276 This configuration, when enabled, will impose a great overhead
277 on the system. This should only be enabled when the system
281 config TRACING_BRANCHES
284 Selected by tracers that will trace the likely and unlikely
285 conditions. This prevents the tracers themselves from being
286 profiled. Profiling the tracing infrastructure can only happen
287 when the likelys and unlikelys are not being traced.
290 bool "Trace likely/unlikely instances"
291 depends on TRACE_BRANCH_PROFILING
292 select TRACING_BRANCHES
294 This traces the events of likely and unlikely condition
295 calls in the kernel. The difference between this and the
296 "Trace likely/unlikely profiler" is that this is not a
297 histogram of the callers, but actually places the calling
298 events into a running trace buffer to see when and where the
299 events happened, as well as their results.
304 bool "Trace power consumption behavior"
308 This tracer helps developers to analyze and optimize the kernels
309 power management decisions, specifically the C-state and P-state
314 bool "Trace max stack"
315 depends on HAVE_FUNCTION_TRACER
316 select FUNCTION_TRACER
320 This special tracer records the maximum stack footprint of the
321 kernel and displays it in debugfs/tracing/stack_trace.
323 This tracer works by hooking into every function call that the
324 kernel executes, and keeping a maximum stack depth value and
325 stack-trace saved. If this is configured with DYNAMIC_FTRACE
326 then it will not have any overhead while the stack tracer
329 To enable the stack tracer on bootup, pass in 'stacktrace'
330 on the kernel command line.
332 The stack tracer can also be enabled or disabled via the
333 sysctl kernel.stack_tracer_enabled
337 config HW_BRANCH_TRACER
338 depends on HAVE_HW_BRANCH_TRACER
339 bool "Trace hw branches"
342 This tracer records all branches on the system in a circular
343 buffer giving access to the last N branches for each cpu.
346 bool "Trace SLAB allocations"
349 kmemtrace provides tracing for slab allocator functions, such as
350 kmalloc, kfree, kmem_cache_alloc, kmem_cache_free etc.. Collected
351 data is then fed to the userspace application in order to analyse
352 allocation hotspots, internal fragmentation and so on, making it
353 possible to see how well an allocator performs, as well as debug
354 and profile kernel code.
356 This requires an userspace application to use. See
357 Documentation/trace/kmemtrace.txt for more information.
359 Saying Y will make the kernel somewhat larger and slower. However,
360 if you disable kmemtrace at run-time or boot-time, the performance
361 impact is minimal (depending on the arch the kernel is built for).
365 config WORKQUEUE_TRACER
366 bool "Trace workqueues"
369 The workqueue tracer provides some statistical informations
370 about each cpu workqueue thread such as the number of the
371 works inserted and executed since their creation. It can help
372 to evaluate the amount of work each of them have to perform.
373 For example it can help a developer to decide whether he should
374 choose a per cpu workqueue instead of a singlethreaded one.
376 config BLK_DEV_IO_TRACE
377 bool "Support for tracing block io actions"
386 Say Y here if you want to be able to trace the block layer actions
387 on a given queue. Tracing allows you to see any traffic happening
388 on a block device queue. For more information (and the userspace
389 support tools needed), fetch the blktrace tools from:
391 git://git.kernel.dk/blktrace.git
393 Tracing also is possible using the ftrace interface, e.g.:
395 echo 1 > /sys/block/sda/sda1/trace/enable
396 echo blk > /sys/kernel/debug/tracing/current_tracer
397 cat /sys/kernel/debug/tracing/trace_pipe
401 config DYNAMIC_FTRACE
402 bool "enable/disable ftrace tracepoints dynamically"
403 depends on FUNCTION_TRACER
404 depends on HAVE_DYNAMIC_FTRACE
407 This option will modify all the calls to ftrace dynamically
408 (will patch them out of the binary image and replaces them
409 with a No-Op instruction) as they are called. A table is
410 created to dynamically enable them again.
412 This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but otherwise
413 has native performance as long as no tracing is active.
415 The changes to the code are done by a kernel thread that
416 wakes up once a second and checks to see if any ftrace calls
417 were made. If so, it runs stop_machine (stops all CPUS)
418 and modifies the code to jump over the call to ftrace.
420 config FUNCTION_PROFILER
421 bool "Kernel function profiler"
422 depends on FUNCTION_TRACER
425 This option enables the kernel function profiler. A file is created
426 in debugfs called function_profile_enabled which defaults to zero.
427 When a 1 is echoed into this file profiling begins, and when a
428 zero is entered, profiling stops. A file in the trace_stats
429 directory called functions, that show the list of functions that
430 have been hit and their counters.
434 config FTRACE_MCOUNT_RECORD
436 depends on DYNAMIC_FTRACE
437 depends on HAVE_FTRACE_MCOUNT_RECORD
439 config FTRACE_SELFTEST
442 config FTRACE_STARTUP_TEST
443 bool "Perform a startup test on ftrace"
445 select FTRACE_SELFTEST
447 This option performs a series of startup tests on ftrace. On bootup
448 a series of tests are made to verify that the tracer is
449 functioning properly. It will do tests on all the configured
453 bool "Memory mapped IO tracing"
454 depends on HAVE_MMIOTRACE_SUPPORT && PCI
457 Mmiotrace traces Memory Mapped I/O access and is meant for
458 debugging and reverse engineering. It is called from the ioremap
459 implementation and works via page faults. Tracing is disabled by
460 default and can be enabled at run-time.
462 See Documentation/trace/mmiotrace.txt.
463 If you are not helping to develop drivers, say N.
465 config MMIOTRACE_TEST
466 tristate "Test module for mmiotrace"
467 depends on MMIOTRACE && m
469 This is a dumb module for testing mmiotrace. It is very dangerous
470 as it will write garbage to IO memory starting at a given address.
471 However, it should be safe to use on e.g. unused portion of VRAM.
473 Say N, unless you absolutely know what you are doing.
475 config RING_BUFFER_BENCHMARK
476 tristate "Ring buffer benchmark stress tester"
477 depends on RING_BUFFER
479 This option creates a test to stress the ring buffer and bench mark it.
480 It creates its own ring buffer such that it will not interfer with
481 any other users of the ring buffer (such as ftrace). It then creates
482 a producer and consumer that will run for 10 seconds and sleep for
483 10 seconds. Each interval it will print out the number of events
484 it recorded and give a rough estimate of how long each iteration took.
486 It does not disable interrupts or raise its priority, so it may be
487 affected by processes that are running.
493 endif # TRACING_SUPPORT