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