kernel/trace/Kconfig

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