tracing: add average time in function to function profiler
[pandora-kernel.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
15 config HAVE_FUNCTION_TRACER
16         bool
17
18 config HAVE_FUNCTION_GRAPH_TRACER
19         bool
20
21 config HAVE_FUNCTION_TRACE_MCOUNT_TEST
22         bool
23         help
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.
27
28 config HAVE_DYNAMIC_FTRACE
29         bool
30
31 config HAVE_FTRACE_MCOUNT_RECORD
32         bool
33
34 config HAVE_HW_BRANCH_TRACER
35         bool
36
37 config HAVE_FTRACE_SYSCALLS
38         bool
39
40 config TRACER_MAX_TRACE
41         bool
42
43 config RING_BUFFER
44         bool
45
46 config FTRACE_NMI_ENTER
47        bool
48        depends on HAVE_FTRACE_NMI_ENTER
49        default y
50
51 config TRACING
52         bool
53         select DEBUG_FS
54         select RING_BUFFER
55         select STACKTRACE if STACKTRACE_SUPPORT
56         select TRACEPOINTS
57         select NOP_TRACER
58         select BINARY_PRINTF
59
60 #
61 # Minimum requirements an architecture has to meet for us to
62 # be able to offer generic tracing facilities:
63 #
64 config TRACING_SUPPORT
65         bool
66         # PPC32 has no irqflags tracing support, but it can use most of the
67         # tracers anyway, they were tested to build and work. Note that new
68         # exceptions to this list aren't welcomed, better implement the
69         # irqflags tracing for your architecture.
70         depends on TRACE_IRQFLAGS_SUPPORT || PPC32
71         depends on STACKTRACE_SUPPORT
72         default y
73
74 if TRACING_SUPPORT
75
76 menu "Tracers"
77
78 config FUNCTION_TRACER
79         bool "Kernel Function Tracer"
80         depends on HAVE_FUNCTION_TRACER
81         select FRAME_POINTER
82         select KALLSYMS
83         select TRACING
84         select CONTEXT_SWITCH_TRACER
85         help
86           Enable the kernel to trace every kernel function. This is done
87           by using a compiler feature to insert a small, 5-byte No-Operation
88           instruction to the beginning of every kernel function, which NOP
89           sequence is then dynamically patched into a tracer call when
90           tracing is enabled by the administrator. If it's runtime disabled
91           (the bootup default), then the overhead of the instructions is very
92           small and not measurable even in micro-benchmarks.
93
94 config FUNCTION_GRAPH_TRACER
95         bool "Kernel Function Graph Tracer"
96         depends on HAVE_FUNCTION_GRAPH_TRACER
97         depends on FUNCTION_TRACER
98         default y
99         help
100           Enable the kernel to trace a function at both its return
101           and its entry.
102           It's first purpose is to trace the duration of functions and
103           draw a call graph for each thread with some informations like
104           the return value.
105           This is done by setting the current return address on the current
106           task structure into a stack of calls.
107
108
109 config IRQSOFF_TRACER
110         bool "Interrupts-off Latency Tracer"
111         default n
112         depends on TRACE_IRQFLAGS_SUPPORT
113         depends on GENERIC_TIME
114         select TRACE_IRQFLAGS
115         select TRACING
116         select TRACER_MAX_TRACE
117         help
118           This option measures the time spent in irqs-off critical
119           sections, with microsecond accuracy.
120
121           The default measurement method is a maximum search, which is
122           disabled by default and can be runtime (re-)started
123           via:
124
125               echo 0 > /debugfs/tracing/tracing_max_latency
126
127           (Note that kernel size and overhead increases with this option
128           enabled. This option and the preempt-off timing option can be
129           used together or separately.)
130
131 config PREEMPT_TRACER
132         bool "Preemption-off Latency Tracer"
133         default n
134         depends on GENERIC_TIME
135         depends on PREEMPT
136         select TRACING
137         select TRACER_MAX_TRACE
138         help
139           This option measures the time spent in preemption off critical
140           sections, with microsecond accuracy.
141
142           The default measurement method is a maximum search, which is
143           disabled by default and can be runtime (re-)started
144           via:
145
146               echo 0 > /debugfs/tracing/tracing_max_latency
147
148           (Note that kernel size and overhead increases with this option
149           enabled. This option and the irqs-off timing option can be
150           used together or separately.)
151
152 config SYSPROF_TRACER
153         bool "Sysprof Tracer"
154         depends on X86
155         select TRACING
156         select CONTEXT_SWITCH_TRACER
157         help
158           This tracer provides the trace needed by the 'Sysprof' userspace
159           tool.
160
161 config SCHED_TRACER
162         bool "Scheduling Latency Tracer"
163         select TRACING
164         select CONTEXT_SWITCH_TRACER
165         select TRACER_MAX_TRACE
166         help
167           This tracer tracks the latency of the highest priority task
168           to be scheduled in, starting from the point it has woken up.
169
170 config CONTEXT_SWITCH_TRACER
171         bool "Trace process context switches"
172         select TRACING
173         select MARKERS
174         help
175           This tracer gets called from the context switch and records
176           all switching of tasks.
177
178 config EVENT_TRACER
179         bool "Trace various events in the kernel"
180         select TRACING
181         help
182           This tracer hooks to various trace points in the kernel
183           allowing the user to pick and choose which trace point they
184           want to trace.
185
186 config FTRACE_SYSCALLS
187         bool "Trace syscalls"
188         depends on HAVE_FTRACE_SYSCALLS
189         select TRACING
190         select KALLSYMS
191         help
192           Basic tracer to catch the syscall entry and exit events.
193
194 config BOOT_TRACER
195         bool "Trace boot initcalls"
196         select TRACING
197         select CONTEXT_SWITCH_TRACER
198         help
199           This tracer helps developers to optimize boot times: it records
200           the timings of the initcalls and traces key events and the identity
201           of tasks that can cause boot delays, such as context-switches.
202
203           Its aim is to be parsed by the /scripts/bootgraph.pl tool to
204           produce pretty graphics about boot inefficiencies, giving a visual
205           representation of the delays during initcalls - but the raw
206           /debug/tracing/trace text output is readable too.
207
208           You must pass in ftrace=initcall to the kernel command line
209           to enable this on bootup.
210
211 config TRACE_BRANCH_PROFILING
212         bool "Trace likely/unlikely profiler"
213         select TRACING
214         help
215           This tracer profiles all the the likely and unlikely macros
216           in the kernel. It will display the results in:
217
218           /debugfs/tracing/profile_annotated_branch
219
220           Note: this will add a significant overhead, only turn this
221           on if you need to profile the system's use of these macros.
222
223           Say N if unsure.
224
225 config PROFILE_ALL_BRANCHES
226         bool "Profile all if conditionals"
227         depends on TRACE_BRANCH_PROFILING
228         help
229           This tracer profiles all branch conditions. Every if ()
230           taken in the kernel is recorded whether it hit or miss.
231           The results will be displayed in:
232
233           /debugfs/tracing/profile_branch
234
235           This configuration, when enabled, will impose a great overhead
236           on the system. This should only be enabled when the system
237           is to be analyzed
238
239           Say N if unsure.
240
241 config TRACING_BRANCHES
242         bool
243         help
244           Selected by tracers that will trace the likely and unlikely
245           conditions. This prevents the tracers themselves from being
246           profiled. Profiling the tracing infrastructure can only happen
247           when the likelys and unlikelys are not being traced.
248
249 config BRANCH_TRACER
250         bool "Trace likely/unlikely instances"
251         depends on TRACE_BRANCH_PROFILING
252         select TRACING_BRANCHES
253         help
254           This traces the events of likely and unlikely condition
255           calls in the kernel.  The difference between this and the
256           "Trace likely/unlikely profiler" is that this is not a
257           histogram of the callers, but actually places the calling
258           events into a running trace buffer to see when and where the
259           events happened, as well as their results.
260
261           Say N if unsure.
262
263 config POWER_TRACER
264         bool "Trace power consumption behavior"
265         depends on X86
266         select TRACING
267         help
268           This tracer helps developers to analyze and optimize the kernels
269           power management decisions, specifically the C-state and P-state
270           behavior.
271
272
273 config STACK_TRACER
274         bool "Trace max stack"
275         depends on HAVE_FUNCTION_TRACER
276         select FUNCTION_TRACER
277         select STACKTRACE
278         select KALLSYMS
279         help
280           This special tracer records the maximum stack footprint of the
281           kernel and displays it in debugfs/tracing/stack_trace.
282
283           This tracer works by hooking into every function call that the
284           kernel executes, and keeping a maximum stack depth value and
285           stack-trace saved.  If this is configured with DYNAMIC_FTRACE
286           then it will not have any overhead while the stack tracer
287           is disabled.
288
289           To enable the stack tracer on bootup, pass in 'stacktrace'
290           on the kernel command line.
291
292           The stack tracer can also be enabled or disabled via the
293           sysctl kernel.stack_tracer_enabled
294
295           Say N if unsure.
296
297 config HW_BRANCH_TRACER
298         depends on HAVE_HW_BRANCH_TRACER
299         bool "Trace hw branches"
300         select TRACING
301         help
302           This tracer records all branches on the system in a circular
303           buffer giving access to the last N branches for each cpu.
304
305 config KMEMTRACE
306         bool "Trace SLAB allocations"
307         select TRACING
308         help
309           kmemtrace provides tracing for slab allocator functions, such as
310           kmalloc, kfree, kmem_cache_alloc, kmem_cache_free etc.. Collected
311           data is then fed to the userspace application in order to analyse
312           allocation hotspots, internal fragmentation and so on, making it
313           possible to see how well an allocator performs, as well as debug
314           and profile kernel code.
315
316           This requires an userspace application to use. See
317           Documentation/vm/kmemtrace.txt for more information.
318
319           Saying Y will make the kernel somewhat larger and slower. However,
320           if you disable kmemtrace at run-time or boot-time, the performance
321           impact is minimal (depending on the arch the kernel is built for).
322
323           If unsure, say N.
324
325 config WORKQUEUE_TRACER
326         bool "Trace workqueues"
327         select TRACING
328         help
329           The workqueue tracer provides some statistical informations
330           about each cpu workqueue thread such as the number of the
331           works inserted and executed since their creation. It can help
332           to evaluate the amount of work each of them have to perform.
333           For example it can help a developer to decide whether he should
334           choose a per cpu workqueue instead of a singlethreaded one.
335
336 config BLK_DEV_IO_TRACE
337         bool "Support for tracing block io actions"
338         depends on SYSFS
339         depends on BLOCK
340         select RELAY
341         select DEBUG_FS
342         select TRACEPOINTS
343         select TRACING
344         select STACKTRACE
345         help
346           Say Y here if you want to be able to trace the block layer actions
347           on a given queue. Tracing allows you to see any traffic happening
348           on a block device queue. For more information (and the userspace
349           support tools needed), fetch the blktrace tools from:
350
351           git://git.kernel.dk/blktrace.git
352
353           Tracing also is possible using the ftrace interface, e.g.:
354
355             echo 1 > /sys/block/sda/sda1/trace/enable
356             echo blk > /sys/kernel/debug/tracing/current_tracer
357             cat /sys/kernel/debug/tracing/trace_pipe
358
359           If unsure, say N.
360
361 config DYNAMIC_FTRACE
362         bool "enable/disable ftrace tracepoints dynamically"
363         depends on FUNCTION_TRACER
364         depends on HAVE_DYNAMIC_FTRACE
365         default y
366         help
367          This option will modify all the calls to ftrace dynamically
368          (will patch them out of the binary image and replaces them
369          with a No-Op instruction) as they are called. A table is
370          created to dynamically enable them again.
371
372          This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but otherwise
373          has native performance as long as no tracing is active.
374
375          The changes to the code are done by a kernel thread that
376          wakes up once a second and checks to see if any ftrace calls
377          were made. If so, it runs stop_machine (stops all CPUS)
378          and modifies the code to jump over the call to ftrace.
379
380 config FUNCTION_PROFILER
381         bool "Kernel function profiler"
382         depends on FUNCTION_TRACER
383         default n
384         help
385          This option enables the kernel function profiler. A file is created
386          in debugfs called function_profile_enabled which defaults to zero.
387          When a 1 is echoed into this file profiling begins, and when a
388          zero is entered, profiling stops. A file in the trace_stats
389          directory called functions, that show the list of functions that
390          have been hit and their counters.
391
392          If in doubt, say N
393
394 config FTRACE_MCOUNT_RECORD
395         def_bool y
396         depends on DYNAMIC_FTRACE
397         depends on HAVE_FTRACE_MCOUNT_RECORD
398
399 config FTRACE_SELFTEST
400         bool
401
402 config FTRACE_STARTUP_TEST
403         bool "Perform a startup test on ftrace"
404         depends on TRACING
405         select FTRACE_SELFTEST
406         help
407           This option performs a series of startup tests on ftrace. On bootup
408           a series of tests are made to verify that the tracer is
409           functioning properly. It will do tests on all the configured
410           tracers of ftrace.
411
412 config MMIOTRACE
413         bool "Memory mapped IO tracing"
414         depends on HAVE_MMIOTRACE_SUPPORT && PCI
415         select TRACING
416         help
417           Mmiotrace traces Memory Mapped I/O access and is meant for
418           debugging and reverse engineering. It is called from the ioremap
419           implementation and works via page faults. Tracing is disabled by
420           default and can be enabled at run-time.
421
422           See Documentation/tracers/mmiotrace.txt.
423           If you are not helping to develop drivers, say N.
424
425 config MMIOTRACE_TEST
426         tristate "Test module for mmiotrace"
427         depends on MMIOTRACE && m
428         help
429           This is a dumb module for testing mmiotrace. It is very dangerous
430           as it will write garbage to IO memory starting at a given address.
431           However, it should be safe to use on e.g. unused portion of VRAM.
432
433           Say N, unless you absolutely know what you are doing.
434
435 endmenu
436
437 endif # TRACING_SUPPORT
438