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_DYNAMIC_FTRACE 33 bool 34 help 35 See Documentation/trace/ftrace-design.txt 36 37config HAVE_DYNAMIC_FTRACE_WITH_REGS 38 bool 39 40config HAVE_FTRACE_MCOUNT_RECORD 41 bool 42 help 43 See Documentation/trace/ftrace-design.txt 44 45config HAVE_SYSCALL_TRACEPOINTS 46 bool 47 help 48 See Documentation/trace/ftrace-design.txt 49 50config HAVE_FENTRY 51 bool 52 help 53 Arch supports the gcc options -pg with -mfentry 54 55config HAVE_C_RECORDMCOUNT 56 bool 57 help 58 C version of recordmcount available? 59 60config TRACER_MAX_TRACE 61 bool 62 63config TRACE_CLOCK 64 bool 65 66config RING_BUFFER 67 bool 68 select TRACE_CLOCK 69 select IRQ_WORK 70 71config FTRACE_NMI_ENTER 72 bool 73 depends on HAVE_FTRACE_NMI_ENTER 74 default y 75 76config EVENT_TRACING 77 select CONTEXT_SWITCH_TRACER 78 bool 79 80config CONTEXT_SWITCH_TRACER 81 bool 82 83config RING_BUFFER_ALLOW_SWAP 84 bool 85 help 86 Allow the use of ring_buffer_swap_cpu. 87 Adds a very slight overhead to tracing when enabled. 88 89# All tracer options should select GENERIC_TRACER. For those options that are 90# enabled by all tracers (context switch and event tracer) they select TRACING. 91# This allows those options to appear when no other tracer is selected. But the 92# options do not appear when something else selects it. We need the two options 93# GENERIC_TRACER and TRACING to avoid circular dependencies to accomplish the 94# hiding of the automatic options. 95 96config TRACING 97 bool 98 select DEBUG_FS 99 select RING_BUFFER 100 select STACKTRACE if STACKTRACE_SUPPORT 101 select TRACEPOINTS 102 select NOP_TRACER 103 select BINARY_PRINTF 104 select EVENT_TRACING 105 select TRACE_CLOCK 106 107config GENERIC_TRACER 108 bool 109 select TRACING 110 111# 112# Minimum requirements an architecture has to meet for us to 113# be able to offer generic tracing facilities: 114# 115config TRACING_SUPPORT 116 bool 117 # PPC32 has no irqflags tracing support, but it can use most of the 118 # tracers anyway, they were tested to build and work. Note that new 119 # exceptions to this list aren't welcomed, better implement the 120 # irqflags tracing for your architecture. 121 depends on TRACE_IRQFLAGS_SUPPORT || PPC32 122 depends on STACKTRACE_SUPPORT 123 default y 124 125if TRACING_SUPPORT 126 127menuconfig FTRACE 128 bool "Tracers" 129 default y if DEBUG_KERNEL 130 help 131 Enable the kernel tracing infrastructure. 132 133if FTRACE 134 135config FUNCTION_TRACER 136 bool "Kernel Function Tracer" 137 depends on HAVE_FUNCTION_TRACER 138 select KALLSYMS 139 select GENERIC_TRACER 140 select CONTEXT_SWITCH_TRACER 141 help 142 Enable the kernel to trace every kernel function. This is done 143 by using a compiler feature to insert a small, 5-byte No-Operation 144 instruction at the beginning of every kernel function, which NOP 145 sequence is then dynamically patched into a tracer call when 146 tracing is enabled by the administrator. If it's runtime disabled 147 (the bootup default), then the overhead of the instructions is very 148 small and not measurable even in micro-benchmarks. 149 150config FUNCTION_GRAPH_TRACER 151 bool "Kernel Function Graph Tracer" 152 depends on HAVE_FUNCTION_GRAPH_TRACER 153 depends on FUNCTION_TRACER 154 depends on !X86_32 || !CC_OPTIMIZE_FOR_SIZE 155 default y 156 help 157 Enable the kernel to trace a function at both its return 158 and its entry. 159 Its first purpose is to trace the duration of functions and 160 draw a call graph for each thread with some information like 161 the return value. This is done by setting the current return 162 address on the current task structure into a stack of calls. 163 164 165config IRQSOFF_TRACER 166 bool "Interrupts-off Latency Tracer" 167 default n 168 depends on TRACE_IRQFLAGS_SUPPORT 169 depends on !ARCH_USES_GETTIMEOFFSET 170 select TRACE_IRQFLAGS 171 select GENERIC_TRACER 172 select TRACER_MAX_TRACE 173 select RING_BUFFER_ALLOW_SWAP 174 select TRACER_SNAPSHOT 175 select TRACER_SNAPSHOT_PER_CPU_SWAP 176 help 177 This option measures the time spent in irqs-off critical 178 sections, with microsecond accuracy. 179 180 The default measurement method is a maximum search, which is 181 disabled by default and can be runtime (re-)started 182 via: 183 184 echo 0 > /sys/kernel/debug/tracing/tracing_max_latency 185 186 (Note that kernel size and overhead increase with this option 187 enabled. This option and the preempt-off timing option can be 188 used together or separately.) 189 190config PREEMPT_TRACER 191 bool "Preemption-off Latency Tracer" 192 default n 193 depends on !ARCH_USES_GETTIMEOFFSET 194 depends on PREEMPT 195 select GENERIC_TRACER 196 select TRACER_MAX_TRACE 197 select RING_BUFFER_ALLOW_SWAP 198 select TRACER_SNAPSHOT 199 select TRACER_SNAPSHOT_PER_CPU_SWAP 200 help 201 This option measures the time spent in preemption-off critical 202 sections, with microsecond accuracy. 203 204 The default measurement method is a maximum search, which is 205 disabled by default and can be runtime (re-)started 206 via: 207 208 echo 0 > /sys/kernel/debug/tracing/tracing_max_latency 209 210 (Note that kernel size and overhead increase with this option 211 enabled. This option and the irqs-off timing option can be 212 used together or separately.) 213 214config SCHED_TRACER 215 bool "Scheduling Latency Tracer" 216 select GENERIC_TRACER 217 select CONTEXT_SWITCH_TRACER 218 select TRACER_MAX_TRACE 219 select TRACER_SNAPSHOT 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 HWLAT_TRACER 225 bool "Tracer to detect hardware latencies (like SMIs)" 226 select GENERIC_TRACER 227 help 228 This tracer, when enabled will create one or more kernel threads, 229 depening on what the cpumask file is set to, which each thread 230 spinning in a loop looking for interruptions caused by 231 something other than the kernel. For example, if a 232 System Management Interrupt (SMI) takes a noticeable amount of 233 time, this tracer will detect it. This is useful for testing 234 if a system is reliable for Real Time tasks. 235 236 Some files are created in the tracing directory when this 237 is enabled: 238 239 hwlat_detector/width - time in usecs for how long to spin for 240 hwlat_detector/window - time in usecs between the start of each 241 iteration 242 243 A kernel thread is created that will spin with interrupts disabled 244 for "width" microseconds in every "widow" cycle. It will not spin 245 for "window - width" microseconds, where the system can 246 continue to operate. 247 248 The output will appear in the trace and trace_pipe files. 249 250 When the tracer is not running, it has no affect on the system, 251 but when it is running, it can cause the system to be 252 periodically non responsive. Do not run this tracer on a 253 production system. 254 255 To enable this tracer, echo in "hwlat" into the current_tracer 256 file. Every time a latency is greater than tracing_thresh, it will 257 be recorded into the ring buffer. 258 259config ENABLE_DEFAULT_TRACERS 260 bool "Trace process context switches and events" 261 depends on !GENERIC_TRACER 262 select TRACING 263 help 264 This tracer hooks to various trace points in the kernel, 265 allowing the user to pick and choose which trace point they 266 want to trace. It also includes the sched_switch tracer plugin. 267 268config FTRACE_SYSCALLS 269 bool "Trace syscalls" 270 depends on HAVE_SYSCALL_TRACEPOINTS 271 select GENERIC_TRACER 272 select KALLSYMS 273 help 274 Basic tracer to catch the syscall entry and exit events. 275 276config TRACER_SNAPSHOT 277 bool "Create a snapshot trace buffer" 278 select TRACER_MAX_TRACE 279 help 280 Allow tracing users to take snapshot of the current buffer using the 281 ftrace interface, e.g.: 282 283 echo 1 > /sys/kernel/debug/tracing/snapshot 284 cat snapshot 285 286config TRACER_SNAPSHOT_PER_CPU_SWAP 287 bool "Allow snapshot to swap per CPU" 288 depends on TRACER_SNAPSHOT 289 select RING_BUFFER_ALLOW_SWAP 290 help 291 Allow doing a snapshot of a single CPU buffer instead of a 292 full swap (all buffers). If this is set, then the following is 293 allowed: 294 295 echo 1 > /sys/kernel/debug/tracing/per_cpu/cpu2/snapshot 296 297 After which, only the tracing buffer for CPU 2 was swapped with 298 the main tracing buffer, and the other CPU buffers remain the same. 299 300 When this is enabled, this adds a little more overhead to the 301 trace recording, as it needs to add some checks to synchronize 302 recording with swaps. But this does not affect the performance 303 of the overall system. This is enabled by default when the preempt 304 or irq latency tracers are enabled, as those need to swap as well 305 and already adds the overhead (plus a lot more). 306 307config TRACE_BRANCH_PROFILING 308 bool 309 select GENERIC_TRACER 310 311choice 312 prompt "Branch Profiling" 313 default BRANCH_PROFILE_NONE 314 help 315 The branch profiling is a software profiler. It will add hooks 316 into the C conditionals to test which path a branch takes. 317 318 The likely/unlikely profiler only looks at the conditions that 319 are annotated with a likely or unlikely macro. 320 321 The "all branch" profiler will profile every if-statement in the 322 kernel. This profiler will also enable the likely/unlikely 323 profiler. 324 325 Either of the above profilers adds a bit of overhead to the system. 326 If unsure, choose "No branch profiling". 327 328config BRANCH_PROFILE_NONE 329 bool "No branch profiling" 330 help 331 No branch profiling. Branch profiling adds a bit of overhead. 332 Only enable it if you want to analyse the branching behavior. 333 Otherwise keep it disabled. 334 335config PROFILE_ANNOTATED_BRANCHES 336 bool "Trace likely/unlikely profiler" 337 select TRACE_BRANCH_PROFILING 338 help 339 This tracer profiles all likely and unlikely macros 340 in the kernel. It will display the results in: 341 342 /sys/kernel/debug/tracing/trace_stat/branch_annotated 343 344 Note: this will add a significant overhead; only turn this 345 on if you need to profile the system's use of these macros. 346 347config PROFILE_ALL_BRANCHES 348 bool "Profile all if conditionals" 349 select TRACE_BRANCH_PROFILING 350 help 351 This tracer profiles all branch conditions. Every if () 352 taken in the kernel is recorded whether it hit or miss. 353 The results will be displayed in: 354 355 /sys/kernel/debug/tracing/trace_stat/branch_all 356 357 This option also enables the likely/unlikely profiler. 358 359 This configuration, when enabled, will impose a great overhead 360 on the system. This should only be enabled when the system 361 is to be analyzed in much detail. 362endchoice 363 364config TRACING_BRANCHES 365 bool 366 help 367 Selected by tracers that will trace the likely and unlikely 368 conditions. This prevents the tracers themselves from being 369 profiled. Profiling the tracing infrastructure can only happen 370 when the likelys and unlikelys are not being traced. 371 372config BRANCH_TRACER 373 bool "Trace likely/unlikely instances" 374 depends on TRACE_BRANCH_PROFILING 375 select TRACING_BRANCHES 376 help 377 This traces the events of likely and unlikely condition 378 calls in the kernel. The difference between this and the 379 "Trace likely/unlikely profiler" is that this is not a 380 histogram of the callers, but actually places the calling 381 events into a running trace buffer to see when and where the 382 events happened, as well as their results. 383 384 Say N if unsure. 385 386config STACK_TRACER 387 bool "Trace max stack" 388 depends on HAVE_FUNCTION_TRACER 389 select FUNCTION_TRACER 390 select STACKTRACE 391 select KALLSYMS 392 help 393 This special tracer records the maximum stack footprint of the 394 kernel and displays it in /sys/kernel/debug/tracing/stack_trace. 395 396 This tracer works by hooking into every function call that the 397 kernel executes, and keeping a maximum stack depth value and 398 stack-trace saved. If this is configured with DYNAMIC_FTRACE 399 then it will not have any overhead while the stack tracer 400 is disabled. 401 402 To enable the stack tracer on bootup, pass in 'stacktrace' 403 on the kernel command line. 404 405 The stack tracer can also be enabled or disabled via the 406 sysctl kernel.stack_tracer_enabled 407 408 Say N if unsure. 409 410config BLK_DEV_IO_TRACE 411 bool "Support for tracing block IO actions" 412 depends on SYSFS 413 depends on BLOCK 414 select RELAY 415 select DEBUG_FS 416 select TRACEPOINTS 417 select GENERIC_TRACER 418 select STACKTRACE 419 help 420 Say Y here if you want to be able to trace the block layer actions 421 on a given queue. Tracing allows you to see any traffic happening 422 on a block device queue. For more information (and the userspace 423 support tools needed), fetch the blktrace tools from: 424 425 git://git.kernel.dk/blktrace.git 426 427 Tracing also is possible using the ftrace interface, e.g.: 428 429 echo 1 > /sys/block/sda/sda1/trace/enable 430 echo blk > /sys/kernel/debug/tracing/current_tracer 431 cat /sys/kernel/debug/tracing/trace_pipe 432 433 If unsure, say N. 434 435config KPROBE_EVENT 436 depends on KPROBES 437 depends on HAVE_REGS_AND_STACK_ACCESS_API 438 bool "Enable kprobes-based dynamic events" 439 select TRACING 440 select PROBE_EVENTS 441 default y 442 help 443 This allows the user to add tracing events (similar to tracepoints) 444 on the fly via the ftrace interface. See 445 Documentation/trace/kprobetrace.txt for more details. 446 447 Those events can be inserted wherever kprobes can probe, and record 448 various register and memory values. 449 450 This option is also required by perf-probe subcommand of perf tools. 451 If you want to use perf tools, this option is strongly recommended. 452 453config UPROBE_EVENT 454 bool "Enable uprobes-based dynamic events" 455 depends on ARCH_SUPPORTS_UPROBES 456 depends on MMU 457 depends on PERF_EVENTS 458 select UPROBES 459 select PROBE_EVENTS 460 select TRACING 461 default n 462 help 463 This allows the user to add tracing events on top of userspace 464 dynamic events (similar to tracepoints) on the fly via the trace 465 events interface. Those events can be inserted wherever uprobes 466 can probe, and record various registers. 467 This option is required if you plan to use perf-probe subcommand 468 of perf tools on user space applications. 469 470config BPF_EVENTS 471 depends on BPF_SYSCALL 472 depends on (KPROBE_EVENT || UPROBE_EVENT) && PERF_EVENTS 473 bool 474 default y 475 help 476 This allows the user to attach BPF programs to kprobe events. 477 478config PROBE_EVENTS 479 def_bool n 480 481config DYNAMIC_FTRACE 482 bool "enable/disable function tracing dynamically" 483 depends on FUNCTION_TRACER 484 depends on HAVE_DYNAMIC_FTRACE 485 default y 486 help 487 This option will modify all the calls to function tracing 488 dynamically (will patch them out of the binary image and 489 replace them with a No-Op instruction) on boot up. During 490 compile time, a table is made of all the locations that ftrace 491 can function trace, and this table is linked into the kernel 492 image. When this is enabled, functions can be individually 493 enabled, and the functions not enabled will not affect 494 performance of the system. 495 496 See the files in /sys/kernel/debug/tracing: 497 available_filter_functions 498 set_ftrace_filter 499 set_ftrace_notrace 500 501 This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but 502 otherwise has native performance as long as no tracing is active. 503 504config DYNAMIC_FTRACE_WITH_REGS 505 def_bool y 506 depends on DYNAMIC_FTRACE 507 depends on HAVE_DYNAMIC_FTRACE_WITH_REGS 508 509config FUNCTION_PROFILER 510 bool "Kernel function profiler" 511 depends on FUNCTION_TRACER 512 default n 513 help 514 This option enables the kernel function profiler. A file is created 515 in debugfs called function_profile_enabled which defaults to zero. 516 When a 1 is echoed into this file profiling begins, and when a 517 zero is entered, profiling stops. A "functions" file is created in 518 the trace_stats directory; this file shows the list of functions that 519 have been hit and their counters. 520 521 If in doubt, say N. 522 523config FTRACE_MCOUNT_RECORD 524 def_bool y 525 depends on DYNAMIC_FTRACE 526 depends on HAVE_FTRACE_MCOUNT_RECORD 527 528config FTRACE_SELFTEST 529 bool 530 531config FTRACE_STARTUP_TEST 532 bool "Perform a startup test on ftrace" 533 depends on GENERIC_TRACER 534 select FTRACE_SELFTEST 535 help 536 This option performs a series of startup tests on ftrace. On bootup 537 a series of tests are made to verify that the tracer is 538 functioning properly. It will do tests on all the configured 539 tracers of ftrace. 540 541config EVENT_TRACE_TEST_SYSCALLS 542 bool "Run selftest on syscall events" 543 depends on FTRACE_STARTUP_TEST 544 help 545 This option will also enable testing every syscall event. 546 It only enables the event and disables it and runs various loads 547 with the event enabled. This adds a bit more time for kernel boot 548 up since it runs this on every system call defined. 549 550 TBD - enable a way to actually call the syscalls as we test their 551 events 552 553config MMIOTRACE 554 bool "Memory mapped IO tracing" 555 depends on HAVE_MMIOTRACE_SUPPORT && PCI 556 select GENERIC_TRACER 557 help 558 Mmiotrace traces Memory Mapped I/O access and is meant for 559 debugging and reverse engineering. It is called from the ioremap 560 implementation and works via page faults. Tracing is disabled by 561 default and can be enabled at run-time. 562 563 See Documentation/trace/mmiotrace.txt. 564 If you are not helping to develop drivers, say N. 565 566config TRACING_MAP 567 bool 568 depends on ARCH_HAVE_NMI_SAFE_CMPXCHG 569 help 570 tracing_map is a special-purpose lock-free map for tracing, 571 separated out as a stand-alone facility in order to allow it 572 to be shared between multiple tracers. It isn't meant to be 573 generally used outside of that context, and is normally 574 selected by tracers that use it. 575 576config HIST_TRIGGERS 577 bool "Histogram triggers" 578 depends on ARCH_HAVE_NMI_SAFE_CMPXCHG 579 select TRACING_MAP 580 select TRACING 581 default n 582 help 583 Hist triggers allow one or more arbitrary trace event fields 584 to be aggregated into hash tables and dumped to stdout by 585 reading a debugfs/tracefs file. They're useful for 586 gathering quick and dirty (though precise) summaries of 587 event activity as an initial guide for further investigation 588 using more advanced tools. 589 590 See Documentation/trace/events.txt. 591 If in doubt, say N. 592 593config MMIOTRACE_TEST 594 tristate "Test module for mmiotrace" 595 depends on MMIOTRACE && m 596 help 597 This is a dumb module for testing mmiotrace. It is very dangerous 598 as it will write garbage to IO memory starting at a given address. 599 However, it should be safe to use on e.g. unused portion of VRAM. 600 601 Say N, unless you absolutely know what you are doing. 602 603config TRACEPOINT_BENCHMARK 604 bool "Add tracepoint that benchmarks tracepoints" 605 help 606 This option creates the tracepoint "benchmark:benchmark_event". 607 When the tracepoint is enabled, it kicks off a kernel thread that 608 goes into an infinite loop (calling cond_sched() to let other tasks 609 run), and calls the tracepoint. Each iteration will record the time 610 it took to write to the tracepoint and the next iteration that 611 data will be passed to the tracepoint itself. That is, the tracepoint 612 will report the time it took to do the previous tracepoint. 613 The string written to the tracepoint is a static string of 128 bytes 614 to keep the time the same. The initial string is simply a write of 615 "START". The second string records the cold cache time of the first 616 write which is not added to the rest of the calculations. 617 618 As it is a tight loop, it benchmarks as hot cache. That's fine because 619 we care most about hot paths that are probably in cache already. 620 621 An example of the output: 622 623 START 624 first=3672 [COLD CACHED] 625 last=632 first=3672 max=632 min=632 avg=316 std=446 std^2=199712 626 last=278 first=3672 max=632 min=278 avg=303 std=316 std^2=100337 627 last=277 first=3672 max=632 min=277 avg=296 std=258 std^2=67064 628 last=273 first=3672 max=632 min=273 avg=292 std=224 std^2=50411 629 last=273 first=3672 max=632 min=273 avg=288 std=200 std^2=40389 630 last=281 first=3672 max=632 min=273 avg=287 std=183 std^2=33666 631 632 633config RING_BUFFER_BENCHMARK 634 tristate "Ring buffer benchmark stress tester" 635 depends on RING_BUFFER 636 help 637 This option creates a test to stress the ring buffer and benchmark it. 638 It creates its own ring buffer such that it will not interfere with 639 any other users of the ring buffer (such as ftrace). It then creates 640 a producer and consumer that will run for 10 seconds and sleep for 641 10 seconds. Each interval it will print out the number of events 642 it recorded and give a rough estimate of how long each iteration took. 643 644 It does not disable interrupts or raise its priority, so it may be 645 affected by processes that are running. 646 647 If unsure, say N. 648 649config RING_BUFFER_STARTUP_TEST 650 bool "Ring buffer startup self test" 651 depends on RING_BUFFER 652 help 653 Run a simple self test on the ring buffer on boot up. Late in the 654 kernel boot sequence, the test will start that kicks off 655 a thread per cpu. Each thread will write various size events 656 into the ring buffer. Another thread is created to send IPIs 657 to each of the threads, where the IPI handler will also write 658 to the ring buffer, to test/stress the nesting ability. 659 If any anomalies are discovered, a warning will be displayed 660 and all ring buffers will be disabled. 661 662 The test runs for 10 seconds. This will slow your boot time 663 by at least 10 more seconds. 664 665 At the end of the test, statics and more checks are done. 666 It will output the stats of each per cpu buffer. What 667 was written, the sizes, what was read, what was lost, and 668 other similar details. 669 670 If unsure, say N 671 672config TRACE_ENUM_MAP_FILE 673 bool "Show enum mappings for trace events" 674 depends on TRACING 675 help 676 The "print fmt" of the trace events will show the enum names instead 677 of their values. This can cause problems for user space tools that 678 use this string to parse the raw data as user space does not know 679 how to convert the string to its value. 680 681 To fix this, there's a special macro in the kernel that can be used 682 to convert the enum into its value. If this macro is used, then the 683 print fmt strings will have the enums converted to their values. 684 685 If something does not get converted properly, this option can be 686 used to show what enums the kernel tried to convert. 687 688 This option is for debugging the enum conversions. A file is created 689 in the tracing directory called "enum_map" that will show the enum 690 names matched with their values and what trace event system they 691 belong too. 692 693 Normally, the mapping of the strings to values will be freed after 694 boot up or module load. With this option, they will not be freed, as 695 they are needed for the "enum_map" file. Enabling this option will 696 increase the memory footprint of the running kernel. 697 698 If unsure, say N 699 700config TRACING_EVENTS_GPIO 701 bool "Trace gpio events" 702 depends on GPIOLIB 703 default y 704 help 705 Enable tracing events for gpio subsystem 706 707endif # FTRACE 708 709endif # TRACING_SUPPORT 710 711