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