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