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_FTRACE_MCOUNT_RECORD 43 bool 44 help 45 See Documentation/trace/ftrace-design.txt 46 47config HAVE_HW_BRANCH_TRACER 48 bool 49 50config HAVE_SYSCALL_TRACEPOINTS 51 bool 52 help 53 See Documentation/trace/ftrace-design.txt 54 55config TRACER_MAX_TRACE 56 bool 57 58config RING_BUFFER 59 bool 60 61config FTRACE_NMI_ENTER 62 bool 63 depends on HAVE_FTRACE_NMI_ENTER 64 default y 65 66config EVENT_TRACING 67 select CONTEXT_SWITCH_TRACER 68 bool 69 70config CONTEXT_SWITCH_TRACER 71 bool 72 73config RING_BUFFER_ALLOW_SWAP 74 bool 75 help 76 Allow the use of ring_buffer_swap_cpu. 77 Adds a very slight overhead to tracing when enabled. 78 79# All tracer options should select GENERIC_TRACER. For those options that are 80# enabled by all tracers (context switch and event tracer) they select TRACING. 81# This allows those options to appear when no other tracer is selected. But the 82# options do not appear when something else selects it. We need the two options 83# GENERIC_TRACER and TRACING to avoid circular dependencies to accomplish the 84# hiding of the automatic options. 85 86config TRACING 87 bool 88 select DEBUG_FS 89 select RING_BUFFER 90 select STACKTRACE if STACKTRACE_SUPPORT 91 select TRACEPOINTS 92 select NOP_TRACER 93 select BINARY_PRINTF 94 select EVENT_TRACING 95 96config GENERIC_TRACER 97 bool 98 select TRACING 99 100# 101# Minimum requirements an architecture has to meet for us to 102# be able to offer generic tracing facilities: 103# 104config TRACING_SUPPORT 105 bool 106 # PPC32 has no irqflags tracing support, but it can use most of the 107 # tracers anyway, they were tested to build and work. Note that new 108 # exceptions to this list aren't welcomed, better implement the 109 # irqflags tracing for your architecture. 110 depends on TRACE_IRQFLAGS_SUPPORT || PPC32 111 depends on STACKTRACE_SUPPORT 112 default y 113 114if TRACING_SUPPORT 115 116menuconfig FTRACE 117 bool "Tracers" 118 default y if DEBUG_KERNEL 119 help 120 Enable the kernel tracing infrastructure. 121 122if FTRACE 123 124config FUNCTION_TRACER 125 bool "Kernel Function Tracer" 126 depends on HAVE_FUNCTION_TRACER 127 select FRAME_POINTER 128 select KALLSYMS 129 select GENERIC_TRACER 130 select CONTEXT_SWITCH_TRACER 131 help 132 Enable the kernel to trace every kernel function. This is done 133 by using a compiler feature to insert a small, 5-byte No-Operation 134 instruction at the beginning of every kernel function, which NOP 135 sequence is then dynamically patched into a tracer call when 136 tracing is enabled by the administrator. If it's runtime disabled 137 (the bootup default), then the overhead of the instructions is very 138 small and not measurable even in micro-benchmarks. 139 140config FUNCTION_GRAPH_TRACER 141 bool "Kernel Function Graph Tracer" 142 depends on HAVE_FUNCTION_GRAPH_TRACER 143 depends on FUNCTION_TRACER 144 depends on !X86_32 || !CC_OPTIMIZE_FOR_SIZE 145 default y 146 help 147 Enable the kernel to trace a function at both its return 148 and its entry. 149 Its first purpose is to trace the duration of functions and 150 draw a call graph for each thread with some information like 151 the return value. This is done by setting the current return 152 address on the current task structure into a stack of calls. 153 154 155config IRQSOFF_TRACER 156 bool "Interrupts-off Latency Tracer" 157 default n 158 depends on TRACE_IRQFLAGS_SUPPORT 159 depends on GENERIC_TIME 160 select TRACE_IRQFLAGS 161 select GENERIC_TRACER 162 select TRACER_MAX_TRACE 163 select RING_BUFFER_ALLOW_SWAP 164 help 165 This option measures the time spent in irqs-off critical 166 sections, with microsecond accuracy. 167 168 The default measurement method is a maximum search, which is 169 disabled by default and can be runtime (re-)started 170 via: 171 172 echo 0 > /sys/kernel/debug/tracing/tracing_max_latency 173 174 (Note that kernel size and overhead increase with this option 175 enabled. This option and the preempt-off timing option can be 176 used together or separately.) 177 178config PREEMPT_TRACER 179 bool "Preemption-off Latency Tracer" 180 default n 181 depends on GENERIC_TIME 182 depends on PREEMPT 183 select GENERIC_TRACER 184 select TRACER_MAX_TRACE 185 select RING_BUFFER_ALLOW_SWAP 186 help 187 This option measures the time spent in preemption-off critical 188 sections, with microsecond accuracy. 189 190 The default measurement method is a maximum search, which is 191 disabled by default and can be runtime (re-)started 192 via: 193 194 echo 0 > /sys/kernel/debug/tracing/tracing_max_latency 195 196 (Note that kernel size and overhead increase with this option 197 enabled. This option and the irqs-off timing option can be 198 used together or separately.) 199 200config SYSPROF_TRACER 201 bool "Sysprof Tracer" 202 depends on X86 203 select GENERIC_TRACER 204 select CONTEXT_SWITCH_TRACER 205 help 206 This tracer provides the trace needed by the 'Sysprof' userspace 207 tool. 208 209config SCHED_TRACER 210 bool "Scheduling Latency Tracer" 211 select GENERIC_TRACER 212 select CONTEXT_SWITCH_TRACER 213 select TRACER_MAX_TRACE 214 help 215 This tracer tracks the latency of the highest priority task 216 to be scheduled in, starting from the point it has woken up. 217 218config ENABLE_DEFAULT_TRACERS 219 bool "Trace process context switches and events" 220 depends on !GENERIC_TRACER 221 select TRACING 222 help 223 This tracer hooks to various trace points in the kernel, 224 allowing the user to pick and choose which trace point they 225 want to trace. It also includes the sched_switch tracer plugin. 226 227config FTRACE_SYSCALLS 228 bool "Trace syscalls" 229 depends on HAVE_SYSCALL_TRACEPOINTS 230 select GENERIC_TRACER 231 select KALLSYMS 232 help 233 Basic tracer to catch the syscall entry and exit events. 234 235config BOOT_TRACER 236 bool "Trace boot initcalls" 237 select GENERIC_TRACER 238 select CONTEXT_SWITCH_TRACER 239 help 240 This tracer helps developers to optimize boot times: it records 241 the timings of the initcalls and traces key events and the identity 242 of tasks that can cause boot delays, such as context-switches. 243 244 Its aim is to be parsed by the scripts/bootgraph.pl tool to 245 produce pretty graphics about boot inefficiencies, giving a visual 246 representation of the delays during initcalls - but the raw 247 /debug/tracing/trace text output is readable too. 248 249 You must pass in initcall_debug and ftrace=initcall to the kernel 250 command line to enable this on bootup. 251 252config TRACE_BRANCH_PROFILING 253 bool 254 select GENERIC_TRACER 255 256choice 257 prompt "Branch Profiling" 258 default BRANCH_PROFILE_NONE 259 help 260 The branch profiling is a software profiler. It will add hooks 261 into the C conditionals to test which path a branch takes. 262 263 The likely/unlikely profiler only looks at the conditions that 264 are annotated with a likely or unlikely macro. 265 266 The "all branch" profiler will profile every if-statement in the 267 kernel. This profiler will also enable the likely/unlikely 268 profiler. 269 270 Either of the above profilers adds a bit of overhead to the system. 271 If unsure, choose "No branch profiling". 272 273config BRANCH_PROFILE_NONE 274 bool "No branch profiling" 275 help 276 No branch profiling. Branch profiling adds a bit of overhead. 277 Only enable it if you want to analyse the branching behavior. 278 Otherwise keep it disabled. 279 280config PROFILE_ANNOTATED_BRANCHES 281 bool "Trace likely/unlikely profiler" 282 select TRACE_BRANCH_PROFILING 283 help 284 This tracer profiles all the the likely and unlikely macros 285 in the kernel. It will display the results in: 286 287 /sys/kernel/debug/tracing/profile_annotated_branch 288 289 Note: this will add a significant overhead; only turn this 290 on if you need to profile the system's use of these macros. 291 292config PROFILE_ALL_BRANCHES 293 bool "Profile all if conditionals" 294 select TRACE_BRANCH_PROFILING 295 help 296 This tracer profiles all branch conditions. Every if () 297 taken in the kernel is recorded whether it hit or miss. 298 The results will be displayed in: 299 300 /sys/kernel/debug/tracing/profile_branch 301 302 This option also enables the likely/unlikely profiler. 303 304 This configuration, when enabled, will impose a great overhead 305 on the system. This should only be enabled when the system 306 is to be analyzed in much detail. 307endchoice 308 309config TRACING_BRANCHES 310 bool 311 help 312 Selected by tracers that will trace the likely and unlikely 313 conditions. This prevents the tracers themselves from being 314 profiled. Profiling the tracing infrastructure can only happen 315 when the likelys and unlikelys are not being traced. 316 317config BRANCH_TRACER 318 bool "Trace likely/unlikely instances" 319 depends on TRACE_BRANCH_PROFILING 320 select TRACING_BRANCHES 321 help 322 This traces the events of likely and unlikely condition 323 calls in the kernel. The difference between this and the 324 "Trace likely/unlikely profiler" is that this is not a 325 histogram of the callers, but actually places the calling 326 events into a running trace buffer to see when and where the 327 events happened, as well as their results. 328 329 Say N if unsure. 330 331config POWER_TRACER 332 bool "Trace power consumption behavior" 333 depends on X86 334 select GENERIC_TRACER 335 help 336 This tracer helps developers to analyze and optimize the kernel's 337 power management decisions, specifically the C-state and P-state 338 behavior. 339 340config KSYM_TRACER 341 bool "Trace read and write access on kernel memory locations" 342 depends on HAVE_HW_BREAKPOINT 343 select TRACING 344 help 345 This tracer helps find read and write operations on any given kernel 346 symbol i.e. /proc/kallsyms. 347 348config PROFILE_KSYM_TRACER 349 bool "Profile all kernel memory accesses on 'watched' variables" 350 depends on KSYM_TRACER 351 help 352 This tracer profiles kernel accesses on variables watched through the 353 ksym tracer ftrace plugin. Depending upon the hardware, all read 354 and write operations on kernel variables can be monitored for 355 accesses. 356 357 The results will be displayed in: 358 /debugfs/tracing/profile_ksym 359 360 Say N if unsure. 361 362config STACK_TRACER 363 bool "Trace max stack" 364 depends on HAVE_FUNCTION_TRACER 365 select FUNCTION_TRACER 366 select STACKTRACE 367 select KALLSYMS 368 help 369 This special tracer records the maximum stack footprint of the 370 kernel and displays it in /sys/kernel/debug/tracing/stack_trace. 371 372 This tracer works by hooking into every function call that the 373 kernel executes, and keeping a maximum stack depth value and 374 stack-trace saved. If this is configured with DYNAMIC_FTRACE 375 then it will not have any overhead while the stack tracer 376 is disabled. 377 378 To enable the stack tracer on bootup, pass in 'stacktrace' 379 on the kernel command line. 380 381 The stack tracer can also be enabled or disabled via the 382 sysctl kernel.stack_tracer_enabled 383 384 Say N if unsure. 385 386config HW_BRANCH_TRACER 387 depends on HAVE_HW_BRANCH_TRACER 388 bool "Trace hw branches" 389 select GENERIC_TRACER 390 help 391 This tracer records all branches on the system in a circular 392 buffer, giving access to the last N branches for each cpu. 393 394config KMEMTRACE 395 bool "Trace SLAB allocations" 396 select GENERIC_TRACER 397 help 398 kmemtrace provides tracing for slab allocator functions, such as 399 kmalloc, kfree, kmem_cache_alloc, kmem_cache_free, etc. Collected 400 data is then fed to the userspace application in order to analyse 401 allocation hotspots, internal fragmentation and so on, making it 402 possible to see how well an allocator performs, as well as debug 403 and profile kernel code. 404 405 This requires an userspace application to use. See 406 Documentation/trace/kmemtrace.txt for more information. 407 408 Saying Y will make the kernel somewhat larger and slower. However, 409 if you disable kmemtrace at run-time or boot-time, the performance 410 impact is minimal (depending on the arch the kernel is built for). 411 412 If unsure, say N. 413 414config WORKQUEUE_TRACER 415 bool "Trace workqueues" 416 select GENERIC_TRACER 417 help 418 The workqueue tracer provides some statistical information 419 about each cpu workqueue thread such as the number of the 420 works inserted and executed since their creation. It can help 421 to evaluate the amount of work each of them has to perform. 422 For example it can help a developer to decide whether he should 423 choose a per-cpu workqueue instead of a singlethreaded one. 424 425config BLK_DEV_IO_TRACE 426 bool "Support for tracing block IO actions" 427 depends on SYSFS 428 depends on BLOCK 429 select RELAY 430 select DEBUG_FS 431 select TRACEPOINTS 432 select GENERIC_TRACER 433 select STACKTRACE 434 help 435 Say Y here if you want to be able to trace the block layer actions 436 on a given queue. Tracing allows you to see any traffic happening 437 on a block device queue. For more information (and the userspace 438 support tools needed), fetch the blktrace tools from: 439 440 git://git.kernel.dk/blktrace.git 441 442 Tracing also is possible using the ftrace interface, e.g.: 443 444 echo 1 > /sys/block/sda/sda1/trace/enable 445 echo blk > /sys/kernel/debug/tracing/current_tracer 446 cat /sys/kernel/debug/tracing/trace_pipe 447 448 If unsure, say N. 449 450config KPROBE_EVENT 451 depends on KPROBES 452 depends on X86 453 bool "Enable kprobes-based dynamic events" 454 select TRACING 455 default y 456 help 457 This allows the user to add tracing events (similar to tracepoints) 458 on the fly via the ftrace interface. See 459 Documentation/trace/kprobetrace.txt for more details. 460 461 Those events can be inserted wherever kprobes can probe, and record 462 various register and memory values. 463 464 This option is also required by perf-probe subcommand of perf tools. 465 If you want to use perf tools, this option is strongly recommended. 466 467config DYNAMIC_FTRACE 468 bool "enable/disable ftrace tracepoints dynamically" 469 depends on FUNCTION_TRACER 470 depends on HAVE_DYNAMIC_FTRACE 471 default y 472 help 473 This option will modify all the calls to ftrace dynamically 474 (will patch them out of the binary image and replace them 475 with a No-Op instruction) as they are called. A table is 476 created to dynamically enable them again. 477 478 This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but 479 otherwise has native performance as long as no tracing is active. 480 481 The changes to the code are done by a kernel thread that 482 wakes up once a second and checks to see if any ftrace calls 483 were made. If so, it runs stop_machine (stops all CPUS) 484 and modifies the code to jump over the call to ftrace. 485 486config FUNCTION_PROFILER 487 bool "Kernel function profiler" 488 depends on FUNCTION_TRACER 489 default n 490 help 491 This option enables the kernel function profiler. A file is created 492 in debugfs called function_profile_enabled which defaults to zero. 493 When a 1 is echoed into this file profiling begins, and when a 494 zero is entered, profiling stops. A "functions" file is created in 495 the trace_stats directory; this file shows the list of functions that 496 have been hit and their counters. 497 498 If in doubt, say N. 499 500config FTRACE_MCOUNT_RECORD 501 def_bool y 502 depends on DYNAMIC_FTRACE 503 depends on HAVE_FTRACE_MCOUNT_RECORD 504 505config FTRACE_SELFTEST 506 bool 507 508config FTRACE_STARTUP_TEST 509 bool "Perform a startup test on ftrace" 510 depends on GENERIC_TRACER 511 select FTRACE_SELFTEST 512 help 513 This option performs a series of startup tests on ftrace. On bootup 514 a series of tests are made to verify that the tracer is 515 functioning properly. It will do tests on all the configured 516 tracers of ftrace. 517 518config EVENT_TRACE_TEST_SYSCALLS 519 bool "Run selftest on syscall events" 520 depends on FTRACE_STARTUP_TEST 521 help 522 This option will also enable testing every syscall event. 523 It only enables the event and disables it and runs various loads 524 with the event enabled. This adds a bit more time for kernel boot 525 up since it runs this on every system call defined. 526 527 TBD - enable a way to actually call the syscalls as we test their 528 events 529 530config MMIOTRACE 531 bool "Memory mapped IO tracing" 532 depends on HAVE_MMIOTRACE_SUPPORT && PCI 533 select GENERIC_TRACER 534 help 535 Mmiotrace traces Memory Mapped I/O access and is meant for 536 debugging and reverse engineering. It is called from the ioremap 537 implementation and works via page faults. Tracing is disabled by 538 default and can be enabled at run-time. 539 540 See Documentation/trace/mmiotrace.txt. 541 If you are not helping to develop drivers, say N. 542 543config MMIOTRACE_TEST 544 tristate "Test module for mmiotrace" 545 depends on MMIOTRACE && m 546 help 547 This is a dumb module for testing mmiotrace. It is very dangerous 548 as it will write garbage to IO memory starting at a given address. 549 However, it should be safe to use on e.g. unused portion of VRAM. 550 551 Say N, unless you absolutely know what you are doing. 552 553config RING_BUFFER_BENCHMARK 554 tristate "Ring buffer benchmark stress tester" 555 depends on RING_BUFFER 556 help 557 This option creates a test to stress the ring buffer and benchmark it. 558 It creates its own ring buffer such that it will not interfere with 559 any other users of the ring buffer (such as ftrace). It then creates 560 a producer and consumer that will run for 10 seconds and sleep for 561 10 seconds. Each interval it will print out the number of events 562 it recorded and give a rough estimate of how long each iteration took. 563 564 It does not disable interrupts or raise its priority, so it may be 565 affected by processes that are running. 566 567 If unsure, say N. 568 569endif # FTRACE 570 571endif # TRACING_SUPPORT 572 573