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         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, uprobe, and
 524           tracepoint events.
 525
 526 config DYNAMIC_EVENTS
 527         def_bool n
 528
 529 config PROBE_EVENTS
 530         def_bool n
 531
 532 config DYNAMIC_FTRACE
 533         bool "enable/disable function tracing dynamically"
 534         depends on FUNCTION_TRACER
 535         depends on HAVE_DYNAMIC_FTRACE
 536         default y
 537         help
 538           This option will modify all the calls to function tracing
 539           dynamically (will patch them out of the binary image and
 540           replace them with a No-Op instruction) on boot up. During
 541           compile time, a table is made of all the locations that ftrace
 542           can function trace, and this table is linked into the kernel
 543           image. When this is enabled, functions can be individually
 544           enabled, and the functions not enabled will not affect
 545           performance of the system.
 546
 547           See the files in /sys/kernel/debug/tracing:
 548             available_filter_functions
 549             set_ftrace_filter
 550             set_ftrace_notrace
 551
 552           This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but
 553           otherwise has native performance as long as no tracing is active.
 554
 555 config DYNAMIC_FTRACE_WITH_REGS
 556         def_bool y
 557         depends on DYNAMIC_FTRACE
 558         depends on HAVE_DYNAMIC_FTRACE_WITH_REGS
 559
 560 config FUNCTION_PROFILER
 561         bool "Kernel function profiler"
 562         depends on FUNCTION_TRACER
 563         default n
 564         help
 565           This option enables the kernel function profiler. A file is created
 566           in debugfs called function_profile_enabled which defaults to zero.
 567           When a 1 is echoed into this file profiling begins, and when a
 568           zero is entered, profiling stops. A "functions" file is created in
 569           the trace_stat directory; this file shows the list of functions that
 570           have been hit and their counters.
 571
 572           If in doubt, say N.
 573
 574 config BPF_KPROBE_OVERRIDE
 575         bool "Enable BPF programs to override a kprobed function"
 576         depends on BPF_EVENTS
 577         depends on FUNCTION_ERROR_INJECTION
 578         default n
 579         help
 580          Allows BPF to override the execution of a probed function and
 581          set a different return value.  This is used for error injection.
 582
 583 config FTRACE_MCOUNT_RECORD
 584         def_bool y
 585         depends on DYNAMIC_FTRACE
 586         depends on HAVE_FTRACE_MCOUNT_RECORD
 587
 588 config FTRACE_SELFTEST
 589         bool
 590
 591 config FTRACE_STARTUP_TEST
 592         bool "Perform a startup test on ftrace"
 593         depends on GENERIC_TRACER
 594         select FTRACE_SELFTEST
 595         help
 596           This option performs a series of startup tests on ftrace. On bootup
 597           a series of tests are made to verify that the tracer is
 598           functioning properly. It will do tests on all the configured
 599           tracers of ftrace.
 600
 601 config EVENT_TRACE_STARTUP_TEST
 602         bool "Run selftest on trace events"
 603         depends on FTRACE_STARTUP_TEST
 604         default y
 605         help
 606           This option performs a test on all trace events in the system.
 607           It basically just enables each event and runs some code that
 608           will trigger events (not necessarily the event it enables)
 609           This may take some time run as there are a lot of events.
 610
 611 config EVENT_TRACE_TEST_SYSCALLS
 612         bool "Run selftest on syscall events"
 613         depends on EVENT_TRACE_STARTUP_TEST
 614         help
 615          This option will also enable testing every syscall event.
 616          It only enables the event and disables it and runs various loads
 617          with the event enabled. This adds a bit more time for kernel boot
 618          up since it runs this on every system call defined.
 619
 620          TBD - enable a way to actually call the syscalls as we test their
 621                events
 622
 623 config MMIOTRACE
 624         bool "Memory mapped IO tracing"
 625         depends on HAVE_MMIOTRACE_SUPPORT && PCI
 626         select GENERIC_TRACER
 627         help
 628           Mmiotrace traces Memory Mapped I/O access and is meant for
 629           debugging and reverse engineering. It is called from the ioremap
 630           implementation and works via page faults. Tracing is disabled by
 631           default and can be enabled at run-time.
 632
 633           See Documentation/trace/mmiotrace.rst.
 634           If you are not helping to develop drivers, say N.
 635
 636 config TRACING_MAP
 637         bool
 638         depends on ARCH_HAVE_NMI_SAFE_CMPXCHG
 639         help
 640           tracing_map is a special-purpose lock-free map for tracing,
 641           separated out as a stand-alone facility in order to allow it
 642           to be shared between multiple tracers.  It isn't meant to be
 643           generally used outside of that context, and is normally
 644           selected by tracers that use it.
 645
 646 config HIST_TRIGGERS
 647         bool "Histogram triggers"
 648         depends on ARCH_HAVE_NMI_SAFE_CMPXCHG
 649         select TRACING_MAP
 650         select TRACING
 651         select DYNAMIC_EVENTS
 652         default n
 653         help
 654           Hist triggers allow one or more arbitrary trace event fields
 655           to be aggregated into hash tables and dumped to stdout by
 656           reading a debugfs/tracefs file.  They're useful for
 657           gathering quick and dirty (though precise) summaries of
 658           event activity as an initial guide for further investigation
 659           using more advanced tools.
 660
 661           Inter-event tracing of quantities such as latencies is also
 662           supported using hist triggers under this option.
 663
 664           See Documentation/trace/histogram.rst.
 665           If in doubt, say N.
 666
 667 config MMIOTRACE_TEST
 668         tristate "Test module for mmiotrace"
 669         depends on MMIOTRACE && m
 670         help
 671           This is a dumb module for testing mmiotrace. It is very dangerous
 672           as it will write garbage to IO memory starting at a given address.
 673           However, it should be safe to use on e.g. unused portion of VRAM.
 674
 675           Say N, unless you absolutely know what you are doing.
 676
 677 config TRACEPOINT_BENCHMARK
 678         bool "Add tracepoint that benchmarks tracepoints"
 679         help
 680          This option creates the tracepoint "benchmark:benchmark_event".
 681          When the tracepoint is enabled, it kicks off a kernel thread that
 682          goes into an infinite loop (calling cond_sched() to let other tasks
 683          run), and calls the tracepoint. Each iteration will record the time
 684          it took to write to the tracepoint and the next iteration that
 685          data will be passed to the tracepoint itself. That is, the tracepoint
 686          will report the time it took to do the previous tracepoint.
 687          The string written to the tracepoint is a static string of 128 bytes
 688          to keep the time the same. The initial string is simply a write of
 689          "START". The second string records the cold cache time of the first
 690          write which is not added to the rest of the calculations.
 691
 692          As it is a tight loop, it benchmarks as hot cache. That's fine because
 693          we care most about hot paths that are probably in cache already.
 694
 695          An example of the output:
 696
 697               START
 698               first=3672 [COLD CACHED]
 699               last=632 first=3672 max=632 min=632 avg=316 std=446 std^2=199712
 700               last=278 first=3672 max=632 min=278 avg=303 std=316 std^2=100337
 701               last=277 first=3672 max=632 min=277 avg=296 std=258 std^2=67064
 702               last=273 first=3672 max=632 min=273 avg=292 std=224 std^2=50411
 703               last=273 first=3672 max=632 min=273 avg=288 std=200 std^2=40389
 704               last=281 first=3672 max=632 min=273 avg=287 std=183 std^2=33666
 705
 706
 707 config RING_BUFFER_BENCHMARK
 708         tristate "Ring buffer benchmark stress tester"
 709         depends on RING_BUFFER
 710         help
 711           This option creates a test to stress the ring buffer and benchmark it.
 712           It creates its own ring buffer such that it will not interfere with
 713           any other users of the ring buffer (such as ftrace). It then creates
 714           a producer and consumer that will run for 10 seconds and sleep for
 715           10 seconds. Each interval it will print out the number of events
 716           it recorded and give a rough estimate of how long each iteration took.
 717
 718           It does not disable interrupts or raise its priority, so it may be
 719           affected by processes that are running.
 720
 721           If unsure, say N.
 722
 723 config RING_BUFFER_STARTUP_TEST
 724        bool "Ring buffer startup self test"
 725        depends on RING_BUFFER
 726        help
 727          Run a simple self test on the ring buffer on boot up. Late in the
 728          kernel boot sequence, the test will start that kicks off
 729          a thread per cpu. Each thread will write various size events
 730          into the ring buffer. Another thread is created to send IPIs
 731          to each of the threads, where the IPI handler will also write
 732          to the ring buffer, to test/stress the nesting ability.
 733          If any anomalies are discovered, a warning will be displayed
 734          and all ring buffers will be disabled.
 735
 736          The test runs for 10 seconds. This will slow your boot time
 737          by at least 10 more seconds.
 738
 739          At the end of the test, statics and more checks are done.
 740          It will output the stats of each per cpu buffer. What
 741          was written, the sizes, what was read, what was lost, and
 742          other similar details.
 743
 744          If unsure, say N
 745
 746 config PREEMPTIRQ_DELAY_TEST
 747         tristate "Preempt / IRQ disable delay thread to test latency tracers"
 748         depends on m
 749         help
 750           Select this option to build a test module that can help test latency
 751           tracers by executing a preempt or irq disable section with a user
 752           configurable delay. The module busy waits for the duration of the
 753           critical section.
 754
 755           For example, the following invocation forces a one-time irq-disabled
 756           critical section for 500us:
 757           modprobe preemptirq_delay_test test_mode=irq delay=500000
 758
 759           If unsure, say N
 760
 761 config TRACE_EVAL_MAP_FILE
 762        bool "Show eval mappings for trace events"
 763        depends on TRACING
 764        help
 765         The "print fmt" of the trace events will show the enum/sizeof names
 766         instead of their values. This can cause problems for user space tools
 767         that use this string to parse the raw data as user space does not know
 768         how to convert the string to its value.
 769
 770         To fix this, there's a special macro in the kernel that can be used
 771         to convert an enum/sizeof into its value. If this macro is used, then
 772         the print fmt strings will be converted to their values.
 773
 774         If something does not get converted properly, this option can be
 775         used to show what enums/sizeof the kernel tried to convert.
 776
 777         This option is for debugging the conversions. A file is created
 778         in the tracing directory called "eval_map" that will show the
 779         names matched with their values and what trace event system they
 780         belong too.
 781
 782         Normally, the mapping of the strings to values will be freed after
 783         boot up or module load. With this option, they will not be freed, as
 784         they are needed for the "eval_map" file. Enabling this option will
 785         increase the memory footprint of the running kernel.
 786
 787         If unsure, say N
 788
 789 config GCOV_PROFILE_FTRACE
 790         bool "Enable GCOV profiling on ftrace subsystem"
 791         depends on GCOV_KERNEL
 792         help
 793           Enable GCOV profiling on ftrace subsystem for checking
 794           which functions/lines are tested.
 795
 796           If unsure, say N.
 797
 798           Note that on a kernel compiled with this config, ftrace will
 799           run significantly slower.
 800
 801 endif # FTRACE
 802
 803 endif # TRACING_SUPPORT
 804