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 select IRQ_WORK 75 76config FTRACE_NMI_ENTER 77 bool 78 depends on HAVE_FTRACE_NMI_ENTER 79 default y 80 81config EVENT_TRACING 82 select CONTEXT_SWITCH_TRACER 83 bool 84 85config CONTEXT_SWITCH_TRACER 86 bool 87 88config RING_BUFFER_ALLOW_SWAP 89 bool 90 help 91 Allow the use of ring_buffer_swap_cpu. 92 Adds a very slight overhead to tracing when enabled. 93 94# All tracer options should select GENERIC_TRACER. For those options that are 95# enabled by all tracers (context switch and event tracer) they select TRACING. 96# This allows those options to appear when no other tracer is selected. But the 97# options do not appear when something else selects it. We need the two options 98# GENERIC_TRACER and TRACING to avoid circular dependencies to accomplish the 99# hiding of the automatic options. 100 101config TRACING 102 bool 103 select DEBUG_FS 104 select RING_BUFFER 105 select STACKTRACE if STACKTRACE_SUPPORT 106 select TRACEPOINTS 107 select NOP_TRACER 108 select BINARY_PRINTF 109 select EVENT_TRACING 110 select TRACE_CLOCK 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 select TRACER_SNAPSHOT 180 select TRACER_SNAPSHOT_PER_CPU_SWAP 181 help 182 This option measures the time spent in irqs-off critical 183 sections, with microsecond accuracy. 184 185 The default measurement method is a maximum search, which is 186 disabled by default and can be runtime (re-)started 187 via: 188 189 echo 0 > /sys/kernel/debug/tracing/tracing_max_latency 190 191 (Note that kernel size and overhead increase with this option 192 enabled. This option and the preempt-off timing option can be 193 used together or separately.) 194 195config PREEMPT_TRACER 196 bool "Preemption-off Latency Tracer" 197 default n 198 depends on !ARCH_USES_GETTIMEOFFSET 199 depends on PREEMPT 200 select GENERIC_TRACER 201 select TRACER_MAX_TRACE 202 select RING_BUFFER_ALLOW_SWAP 203 select TRACER_SNAPSHOT 204 select TRACER_SNAPSHOT_PER_CPU_SWAP 205 help 206 This option measures the time spent in preemption-off critical 207 sections, with microsecond accuracy. 208 209 The default measurement method is a maximum search, which is 210 disabled by default and can be runtime (re-)started 211 via: 212 213 echo 0 > /sys/kernel/debug/tracing/tracing_max_latency 214 215 (Note that kernel size and overhead increase with this option 216 enabled. This option and the irqs-off timing option can be 217 used together or separately.) 218 219config SCHED_TRACER 220 bool "Scheduling Latency Tracer" 221 select GENERIC_TRACER 222 select CONTEXT_SWITCH_TRACER 223 select TRACER_MAX_TRACE 224 select TRACER_SNAPSHOT 225 help 226 This tracer tracks the latency of the highest priority task 227 to be scheduled in, starting from the point it has woken up. 228 229config ENABLE_DEFAULT_TRACERS 230 bool "Trace process context switches and events" 231 depends on !GENERIC_TRACER 232 select TRACING 233 help 234 This tracer hooks to various trace points in the kernel, 235 allowing the user to pick and choose which trace point they 236 want to trace. It also includes the sched_switch tracer plugin. 237 238config FTRACE_SYSCALLS 239 bool "Trace syscalls" 240 depends on HAVE_SYSCALL_TRACEPOINTS 241 select GENERIC_TRACER 242 select KALLSYMS 243 help 244 Basic tracer to catch the syscall entry and exit events. 245 246config TRACER_SNAPSHOT 247 bool "Create a snapshot trace buffer" 248 select TRACER_MAX_TRACE 249 help 250 Allow tracing users to take snapshot of the current buffer using the 251 ftrace interface, e.g.: 252 253 echo 1 > /sys/kernel/debug/tracing/snapshot 254 cat snapshot 255 256config TRACER_SNAPSHOT_PER_CPU_SWAP 257 bool "Allow snapshot to swap per CPU" 258 depends on TRACER_SNAPSHOT 259 select RING_BUFFER_ALLOW_SWAP 260 help 261 Allow doing a snapshot of a single CPU buffer instead of a 262 full swap (all buffers). If this is set, then the following is 263 allowed: 264 265 echo 1 > /sys/kernel/debug/tracing/per_cpu/cpu2/snapshot 266 267 After which, only the tracing buffer for CPU 2 was swapped with 268 the main tracing buffer, and the other CPU buffers remain the same. 269 270 When this is enabled, this adds a little more overhead to the 271 trace recording, as it needs to add some checks to synchronize 272 recording with swaps. But this does not affect the performance 273 of the overall system. This is enabled by default when the preempt 274 or irq latency tracers are enabled, as those need to swap as well 275 and already adds the overhead (plus a lot more). 276 277config TRACE_BRANCH_PROFILING 278 bool 279 select GENERIC_TRACER 280 281choice 282 prompt "Branch Profiling" 283 default BRANCH_PROFILE_NONE 284 help 285 The branch profiling is a software profiler. It will add hooks 286 into the C conditionals to test which path a branch takes. 287 288 The likely/unlikely profiler only looks at the conditions that 289 are annotated with a likely or unlikely macro. 290 291 The "all branch" profiler will profile every if-statement in the 292 kernel. This profiler will also enable the likely/unlikely 293 profiler. 294 295 Either of the above profilers adds a bit of overhead to the system. 296 If unsure, choose "No branch profiling". 297 298config BRANCH_PROFILE_NONE 299 bool "No branch profiling" 300 help 301 No branch profiling. Branch profiling adds a bit of overhead. 302 Only enable it if you want to analyse the branching behavior. 303 Otherwise keep it disabled. 304 305config PROFILE_ANNOTATED_BRANCHES 306 bool "Trace likely/unlikely profiler" 307 select TRACE_BRANCH_PROFILING 308 help 309 This tracer profiles all likely and unlikely macros 310 in the kernel. It will display the results in: 311 312 /sys/kernel/debug/tracing/trace_stat/branch_annotated 313 314 Note: this will add a significant overhead; only turn this 315 on if you need to profile the system's use of these macros. 316 317config PROFILE_ALL_BRANCHES 318 bool "Profile all if conditionals" 319 select TRACE_BRANCH_PROFILING 320 help 321 This tracer profiles all branch conditions. Every if () 322 taken in the kernel is recorded whether it hit or miss. 323 The results will be displayed in: 324 325 /sys/kernel/debug/tracing/trace_stat/branch_all 326 327 This option also enables the likely/unlikely profiler. 328 329 This configuration, when enabled, will impose a great overhead 330 on the system. This should only be enabled when the system 331 is to be analyzed in much detail. 332endchoice 333 334config TRACING_BRANCHES 335 bool 336 help 337 Selected by tracers that will trace the likely and unlikely 338 conditions. This prevents the tracers themselves from being 339 profiled. Profiling the tracing infrastructure can only happen 340 when the likelys and unlikelys are not being traced. 341 342config BRANCH_TRACER 343 bool "Trace likely/unlikely instances" 344 depends on TRACE_BRANCH_PROFILING 345 select TRACING_BRANCHES 346 help 347 This traces the events of likely and unlikely condition 348 calls in the kernel. The difference between this and the 349 "Trace likely/unlikely profiler" is that this is not a 350 histogram of the callers, but actually places the calling 351 events into a running trace buffer to see when and where the 352 events happened, as well as their results. 353 354 Say N if unsure. 355 356config STACK_TRACER 357 bool "Trace max stack" 358 depends on HAVE_FUNCTION_TRACER 359 select FUNCTION_TRACER 360 select STACKTRACE 361 select KALLSYMS 362 help 363 This special tracer records the maximum stack footprint of the 364 kernel and displays it in /sys/kernel/debug/tracing/stack_trace. 365 366 This tracer works by hooking into every function call that the 367 kernel executes, and keeping a maximum stack depth value and 368 stack-trace saved. If this is configured with DYNAMIC_FTRACE 369 then it will not have any overhead while the stack tracer 370 is disabled. 371 372 To enable the stack tracer on bootup, pass in 'stacktrace' 373 on the kernel command line. 374 375 The stack tracer can also be enabled or disabled via the 376 sysctl kernel.stack_tracer_enabled 377 378 Say N if unsure. 379 380config BLK_DEV_IO_TRACE 381 bool "Support for tracing block IO actions" 382 depends on SYSFS 383 depends on BLOCK 384 select RELAY 385 select DEBUG_FS 386 select TRACEPOINTS 387 select GENERIC_TRACER 388 select STACKTRACE 389 help 390 Say Y here if you want to be able to trace the block layer actions 391 on a given queue. Tracing allows you to see any traffic happening 392 on a block device queue. For more information (and the userspace 393 support tools needed), fetch the blktrace tools from: 394 395 git://git.kernel.dk/blktrace.git 396 397 Tracing also is possible using the ftrace interface, e.g.: 398 399 echo 1 > /sys/block/sda/sda1/trace/enable 400 echo blk > /sys/kernel/debug/tracing/current_tracer 401 cat /sys/kernel/debug/tracing/trace_pipe 402 403 If unsure, say N. 404 405config KPROBE_EVENT 406 depends on KPROBES 407 depends on HAVE_REGS_AND_STACK_ACCESS_API 408 bool "Enable kprobes-based dynamic events" 409 select TRACING 410 select PROBE_EVENTS 411 default y 412 help 413 This allows the user to add tracing events (similar to tracepoints) 414 on the fly via the ftrace interface. See 415 Documentation/trace/kprobetrace.txt for more details. 416 417 Those events can be inserted wherever kprobes can probe, and record 418 various register and memory values. 419 420 This option is also required by perf-probe subcommand of perf tools. 421 If you want to use perf tools, this option is strongly recommended. 422 423config UPROBE_EVENT 424 bool "Enable uprobes-based dynamic events" 425 depends on ARCH_SUPPORTS_UPROBES 426 depends on MMU 427 depends on PERF_EVENTS 428 select UPROBES 429 select PROBE_EVENTS 430 select TRACING 431 default n 432 help 433 This allows the user to add tracing events on top of userspace 434 dynamic events (similar to tracepoints) on the fly via the trace 435 events interface. Those events can be inserted wherever uprobes 436 can probe, and record various registers. 437 This option is required if you plan to use perf-probe subcommand 438 of perf tools on user space applications. 439 440config PROBE_EVENTS 441 def_bool n 442 443config DYNAMIC_FTRACE 444 bool "enable/disable function tracing dynamically" 445 depends on FUNCTION_TRACER 446 depends on HAVE_DYNAMIC_FTRACE 447 default y 448 help 449 This option will modify all the calls to function tracing 450 dynamically (will patch them out of the binary image and 451 replace them with a No-Op instruction) on boot up. During 452 compile time, a table is made of all the locations that ftrace 453 can function trace, and this table is linked into the kernel 454 image. When this is enabled, functions can be individually 455 enabled, and the functions not enabled will not affect 456 performance of the system. 457 458 See the files in /sys/kernel/debug/tracing: 459 available_filter_functions 460 set_ftrace_filter 461 set_ftrace_notrace 462 463 This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but 464 otherwise has native performance as long as no tracing is active. 465 466config DYNAMIC_FTRACE_WITH_REGS 467 def_bool y 468 depends on DYNAMIC_FTRACE 469 depends on HAVE_DYNAMIC_FTRACE_WITH_REGS 470 471config FUNCTION_PROFILER 472 bool "Kernel function profiler" 473 depends on FUNCTION_TRACER 474 default n 475 help 476 This option enables the kernel function profiler. A file is created 477 in debugfs called function_profile_enabled which defaults to zero. 478 When a 1 is echoed into this file profiling begins, and when a 479 zero is entered, profiling stops. A "functions" file is created in 480 the trace_stats directory; this file shows the list of functions that 481 have been hit and their counters. 482 483 If in doubt, say N. 484 485config FTRACE_MCOUNT_RECORD 486 def_bool y 487 depends on DYNAMIC_FTRACE 488 depends on HAVE_FTRACE_MCOUNT_RECORD 489 490config FTRACE_SELFTEST 491 bool 492 493config FTRACE_STARTUP_TEST 494 bool "Perform a startup test on ftrace" 495 depends on GENERIC_TRACER 496 select FTRACE_SELFTEST 497 help 498 This option performs a series of startup tests on ftrace. On bootup 499 a series of tests are made to verify that the tracer is 500 functioning properly. It will do tests on all the configured 501 tracers of ftrace. 502 503config EVENT_TRACE_TEST_SYSCALLS 504 bool "Run selftest on syscall events" 505 depends on FTRACE_STARTUP_TEST 506 help 507 This option will also enable testing every syscall event. 508 It only enables the event and disables it and runs various loads 509 with the event enabled. This adds a bit more time for kernel boot 510 up since it runs this on every system call defined. 511 512 TBD - enable a way to actually call the syscalls as we test their 513 events 514 515config MMIOTRACE 516 bool "Memory mapped IO tracing" 517 depends on HAVE_MMIOTRACE_SUPPORT && PCI 518 select GENERIC_TRACER 519 help 520 Mmiotrace traces Memory Mapped I/O access and is meant for 521 debugging and reverse engineering. It is called from the ioremap 522 implementation and works via page faults. Tracing is disabled by 523 default and can be enabled at run-time. 524 525 See Documentation/trace/mmiotrace.txt. 526 If you are not helping to develop drivers, say N. 527 528config MMIOTRACE_TEST 529 tristate "Test module for mmiotrace" 530 depends on MMIOTRACE && m 531 help 532 This is a dumb module for testing mmiotrace. It is very dangerous 533 as it will write garbage to IO memory starting at a given address. 534 However, it should be safe to use on e.g. unused portion of VRAM. 535 536 Say N, unless you absolutely know what you are doing. 537 538config TRACEPOINT_BENCHMARK 539 bool "Add tracepoint that benchmarks tracepoints" 540 help 541 This option creates the tracepoint "benchmark:benchmark_event". 542 When the tracepoint is enabled, it kicks off a kernel thread that 543 goes into an infinite loop (calling cond_sched() to let other tasks 544 run), and calls the tracepoint. Each iteration will record the time 545 it took to write to the tracepoint and the next iteration that 546 data will be passed to the tracepoint itself. That is, the tracepoint 547 will report the time it took to do the previous tracepoint. 548 The string written to the tracepoint is a static string of 128 bytes 549 to keep the time the same. The initial string is simply a write of 550 "START". The second string records the cold cache time of the first 551 write which is not added to the rest of the calculations. 552 553 As it is a tight loop, it benchmarks as hot cache. That's fine because 554 we care most about hot paths that are probably in cache already. 555 556 An example of the output: 557 558 START 559 first=3672 [COLD CACHED] 560 last=632 first=3672 max=632 min=632 avg=316 std=446 std^2=199712 561 last=278 first=3672 max=632 min=278 avg=303 std=316 std^2=100337 562 last=277 first=3672 max=632 min=277 avg=296 std=258 std^2=67064 563 last=273 first=3672 max=632 min=273 avg=292 std=224 std^2=50411 564 last=273 first=3672 max=632 min=273 avg=288 std=200 std^2=40389 565 last=281 first=3672 max=632 min=273 avg=287 std=183 std^2=33666 566 567 568config RING_BUFFER_BENCHMARK 569 tristate "Ring buffer benchmark stress tester" 570 depends on RING_BUFFER 571 help 572 This option creates a test to stress the ring buffer and benchmark it. 573 It creates its own ring buffer such that it will not interfere with 574 any other users of the ring buffer (such as ftrace). It then creates 575 a producer and consumer that will run for 10 seconds and sleep for 576 10 seconds. Each interval it will print out the number of events 577 it recorded and give a rough estimate of how long each iteration took. 578 579 It does not disable interrupts or raise its priority, so it may be 580 affected by processes that are running. 581 582 If unsure, say N. 583 584config RING_BUFFER_STARTUP_TEST 585 bool "Ring buffer startup self test" 586 depends on RING_BUFFER 587 help 588 Run a simple self test on the ring buffer on boot up. Late in the 589 kernel boot sequence, the test will start that kicks off 590 a thread per cpu. Each thread will write various size events 591 into the ring buffer. Another thread is created to send IPIs 592 to each of the threads, where the IPI handler will also write 593 to the ring buffer, to test/stress the nesting ability. 594 If any anomalies are discovered, a warning will be displayed 595 and all ring buffers will be disabled. 596 597 The test runs for 10 seconds. This will slow your boot time 598 by at least 10 more seconds. 599 600 At the end of the test, statics and more checks are done. 601 It will output the stats of each per cpu buffer. What 602 was written, the sizes, what was read, what was lost, and 603 other similar details. 604 605 If unsure, say N 606 607endif # FTRACE 608 609endif # TRACING_SUPPORT 610 611