1# SPDX-License-Identifier: GPL-2.0-only 2# 3# Architectures that offer an FUNCTION_TRACER implementation should 4# select HAVE_FUNCTION_TRACER: 5# 6 7config USER_STACKTRACE_SUPPORT 8 bool 9 10config NOP_TRACER 11 bool 12 13config HAVE_FUNCTION_TRACER 14 bool 15 help 16 See Documentation/trace/ftrace-design.rst 17 18config HAVE_FUNCTION_GRAPH_TRACER 19 bool 20 help 21 See Documentation/trace/ftrace-design.rst 22 23config HAVE_DYNAMIC_FTRACE 24 bool 25 help 26 See Documentation/trace/ftrace-design.rst 27 28config HAVE_DYNAMIC_FTRACE_WITH_REGS 29 bool 30 31config HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS 32 bool 33 34config HAVE_FTRACE_MCOUNT_RECORD 35 bool 36 help 37 See Documentation/trace/ftrace-design.rst 38 39config HAVE_SYSCALL_TRACEPOINTS 40 bool 41 help 42 See Documentation/trace/ftrace-design.rst 43 44config HAVE_FENTRY 45 bool 46 help 47 Arch supports the gcc options -pg with -mfentry 48 49config HAVE_NOP_MCOUNT 50 bool 51 help 52 Arch supports the gcc options -pg with -mrecord-mcount and -nop-mcount 53 54config HAVE_OBJTOOL_MCOUNT 55 bool 56 help 57 Arch supports objtool --mcount 58 59config HAVE_C_RECORDMCOUNT 60 bool 61 help 62 C version of recordmcount available? 63 64config TRACER_MAX_TRACE 65 bool 66 67config TRACE_CLOCK 68 bool 69 70config RING_BUFFER 71 bool 72 select TRACE_CLOCK 73 select IRQ_WORK 74 75config EVENT_TRACING 76 select CONTEXT_SWITCH_TRACER 77 select GLOB 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 89config TRACE_MMIO_ACCESS 90 bool "Register read/write tracing" 91 depends on TRACING 92 depends on ARM64 93 help 94 Create tracepoints for IO read/write operations. These trace events 95 can be used for logging all MMIO read/write operations. 96 97config PREEMPTIRQ_TRACEPOINTS 98 bool 99 depends on TRACE_PREEMPT_TOGGLE || TRACE_IRQFLAGS 100 select TRACING 101 default y 102 help 103 Create preempt/irq toggle tracepoints if needed, so that other parts 104 of the kernel can use them to generate or add hooks to them. 105 106menuconfig TRACEFS_DISABLE_AUTOMOUNT 107 bool "Do not autmount tracefs in the debugfs filesystem" 108 help 109 Provides an option to not automount tracefs in /sys/kernel/debug/tracing. 110 111# All tracer options should select GENERIC_TRACER. For those options that are 112# enabled by all tracers (context switch and event tracer) they select TRACING. 113# This allows those options to appear when no other tracer is selected. But the 114# options do not appear when something else selects it. We need the two options 115# GENERIC_TRACER and TRACING to avoid circular dependencies to accomplish the 116# hiding of the automatic options. 117 118config TRACING 119 bool 120 select RING_BUFFER 121 select STACKTRACE if STACKTRACE_SUPPORT 122 select TRACEPOINTS 123 select NOP_TRACER 124 select BINARY_PRINTF 125 select EVENT_TRACING 126 select TRACE_CLOCK 127 128config GENERIC_TRACER 129 bool 130 select TRACING 131 132# 133# Minimum requirements an architecture has to meet for us to 134# be able to offer generic tracing facilities: 135# 136config TRACING_SUPPORT 137 bool 138 depends on TRACE_IRQFLAGS_SUPPORT 139 depends on STACKTRACE_SUPPORT 140 default y 141 142if TRACING_SUPPORT 143 144menuconfig FTRACE 145 bool "Tracers" 146 default y if DEBUG_KERNEL 147 help 148 Enable the kernel tracing infrastructure. 149 150if FTRACE 151 152config BOOTTIME_TRACING 153 bool "Boot-time Tracing support" 154 depends on TRACING 155 select BOOT_CONFIG 156 help 157 Enable developer to setup ftrace subsystem via supplemental 158 kernel cmdline at boot time for debugging (tracing) driver 159 initialization and boot process. 160 161config FUNCTION_TRACER 162 bool "Kernel Function Tracer" 163 depends on HAVE_FUNCTION_TRACER 164 select KALLSYMS 165 select GENERIC_TRACER 166 select CONTEXT_SWITCH_TRACER 167 select GLOB 168 select TASKS_RCU if PREEMPTION 169 select TASKS_RUDE_RCU 170 help 171 Enable the kernel to trace every kernel function. This is done 172 by using a compiler feature to insert a small, 5-byte No-Operation 173 instruction at the beginning of every kernel function, which NOP 174 sequence is then dynamically patched into a tracer call when 175 tracing is enabled by the administrator. If it's runtime disabled 176 (the bootup default), then the overhead of the instructions is very 177 small and not measurable even in micro-benchmarks. 178 179config FUNCTION_GRAPH_TRACER 180 bool "Kernel Function Graph Tracer" 181 depends on HAVE_FUNCTION_GRAPH_TRACER 182 depends on FUNCTION_TRACER 183 depends on !X86_32 || !CC_OPTIMIZE_FOR_SIZE 184 default y 185 help 186 Enable the kernel to trace a function at both its return 187 and its entry. 188 Its first purpose is to trace the duration of functions and 189 draw a call graph for each thread with some information like 190 the return value. This is done by setting the current return 191 address on the current task structure into a stack of calls. 192 193config DYNAMIC_FTRACE 194 bool "enable/disable function tracing dynamically" 195 depends on FUNCTION_TRACER 196 depends on HAVE_DYNAMIC_FTRACE 197 default y 198 help 199 This option will modify all the calls to function tracing 200 dynamically (will patch them out of the binary image and 201 replace them with a No-Op instruction) on boot up. During 202 compile time, a table is made of all the locations that ftrace 203 can function trace, and this table is linked into the kernel 204 image. When this is enabled, functions can be individually 205 enabled, and the functions not enabled will not affect 206 performance of the system. 207 208 See the files in /sys/kernel/debug/tracing: 209 available_filter_functions 210 set_ftrace_filter 211 set_ftrace_notrace 212 213 This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but 214 otherwise has native performance as long as no tracing is active. 215 216config DYNAMIC_FTRACE_WITH_REGS 217 def_bool y 218 depends on DYNAMIC_FTRACE 219 depends on HAVE_DYNAMIC_FTRACE_WITH_REGS 220 221config DYNAMIC_FTRACE_WITH_DIRECT_CALLS 222 def_bool y 223 depends on DYNAMIC_FTRACE_WITH_REGS 224 depends on HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS 225 226config FUNCTION_PROFILER 227 bool "Kernel function profiler" 228 depends on FUNCTION_TRACER 229 default n 230 help 231 This option enables the kernel function profiler. A file is created 232 in debugfs called function_profile_enabled which defaults to zero. 233 When a 1 is echoed into this file profiling begins, and when a 234 zero is entered, profiling stops. A "functions" file is created in 235 the trace_stat directory; this file shows the list of functions that 236 have been hit and their counters. 237 238 If in doubt, say N. 239 240config STACK_TRACER 241 bool "Trace max stack" 242 depends on HAVE_FUNCTION_TRACER 243 select FUNCTION_TRACER 244 select STACKTRACE 245 select KALLSYMS 246 help 247 This special tracer records the maximum stack footprint of the 248 kernel and displays it in /sys/kernel/debug/tracing/stack_trace. 249 250 This tracer works by hooking into every function call that the 251 kernel executes, and keeping a maximum stack depth value and 252 stack-trace saved. If this is configured with DYNAMIC_FTRACE 253 then it will not have any overhead while the stack tracer 254 is disabled. 255 256 To enable the stack tracer on bootup, pass in 'stacktrace' 257 on the kernel command line. 258 259 The stack tracer can also be enabled or disabled via the 260 sysctl kernel.stack_tracer_enabled 261 262 Say N if unsure. 263 264config TRACE_PREEMPT_TOGGLE 265 bool 266 help 267 Enables hooks which will be called when preemption is first disabled, 268 and last enabled. 269 270config IRQSOFF_TRACER 271 bool "Interrupts-off Latency Tracer" 272 default n 273 depends on TRACE_IRQFLAGS_SUPPORT 274 depends on !ARCH_USES_GETTIMEOFFSET 275 select TRACE_IRQFLAGS 276 select GENERIC_TRACER 277 select TRACER_MAX_TRACE 278 select RING_BUFFER_ALLOW_SWAP 279 select TRACER_SNAPSHOT 280 select TRACER_SNAPSHOT_PER_CPU_SWAP 281 help 282 This option measures the time spent in irqs-off critical 283 sections, with microsecond accuracy. 284 285 The default measurement method is a maximum search, which is 286 disabled by default and can be runtime (re-)started 287 via: 288 289 echo 0 > /sys/kernel/debug/tracing/tracing_max_latency 290 291 (Note that kernel size and overhead increase with this option 292 enabled. This option and the preempt-off timing option can be 293 used together or separately.) 294 295config PREEMPT_TRACER 296 bool "Preemption-off Latency Tracer" 297 default n 298 depends on !ARCH_USES_GETTIMEOFFSET 299 depends on PREEMPTION 300 select GENERIC_TRACER 301 select TRACER_MAX_TRACE 302 select RING_BUFFER_ALLOW_SWAP 303 select TRACER_SNAPSHOT 304 select TRACER_SNAPSHOT_PER_CPU_SWAP 305 select TRACE_PREEMPT_TOGGLE 306 help 307 This option measures the time spent in preemption-off critical 308 sections, with microsecond accuracy. 309 310 The default measurement method is a maximum search, which is 311 disabled by default and can be runtime (re-)started 312 via: 313 314 echo 0 > /sys/kernel/debug/tracing/tracing_max_latency 315 316 (Note that kernel size and overhead increase with this option 317 enabled. This option and the irqs-off timing option can be 318 used together or separately.) 319 320config SCHED_TRACER 321 bool "Scheduling Latency Tracer" 322 select GENERIC_TRACER 323 select CONTEXT_SWITCH_TRACER 324 select TRACER_MAX_TRACE 325 select TRACER_SNAPSHOT 326 help 327 This tracer tracks the latency of the highest priority task 328 to be scheduled in, starting from the point it has woken up. 329 330config HWLAT_TRACER 331 bool "Tracer to detect hardware latencies (like SMIs)" 332 select GENERIC_TRACER 333 help 334 This tracer, when enabled will create one or more kernel threads, 335 depending on what the cpumask file is set to, which each thread 336 spinning in a loop looking for interruptions caused by 337 something other than the kernel. For example, if a 338 System Management Interrupt (SMI) takes a noticeable amount of 339 time, this tracer will detect it. This is useful for testing 340 if a system is reliable for Real Time tasks. 341 342 Some files are created in the tracing directory when this 343 is enabled: 344 345 hwlat_detector/width - time in usecs for how long to spin for 346 hwlat_detector/window - time in usecs between the start of each 347 iteration 348 349 A kernel thread is created that will spin with interrupts disabled 350 for "width" microseconds in every "window" cycle. It will not spin 351 for "window - width" microseconds, where the system can 352 continue to operate. 353 354 The output will appear in the trace and trace_pipe files. 355 356 When the tracer is not running, it has no affect on the system, 357 but when it is running, it can cause the system to be 358 periodically non responsive. Do not run this tracer on a 359 production system. 360 361 To enable this tracer, echo in "hwlat" into the current_tracer 362 file. Every time a latency is greater than tracing_thresh, it will 363 be recorded into the ring buffer. 364 365config MMIOTRACE 366 bool "Memory mapped IO tracing" 367 depends on HAVE_MMIOTRACE_SUPPORT && PCI 368 select GENERIC_TRACER 369 help 370 Mmiotrace traces Memory Mapped I/O access and is meant for 371 debugging and reverse engineering. It is called from the ioremap 372 implementation and works via page faults. Tracing is disabled by 373 default and can be enabled at run-time. 374 375 See Documentation/trace/mmiotrace.rst. 376 If you are not helping to develop drivers, say N. 377 378config ENABLE_DEFAULT_TRACERS 379 bool "Trace process context switches and events" 380 depends on !GENERIC_TRACER 381 select TRACING 382 help 383 This tracer hooks to various trace points in the kernel, 384 allowing the user to pick and choose which trace point they 385 want to trace. It also includes the sched_switch tracer plugin. 386 387config FTRACE_SYSCALLS 388 bool "Trace syscalls" 389 depends on HAVE_SYSCALL_TRACEPOINTS 390 select GENERIC_TRACER 391 select KALLSYMS 392 help 393 Basic tracer to catch the syscall entry and exit events. 394 395config TRACER_SNAPSHOT 396 bool "Create a snapshot trace buffer" 397 select TRACER_MAX_TRACE 398 help 399 Allow tracing users to take snapshot of the current buffer using the 400 ftrace interface, e.g.: 401 402 echo 1 > /sys/kernel/debug/tracing/snapshot 403 cat snapshot 404 405config TRACER_SNAPSHOT_PER_CPU_SWAP 406 bool "Allow snapshot to swap per CPU" 407 depends on TRACER_SNAPSHOT 408 select RING_BUFFER_ALLOW_SWAP 409 help 410 Allow doing a snapshot of a single CPU buffer instead of a 411 full swap (all buffers). If this is set, then the following is 412 allowed: 413 414 echo 1 > /sys/kernel/debug/tracing/per_cpu/cpu2/snapshot 415 416 After which, only the tracing buffer for CPU 2 was swapped with 417 the main tracing buffer, and the other CPU buffers remain the same. 418 419 When this is enabled, this adds a little more overhead to the 420 trace recording, as it needs to add some checks to synchronize 421 recording with swaps. But this does not affect the performance 422 of the overall system. This is enabled by default when the preempt 423 or irq latency tracers are enabled, as those need to swap as well 424 and already adds the overhead (plus a lot more). 425 426config TRACE_BRANCH_PROFILING 427 bool 428 select GENERIC_TRACER 429 430choice 431 prompt "Branch Profiling" 432 default BRANCH_PROFILE_NONE 433 help 434 The branch profiling is a software profiler. It will add hooks 435 into the C conditionals to test which path a branch takes. 436 437 The likely/unlikely profiler only looks at the conditions that 438 are annotated with a likely or unlikely macro. 439 440 The "all branch" profiler will profile every if-statement in the 441 kernel. This profiler will also enable the likely/unlikely 442 profiler. 443 444 Either of the above profilers adds a bit of overhead to the system. 445 If unsure, choose "No branch profiling". 446 447config BRANCH_PROFILE_NONE 448 bool "No branch profiling" 449 help 450 No branch profiling. Branch profiling adds a bit of overhead. 451 Only enable it if you want to analyse the branching behavior. 452 Otherwise keep it disabled. 453 454config PROFILE_ANNOTATED_BRANCHES 455 bool "Trace likely/unlikely profiler" 456 select TRACE_BRANCH_PROFILING 457 help 458 This tracer profiles all likely and unlikely macros 459 in the kernel. It will display the results in: 460 461 /sys/kernel/debug/tracing/trace_stat/branch_annotated 462 463 Note: this will add a significant overhead; only turn this 464 on if you need to profile the system's use of these macros. 465 466config PROFILE_ALL_BRANCHES 467 bool "Profile all if conditionals" if !FORTIFY_SOURCE 468 select TRACE_BRANCH_PROFILING 469 help 470 This tracer profiles all branch conditions. Every if () 471 taken in the kernel is recorded whether it hit or miss. 472 The results will be displayed in: 473 474 /sys/kernel/debug/tracing/trace_stat/branch_all 475 476 This option also enables the likely/unlikely profiler. 477 478 This configuration, when enabled, will impose a great overhead 479 on the system. This should only be enabled when the system 480 is to be analyzed in much detail. 481endchoice 482 483config TRACING_BRANCHES 484 bool 485 help 486 Selected by tracers that will trace the likely and unlikely 487 conditions. This prevents the tracers themselves from being 488 profiled. Profiling the tracing infrastructure can only happen 489 when the likelys and unlikelys are not being traced. 490 491config BRANCH_TRACER 492 bool "Trace likely/unlikely instances" 493 depends on TRACE_BRANCH_PROFILING 494 select TRACING_BRANCHES 495 help 496 This traces the events of likely and unlikely condition 497 calls in the kernel. The difference between this and the 498 "Trace likely/unlikely profiler" is that this is not a 499 histogram of the callers, but actually places the calling 500 events into a running trace buffer to see when and where the 501 events happened, as well as their results. 502 503 Say N if unsure. 504 505config BLK_DEV_IO_TRACE 506 bool "Support for tracing block IO actions" 507 depends on SYSFS 508 depends on BLOCK 509 select RELAY 510 select DEBUG_FS 511 select TRACEPOINTS 512 select GENERIC_TRACER 513 select STACKTRACE 514 help 515 Say Y here if you want to be able to trace the block layer actions 516 on a given queue. Tracing allows you to see any traffic happening 517 on a block device queue. For more information (and the userspace 518 support tools needed), fetch the blktrace tools from: 519 520 git://git.kernel.dk/blktrace.git 521 522 Tracing also is possible using the ftrace interface, e.g.: 523 524 echo 1 > /sys/block/sda/sda1/trace/enable 525 echo blk > /sys/kernel/debug/tracing/current_tracer 526 cat /sys/kernel/debug/tracing/trace_pipe 527 528 If unsure, say N. 529 530config KPROBE_EVENTS 531 depends on KPROBES 532 depends on HAVE_REGS_AND_STACK_ACCESS_API 533 bool "Enable kprobes-based dynamic events" 534 select TRACING 535 select PROBE_EVENTS 536 select DYNAMIC_EVENTS 537 default y 538 help 539 This allows the user to add tracing events (similar to tracepoints) 540 on the fly via the ftrace interface. See 541 Documentation/trace/kprobetrace.rst for more details. 542 543 Those events can be inserted wherever kprobes can probe, and record 544 various register and memory values. 545 546 This option is also required by perf-probe subcommand of perf tools. 547 If you want to use perf tools, this option is strongly recommended. 548 549config KPROBE_EVENTS_ON_NOTRACE 550 bool "Do NOT protect notrace function from kprobe events" 551 depends on KPROBE_EVENTS 552 depends on DYNAMIC_FTRACE 553 default n 554 help 555 This is only for the developers who want to debug ftrace itself 556 using kprobe events. 557 558 If kprobes can use ftrace instead of breakpoint, ftrace related 559 functions are protected from kprobe-events to prevent an infinit 560 recursion or any unexpected execution path which leads to a kernel 561 crash. 562 563 This option disables such protection and allows you to put kprobe 564 events on ftrace functions for debugging ftrace by itself. 565 Note that this might let you shoot yourself in the foot. 566 567 If unsure, say N. 568 569config UPROBE_EVENTS 570 bool "Enable uprobes-based dynamic events" 571 depends on ARCH_SUPPORTS_UPROBES 572 depends on MMU 573 depends on PERF_EVENTS 574 select UPROBES 575 select PROBE_EVENTS 576 select DYNAMIC_EVENTS 577 select TRACING 578 default y 579 help 580 This allows the user to add tracing events on top of userspace 581 dynamic events (similar to tracepoints) on the fly via the trace 582 events interface. Those events can be inserted wherever uprobes 583 can probe, and record various registers. 584 This option is required if you plan to use perf-probe subcommand 585 of perf tools on user space applications. 586 587config BPF_EVENTS 588 depends on BPF_SYSCALL 589 depends on (KPROBE_EVENTS || UPROBE_EVENTS) && PERF_EVENTS 590 bool 591 default y 592 help 593 This allows the user to attach BPF programs to kprobe, uprobe, and 594 tracepoint events. 595 596config DYNAMIC_EVENTS 597 def_bool n 598 599config PROBE_EVENTS 600 def_bool n 601 602config BPF_KPROBE_OVERRIDE 603 bool "Enable BPF programs to override a kprobed function" 604 depends on BPF_EVENTS 605 depends on FUNCTION_ERROR_INJECTION 606 default n 607 help 608 Allows BPF to override the execution of a probed function and 609 set a different return value. This is used for error injection. 610 611config FTRACE_MCOUNT_RECORD 612 def_bool y 613 depends on DYNAMIC_FTRACE 614 depends on HAVE_FTRACE_MCOUNT_RECORD 615 616config FTRACE_MCOUNT_USE_PATCHABLE_FUNCTION_ENTRY 617 bool 618 depends on FTRACE_MCOUNT_RECORD 619 620config FTRACE_MCOUNT_USE_CC 621 def_bool y 622 depends on $(cc-option,-mrecord-mcount) 623 depends on !FTRACE_MCOUNT_USE_PATCHABLE_FUNCTION_ENTRY 624 depends on FTRACE_MCOUNT_RECORD 625 626config FTRACE_MCOUNT_USE_OBJTOOL 627 def_bool y 628 depends on HAVE_OBJTOOL_MCOUNT 629 depends on !FTRACE_MCOUNT_USE_PATCHABLE_FUNCTION_ENTRY 630 depends on !FTRACE_MCOUNT_USE_CC 631 depends on FTRACE_MCOUNT_RECORD 632 633config FTRACE_MCOUNT_USE_RECORDMCOUNT 634 def_bool y 635 depends on !FTRACE_MCOUNT_USE_PATCHABLE_FUNCTION_ENTRY 636 depends on !FTRACE_MCOUNT_USE_CC 637 depends on !FTRACE_MCOUNT_USE_OBJTOOL 638 depends on FTRACE_MCOUNT_RECORD 639 640config TRACING_MAP 641 bool 642 depends on ARCH_HAVE_NMI_SAFE_CMPXCHG 643 help 644 tracing_map is a special-purpose lock-free map for tracing, 645 separated out as a stand-alone facility in order to allow it 646 to be shared between multiple tracers. It isn't meant to be 647 generally used outside of that context, and is normally 648 selected by tracers that use it. 649 650config SYNTH_EVENTS 651 bool "Synthetic trace events" 652 select TRACING 653 select DYNAMIC_EVENTS 654 default n 655 help 656 Synthetic events are user-defined trace events that can be 657 used to combine data from other trace events or in fact any 658 data source. Synthetic events can be generated indirectly 659 via the trace() action of histogram triggers or directly 660 by way of an in-kernel API. 661 662 See Documentation/trace/events.rst or 663 Documentation/trace/histogram.rst for details and examples. 664 665 If in doubt, say N. 666 667config HIST_TRIGGERS 668 bool "Histogram triggers" 669 depends on ARCH_HAVE_NMI_SAFE_CMPXCHG 670 select TRACING_MAP 671 select TRACING 672 select DYNAMIC_EVENTS 673 select SYNTH_EVENTS 674 default n 675 help 676 Hist triggers allow one or more arbitrary trace event fields 677 to be aggregated into hash tables and dumped to stdout by 678 reading a debugfs/tracefs file. They're useful for 679 gathering quick and dirty (though precise) summaries of 680 event activity as an initial guide for further investigation 681 using more advanced tools. 682 683 Inter-event tracing of quantities such as latencies is also 684 supported using hist triggers under this option. 685 686 See Documentation/trace/histogram.rst. 687 If in doubt, say N. 688 689config TRACE_EVENT_INJECT 690 bool "Trace event injection" 691 depends on TRACING 692 help 693 Allow user-space to inject a specific trace event into the ring 694 buffer. This is mainly used for testing purpose. 695 696 If unsure, say N. 697 698config TRACEPOINT_BENCHMARK 699 bool "Add tracepoint that benchmarks tracepoints" 700 help 701 This option creates the tracepoint "benchmark:benchmark_event". 702 When the tracepoint is enabled, it kicks off a kernel thread that 703 goes into an infinite loop (calling cond_sched() to let other tasks 704 run), and calls the tracepoint. Each iteration will record the time 705 it took to write to the tracepoint and the next iteration that 706 data will be passed to the tracepoint itself. That is, the tracepoint 707 will report the time it took to do the previous tracepoint. 708 The string written to the tracepoint is a static string of 128 bytes 709 to keep the time the same. The initial string is simply a write of 710 "START". The second string records the cold cache time of the first 711 write which is not added to the rest of the calculations. 712 713 As it is a tight loop, it benchmarks as hot cache. That's fine because 714 we care most about hot paths that are probably in cache already. 715 716 An example of the output: 717 718 START 719 first=3672 [COLD CACHED] 720 last=632 first=3672 max=632 min=632 avg=316 std=446 std^2=199712 721 last=278 first=3672 max=632 min=278 avg=303 std=316 std^2=100337 722 last=277 first=3672 max=632 min=277 avg=296 std=258 std^2=67064 723 last=273 first=3672 max=632 min=273 avg=292 std=224 std^2=50411 724 last=273 first=3672 max=632 min=273 avg=288 std=200 std^2=40389 725 last=281 first=3672 max=632 min=273 avg=287 std=183 std^2=33666 726 727 728config RING_BUFFER_BENCHMARK 729 tristate "Ring buffer benchmark stress tester" 730 depends on RING_BUFFER 731 help 732 This option creates a test to stress the ring buffer and benchmark it. 733 It creates its own ring buffer such that it will not interfere with 734 any other users of the ring buffer (such as ftrace). It then creates 735 a producer and consumer that will run for 10 seconds and sleep for 736 10 seconds. Each interval it will print out the number of events 737 it recorded and give a rough estimate of how long each iteration took. 738 739 It does not disable interrupts or raise its priority, so it may be 740 affected by processes that are running. 741 742 If unsure, say N. 743 744config TRACE_EVAL_MAP_FILE 745 bool "Show eval mappings for trace events" 746 depends on TRACING 747 help 748 The "print fmt" of the trace events will show the enum/sizeof names 749 instead of their values. This can cause problems for user space tools 750 that use this string to parse the raw data as user space does not know 751 how to convert the string to its value. 752 753 To fix this, there's a special macro in the kernel that can be used 754 to convert an enum/sizeof into its value. If this macro is used, then 755 the print fmt strings will be converted to their values. 756 757 If something does not get converted properly, this option can be 758 used to show what enums/sizeof the kernel tried to convert. 759 760 This option is for debugging the conversions. A file is created 761 in the tracing directory called "eval_map" that will show the 762 names matched with their values and what trace event system they 763 belong too. 764 765 Normally, the mapping of the strings to values will be freed after 766 boot up or module load. With this option, they will not be freed, as 767 they are needed for the "eval_map" file. Enabling this option will 768 increase the memory footprint of the running kernel. 769 770 If unsure, say N. 771 772config GCOV_PROFILE_FTRACE 773 bool "Enable GCOV profiling on ftrace subsystem" 774 depends on GCOV_KERNEL 775 help 776 Enable GCOV profiling on ftrace subsystem for checking 777 which functions/lines are tested. 778 779 If unsure, say N. 780 781 Note that on a kernel compiled with this config, ftrace will 782 run significantly slower. 783 784config FTRACE_SELFTEST 785 bool 786 787config FTRACE_STARTUP_TEST 788 bool "Perform a startup test on ftrace" 789 depends on GENERIC_TRACER 790 select FTRACE_SELFTEST 791 help 792 This option performs a series of startup tests on ftrace. On bootup 793 a series of tests are made to verify that the tracer is 794 functioning properly. It will do tests on all the configured 795 tracers of ftrace. 796 797config EVENT_TRACE_STARTUP_TEST 798 bool "Run selftest on trace events" 799 depends on FTRACE_STARTUP_TEST 800 default y 801 help 802 This option performs a test on all trace events in the system. 803 It basically just enables each event and runs some code that 804 will trigger events (not necessarily the event it enables) 805 This may take some time run as there are a lot of events. 806 807config EVENT_TRACE_TEST_SYSCALLS 808 bool "Run selftest on syscall events" 809 depends on EVENT_TRACE_STARTUP_TEST 810 help 811 This option will also enable testing every syscall event. 812 It only enables the event and disables it and runs various loads 813 with the event enabled. This adds a bit more time for kernel boot 814 up since it runs this on every system call defined. 815 816 TBD - enable a way to actually call the syscalls as we test their 817 events 818 819config RING_BUFFER_STARTUP_TEST 820 bool "Ring buffer startup self test" 821 depends on RING_BUFFER 822 help 823 Run a simple self test on the ring buffer on boot up. Late in the 824 kernel boot sequence, the test will start that kicks off 825 a thread per cpu. Each thread will write various size events 826 into the ring buffer. Another thread is created to send IPIs 827 to each of the threads, where the IPI handler will also write 828 to the ring buffer, to test/stress the nesting ability. 829 If any anomalies are discovered, a warning will be displayed 830 and all ring buffers will be disabled. 831 832 The test runs for 10 seconds. This will slow your boot time 833 by at least 10 more seconds. 834 835 At the end of the test, statics and more checks are done. 836 It will output the stats of each per cpu buffer. What 837 was written, the sizes, what was read, what was lost, and 838 other similar details. 839 840 If unsure, say N 841 842config MMIOTRACE_TEST 843 tristate "Test module for mmiotrace" 844 depends on MMIOTRACE && m 845 help 846 This is a dumb module for testing mmiotrace. It is very dangerous 847 as it will write garbage to IO memory starting at a given address. 848 However, it should be safe to use on e.g. unused portion of VRAM. 849 850 Say N, unless you absolutely know what you are doing. 851 852config PREEMPTIRQ_DELAY_TEST 853 tristate "Test module to create a preempt / IRQ disable delay thread to test latency tracers" 854 depends on m 855 help 856 Select this option to build a test module that can help test latency 857 tracers by executing a preempt or irq disable section with a user 858 configurable delay. The module busy waits for the duration of the 859 critical section. 860 861 For example, the following invocation generates a burst of three 862 irq-disabled critical sections for 500us: 863 modprobe preemptirq_delay_test test_mode=irq delay=500 burst_size=3 864 865 If unsure, say N 866 867config SYNTH_EVENT_GEN_TEST 868 tristate "Test module for in-kernel synthetic event generation" 869 depends on SYNTH_EVENTS 870 help 871 This option creates a test module to check the base 872 functionality of in-kernel synthetic event definition and 873 generation. 874 875 To test, insert the module, and then check the trace buffer 876 for the generated sample events. 877 878 If unsure, say N. 879 880config KPROBE_EVENT_GEN_TEST 881 tristate "Test module for in-kernel kprobe event generation" 882 depends on KPROBE_EVENTS 883 help 884 This option creates a test module to check the base 885 functionality of in-kernel kprobe event definition. 886 887 To test, insert the module, and then check the trace buffer 888 for the generated kprobe events. 889 890 If unsure, say N. 891 892config HIST_TRIGGERS_DEBUG 893 bool "Hist trigger debug support" 894 depends on HIST_TRIGGERS 895 help 896 Add "hist_debug" file for each event, which when read will 897 dump out a bunch of internal details about the hist triggers 898 defined on that event. 899 900 The hist_debug file serves a couple of purposes: 901 902 - Helps developers verify that nothing is broken. 903 904 - Provides educational information to support the details 905 of the hist trigger internals as described by 906 Documentation/trace/histogram-design.rst. 907 908 The hist_debug output only covers the data structures 909 related to the histogram definitions themselves and doesn't 910 display the internals of map buckets or variable values of 911 running histograms. 912 913 If unsure, say N. 914 915endif # FTRACE 916 917endif # TRACING_SUPPORT 918 919