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