kernel/trace/Kconfig

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