Pileus Git - ~andy/linux/blob - 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_FUNCTION_TRACE_MCOUNT_TEST
  33         bool
  34         help
  35           See Documentation/trace/ftrace-design.txt
  36
  37 config HAVE_DYNAMIC_FTRACE
  38         bool
  39         help
  40           See Documentation/trace/ftrace-design.txt
  41
  42 config HAVE_DYNAMIC_FTRACE_WITH_REGS
  43         bool
  44
  45 config HAVE_FTRACE_MCOUNT_RECORD
  46         bool
  47         help
  48           See Documentation/trace/ftrace-design.txt
  49
  50 config HAVE_SYSCALL_TRACEPOINTS
  51         bool
  52         help
  53           See Documentation/trace/ftrace-design.txt
  54
  55 config HAVE_FENTRY
  56         bool
  57         help
  58           Arch supports the gcc options -pg with -mfentry
  59
  60 config HAVE_C_RECORDMCOUNT
  61         bool
  62         help
  63           C version of recordmcount available?
  64
  65 config TRACER_MAX_TRACE
  66         bool
  67
  68 config TRACE_CLOCK
  69         bool
  70
  71 config RING_BUFFER
  72         bool
  73         select TRACE_CLOCK
  74
  75 config FTRACE_NMI_ENTER
  76        bool
  77        depends on HAVE_FTRACE_NMI_ENTER
  78        default y
  79
  80 config EVENT_TRACING
  81         select CONTEXT_SWITCH_TRACER
  82         bool
  83
  84 config EVENT_POWER_TRACING_DEPRECATED
  85         depends on EVENT_TRACING
  86         bool "Deprecated power event trace API, to be removed"
  87         default y
  88         help
  89           Provides old power event types:
  90           C-state/idle accounting events:
  91           power:power_start
  92           power:power_end
  93           and old cpufreq accounting event:
  94           power:power_frequency
  95           This is for userspace compatibility
  96           and will vanish after 5 kernel iterations,
  97           namely 3.1.
  98
  99 config CONTEXT_SWITCH_TRACER
 100         bool
 101
 102 config RING_BUFFER_ALLOW_SWAP
 103         bool
 104         help
 105          Allow the use of ring_buffer_swap_cpu.
 106          Adds a very slight overhead to tracing when enabled.
 107
 108 # All tracer options should select GENERIC_TRACER. For those options that are
 109 # enabled by all tracers (context switch and event tracer) they select TRACING.
 110 # This allows those options to appear when no other tracer is selected. But the
 111 # options do not appear when something else selects it. We need the two options
 112 # GENERIC_TRACER and TRACING to avoid circular dependencies to accomplish the
 113 # hiding of the automatic options.
 114
 115 config TRACING
 116         bool
 117         select DEBUG_FS
 118         select RING_BUFFER
 119         select STACKTRACE if STACKTRACE_SUPPORT
 120         select TRACEPOINTS
 121         select NOP_TRACER
 122         select BINARY_PRINTF
 123         select EVENT_TRACING
 124         select TRACE_CLOCK
 125         select IRQ_WORK
 126
 127 config GENERIC_TRACER
 128         bool
 129         select TRACING
 130
 131 #
 132 # Minimum requirements an architecture has to meet for us to
 133 # be able to offer generic tracing facilities:
 134 #
 135 config TRACING_SUPPORT
 136         bool
 137         # PPC32 has no irqflags tracing support, but it can use most of the
 138         # tracers anyway, they were tested to build and work. Note that new
 139         # exceptions to this list aren't welcomed, better implement the
 140         # irqflags tracing for your architecture.
 141         depends on TRACE_IRQFLAGS_SUPPORT || PPC32
 142         depends on STACKTRACE_SUPPORT
 143         default y
 144
 145 if TRACING_SUPPORT
 146
 147 menuconfig FTRACE
 148         bool "Tracers"
 149         default y if DEBUG_KERNEL
 150         help
 151           Enable the kernel tracing infrastructure.
 152
 153 if FTRACE
 154
 155 config FUNCTION_TRACER
 156         bool "Kernel Function Tracer"
 157         depends on HAVE_FUNCTION_TRACER
 158         select KALLSYMS
 159         select GENERIC_TRACER
 160         select CONTEXT_SWITCH_TRACER
 161         help
 162           Enable the kernel to trace every kernel function. This is done
 163           by using a compiler feature to insert a small, 5-byte No-Operation
 164           instruction at the beginning of every kernel function, which NOP
 165           sequence is then dynamically patched into a tracer call when
 166           tracing is enabled by the administrator. If it's runtime disabled
 167           (the bootup default), then the overhead of the instructions is very
 168           small and not measurable even in micro-benchmarks.
 169
 170 config FUNCTION_GRAPH_TRACER
 171         bool "Kernel Function Graph Tracer"
 172         depends on HAVE_FUNCTION_GRAPH_TRACER
 173         depends on FUNCTION_TRACER
 174         depends on !X86_32 || !CC_OPTIMIZE_FOR_SIZE
 175         default y
 176         help
 177           Enable the kernel to trace a function at both its return
 178           and its entry.
 179           Its first purpose is to trace the duration of functions and
 180           draw a call graph for each thread with some information like
 181           the return value. This is done by setting the current return
 182           address on the current task structure into a stack of calls.
 183
 184
 185 config IRQSOFF_TRACER
 186         bool "Interrupts-off Latency Tracer"
 187         default n
 188         depends on TRACE_IRQFLAGS_SUPPORT
 189         depends on !ARCH_USES_GETTIMEOFFSET
 190         select TRACE_IRQFLAGS
 191         select GENERIC_TRACER
 192         select TRACER_MAX_TRACE
 193         select RING_BUFFER_ALLOW_SWAP
 194         help
 195           This option measures the time spent in irqs-off critical
 196           sections, with microsecond accuracy.
 197
 198           The default measurement method is a maximum search, which is
 199           disabled by default and can be runtime (re-)started
 200           via:
 201
 202               echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
 203
 204           (Note that kernel size and overhead increase with this option
 205           enabled. This option and the preempt-off timing option can be
 206           used together or separately.)
 207
 208 config PREEMPT_TRACER
 209         bool "Preemption-off Latency Tracer"
 210         default n
 211         depends on !ARCH_USES_GETTIMEOFFSET
 212         depends on PREEMPT
 213         select GENERIC_TRACER
 214         select TRACER_MAX_TRACE
 215         select RING_BUFFER_ALLOW_SWAP
 216         help
 217           This option measures the time spent in preemption-off critical
 218           sections, with microsecond accuracy.
 219
 220           The default measurement method is a maximum search, which is
 221           disabled by default and can be runtime (re-)started
 222           via:
 223
 224               echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
 225
 226           (Note that kernel size and overhead increase with this option
 227           enabled. This option and the irqs-off timing option can be
 228           used together or separately.)
 229
 230 config SCHED_TRACER
 231         bool "Scheduling Latency Tracer"
 232         select GENERIC_TRACER
 233         select CONTEXT_SWITCH_TRACER
 234         select TRACER_MAX_TRACE
 235         help
 236           This tracer tracks the latency of the highest priority task
 237           to be scheduled in, starting from the point it has woken up.
 238
 239 config ENABLE_DEFAULT_TRACERS
 240         bool "Trace process context switches and events"
 241         depends on !GENERIC_TRACER
 242         select TRACING
 243         help
 244           This tracer hooks to various trace points in the kernel,
 245           allowing the user to pick and choose which trace point they
 246           want to trace. It also includes the sched_switch tracer plugin.
 247
 248 config FTRACE_SYSCALLS
 249         bool "Trace syscalls"
 250         depends on HAVE_SYSCALL_TRACEPOINTS
 251         select GENERIC_TRACER
 252         select KALLSYMS
 253         help
 254           Basic tracer to catch the syscall entry and exit events.
 255
 256 config TRACER_SNAPSHOT
 257         bool "Create a snapshot trace buffer"
 258         select TRACER_MAX_TRACE
 259         help
 260           Allow tracing users to take snapshot of the current buffer using the
 261           ftrace interface, e.g.:
 262
 263               echo 1 > /sys/kernel/debug/tracing/snapshot
 264               cat snapshot
 265
 266 config TRACE_BRANCH_PROFILING
 267         bool
 268         select GENERIC_TRACER
 269
 270 choice
 271         prompt "Branch Profiling"
 272         default BRANCH_PROFILE_NONE
 273         help
 274          The branch profiling is a software profiler. It will add hooks
 275          into the C conditionals to test which path a branch takes.
 276
 277          The likely/unlikely profiler only looks at the conditions that
 278          are annotated with a likely or unlikely macro.
 279
 280          The "all branch" profiler will profile every if-statement in the
 281          kernel. This profiler will also enable the likely/unlikely
 282          profiler.
 283
 284          Either of the above profilers adds a bit of overhead to the system.
 285          If unsure, choose "No branch profiling".
 286
 287 config BRANCH_PROFILE_NONE
 288         bool "No branch profiling"
 289         help
 290           No branch profiling. Branch profiling adds a bit of overhead.
 291           Only enable it if you want to analyse the branching behavior.
 292           Otherwise keep it disabled.
 293
 294 config PROFILE_ANNOTATED_BRANCHES
 295         bool "Trace likely/unlikely profiler"
 296         select TRACE_BRANCH_PROFILING
 297         help
 298           This tracer profiles all likely and unlikely macros
 299           in the kernel. It will display the results in:
 300
 301           /sys/kernel/debug/tracing/trace_stat/branch_annotated
 302
 303           Note: this will add a significant overhead; only turn this
 304           on if you need to profile the system's use of these macros.
 305
 306 config PROFILE_ALL_BRANCHES
 307         bool "Profile all if conditionals"
 308         select TRACE_BRANCH_PROFILING
 309         help
 310           This tracer profiles all branch conditions. Every if ()
 311           taken in the kernel is recorded whether it hit or miss.
 312           The results will be displayed in:
 313
 314           /sys/kernel/debug/tracing/trace_stat/branch_all
 315
 316           This option also enables the likely/unlikely profiler.
 317
 318           This configuration, when enabled, will impose a great overhead
 319           on the system. This should only be enabled when the system
 320           is to be analyzed in much detail.
 321 endchoice
 322
 323 config TRACING_BRANCHES
 324         bool
 325         help
 326           Selected by tracers that will trace the likely and unlikely
 327           conditions. This prevents the tracers themselves from being
 328           profiled. Profiling the tracing infrastructure can only happen
 329           when the likelys and unlikelys are not being traced.
 330
 331 config BRANCH_TRACER
 332         bool "Trace likely/unlikely instances"
 333         depends on TRACE_BRANCH_PROFILING
 334         select TRACING_BRANCHES
 335         help
 336           This traces the events of likely and unlikely condition
 337           calls in the kernel.  The difference between this and the
 338           "Trace likely/unlikely profiler" is that this is not a
 339           histogram of the callers, but actually places the calling
 340           events into a running trace buffer to see when and where the
 341           events happened, as well as their results.
 342
 343           Say N if unsure.
 344
 345 config STACK_TRACER
 346         bool "Trace max stack"
 347         depends on HAVE_FUNCTION_TRACER
 348         select FUNCTION_TRACER
 349         select STACKTRACE
 350         select KALLSYMS
 351         help
 352           This special tracer records the maximum stack footprint of the
 353           kernel and displays it in /sys/kernel/debug/tracing/stack_trace.
 354
 355           This tracer works by hooking into every function call that the
 356           kernel executes, and keeping a maximum stack depth value and
 357           stack-trace saved.  If this is configured with DYNAMIC_FTRACE
 358           then it will not have any overhead while the stack tracer
 359           is disabled.
 360
 361           To enable the stack tracer on bootup, pass in 'stacktrace'
 362           on the kernel command line.
 363
 364           The stack tracer can also be enabled or disabled via the
 365           sysctl kernel.stack_tracer_enabled
 366
 367           Say N if unsure.
 368
 369 config BLK_DEV_IO_TRACE
 370         bool "Support for tracing block IO actions"
 371         depends on SYSFS
 372         depends on BLOCK
 373         select RELAY
 374         select DEBUG_FS
 375         select TRACEPOINTS
 376         select GENERIC_TRACER
 377         select STACKTRACE
 378         help
 379           Say Y here if you want to be able to trace the block layer actions
 380           on a given queue. Tracing allows you to see any traffic happening
 381           on a block device queue. For more information (and the userspace
 382           support tools needed), fetch the blktrace tools from:
 383
 384           git://git.kernel.dk/blktrace.git
 385
 386           Tracing also is possible using the ftrace interface, e.g.:
 387
 388             echo 1 > /sys/block/sda/sda1/trace/enable
 389             echo blk > /sys/kernel/debug/tracing/current_tracer
 390             cat /sys/kernel/debug/tracing/trace_pipe
 391
 392           If unsure, say N.
 393
 394 config KPROBE_EVENT
 395         depends on KPROBES
 396         depends on HAVE_REGS_AND_STACK_ACCESS_API
 397         bool "Enable kprobes-based dynamic events"
 398         select TRACING
 399         select PROBE_EVENTS
 400         default y
 401         help
 402           This allows the user to add tracing events (similar to tracepoints)
 403           on the fly via the ftrace interface. See
 404           Documentation/trace/kprobetrace.txt for more details.
 405
 406           Those events can be inserted wherever kprobes can probe, and record
 407           various register and memory values.
 408
 409           This option is also required by perf-probe subcommand of perf tools.
 410           If you want to use perf tools, this option is strongly recommended.
 411
 412 config UPROBE_EVENT
 413         bool "Enable uprobes-based dynamic events"
 414         depends on ARCH_SUPPORTS_UPROBES
 415         depends on MMU
 416         select UPROBES
 417         select PROBE_EVENTS
 418         select TRACING
 419         default n
 420         help
 421           This allows the user to add tracing events on top of userspace
 422           dynamic events (similar to tracepoints) on the fly via the trace
 423           events interface. Those events can be inserted wherever uprobes
 424           can probe, and record various registers.
 425           This option is required if you plan to use perf-probe subcommand
 426           of perf tools on user space applications.
 427
 428 config PROBE_EVENTS
 429         def_bool n
 430
 431 config DYNAMIC_FTRACE
 432         bool "enable/disable ftrace tracepoints dynamically"
 433         depends on FUNCTION_TRACER
 434         depends on HAVE_DYNAMIC_FTRACE
 435         default y
 436         help
 437           This option will modify all the calls to ftrace dynamically
 438           (will patch them out of the binary image and replace them
 439           with a No-Op instruction) as they are called. A table is
 440           created to dynamically enable them again.
 441
 442           This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but
 443           otherwise has native performance as long as no tracing is active.
 444
 445           The changes to the code are done by a kernel thread that
 446           wakes up once a second and checks to see if any ftrace calls
 447           were made. If so, it runs stop_machine (stops all CPUS)
 448           and modifies the code to jump over the call to ftrace.
 449
 450 config DYNAMIC_FTRACE_WITH_REGS
 451         def_bool y
 452         depends on DYNAMIC_FTRACE
 453         depends on HAVE_DYNAMIC_FTRACE_WITH_REGS
 454
 455 config FUNCTION_PROFILER
 456         bool "Kernel function profiler"
 457         depends on FUNCTION_TRACER
 458         default n
 459         help
 460           This option enables the kernel function profiler. A file is created
 461           in debugfs called function_profile_enabled which defaults to zero.
 462           When a 1 is echoed into this file profiling begins, and when a
 463           zero is entered, profiling stops. A "functions" file is created in
 464           the trace_stats directory; this file shows the list of functions that
 465           have been hit and their counters.
 466
 467           If in doubt, say N.
 468
 469 config FTRACE_MCOUNT_RECORD
 470         def_bool y
 471         depends on DYNAMIC_FTRACE
 472         depends on HAVE_FTRACE_MCOUNT_RECORD
 473
 474 config FTRACE_SELFTEST
 475         bool
 476
 477 config FTRACE_STARTUP_TEST
 478         bool "Perform a startup test on ftrace"
 479         depends on GENERIC_TRACER
 480         select FTRACE_SELFTEST
 481         help
 482           This option performs a series of startup tests on ftrace. On bootup
 483           a series of tests are made to verify that the tracer is
 484           functioning properly. It will do tests on all the configured
 485           tracers of ftrace.
 486
 487 config EVENT_TRACE_TEST_SYSCALLS
 488         bool "Run selftest on syscall events"
 489         depends on FTRACE_STARTUP_TEST
 490         help
 491          This option will also enable testing every syscall event.
 492          It only enables the event and disables it and runs various loads
 493          with the event enabled. This adds a bit more time for kernel boot
 494          up since it runs this on every system call defined.
 495
 496          TBD - enable a way to actually call the syscalls as we test their
 497                events
 498
 499 config MMIOTRACE
 500         bool "Memory mapped IO tracing"
 501         depends on HAVE_MMIOTRACE_SUPPORT && PCI
 502         select GENERIC_TRACER
 503         help
 504           Mmiotrace traces Memory Mapped I/O access and is meant for
 505           debugging and reverse engineering. It is called from the ioremap
 506           implementation and works via page faults. Tracing is disabled by
 507           default and can be enabled at run-time.
 508
 509           See Documentation/trace/mmiotrace.txt.
 510           If you are not helping to develop drivers, say N.
 511
 512 config MMIOTRACE_TEST
 513         tristate "Test module for mmiotrace"
 514         depends on MMIOTRACE && m
 515         help
 516           This is a dumb module for testing mmiotrace. It is very dangerous
 517           as it will write garbage to IO memory starting at a given address.
 518           However, it should be safe to use on e.g. unused portion of VRAM.
 519
 520           Say N, unless you absolutely know what you are doing.
 521
 522 config RING_BUFFER_BENCHMARK
 523         tristate "Ring buffer benchmark stress tester"
 524         depends on RING_BUFFER
 525         help
 526           This option creates a test to stress the ring buffer and benchmark it.
 527           It creates its own ring buffer such that it will not interfere with
 528           any other users of the ring buffer (such as ftrace). It then creates
 529           a producer and consumer that will run for 10 seconds and sleep for
 530           10 seconds. Each interval it will print out the number of events
 531           it recorded and give a rough estimate of how long each iteration took.
 532
 533           It does not disable interrupts or raise its priority, so it may be
 534           affected by processes that are running.
 535
 536           If unsure, say N.
 537
 538 endif # FTRACE
 539
 540 endif # TRACING_SUPPORT
 541