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 PREEMPT
 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 PREEMPT
 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 PREEMPT
 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         imply CC_DISABLE_WARN_MAYBE_UNINITIALIZED  # avoid false positives
 375         help
 376           This tracer profiles all branch conditions. Every if ()
 377           taken in the kernel is recorded whether it hit or miss.
 378           The results will be displayed in:
 379
 380           /sys/kernel/debug/tracing/trace_stat/branch_all
 381
 382           This option also enables the likely/unlikely profiler.
 383
 384           This configuration, when enabled, will impose a great overhead
 385           on the system. This should only be enabled when the system
 386           is to be analyzed in much detail.
 387 endchoice
 388
 389 config TRACING_BRANCHES
 390         bool
 391         help
 392           Selected by tracers that will trace the likely and unlikely
 393           conditions. This prevents the tracers themselves from being
 394           profiled. Profiling the tracing infrastructure can only happen
 395           when the likelys and unlikelys are not being traced.
 396
 397 config BRANCH_TRACER
 398         bool "Trace likely/unlikely instances"
 399         depends on TRACE_BRANCH_PROFILING
 400         select TRACING_BRANCHES
 401         help
 402           This traces the events of likely and unlikely condition
 403           calls in the kernel.  The difference between this and the
 404           "Trace likely/unlikely profiler" is that this is not a
 405           histogram of the callers, but actually places the calling
 406           events into a running trace buffer to see when and where the
 407           events happened, as well as their results.
 408
 409           Say N if unsure.
 410
 411 config STACK_TRACER
 412         bool "Trace max stack"
 413         depends on HAVE_FUNCTION_TRACER
 414         select FUNCTION_TRACER
 415         select STACKTRACE
 416         select KALLSYMS
 417         help
 418           This special tracer records the maximum stack footprint of the
 419           kernel and displays it in /sys/kernel/debug/tracing/stack_trace.
 420
 421           This tracer works by hooking into every function call that the
 422           kernel executes, and keeping a maximum stack depth value and
 423           stack-trace saved.  If this is configured with DYNAMIC_FTRACE
 424           then it will not have any overhead while the stack tracer
 425           is disabled.
 426
 427           To enable the stack tracer on bootup, pass in 'stacktrace'
 428           on the kernel command line.
 429
 430           The stack tracer can also be enabled or disabled via the
 431           sysctl kernel.stack_tracer_enabled
 432
 433           Say N if unsure.
 434
 435 config BLK_DEV_IO_TRACE
 436         bool "Support for tracing block IO actions"
 437         depends on SYSFS
 438         depends on BLOCK
 439         select RELAY
 440         select DEBUG_FS
 441         select TRACEPOINTS
 442         select GENERIC_TRACER
 443         select STACKTRACE
 444         help
 445           Say Y here if you want to be able to trace the block layer actions
 446           on a given queue. Tracing allows you to see any traffic happening
 447           on a block device queue. For more information (and the userspace
 448           support tools needed), fetch the blktrace tools from:
 449
 450           git://git.kernel.dk/blktrace.git
 451
 452           Tracing also is possible using the ftrace interface, e.g.:
 453
 454             echo 1 > /sys/block/sda/sda1/trace/enable
 455             echo blk > /sys/kernel/debug/tracing/current_tracer
 456             cat /sys/kernel/debug/tracing/trace_pipe
 457
 458           If unsure, say N.
 459
 460 config KPROBE_EVENTS
 461         depends on KPROBES
 462         depends on HAVE_REGS_AND_STACK_ACCESS_API
 463         bool "Enable kprobes-based dynamic events"
 464         select TRACING
 465         select PROBE_EVENTS
 466         select DYNAMIC_EVENTS
 467         default y
 468         help
 469           This allows the user to add tracing events (similar to tracepoints)
 470           on the fly via the ftrace interface. See
 471           Documentation/trace/kprobetrace.rst for more details.
 472
 473           Those events can be inserted wherever kprobes can probe, and record
 474           various register and memory values.
 475
 476           This option is also required by perf-probe subcommand of perf tools.
 477           If you want to use perf tools, this option is strongly recommended.
 478
 479 config KPROBE_EVENTS_ON_NOTRACE
 480         bool "Do NOT protect notrace function from kprobe events"
 481         depends on KPROBE_EVENTS
 482         depends on KPROBES_ON_FTRACE
 483         default n
 484         help
 485           This is only for the developers who want to debug ftrace itself
 486           using kprobe events.
 487
 488           If kprobes can use ftrace instead of breakpoint, ftrace related
 489           functions are protected from kprobe-events to prevent an infinit
 490           recursion or any unexpected execution path which leads to a kernel
 491           crash.
 492
 493           This option disables such protection and allows you to put kprobe
 494           events on ftrace functions for debugging ftrace by itself.
 495           Note that this might let you shoot yourself in the foot.
 496
 497           If unsure, say N.
 498
 499 config UPROBE_EVENTS
 500         bool "Enable uprobes-based dynamic events"
 501         depends on ARCH_SUPPORTS_UPROBES
 502         depends on MMU
 503         depends on PERF_EVENTS
 504         select UPROBES
 505         select PROBE_EVENTS
 506         select DYNAMIC_EVENTS
 507         select TRACING
 508         default y
 509         help
 510           This allows the user to add tracing events on top of userspace
 511           dynamic events (similar to tracepoints) on the fly via the trace
 512           events interface. Those events can be inserted wherever uprobes
 513           can probe, and record various registers.
 514           This option is required if you plan to use perf-probe subcommand
 515           of perf tools on user space applications.
 516
 517 config BPF_EVENTS
 518         depends on BPF_SYSCALL
 519         depends on (KPROBE_EVENTS || UPROBE_EVENTS) && PERF_EVENTS
 520         bool
 521         default y
 522         help
 523           This allows the user to attach BPF programs to kprobe 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_TEST_SYSCALLS
 601         bool "Run selftest on syscall events"
 602         depends on FTRACE_STARTUP_TEST
 603         help
 604          This option will also enable testing every syscall event.
 605          It only enables the event and disables it and runs various loads
 606          with the event enabled. This adds a bit more time for kernel boot
 607          up since it runs this on every system call defined.
 608
 609          TBD - enable a way to actually call the syscalls as we test their
 610                events
 611
 612 config MMIOTRACE
 613         bool "Memory mapped IO tracing"
 614         depends on HAVE_MMIOTRACE_SUPPORT && PCI
 615         select GENERIC_TRACER
 616         help
 617           Mmiotrace traces Memory Mapped I/O access and is meant for
 618           debugging and reverse engineering. It is called from the ioremap
 619           implementation and works via page faults. Tracing is disabled by
 620           default and can be enabled at run-time.
 621
 622           See Documentation/trace/mmiotrace.rst.
 623           If you are not helping to develop drivers, say N.
 624
 625 config TRACING_MAP
 626         bool
 627         depends on ARCH_HAVE_NMI_SAFE_CMPXCHG
 628         help
 629           tracing_map is a special-purpose lock-free map for tracing,
 630           separated out as a stand-alone facility in order to allow it
 631           to be shared between multiple tracers.  It isn't meant to be
 632           generally used outside of that context, and is normally
 633           selected by tracers that use it.
 634
 635 config HIST_TRIGGERS
 636         bool "Histogram triggers"
 637         depends on ARCH_HAVE_NMI_SAFE_CMPXCHG
 638         select TRACING_MAP
 639         select TRACING
 640         select DYNAMIC_EVENTS
 641         default n
 642         help
 643           Hist triggers allow one or more arbitrary trace event fields
 644           to be aggregated into hash tables and dumped to stdout by
 645           reading a debugfs/tracefs file.  They're useful for
 646           gathering quick and dirty (though precise) summaries of
 647           event activity as an initial guide for further investigation
 648           using more advanced tools.
 649
 650           Inter-event tracing of quantities such as latencies is also
 651           supported using hist triggers under this option.
 652
 653           See Documentation/trace/histogram.rst.
 654           If in doubt, say N.
 655
 656 config MMIOTRACE_TEST
 657         tristate "Test module for mmiotrace"
 658         depends on MMIOTRACE && m
 659         help
 660           This is a dumb module for testing mmiotrace. It is very dangerous
 661           as it will write garbage to IO memory starting at a given address.
 662           However, it should be safe to use on e.g. unused portion of VRAM.
 663
 664           Say N, unless you absolutely know what you are doing.
 665
 666 config TRACEPOINT_BENCHMARK
 667         bool "Add tracepoint that benchmarks tracepoints"
 668         help
 669          This option creates the tracepoint "benchmark:benchmark_event".
 670          When the tracepoint is enabled, it kicks off a kernel thread that
 671          goes into an infinite loop (calling cond_sched() to let other tasks
 672          run), and calls the tracepoint. Each iteration will record the time
 673          it took to write to the tracepoint and the next iteration that
 674          data will be passed to the tracepoint itself. That is, the tracepoint
 675          will report the time it took to do the previous tracepoint.
 676          The string written to the tracepoint is a static string of 128 bytes
 677          to keep the time the same. The initial string is simply a write of
 678          "START". The second string records the cold cache time of the first
 679          write which is not added to the rest of the calculations.
 680
 681          As it is a tight loop, it benchmarks as hot cache. That's fine because
 682          we care most about hot paths that are probably in cache already.
 683
 684          An example of the output:
 685
 686               START
 687               first=3672 [COLD CACHED]
 688               last=632 first=3672 max=632 min=632 avg=316 std=446 std^2=199712
 689               last=278 first=3672 max=632 min=278 avg=303 std=316 std^2=100337
 690               last=277 first=3672 max=632 min=277 avg=296 std=258 std^2=67064
 691               last=273 first=3672 max=632 min=273 avg=292 std=224 std^2=50411
 692               last=273 first=3672 max=632 min=273 avg=288 std=200 std^2=40389
 693               last=281 first=3672 max=632 min=273 avg=287 std=183 std^2=33666
 694
 695
 696 config RING_BUFFER_BENCHMARK
 697         tristate "Ring buffer benchmark stress tester"
 698         depends on RING_BUFFER
 699         help
 700           This option creates a test to stress the ring buffer and benchmark it.
 701           It creates its own ring buffer such that it will not interfere with
 702           any other users of the ring buffer (such as ftrace). It then creates
 703           a producer and consumer that will run for 10 seconds and sleep for
 704           10 seconds. Each interval it will print out the number of events
 705           it recorded and give a rough estimate of how long each iteration took.
 706
 707           It does not disable interrupts or raise its priority, so it may be
 708           affected by processes that are running.
 709
 710           If unsure, say N.
 711
 712 config RING_BUFFER_STARTUP_TEST
 713        bool "Ring buffer startup self test"
 714        depends on RING_BUFFER
 715        help
 716          Run a simple self test on the ring buffer on boot up. Late in the
 717          kernel boot sequence, the test will start that kicks off
 718          a thread per cpu. Each thread will write various size events
 719          into the ring buffer. Another thread is created to send IPIs
 720          to each of the threads, where the IPI handler will also write
 721          to the ring buffer, to test/stress the nesting ability.
 722          If any anomalies are discovered, a warning will be displayed
 723          and all ring buffers will be disabled.
 724
 725          The test runs for 10 seconds. This will slow your boot time
 726          by at least 10 more seconds.
 727
 728          At the end of the test, statics and more checks are done.
 729          It will output the stats of each per cpu buffer. What
 730          was written, the sizes, what was read, what was lost, and
 731          other similar details.
 732
 733          If unsure, say N
 734
 735 config PREEMPTIRQ_DELAY_TEST
 736         tristate "Preempt / IRQ disable delay thread to test latency tracers"
 737         depends on m
 738         help
 739           Select this option to build a test module that can help test latency
 740           tracers by executing a preempt or irq disable section with a user
 741           configurable delay. The module busy waits for the duration of the
 742           critical section.
 743
 744           For example, the following invocation forces a one-time irq-disabled
 745           critical section for 500us:
 746           modprobe preemptirq_delay_test test_mode=irq delay=500000
 747
 748           If unsure, say N
 749
 750 config TRACE_EVAL_MAP_FILE
 751        bool "Show eval mappings for trace events"
 752        depends on TRACING
 753        help
 754         The "print fmt" of the trace events will show the enum/sizeof names
 755         instead of their values. This can cause problems for user space tools
 756         that use this string to parse the raw data as user space does not know
 757         how to convert the string to its value.
 758
 759         To fix this, there's a special macro in the kernel that can be used
 760         to convert an enum/sizeof into its value. If this macro is used, then
 761         the print fmt strings will be converted to their values.
 762
 763         If something does not get converted properly, this option can be
 764         used to show what enums/sizeof the kernel tried to convert.
 765
 766         This option is for debugging the conversions. A file is created
 767         in the tracing directory called "eval_map" that will show the
 768         names matched with their values and what trace event system they
 769         belong too.
 770
 771         Normally, the mapping of the strings to values will be freed after
 772         boot up or module load. With this option, they will not be freed, as
 773         they are needed for the "eval_map" file. Enabling this option will
 774         increase the memory footprint of the running kernel.
 775
 776         If unsure, say N
 777
 778 config GCOV_PROFILE_FTRACE
 779         bool "Enable GCOV profiling on ftrace subsystem"
 780         depends on GCOV_KERNEL
 781         help
 782           Enable GCOV profiling on ftrace subsystem for checking
 783           which functions/lines are tested.
 784
 785           If unsure, say N.
 786
 787           Note that on a kernel compiled with this config, ftrace will
 788           run significantly slower.
 789
 790 endif # FTRACE
 791
 792 endif # TRACING_SUPPORT
 793