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