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_FUNCTION_TRACER
  13         bool
  14
  15 config HAVE_FUNCTION_GRAPH_TRACER
  16         bool
  17
  18 config HAVE_FUNCTION_TRACE_MCOUNT_TEST
  19         bool
  20         help
  21          This gets selected when the arch tests the function_trace_stop
  22          variable at the mcount call site. Otherwise, this variable
  23          is tested by the called function.
  24
  25 config HAVE_DYNAMIC_FTRACE
  26         bool
  27
  28 config HAVE_FTRACE_MCOUNT_RECORD
  29         bool
  30
  31 config HAVE_HW_BRANCH_TRACER
  32         bool
  33
  34 config TRACER_MAX_TRACE
  35         bool
  36
  37 config RING_BUFFER
  38         bool
  39
  40 config TRACING
  41         bool
  42         select DEBUG_FS
  43         select RING_BUFFER
  44         select STACKTRACE if STACKTRACE_SUPPORT
  45         select TRACEPOINTS
  46         select NOP_TRACER
  47
  48 menu "Tracers"
  49
  50 config FUNCTION_TRACER
  51         bool "Kernel Function Tracer"
  52         depends on HAVE_FUNCTION_TRACER
  53         depends on DEBUG_KERNEL
  54         select FRAME_POINTER
  55         select KALLSYMS
  56         select TRACING
  57         select CONTEXT_SWITCH_TRACER
  58         help
  59           Enable the kernel to trace every kernel function. This is done
  60           by using a compiler feature to insert a small, 5-byte No-Operation
  61           instruction to the beginning of every kernel function, which NOP
  62           sequence is then dynamically patched into a tracer call when
  63           tracing is enabled by the administrator. If it's runtime disabled
  64           (the bootup default), then the overhead of the instructions is very
  65           small and not measurable even in micro-benchmarks.
  66
  67 config FUNCTION_GRAPH_TRACER
  68         bool "Kernel Function Graph Tracer"
  69         depends on HAVE_FUNCTION_GRAPH_TRACER
  70         depends on FUNCTION_TRACER
  71         default y
  72         help
  73           Enable the kernel to trace a function at both its return
  74           and its entry.
  75           It's first purpose is to trace the duration of functions and
  76           draw a call graph for each thread with some informations like
  77           the return value.
  78           This is done by setting the current return address on the current
  79           task structure into a stack of calls.
  80
  81 config IRQSOFF_TRACER
  82         bool "Interrupts-off Latency Tracer"
  83         default n
  84         depends on TRACE_IRQFLAGS_SUPPORT
  85         depends on GENERIC_TIME
  86         depends on DEBUG_KERNEL
  87         select TRACE_IRQFLAGS
  88         select TRACING
  89         select TRACER_MAX_TRACE
  90         help
  91           This option measures the time spent in irqs-off critical
  92           sections, with microsecond accuracy.
  93
  94           The default measurement method is a maximum search, which is
  95           disabled by default and can be runtime (re-)started
  96           via:
  97
  98               echo 0 > /debugfs/tracing/tracing_max_latency
  99
 100           (Note that kernel size and overhead increases with this option
 101           enabled. This option and the preempt-off timing option can be
 102           used together or separately.)
 103
 104 config PREEMPT_TRACER
 105         bool "Preemption-off Latency Tracer"
 106         default n
 107         depends on GENERIC_TIME
 108         depends on PREEMPT
 109         depends on DEBUG_KERNEL
 110         select TRACING
 111         select TRACER_MAX_TRACE
 112         help
 113           This option measures the time spent in preemption off critical
 114           sections, with microsecond accuracy.
 115
 116           The default measurement method is a maximum search, which is
 117           disabled by default and can be runtime (re-)started
 118           via:
 119
 120               echo 0 > /debugfs/tracing/tracing_max_latency
 121
 122           (Note that kernel size and overhead increases with this option
 123           enabled. This option and the irqs-off timing option can be
 124           used together or separately.)
 125
 126 config SYSPROF_TRACER
 127         bool "Sysprof Tracer"
 128         depends on X86
 129         select TRACING
 130         help
 131           This tracer provides the trace needed by the 'Sysprof' userspace
 132           tool.
 133
 134 config SCHED_TRACER
 135         bool "Scheduling Latency Tracer"
 136         depends on DEBUG_KERNEL
 137         select TRACING
 138         select CONTEXT_SWITCH_TRACER
 139         select TRACER_MAX_TRACE
 140         help
 141           This tracer tracks the latency of the highest priority task
 142           to be scheduled in, starting from the point it has woken up.
 143
 144 config CONTEXT_SWITCH_TRACER
 145         bool "Trace process context switches"
 146         depends on DEBUG_KERNEL
 147         select TRACING
 148         select MARKERS
 149         help
 150           This tracer gets called from the context switch and records
 151           all switching of tasks.
 152
 153 config BOOT_TRACER
 154         bool "Trace boot initcalls"
 155         depends on DEBUG_KERNEL
 156         select TRACING
 157         select CONTEXT_SWITCH_TRACER
 158         help
 159           This tracer helps developers to optimize boot times: it records
 160           the timings of the initcalls and traces key events and the identity
 161           of tasks that can cause boot delays, such as context-switches.
 162
 163           Its aim is to be parsed by the /scripts/bootgraph.pl tool to
 164           produce pretty graphics about boot inefficiencies, giving a visual
 165           representation of the delays during initcalls - but the raw
 166           /debug/tracing/trace text output is readable too.
 167
 168           ( Note that tracing self tests can't be enabled if this tracer is
 169             selected, because the self-tests are an initcall as well and that
 170             would invalidate the boot trace. )
 171
 172 config TRACE_BRANCH_PROFILING
 173         bool "Trace likely/unlikely profiler"
 174         depends on DEBUG_KERNEL
 175         select TRACING
 176         help
 177           This tracer profiles all the the likely and unlikely macros
 178           in the kernel. It will display the results in:
 179
 180           /debugfs/tracing/profile_annotated_branch
 181
 182           Note: this will add a significant overhead, only turn this
 183           on if you need to profile the system's use of these macros.
 184
 185           Say N if unsure.
 186
 187 config PROFILE_ALL_BRANCHES
 188         bool "Profile all if conditionals"
 189         depends on TRACE_BRANCH_PROFILING
 190         help
 191           This tracer profiles all branch conditions. Every if ()
 192           taken in the kernel is recorded whether it hit or miss.
 193           The results will be displayed in:
 194
 195           /debugfs/tracing/profile_branch
 196
 197           This configuration, when enabled, will impose a great overhead
 198           on the system. This should only be enabled when the system
 199           is to be analyzed
 200
 201           Say N if unsure.
 202
 203 config TRACING_BRANCHES
 204         bool
 205         help
 206           Selected by tracers that will trace the likely and unlikely
 207           conditions. This prevents the tracers themselves from being
 208           profiled. Profiling the tracing infrastructure can only happen
 209           when the likelys and unlikelys are not being traced.
 210
 211 config BRANCH_TRACER
 212         bool "Trace likely/unlikely instances"
 213         depends on TRACE_BRANCH_PROFILING
 214         select TRACING_BRANCHES
 215         help
 216           This traces the events of likely and unlikely condition
 217           calls in the kernel.  The difference between this and the
 218           "Trace likely/unlikely profiler" is that this is not a
 219           histogram of the callers, but actually places the calling
 220           events into a running trace buffer to see when and where the
 221           events happened, as well as their results.
 222
 223           Say N if unsure.
 224
 225 config POWER_TRACER
 226         bool "Trace power consumption behavior"
 227         depends on DEBUG_KERNEL
 228         depends on X86
 229         select TRACING
 230         help
 231           This tracer helps developers to analyze and optimize the kernels
 232           power management decisions, specifically the C-state and P-state
 233           behavior.
 234
 235
 236 config STACK_TRACER
 237         bool "Trace max stack"
 238         depends on HAVE_FUNCTION_TRACER
 239         depends on DEBUG_KERNEL
 240         select FUNCTION_TRACER
 241         select STACKTRACE
 242         select KALLSYMS
 243         help
 244           This special tracer records the maximum stack footprint of the
 245           kernel and displays it in debugfs/tracing/stack_trace.
 246
 247           This tracer works by hooking into every function call that the
 248           kernel executes, and keeping a maximum stack depth value and
 249           stack-trace saved.  If this is configured with DYNAMIC_FTRACE
 250           then it will not have any overhead while the stack tracer
 251           is disabled.
 252
 253           To enable the stack tracer on bootup, pass in 'stacktrace'
 254           on the kernel command line.
 255
 256           The stack tracer can also be enabled or disabled via the
 257           sysctl kernel.stack_tracer_enabled
 258
 259           Say N if unsure.
 260
 261 config HW_BRANCH_TRACER
 262         depends on HAVE_HW_BRANCH_TRACER
 263         bool "Trace hw branches"
 264         select TRACING
 265         help
 266           This tracer records all branches on the system in a circular
 267           buffer giving access to the last N branches for each cpu.
 268
 269 config DYNAMIC_FTRACE
 270         bool "enable/disable ftrace tracepoints dynamically"
 271         depends on FUNCTION_TRACER
 272         depends on HAVE_DYNAMIC_FTRACE
 273         depends on DEBUG_KERNEL
 274         default y
 275         help
 276          This option will modify all the calls to ftrace dynamically
 277          (will patch them out of the binary image and replaces them
 278          with a No-Op instruction) as they are called. A table is
 279          created to dynamically enable them again.
 280
 281          This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but otherwise
 282          has native performance as long as no tracing is active.
 283
 284          The changes to the code are done by a kernel thread that
 285          wakes up once a second and checks to see if any ftrace calls
 286          were made. If so, it runs stop_machine (stops all CPUS)
 287          and modifies the code to jump over the call to ftrace.
 288
 289 config FTRACE_MCOUNT_RECORD
 290         def_bool y
 291         depends on DYNAMIC_FTRACE
 292         depends on HAVE_FTRACE_MCOUNT_RECORD
 293
 294 config FTRACE_SELFTEST
 295         bool
 296
 297 config FTRACE_STARTUP_TEST
 298         bool "Perform a startup test on ftrace"
 299         depends on TRACING && DEBUG_KERNEL && !BOOT_TRACER
 300         select FTRACE_SELFTEST
 301         help
 302           This option performs a series of startup tests on ftrace. On bootup
 303           a series of tests are made to verify that the tracer is
 304           functioning properly. It will do tests on all the configured
 305           tracers of ftrace.
 306
 307 config MMIOTRACE
 308         bool "Memory mapped IO tracing"
 309         depends on HAVE_MMIOTRACE_SUPPORT && DEBUG_KERNEL && PCI
 310         select TRACING
 311         help
 312           Mmiotrace traces Memory Mapped I/O access and is meant for
 313           debugging and reverse engineering. It is called from the ioremap
 314           implementation and works via page faults. Tracing is disabled by
 315           default and can be enabled at run-time.
 316
 317           See Documentation/tracers/mmiotrace.txt.
 318           If you are not helping to develop drivers, say N.
 319
 320 config MMIOTRACE_TEST
 321         tristate "Test module for mmiotrace"
 322         depends on MMIOTRACE && m
 323         help
 324           This is a dumb module for testing mmiotrace. It is very dangerous
 325           as it will write garbage to IO memory starting at a given address.
 326           However, it should be safe to use on e.g. unused portion of VRAM.
 327
 328           Say N, unless you absolutely know what you are doing.
 329
 330 endmenu