SAFE public projects git trees. - safe/jmp/linux-2.6/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
  15 config HAVE_FUNCTION_TRACER
  16         bool
  17
  18 config HAVE_FUNCTION_GRAPH_TRACER
  19         bool
  20
  21 config HAVE_FUNCTION_TRACE_MCOUNT_TEST
  22         bool
  23         help
  24          This gets selected when the arch tests the function_trace_stop
  25          variable at the mcount call site. Otherwise, this variable
  26          is tested by the called function.
  27
  28 config HAVE_DYNAMIC_FTRACE
  29         bool
  30
  31 config HAVE_FTRACE_MCOUNT_RECORD
  32         bool
  33
  34 config HAVE_HW_BRANCH_TRACER
  35         bool
  36
  37 config TRACER_MAX_TRACE
  38         bool
  39
  40 config RING_BUFFER
  41         bool
  42
  43 config FTRACE_NMI_ENTER
  44        bool
  45        depends on HAVE_FTRACE_NMI_ENTER
  46        default y
  47
  48 config TRACING
  49         bool
  50         select DEBUG_FS
  51         select RING_BUFFER
  52         select STACKTRACE if STACKTRACE_SUPPORT
  53         select TRACEPOINTS
  54         select NOP_TRACER
  55
  56 #
  57 # Minimum requirements an architecture has to meet for us to
  58 # be able to offer generic tracing facilities:
  59 #
  60 config TRACING_SUPPORT
  61         bool
  62         depends on TRACE_IRQFLAGS_SUPPORT
  63         depends on STACKTRACE_SUPPORT
  64         default y
  65
  66 if TRACING_SUPPORT
  67
  68 menu "Tracers"
  69
  70 config FUNCTION_TRACER
  71         bool "Kernel Function Tracer"
  72         depends on HAVE_FUNCTION_TRACER
  73         select FRAME_POINTER
  74         select KALLSYMS
  75         select TRACING
  76         select CONTEXT_SWITCH_TRACER
  77         help
  78           Enable the kernel to trace every kernel function. This is done
  79           by using a compiler feature to insert a small, 5-byte No-Operation
  80           instruction to the beginning of every kernel function, which NOP
  81           sequence is then dynamically patched into a tracer call when
  82           tracing is enabled by the administrator. If it's runtime disabled
  83           (the bootup default), then the overhead of the instructions is very
  84           small and not measurable even in micro-benchmarks.
  85
  86 config FUNCTION_GRAPH_TRACER
  87         bool "Kernel Function Graph Tracer"
  88         depends on HAVE_FUNCTION_GRAPH_TRACER
  89         depends on FUNCTION_TRACER
  90         default y
  91         help
  92           Enable the kernel to trace a function at both its return
  93           and its entry.
  94           It's first purpose is to trace the duration of functions and
  95           draw a call graph for each thread with some informations like
  96           the return value.
  97           This is done by setting the current return address on the current
  98           task structure into a stack of calls.
  99
 100 config TRACE_BPRINTK
 101         bool "Binary printk for tracing"
 102         default y
 103         depends on TRACING
 104         select BINARY_PRINTF
 105
 106 config IRQSOFF_TRACER
 107         bool "Interrupts-off Latency Tracer"
 108         default n
 109         depends on TRACE_IRQFLAGS_SUPPORT
 110         depends on GENERIC_TIME
 111         select TRACE_IRQFLAGS
 112         select TRACING
 113         select TRACER_MAX_TRACE
 114         help
 115           This option measures the time spent in irqs-off critical
 116           sections, with microsecond accuracy.
 117
 118           The default measurement method is a maximum search, which is
 119           disabled by default and can be runtime (re-)started
 120           via:
 121
 122               echo 0 > /debugfs/tracing/tracing_max_latency
 123
 124           (Note that kernel size and overhead increases with this option
 125           enabled. This option and the preempt-off timing option can be
 126           used together or separately.)
 127
 128 config PREEMPT_TRACER
 129         bool "Preemption-off Latency Tracer"
 130         default n
 131         depends on GENERIC_TIME
 132         depends on PREEMPT
 133         select TRACING
 134         select TRACER_MAX_TRACE
 135         help
 136           This option measures the time spent in preemption off critical
 137           sections, with microsecond accuracy.
 138
 139           The default measurement method is a maximum search, which is
 140           disabled by default and can be runtime (re-)started
 141           via:
 142
 143               echo 0 > /debugfs/tracing/tracing_max_latency
 144
 145           (Note that kernel size and overhead increases with this option
 146           enabled. This option and the irqs-off timing option can be
 147           used together or separately.)
 148
 149 config SYSPROF_TRACER
 150         bool "Sysprof Tracer"
 151         depends on X86
 152         select TRACING
 153         select CONTEXT_SWITCH_TRACER
 154         help
 155           This tracer provides the trace needed by the 'Sysprof' userspace
 156           tool.
 157
 158 config SCHED_TRACER
 159         bool "Scheduling Latency Tracer"
 160         select TRACING
 161         select CONTEXT_SWITCH_TRACER
 162         select TRACER_MAX_TRACE
 163         help
 164           This tracer tracks the latency of the highest priority task
 165           to be scheduled in, starting from the point it has woken up.
 166
 167 config CONTEXT_SWITCH_TRACER
 168         bool "Trace process context switches"
 169         select TRACING
 170         select MARKERS
 171         help
 172           This tracer gets called from the context switch and records
 173           all switching of tasks.
 174
 175 config EVENT_TRACER
 176         bool "Trace various events in the kernel"
 177         select TRACING
 178         help
 179           This tracer hooks to various trace points in the kernel
 180           allowing the user to pick and choose which trace point they
 181           want to trace.
 182
 183 config BOOT_TRACER
 184         bool "Trace boot initcalls"
 185         select TRACING
 186         select CONTEXT_SWITCH_TRACER
 187         help
 188           This tracer helps developers to optimize boot times: it records
 189           the timings of the initcalls and traces key events and the identity
 190           of tasks that can cause boot delays, such as context-switches.
 191
 192           Its aim is to be parsed by the /scripts/bootgraph.pl tool to
 193           produce pretty graphics about boot inefficiencies, giving a visual
 194           representation of the delays during initcalls - but the raw
 195           /debug/tracing/trace text output is readable too.
 196
 197           You must pass in ftrace=initcall to the kernel command line
 198           to enable this on bootup.
 199
 200 config TRACE_BRANCH_PROFILING
 201         bool "Trace likely/unlikely profiler"
 202         select TRACING
 203         help
 204           This tracer profiles all the the likely and unlikely macros
 205           in the kernel. It will display the results in:
 206
 207           /debugfs/tracing/profile_annotated_branch
 208
 209           Note: this will add a significant overhead, only turn this
 210           on if you need to profile the system's use of these macros.
 211
 212           Say N if unsure.
 213
 214 config PROFILE_ALL_BRANCHES
 215         bool "Profile all if conditionals"
 216         depends on TRACE_BRANCH_PROFILING
 217         help
 218           This tracer profiles all branch conditions. Every if ()
 219           taken in the kernel is recorded whether it hit or miss.
 220           The results will be displayed in:
 221
 222           /debugfs/tracing/profile_branch
 223
 224           This configuration, when enabled, will impose a great overhead
 225           on the system. This should only be enabled when the system
 226           is to be analyzed
 227
 228           Say N if unsure.
 229
 230 config TRACING_BRANCHES
 231         bool
 232         help
 233           Selected by tracers that will trace the likely and unlikely
 234           conditions. This prevents the tracers themselves from being
 235           profiled. Profiling the tracing infrastructure can only happen
 236           when the likelys and unlikelys are not being traced.
 237
 238 config BRANCH_TRACER
 239         bool "Trace likely/unlikely instances"
 240         depends on TRACE_BRANCH_PROFILING
 241         select TRACING_BRANCHES
 242         help
 243           This traces the events of likely and unlikely condition
 244           calls in the kernel.  The difference between this and the
 245           "Trace likely/unlikely profiler" is that this is not a
 246           histogram of the callers, but actually places the calling
 247           events into a running trace buffer to see when and where the
 248           events happened, as well as their results.
 249
 250           Say N if unsure.
 251
 252 config POWER_TRACER
 253         bool "Trace power consumption behavior"
 254         depends on X86
 255         select TRACING
 256         help
 257           This tracer helps developers to analyze and optimize the kernels
 258           power management decisions, specifically the C-state and P-state
 259           behavior.
 260
 261
 262 config STACK_TRACER
 263         bool "Trace max stack"
 264         depends on HAVE_FUNCTION_TRACER
 265         select FUNCTION_TRACER
 266         select STACKTRACE
 267         select KALLSYMS
 268         help
 269           This special tracer records the maximum stack footprint of the
 270           kernel and displays it in debugfs/tracing/stack_trace.
 271
 272           This tracer works by hooking into every function call that the
 273           kernel executes, and keeping a maximum stack depth value and
 274           stack-trace saved.  If this is configured with DYNAMIC_FTRACE
 275           then it will not have any overhead while the stack tracer
 276           is disabled.
 277
 278           To enable the stack tracer on bootup, pass in 'stacktrace'
 279           on the kernel command line.
 280
 281           The stack tracer can also be enabled or disabled via the
 282           sysctl kernel.stack_tracer_enabled
 283
 284           Say N if unsure.
 285
 286 config HW_BRANCH_TRACER
 287         depends on HAVE_HW_BRANCH_TRACER
 288         bool "Trace hw branches"
 289         select TRACING
 290         help
 291           This tracer records all branches on the system in a circular
 292           buffer giving access to the last N branches for each cpu.
 293
 294 config KMEMTRACE
 295         bool "Trace SLAB allocations"
 296         select TRACING
 297         help
 298           kmemtrace provides tracing for slab allocator functions, such as
 299           kmalloc, kfree, kmem_cache_alloc, kmem_cache_free etc.. Collected
 300           data is then fed to the userspace application in order to analyse
 301           allocation hotspots, internal fragmentation and so on, making it
 302           possible to see how well an allocator performs, as well as debug
 303           and profile kernel code.
 304
 305           This requires an userspace application to use. See
 306           Documentation/vm/kmemtrace.txt for more information.
 307
 308           Saying Y will make the kernel somewhat larger and slower. However,
 309           if you disable kmemtrace at run-time or boot-time, the performance
 310           impact is minimal (depending on the arch the kernel is built for).
 311
 312           If unsure, say N.
 313
 314 config WORKQUEUE_TRACER
 315         bool "Trace workqueues"
 316         select TRACING
 317         help
 318           The workqueue tracer provides some statistical informations
 319           about each cpu workqueue thread such as the number of the
 320           works inserted and executed since their creation. It can help
 321           to evaluate the amount of work each of them have to perform.
 322           For example it can help a developer to decide whether he should
 323           choose a per cpu workqueue instead of a singlethreaded one.
 324
 325 config BLK_DEV_IO_TRACE
 326         bool "Support for tracing block io actions"
 327         depends on SYSFS
 328         depends on BLOCK
 329         select RELAY
 330         select DEBUG_FS
 331         select TRACEPOINTS
 332         select TRACING
 333         select STACKTRACE
 334         help
 335           Say Y here if you want to be able to trace the block layer actions
 336           on a given queue. Tracing allows you to see any traffic happening
 337           on a block device queue. For more information (and the userspace
 338           support tools needed), fetch the blktrace tools from:
 339
 340           git://git.kernel.dk/blktrace.git
 341
 342           Tracing also is possible using the ftrace interface, e.g.:
 343
 344             echo 1 > /sys/block/sda/sda1/trace/enable
 345             echo blk > /sys/kernel/debug/tracing/current_tracer
 346             cat /sys/kernel/debug/tracing/trace_pipe
 347
 348           If unsure, say N.
 349
 350 config DYNAMIC_FTRACE
 351         bool "enable/disable ftrace tracepoints dynamically"
 352         depends on FUNCTION_TRACER
 353         depends on HAVE_DYNAMIC_FTRACE
 354         default y
 355         help
 356          This option will modify all the calls to ftrace dynamically
 357          (will patch them out of the binary image and replaces them
 358          with a No-Op instruction) as they are called. A table is
 359          created to dynamically enable them again.
 360
 361          This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but otherwise
 362          has native performance as long as no tracing is active.
 363
 364          The changes to the code are done by a kernel thread that
 365          wakes up once a second and checks to see if any ftrace calls
 366          were made. If so, it runs stop_machine (stops all CPUS)
 367          and modifies the code to jump over the call to ftrace.
 368
 369 config FTRACE_MCOUNT_RECORD
 370         def_bool y
 371         depends on DYNAMIC_FTRACE
 372         depends on HAVE_FTRACE_MCOUNT_RECORD
 373
 374 config FTRACE_SELFTEST
 375         bool
 376
 377 config FTRACE_STARTUP_TEST
 378         bool "Perform a startup test on ftrace"
 379         depends on TRACING
 380         select FTRACE_SELFTEST
 381         help
 382           This option performs a series of startup tests on ftrace. On bootup
 383           a series of tests are made to verify that the tracer is
 384           functioning properly. It will do tests on all the configured
 385           tracers of ftrace.
 386
 387 config MMIOTRACE
 388         bool "Memory mapped IO tracing"
 389         depends on HAVE_MMIOTRACE_SUPPORT && PCI
 390         select TRACING
 391         help
 392           Mmiotrace traces Memory Mapped I/O access and is meant for
 393           debugging and reverse engineering. It is called from the ioremap
 394           implementation and works via page faults. Tracing is disabled by
 395           default and can be enabled at run-time.
 396
 397           See Documentation/tracers/mmiotrace.txt.
 398           If you are not helping to develop drivers, say N.
 399
 400 config MMIOTRACE_TEST
 401         tristate "Test module for mmiotrace"
 402         depends on MMIOTRACE && m
 403         help
 404           This is a dumb module for testing mmiotrace. It is very dangerous
 405           as it will write garbage to IO memory starting at a given address.
 406           However, it should be safe to use on e.g. unused portion of VRAM.
 407
 408           Say N, unless you absolutely know what you are doing.
 409
 410 endmenu
 411
 412 endif # TRACING_SUPPORT
 413