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