1# SPDX-License-Identifier: GPL-2.0-only
  2#
  3# Architectures that offer an FUNCTION_TRACER implementation should
  4#  select HAVE_FUNCTION_TRACER:
  5#
  6
  7config USER_STACKTRACE_SUPPORT
  8	bool
  9
 10config NOP_TRACER
 11	bool
 12
 13config HAVE_FTRACE_NMI_ENTER
 14	bool
 15	help
 16	  See Documentation/trace/ftrace-design.rst
 17
 18config HAVE_FUNCTION_TRACER
 19	bool
 20	help
 21	  See Documentation/trace/ftrace-design.rst
 22
 23config HAVE_FUNCTION_GRAPH_TRACER
 24	bool
 25	help
 26	  See Documentation/trace/ftrace-design.rst
 27
 28config HAVE_DYNAMIC_FTRACE
 29	bool
 30	help
 31	  See Documentation/trace/ftrace-design.rst
 32
 33config HAVE_DYNAMIC_FTRACE_WITH_REGS
 34	bool
 35
 36config HAVE_FTRACE_MCOUNT_RECORD
 37	bool
 38	help
 39	  See Documentation/trace/ftrace-design.rst
 40
 41config HAVE_SYSCALL_TRACEPOINTS
 42	bool
 43	help
 44	  See Documentation/trace/ftrace-design.rst
 45
 46config HAVE_FENTRY
 47	bool
 48	help
 49	  Arch supports the gcc options -pg with -mfentry
 50
 51config HAVE_NOP_MCOUNT
 52	bool
 53	help
 54	  Arch supports the gcc options -pg with -mrecord-mcount and -nop-mcount
 55
 56config HAVE_C_RECORDMCOUNT
 57	bool
 58	help
 59	  C version of recordmcount available?
 60
 61config TRACER_MAX_TRACE
 62	bool
 63
 64config TRACE_CLOCK
 65	bool
 66
 67config RING_BUFFER
 68	bool
 69	select TRACE_CLOCK
 70	select IRQ_WORK
 71
 72config FTRACE_NMI_ENTER
 73       bool
 74       depends on HAVE_FTRACE_NMI_ENTER
 75       default y
 76
 77config EVENT_TRACING
 78	select CONTEXT_SWITCH_TRACER
 79        select GLOB
 80	bool
 81
 82config CONTEXT_SWITCH_TRACER
 83	bool
 84
 85config RING_BUFFER_ALLOW_SWAP
 86	bool
 87	help
 88	 Allow the use of ring_buffer_swap_cpu.
 89	 Adds a very slight overhead to tracing when enabled.
 90
 91config PREEMPTIRQ_TRACEPOINTS
 92	bool
 93	depends on TRACE_PREEMPT_TOGGLE || TRACE_IRQFLAGS
 94	select TRACING
 95	default y
 96	help
 97	  Create preempt/irq toggle tracepoints if needed, so that other parts
 98	  of the kernel can use them to generate or add hooks to them.
 99
100# All tracer options should select GENERIC_TRACER. For those options that are
101# enabled by all tracers (context switch and event tracer) they select TRACING.
102# This allows those options to appear when no other tracer is selected. But the
103# options do not appear when something else selects it. We need the two options
104# GENERIC_TRACER and TRACING to avoid circular dependencies to accomplish the
105# hiding of the automatic options.
106
107config TRACING
108	bool
109	select DEBUG_FS
110	select RING_BUFFER
111	select STACKTRACE if STACKTRACE_SUPPORT
112	select TRACEPOINTS
113	select NOP_TRACER
114	select BINARY_PRINTF
115	select EVENT_TRACING
116	select TRACE_CLOCK
117
118config GENERIC_TRACER
119	bool
120	select TRACING
121
122#
123# Minimum requirements an architecture has to meet for us to
124# be able to offer generic tracing facilities:
125#
126config TRACING_SUPPORT
127	bool
128	depends on TRACE_IRQFLAGS_SUPPORT
 
 
 
 
129	depends on STACKTRACE_SUPPORT
130	default y
131
132if TRACING_SUPPORT
133
134menuconfig FTRACE
135	bool "Tracers"
136	default y if DEBUG_KERNEL
137	help
138	  Enable the kernel tracing infrastructure.
139
140if FTRACE
141
142config FUNCTION_TRACER
143	bool "Kernel Function Tracer"
144	depends on HAVE_FUNCTION_TRACER
145	select KALLSYMS
146	select GENERIC_TRACER
147	select CONTEXT_SWITCH_TRACER
148	select GLOB
149	select TASKS_RCU if PREEMPTION
150	help
151	  Enable the kernel to trace every kernel function. This is done
152	  by using a compiler feature to insert a small, 5-byte No-Operation
153	  instruction at the beginning of every kernel function, which NOP
154	  sequence is then dynamically patched into a tracer call when
155	  tracing is enabled by the administrator. If it's runtime disabled
156	  (the bootup default), then the overhead of the instructions is very
157	  small and not measurable even in micro-benchmarks.
158
159config FUNCTION_GRAPH_TRACER
160	bool "Kernel Function Graph Tracer"
161	depends on HAVE_FUNCTION_GRAPH_TRACER
162	depends on FUNCTION_TRACER
163	depends on !X86_32 || !CC_OPTIMIZE_FOR_SIZE
164	default y
165	help
166	  Enable the kernel to trace a function at both its return
167	  and its entry.
168	  Its first purpose is to trace the duration of functions and
169	  draw a call graph for each thread with some information like
170	  the return value. This is done by setting the current return
171	  address on the current task structure into a stack of calls.
172
173config TRACE_PREEMPT_TOGGLE
174	bool
175	help
176	  Enables hooks which will be called when preemption is first disabled,
177	  and last enabled.
178
179config PREEMPTIRQ_EVENTS
180	bool "Enable trace events for preempt and irq disable/enable"
181	select TRACE_IRQFLAGS
182	select TRACE_PREEMPT_TOGGLE if PREEMPTION
183	select GENERIC_TRACER
184	default n
185	help
186	  Enable tracing of disable and enable events for preemption and irqs.
 
 
 
187
188config IRQSOFF_TRACER
189	bool "Interrupts-off Latency Tracer"
190	default n
191	depends on TRACE_IRQFLAGS_SUPPORT
192	depends on !ARCH_USES_GETTIMEOFFSET
193	select TRACE_IRQFLAGS
194	select GENERIC_TRACER
195	select TRACER_MAX_TRACE
196	select RING_BUFFER_ALLOW_SWAP
197	select TRACER_SNAPSHOT
198	select TRACER_SNAPSHOT_PER_CPU_SWAP
199	help
200	  This option measures the time spent in irqs-off critical
201	  sections, with microsecond accuracy.
202
203	  The default measurement method is a maximum search, which is
204	  disabled by default and can be runtime (re-)started
205	  via:
206
207	      echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
208
209	  (Note that kernel size and overhead increase with this option
210	  enabled. This option and the preempt-off timing option can be
211	  used together or separately.)
212
213config PREEMPT_TRACER
214	bool "Preemption-off Latency Tracer"
215	default n
216	depends on !ARCH_USES_GETTIMEOFFSET
217	depends on PREEMPTION
218	select GENERIC_TRACER
219	select TRACER_MAX_TRACE
220	select RING_BUFFER_ALLOW_SWAP
221	select TRACER_SNAPSHOT
222	select TRACER_SNAPSHOT_PER_CPU_SWAP
223	select TRACE_PREEMPT_TOGGLE
224	help
225	  This option measures the time spent in preemption-off critical
226	  sections, with microsecond accuracy.
227
228	  The default measurement method is a maximum search, which is
229	  disabled by default and can be runtime (re-)started
230	  via:
231
232	      echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
233
234	  (Note that kernel size and overhead increase with this option
235	  enabled. This option and the irqs-off timing option can be
236	  used together or separately.)
237
238config SCHED_TRACER
239	bool "Scheduling Latency Tracer"
240	select GENERIC_TRACER
241	select CONTEXT_SWITCH_TRACER
242	select TRACER_MAX_TRACE
243	select TRACER_SNAPSHOT
244	help
245	  This tracer tracks the latency of the highest priority task
246	  to be scheduled in, starting from the point it has woken up.
247
248config HWLAT_TRACER
249	bool "Tracer to detect hardware latencies (like SMIs)"
250	select GENERIC_TRACER
251	help
252	 This tracer, when enabled will create one or more kernel threads,
253	 depending on what the cpumask file is set to, which each thread
254	 spinning in a loop looking for interruptions caused by
255	 something other than the kernel. For example, if a
256	 System Management Interrupt (SMI) takes a noticeable amount of
257	 time, this tracer will detect it. This is useful for testing
258	 if a system is reliable for Real Time tasks.
259
260	 Some files are created in the tracing directory when this
261	 is enabled:
262
263	   hwlat_detector/width   - time in usecs for how long to spin for
264	   hwlat_detector/window  - time in usecs between the start of each
265				     iteration
266
267	 A kernel thread is created that will spin with interrupts disabled
268	 for "width" microseconds in every "window" cycle. It will not spin
269	 for "window - width" microseconds, where the system can
270	 continue to operate.
271
272	 The output will appear in the trace and trace_pipe files.
273
274	 When the tracer is not running, it has no affect on the system,
275	 but when it is running, it can cause the system to be
276	 periodically non responsive. Do not run this tracer on a
277	 production system.
278
279	 To enable this tracer, echo in "hwlat" into the current_tracer
280	 file. Every time a latency is greater than tracing_thresh, it will
281	 be recorded into the ring buffer.
282
283config ENABLE_DEFAULT_TRACERS
284	bool "Trace process context switches and events"
285	depends on !GENERIC_TRACER
286	select TRACING
287	help
288	  This tracer hooks to various trace points in the kernel,
289	  allowing the user to pick and choose which trace point they
290	  want to trace. It also includes the sched_switch tracer plugin.
291
292config FTRACE_SYSCALLS
293	bool "Trace syscalls"
294	depends on HAVE_SYSCALL_TRACEPOINTS
295	select GENERIC_TRACER
296	select KALLSYMS
297	help
298	  Basic tracer to catch the syscall entry and exit events.
299
300config TRACER_SNAPSHOT
301	bool "Create a snapshot trace buffer"
302	select TRACER_MAX_TRACE
303	help
304	  Allow tracing users to take snapshot of the current buffer using the
305	  ftrace interface, e.g.:
306
307	      echo 1 > /sys/kernel/debug/tracing/snapshot
308	      cat snapshot
309
310config TRACER_SNAPSHOT_PER_CPU_SWAP
311        bool "Allow snapshot to swap per CPU"
312	depends on TRACER_SNAPSHOT
313	select RING_BUFFER_ALLOW_SWAP
314	help
315	  Allow doing a snapshot of a single CPU buffer instead of a
316	  full swap (all buffers). If this is set, then the following is
317	  allowed:
318
319	      echo 1 > /sys/kernel/debug/tracing/per_cpu/cpu2/snapshot
320
321	  After which, only the tracing buffer for CPU 2 was swapped with
322	  the main tracing buffer, and the other CPU buffers remain the same.
323
324	  When this is enabled, this adds a little more overhead to the
325	  trace recording, as it needs to add some checks to synchronize
326	  recording with swaps. But this does not affect the performance
327	  of the overall system. This is enabled by default when the preempt
328	  or irq latency tracers are enabled, as those need to swap as well
329	  and already adds the overhead (plus a lot more).
330
331config TRACE_BRANCH_PROFILING
332	bool
333	select GENERIC_TRACER
334
335choice
336	prompt "Branch Profiling"
337	default BRANCH_PROFILE_NONE
338	help
339	 The branch profiling is a software profiler. It will add hooks
340	 into the C conditionals to test which path a branch takes.
341
342	 The likely/unlikely profiler only looks at the conditions that
343	 are annotated with a likely or unlikely macro.
344
345	 The "all branch" profiler will profile every if-statement in the
346	 kernel. This profiler will also enable the likely/unlikely
347	 profiler.
348
349	 Either of the above profilers adds a bit of overhead to the system.
350	 If unsure, choose "No branch profiling".
351
352config BRANCH_PROFILE_NONE
353	bool "No branch profiling"
354	help
355	  No branch profiling. Branch profiling adds a bit of overhead.
356	  Only enable it if you want to analyse the branching behavior.
357	  Otherwise keep it disabled.
358
359config PROFILE_ANNOTATED_BRANCHES
360	bool "Trace likely/unlikely profiler"
361	select TRACE_BRANCH_PROFILING
362	help
363	  This tracer profiles all likely and unlikely macros
364	  in the kernel. It will display the results in:
365
366	  /sys/kernel/debug/tracing/trace_stat/branch_annotated
367
368	  Note: this will add a significant overhead; only turn this
369	  on if you need to profile the system's use of these macros.
370
371config PROFILE_ALL_BRANCHES
372	bool "Profile all if conditionals" if !FORTIFY_SOURCE
373	select TRACE_BRANCH_PROFILING
374	imply CC_DISABLE_WARN_MAYBE_UNINITIALIZED  # avoid false positives
375	help
376	  This tracer profiles all branch conditions. Every if ()
377	  taken in the kernel is recorded whether it hit or miss.
378	  The results will be displayed in:
379
380	  /sys/kernel/debug/tracing/trace_stat/branch_all
381
382	  This option also enables the likely/unlikely profiler.
383
384	  This configuration, when enabled, will impose a great overhead
385	  on the system. This should only be enabled when the system
386	  is to be analyzed in much detail.
387endchoice
388
389config TRACING_BRANCHES
390	bool
391	help
392	  Selected by tracers that will trace the likely and unlikely
393	  conditions. This prevents the tracers themselves from being
394	  profiled. Profiling the tracing infrastructure can only happen
395	  when the likelys and unlikelys are not being traced.
396
397config BRANCH_TRACER
398	bool "Trace likely/unlikely instances"
399	depends on TRACE_BRANCH_PROFILING
400	select TRACING_BRANCHES
401	help
402	  This traces the events of likely and unlikely condition
403	  calls in the kernel.  The difference between this and the
404	  "Trace likely/unlikely profiler" is that this is not a
405	  histogram of the callers, but actually places the calling
406	  events into a running trace buffer to see when and where the
407	  events happened, as well as their results.
408
409	  Say N if unsure.
410
411config STACK_TRACER
412	bool "Trace max stack"
413	depends on HAVE_FUNCTION_TRACER
414	select FUNCTION_TRACER
415	select STACKTRACE
416	select KALLSYMS
417	help
418	  This special tracer records the maximum stack footprint of the
419	  kernel and displays it in /sys/kernel/debug/tracing/stack_trace.
420
421	  This tracer works by hooking into every function call that the
422	  kernel executes, and keeping a maximum stack depth value and
423	  stack-trace saved.  If this is configured with DYNAMIC_FTRACE
424	  then it will not have any overhead while the stack tracer
425	  is disabled.
426
427	  To enable the stack tracer on bootup, pass in 'stacktrace'
428	  on the kernel command line.
429
430	  The stack tracer can also be enabled or disabled via the
431	  sysctl kernel.stack_tracer_enabled
432
433	  Say N if unsure.
434
435config BLK_DEV_IO_TRACE
436	bool "Support for tracing block IO actions"
437	depends on SYSFS
438	depends on BLOCK
439	select RELAY
440	select DEBUG_FS
441	select TRACEPOINTS
442	select GENERIC_TRACER
443	select STACKTRACE
444	help
445	  Say Y here if you want to be able to trace the block layer actions
446	  on a given queue. Tracing allows you to see any traffic happening
447	  on a block device queue. For more information (and the userspace
448	  support tools needed), fetch the blktrace tools from:
449
450	  git://git.kernel.dk/blktrace.git
451
452	  Tracing also is possible using the ftrace interface, e.g.:
453
454	    echo 1 > /sys/block/sda/sda1/trace/enable
455	    echo blk > /sys/kernel/debug/tracing/current_tracer
456	    cat /sys/kernel/debug/tracing/trace_pipe
457
458	  If unsure, say N.
459
460config KPROBE_EVENTS
461	depends on KPROBES
462	depends on HAVE_REGS_AND_STACK_ACCESS_API
463	bool "Enable kprobes-based dynamic events"
464	select TRACING
465	select PROBE_EVENTS
466	select DYNAMIC_EVENTS
467	default y
468	help
469	  This allows the user to add tracing events (similar to tracepoints)
470	  on the fly via the ftrace interface. See
471	  Documentation/trace/kprobetrace.rst for more details.
472
473	  Those events can be inserted wherever kprobes can probe, and record
474	  various register and memory values.
475
476	  This option is also required by perf-probe subcommand of perf tools.
477	  If you want to use perf tools, this option is strongly recommended.
478
479config KPROBE_EVENTS_ON_NOTRACE
480	bool "Do NOT protect notrace function from kprobe events"
481	depends on KPROBE_EVENTS
482	depends on KPROBES_ON_FTRACE
483	default n
484	help
485	  This is only for the developers who want to debug ftrace itself
486	  using kprobe events.
487
488	  If kprobes can use ftrace instead of breakpoint, ftrace related
489	  functions are protected from kprobe-events to prevent an infinit
490	  recursion or any unexpected execution path which leads to a kernel
491	  crash.
492
493	  This option disables such protection and allows you to put kprobe
494	  events on ftrace functions for debugging ftrace by itself.
495	  Note that this might let you shoot yourself in the foot.
496
497	  If unsure, say N.
498
499config UPROBE_EVENTS
500	bool "Enable uprobes-based dynamic events"
501	depends on ARCH_SUPPORTS_UPROBES
502	depends on MMU
503	depends on PERF_EVENTS
504	select UPROBES
505	select PROBE_EVENTS
506	select DYNAMIC_EVENTS
507	select TRACING
508	default y
509	help
510	  This allows the user to add tracing events on top of userspace
511	  dynamic events (similar to tracepoints) on the fly via the trace
512	  events interface. Those events can be inserted wherever uprobes
513	  can probe, and record various registers.
514	  This option is required if you plan to use perf-probe subcommand
515	  of perf tools on user space applications.
516
517config BPF_EVENTS
518	depends on BPF_SYSCALL
519	depends on (KPROBE_EVENTS || UPROBE_EVENTS) && PERF_EVENTS
520	bool
521	default y
522	help
523	  This allows the user to attach BPF programs to kprobe, uprobe, and
524	  tracepoint events.
525
526config DYNAMIC_EVENTS
527	def_bool n
528
529config PROBE_EVENTS
530	def_bool n
531
532config DYNAMIC_FTRACE
533	bool "enable/disable function tracing dynamically"
534	depends on FUNCTION_TRACER
535	depends on HAVE_DYNAMIC_FTRACE
536	default y
537	help
538	  This option will modify all the calls to function tracing
539	  dynamically (will patch them out of the binary image and
540	  replace them with a No-Op instruction) on boot up. During
541	  compile time, a table is made of all the locations that ftrace
542	  can function trace, and this table is linked into the kernel
543	  image. When this is enabled, functions can be individually
544	  enabled, and the functions not enabled will not affect
545	  performance of the system.
546
547	  See the files in /sys/kernel/debug/tracing:
548	    available_filter_functions
549	    set_ftrace_filter
550	    set_ftrace_notrace
551
552	  This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but
553	  otherwise has native performance as long as no tracing is active.
554
555config DYNAMIC_FTRACE_WITH_REGS
556	def_bool y
557	depends on DYNAMIC_FTRACE
558	depends on HAVE_DYNAMIC_FTRACE_WITH_REGS
559
560config FUNCTION_PROFILER
561	bool "Kernel function profiler"
562	depends on FUNCTION_TRACER
563	default n
564	help
565	  This option enables the kernel function profiler. A file is created
566	  in debugfs called function_profile_enabled which defaults to zero.
567	  When a 1 is echoed into this file profiling begins, and when a
568	  zero is entered, profiling stops. A "functions" file is created in
569	  the trace_stat directory; this file shows the list of functions that
570	  have been hit and their counters.
571
572	  If in doubt, say N.
573
574config BPF_KPROBE_OVERRIDE
575	bool "Enable BPF programs to override a kprobed function"
576	depends on BPF_EVENTS
577	depends on FUNCTION_ERROR_INJECTION
578	default n
579	help
580	 Allows BPF to override the execution of a probed function and
581	 set a different return value.  This is used for error injection.
582
583config FTRACE_MCOUNT_RECORD
584	def_bool y
585	depends on DYNAMIC_FTRACE
586	depends on HAVE_FTRACE_MCOUNT_RECORD
587
588config FTRACE_SELFTEST
589	bool
590
591config FTRACE_STARTUP_TEST
592	bool "Perform a startup test on ftrace"
593	depends on GENERIC_TRACER
594	select FTRACE_SELFTEST
595	help
596	  This option performs a series of startup tests on ftrace. On bootup
597	  a series of tests are made to verify that the tracer is
598	  functioning properly. It will do tests on all the configured
599	  tracers of ftrace.
600
601config EVENT_TRACE_STARTUP_TEST
602	bool "Run selftest on trace events"
603	depends on FTRACE_STARTUP_TEST
604	default y
605	help
606	  This option performs a test on all trace events in the system.
607	  It basically just enables each event and runs some code that
608	  will trigger events (not necessarily the event it enables)
609	  This may take some time run as there are a lot of events.
610
611config EVENT_TRACE_TEST_SYSCALLS
612	bool "Run selftest on syscall events"
613	depends on EVENT_TRACE_STARTUP_TEST
614	help
615	 This option will also enable testing every syscall event.
616	 It only enables the event and disables it and runs various loads
617	 with the event enabled. This adds a bit more time for kernel boot
618	 up since it runs this on every system call defined.
619
620	 TBD - enable a way to actually call the syscalls as we test their
621	       events
622
623config MMIOTRACE
624	bool "Memory mapped IO tracing"
625	depends on HAVE_MMIOTRACE_SUPPORT && PCI
626	select GENERIC_TRACER
627	help
628	  Mmiotrace traces Memory Mapped I/O access and is meant for
629	  debugging and reverse engineering. It is called from the ioremap
630	  implementation and works via page faults. Tracing is disabled by
631	  default and can be enabled at run-time.
632
633	  See Documentation/trace/mmiotrace.rst.
634	  If you are not helping to develop drivers, say N.
635
636config TRACING_MAP
637	bool
638	depends on ARCH_HAVE_NMI_SAFE_CMPXCHG
639	help
640	  tracing_map is a special-purpose lock-free map for tracing,
641	  separated out as a stand-alone facility in order to allow it
642	  to be shared between multiple tracers.  It isn't meant to be
643	  generally used outside of that context, and is normally
644	  selected by tracers that use it.
645
646config HIST_TRIGGERS
647	bool "Histogram triggers"
648	depends on ARCH_HAVE_NMI_SAFE_CMPXCHG
649	select TRACING_MAP
650	select TRACING
651	select DYNAMIC_EVENTS
652	default n
653	help
654	  Hist triggers allow one or more arbitrary trace event fields
655	  to be aggregated into hash tables and dumped to stdout by
656	  reading a debugfs/tracefs file.  They're useful for
657	  gathering quick and dirty (though precise) summaries of
658	  event activity as an initial guide for further investigation
659	  using more advanced tools.
660
661	  Inter-event tracing of quantities such as latencies is also
662	  supported using hist triggers under this option.
663
664	  See Documentation/trace/histogram.rst.
665	  If in doubt, say N.
666
667config MMIOTRACE_TEST
668	tristate "Test module for mmiotrace"
669	depends on MMIOTRACE && m
670	help
671	  This is a dumb module for testing mmiotrace. It is very dangerous
672	  as it will write garbage to IO memory starting at a given address.
673	  However, it should be safe to use on e.g. unused portion of VRAM.
674
675	  Say N, unless you absolutely know what you are doing.
676
677config TRACEPOINT_BENCHMARK
678        bool "Add tracepoint that benchmarks tracepoints"
679	help
680	 This option creates the tracepoint "benchmark:benchmark_event".
681	 When the tracepoint is enabled, it kicks off a kernel thread that
682	 goes into an infinite loop (calling cond_sched() to let other tasks
683	 run), and calls the tracepoint. Each iteration will record the time
684	 it took to write to the tracepoint and the next iteration that
685	 data will be passed to the tracepoint itself. That is, the tracepoint
686	 will report the time it took to do the previous tracepoint.
687	 The string written to the tracepoint is a static string of 128 bytes
688	 to keep the time the same. The initial string is simply a write of
689	 "START". The second string records the cold cache time of the first
690	 write which is not added to the rest of the calculations.
691
692	 As it is a tight loop, it benchmarks as hot cache. That's fine because
693	 we care most about hot paths that are probably in cache already.
694
695	 An example of the output:
696
697	      START
698	      first=3672 [COLD CACHED]
699	      last=632 first=3672 max=632 min=632 avg=316 std=446 std^2=199712
700	      last=278 first=3672 max=632 min=278 avg=303 std=316 std^2=100337
701	      last=277 first=3672 max=632 min=277 avg=296 std=258 std^2=67064
702	      last=273 first=3672 max=632 min=273 avg=292 std=224 std^2=50411
703	      last=273 first=3672 max=632 min=273 avg=288 std=200 std^2=40389
704	      last=281 first=3672 max=632 min=273 avg=287 std=183 std^2=33666
705
706
707config RING_BUFFER_BENCHMARK
708	tristate "Ring buffer benchmark stress tester"
709	depends on RING_BUFFER
710	help
711	  This option creates a test to stress the ring buffer and benchmark it.
712	  It creates its own ring buffer such that it will not interfere with
713	  any other users of the ring buffer (such as ftrace). It then creates
714	  a producer and consumer that will run for 10 seconds and sleep for
715	  10 seconds. Each interval it will print out the number of events
716	  it recorded and give a rough estimate of how long each iteration took.
717
718	  It does not disable interrupts or raise its priority, so it may be
719	  affected by processes that are running.
720
721	  If unsure, say N.
722
723config RING_BUFFER_STARTUP_TEST
724       bool "Ring buffer startup self test"
725       depends on RING_BUFFER
726       help
727         Run a simple self test on the ring buffer on boot up. Late in the
728	 kernel boot sequence, the test will start that kicks off
729	 a thread per cpu. Each thread will write various size events
730	 into the ring buffer. Another thread is created to send IPIs
731	 to each of the threads, where the IPI handler will also write
732	 to the ring buffer, to test/stress the nesting ability.
733	 If any anomalies are discovered, a warning will be displayed
734	 and all ring buffers will be disabled.
735
736	 The test runs for 10 seconds. This will slow your boot time
737	 by at least 10 more seconds.
738
739	 At the end of the test, statics and more checks are done.
740	 It will output the stats of each per cpu buffer. What
741	 was written, the sizes, what was read, what was lost, and
742	 other similar details.
743
744	 If unsure, say N
745
746config PREEMPTIRQ_DELAY_TEST
747	tristate "Preempt / IRQ disable delay thread to test latency tracers"
748	depends on m
749	help
750	  Select this option to build a test module that can help test latency
751	  tracers by executing a preempt or irq disable section with a user
752	  configurable delay. The module busy waits for the duration of the
753	  critical section.
754
755	  For example, the following invocation forces a one-time irq-disabled
756	  critical section for 500us:
757	  modprobe preemptirq_delay_test test_mode=irq delay=500000
758
759	  If unsure, say N
760
761config TRACE_EVAL_MAP_FILE
762       bool "Show eval mappings for trace events"
763       depends on TRACING
764       help
765	The "print fmt" of the trace events will show the enum/sizeof names
766	instead	of their values. This can cause problems for user space tools
767	that use this string to parse the raw data as user space does not know
768	how to convert the string to its value.
769
770	To fix this, there's a special macro in the kernel that can be used
771	to convert an enum/sizeof into its value. If this macro is used, then
772	the print fmt strings will be converted to their values.
773
774	If something does not get converted properly, this option can be
775	used to show what enums/sizeof the kernel tried to convert.
776
777	This option is for debugging the conversions. A file is created
778	in the tracing directory called "eval_map" that will show the
779	names matched with their values and what trace event system they
780	belong too.
781
782	Normally, the mapping of the strings to values will be freed after
783	boot up or module load. With this option, they will not be freed, as
784	they are needed for the "eval_map" file. Enabling this option will
785	increase the memory footprint of the running kernel.
786
787	If unsure, say N
788
789config GCOV_PROFILE_FTRACE
790	bool "Enable GCOV profiling on ftrace subsystem"
791	depends on GCOV_KERNEL
 
792	help
793	  Enable GCOV profiling on ftrace subsystem for checking
794	  which functions/lines are tested.
795
796	  If unsure, say N.
797
798	  Note that on a kernel compiled with this config, ftrace will
799	  run significantly slower.
800
801endif # FTRACE
802
803endif # TRACING_SUPPORT
804

 
  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_DYNAMIC_FTRACE
 28	bool
 29	help
 30	  See Documentation/trace/ftrace-design.txt
 31
 32config HAVE_DYNAMIC_FTRACE_WITH_REGS
 33	bool
 34
 35config HAVE_FTRACE_MCOUNT_RECORD
 36	bool
 37	help
 38	  See Documentation/trace/ftrace-design.txt
 39
 40config HAVE_SYSCALL_TRACEPOINTS
 41	bool
 42	help
 43	  See Documentation/trace/ftrace-design.txt
 44
 45config HAVE_FENTRY
 46	bool
 47	help
 48	  Arch supports the gcc options -pg with -mfentry
 49
 
 
 
 
 
 50config HAVE_C_RECORDMCOUNT
 51	bool
 52	help
 53	  C version of recordmcount available?
 54
 55config TRACER_MAX_TRACE
 56	bool
 57
 58config TRACE_CLOCK
 59	bool
 60
 61config RING_BUFFER
 62	bool
 63	select TRACE_CLOCK
 64	select IRQ_WORK
 65
 66config FTRACE_NMI_ENTER
 67       bool
 68       depends on HAVE_FTRACE_NMI_ENTER
 69       default y
 70
 71config EVENT_TRACING
 72	select CONTEXT_SWITCH_TRACER
 73        select GLOB
 74	bool
 75
 76config CONTEXT_SWITCH_TRACER
 77	bool
 78
 79config RING_BUFFER_ALLOW_SWAP
 80	bool
 81	help
 82	 Allow the use of ring_buffer_swap_cpu.
 83	 Adds a very slight overhead to tracing when enabled.
 84
 
 
 
 
 
 
 
 
 
 85# All tracer options should select GENERIC_TRACER. For those options that are
 86# enabled by all tracers (context switch and event tracer) they select TRACING.
 87# This allows those options to appear when no other tracer is selected. But the
 88# options do not appear when something else selects it. We need the two options
 89# GENERIC_TRACER and TRACING to avoid circular dependencies to accomplish the
 90# hiding of the automatic options.
 91
 92config TRACING
 93	bool
 94	select DEBUG_FS
 95	select RING_BUFFER
 96	select STACKTRACE if STACKTRACE_SUPPORT
 97	select TRACEPOINTS
 98	select NOP_TRACER
 99	select BINARY_PRINTF
100	select EVENT_TRACING
101	select TRACE_CLOCK
102
103config GENERIC_TRACER
104	bool
105	select TRACING
106
107#
108# Minimum requirements an architecture has to meet for us to
109# be able to offer generic tracing facilities:
110#
111config TRACING_SUPPORT
112	bool
113	# PPC32 has no irqflags tracing support, but it can use most of the
114	# tracers anyway, they were tested to build and work. Note that new
115	# exceptions to this list aren't welcomed, better implement the
116	# irqflags tracing for your architecture.
117	depends on TRACE_IRQFLAGS_SUPPORT || PPC32
118	depends on STACKTRACE_SUPPORT
119	default y
120
121if TRACING_SUPPORT
122
123menuconfig FTRACE
124	bool "Tracers"
125	default y if DEBUG_KERNEL
126	help
127	  Enable the kernel tracing infrastructure.
128
129if FTRACE
130
131config FUNCTION_TRACER
132	bool "Kernel Function Tracer"
133	depends on HAVE_FUNCTION_TRACER
134	select KALLSYMS
135	select GENERIC_TRACER
136	select CONTEXT_SWITCH_TRACER
137	select GLOB
138	select TASKS_RCU if PREEMPT
139	help
140	  Enable the kernel to trace every kernel function. This is done
141	  by using a compiler feature to insert a small, 5-byte No-Operation
142	  instruction at the beginning of every kernel function, which NOP
143	  sequence is then dynamically patched into a tracer call when
144	  tracing is enabled by the administrator. If it's runtime disabled
145	  (the bootup default), then the overhead of the instructions is very
146	  small and not measurable even in micro-benchmarks.
147
148config FUNCTION_GRAPH_TRACER
149	bool "Kernel Function Graph Tracer"
150	depends on HAVE_FUNCTION_GRAPH_TRACER
151	depends on FUNCTION_TRACER
152	depends on !X86_32 || !CC_OPTIMIZE_FOR_SIZE
153	default y
154	help
155	  Enable the kernel to trace a function at both its return
156	  and its entry.
157	  Its first purpose is to trace the duration of functions and
158	  draw a call graph for each thread with some information like
159	  the return value. This is done by setting the current return
160	  address on the current task structure into a stack of calls.
161
 
 
 
 
 
162
163config PREEMPTIRQ_EVENTS
164	bool "Enable trace events for preempt and irq disable/enable"
165	select TRACE_IRQFLAGS
166	depends on DEBUG_PREEMPT || !PROVE_LOCKING
167	depends on TRACING
168	default n
169	help
170	  Enable tracing of disable and enable events for preemption and irqs.
171	  For tracing preempt disable/enable events, DEBUG_PREEMPT must be
172	  enabled. For tracing irq disable/enable events, PROVE_LOCKING must
173	  be disabled.
174
175config IRQSOFF_TRACER
176	bool "Interrupts-off Latency Tracer"
177	default n
178	depends on TRACE_IRQFLAGS_SUPPORT
179	depends on !ARCH_USES_GETTIMEOFFSET
180	select TRACE_IRQFLAGS
181	select GENERIC_TRACER
182	select TRACER_MAX_TRACE
183	select RING_BUFFER_ALLOW_SWAP
184	select TRACER_SNAPSHOT
185	select TRACER_SNAPSHOT_PER_CPU_SWAP
186	help
187	  This option measures the time spent in irqs-off critical
188	  sections, with microsecond accuracy.
189
190	  The default measurement method is a maximum search, which is
191	  disabled by default and can be runtime (re-)started
192	  via:
193
194	      echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
195
196	  (Note that kernel size and overhead increase with this option
197	  enabled. This option and the preempt-off timing option can be
198	  used together or separately.)
199
200config PREEMPT_TRACER
201	bool "Preemption-off Latency Tracer"
202	default n
203	depends on !ARCH_USES_GETTIMEOFFSET
204	depends on PREEMPT
205	select GENERIC_TRACER
206	select TRACER_MAX_TRACE
207	select RING_BUFFER_ALLOW_SWAP
208	select TRACER_SNAPSHOT
209	select TRACER_SNAPSHOT_PER_CPU_SWAP
 
210	help
211	  This option measures the time spent in preemption-off critical
212	  sections, with microsecond accuracy.
213
214	  The default measurement method is a maximum search, which is
215	  disabled by default and can be runtime (re-)started
216	  via:
217
218	      echo 0 > /sys/kernel/debug/tracing/tracing_max_latency
219
220	  (Note that kernel size and overhead increase with this option
221	  enabled. This option and the irqs-off timing option can be
222	  used together or separately.)
223
224config SCHED_TRACER
225	bool "Scheduling Latency Tracer"
226	select GENERIC_TRACER
227	select CONTEXT_SWITCH_TRACER
228	select TRACER_MAX_TRACE
229	select TRACER_SNAPSHOT
230	help
231	  This tracer tracks the latency of the highest priority task
232	  to be scheduled in, starting from the point it has woken up.
233
234config HWLAT_TRACER
235	bool "Tracer to detect hardware latencies (like SMIs)"
236	select GENERIC_TRACER
237	help
238	 This tracer, when enabled will create one or more kernel threads,
239	 depending on what the cpumask file is set to, which each thread
240	 spinning in a loop looking for interruptions caused by
241	 something other than the kernel. For example, if a
242	 System Management Interrupt (SMI) takes a noticeable amount of
243	 time, this tracer will detect it. This is useful for testing
244	 if a system is reliable for Real Time tasks.
245
246	 Some files are created in the tracing directory when this
247	 is enabled:
248
249	   hwlat_detector/width   - time in usecs for how long to spin for
250	   hwlat_detector/window  - time in usecs between the start of each
251				     iteration
252
253	 A kernel thread is created that will spin with interrupts disabled
254	 for "width" microseconds in every "window" cycle. It will not spin
255	 for "window - width" microseconds, where the system can
256	 continue to operate.
257
258	 The output will appear in the trace and trace_pipe files.
259
260	 When the tracer is not running, it has no affect on the system,
261	 but when it is running, it can cause the system to be
262	 periodically non responsive. Do not run this tracer on a
263	 production system.
264
265	 To enable this tracer, echo in "hwlat" into the current_tracer
266	 file. Every time a latency is greater than tracing_thresh, it will
267	 be recorded into the ring buffer.
268
269config ENABLE_DEFAULT_TRACERS
270	bool "Trace process context switches and events"
271	depends on !GENERIC_TRACER
272	select TRACING
273	help
274	  This tracer hooks to various trace points in the kernel,
275	  allowing the user to pick and choose which trace point they
276	  want to trace. It also includes the sched_switch tracer plugin.
277
278config FTRACE_SYSCALLS
279	bool "Trace syscalls"
280	depends on HAVE_SYSCALL_TRACEPOINTS
281	select GENERIC_TRACER
282	select KALLSYMS
283	help
284	  Basic tracer to catch the syscall entry and exit events.
285
286config TRACER_SNAPSHOT
287	bool "Create a snapshot trace buffer"
288	select TRACER_MAX_TRACE
289	help
290	  Allow tracing users to take snapshot of the current buffer using the
291	  ftrace interface, e.g.:
292
293	      echo 1 > /sys/kernel/debug/tracing/snapshot
294	      cat snapshot
295
296config TRACER_SNAPSHOT_PER_CPU_SWAP
297        bool "Allow snapshot to swap per CPU"
298	depends on TRACER_SNAPSHOT
299	select RING_BUFFER_ALLOW_SWAP
300	help
301	  Allow doing a snapshot of a single CPU buffer instead of a
302	  full swap (all buffers). If this is set, then the following is
303	  allowed:
304
305	      echo 1 > /sys/kernel/debug/tracing/per_cpu/cpu2/snapshot
306
307	  After which, only the tracing buffer for CPU 2 was swapped with
308	  the main tracing buffer, and the other CPU buffers remain the same.
309
310	  When this is enabled, this adds a little more overhead to the
311	  trace recording, as it needs to add some checks to synchronize
312	  recording with swaps. But this does not affect the performance
313	  of the overall system. This is enabled by default when the preempt
314	  or irq latency tracers are enabled, as those need to swap as well
315	  and already adds the overhead (plus a lot more).
316
317config TRACE_BRANCH_PROFILING
318	bool
319	select GENERIC_TRACER
320
321choice
322	prompt "Branch Profiling"
323	default BRANCH_PROFILE_NONE
324	help
325	 The branch profiling is a software profiler. It will add hooks
326	 into the C conditionals to test which path a branch takes.
327
328	 The likely/unlikely profiler only looks at the conditions that
329	 are annotated with a likely or unlikely macro.
330
331	 The "all branch" profiler will profile every if-statement in the
332	 kernel. This profiler will also enable the likely/unlikely
333	 profiler.
334
335	 Either of the above profilers adds a bit of overhead to the system.
336	 If unsure, choose "No branch profiling".
337
338config BRANCH_PROFILE_NONE
339	bool "No branch profiling"
340	help
341	  No branch profiling. Branch profiling adds a bit of overhead.
342	  Only enable it if you want to analyse the branching behavior.
343	  Otherwise keep it disabled.
344
345config PROFILE_ANNOTATED_BRANCHES
346	bool "Trace likely/unlikely profiler"
347	select TRACE_BRANCH_PROFILING
348	help
349	  This tracer profiles all likely and unlikely macros
350	  in the kernel. It will display the results in:
351
352	  /sys/kernel/debug/tracing/trace_stat/branch_annotated
353
354	  Note: this will add a significant overhead; only turn this
355	  on if you need to profile the system's use of these macros.
356
357config PROFILE_ALL_BRANCHES
358	bool "Profile all if conditionals" if !FORTIFY_SOURCE
359	select TRACE_BRANCH_PROFILING
 
360	help
361	  This tracer profiles all branch conditions. Every if ()
362	  taken in the kernel is recorded whether it hit or miss.
363	  The results will be displayed in:
364
365	  /sys/kernel/debug/tracing/trace_stat/branch_all
366
367	  This option also enables the likely/unlikely profiler.
368
369	  This configuration, when enabled, will impose a great overhead
370	  on the system. This should only be enabled when the system
371	  is to be analyzed in much detail.
372endchoice
373
374config TRACING_BRANCHES
375	bool
376	help
377	  Selected by tracers that will trace the likely and unlikely
378	  conditions. This prevents the tracers themselves from being
379	  profiled. Profiling the tracing infrastructure can only happen
380	  when the likelys and unlikelys are not being traced.
381
382config BRANCH_TRACER
383	bool "Trace likely/unlikely instances"
384	depends on TRACE_BRANCH_PROFILING
385	select TRACING_BRANCHES
386	help
387	  This traces the events of likely and unlikely condition
388	  calls in the kernel.  The difference between this and the
389	  "Trace likely/unlikely profiler" is that this is not a
390	  histogram of the callers, but actually places the calling
391	  events into a running trace buffer to see when and where the
392	  events happened, as well as their results.
393
394	  Say N if unsure.
395
396config STACK_TRACER
397	bool "Trace max stack"
398	depends on HAVE_FUNCTION_TRACER
399	select FUNCTION_TRACER
400	select STACKTRACE
401	select KALLSYMS
402	help
403	  This special tracer records the maximum stack footprint of the
404	  kernel and displays it in /sys/kernel/debug/tracing/stack_trace.
405
406	  This tracer works by hooking into every function call that the
407	  kernel executes, and keeping a maximum stack depth value and
408	  stack-trace saved.  If this is configured with DYNAMIC_FTRACE
409	  then it will not have any overhead while the stack tracer
410	  is disabled.
411
412	  To enable the stack tracer on bootup, pass in 'stacktrace'
413	  on the kernel command line.
414
415	  The stack tracer can also be enabled or disabled via the
416	  sysctl kernel.stack_tracer_enabled
417
418	  Say N if unsure.
419
420config BLK_DEV_IO_TRACE
421	bool "Support for tracing block IO actions"
422	depends on SYSFS
423	depends on BLOCK
424	select RELAY
425	select DEBUG_FS
426	select TRACEPOINTS
427	select GENERIC_TRACER
428	select STACKTRACE
429	help
430	  Say Y here if you want to be able to trace the block layer actions
431	  on a given queue. Tracing allows you to see any traffic happening
432	  on a block device queue. For more information (and the userspace
433	  support tools needed), fetch the blktrace tools from:
434
435	  git://git.kernel.dk/blktrace.git
436
437	  Tracing also is possible using the ftrace interface, e.g.:
438
439	    echo 1 > /sys/block/sda/sda1/trace/enable
440	    echo blk > /sys/kernel/debug/tracing/current_tracer
441	    cat /sys/kernel/debug/tracing/trace_pipe
442
443	  If unsure, say N.
444
445config KPROBE_EVENTS
446	depends on KPROBES
447	depends on HAVE_REGS_AND_STACK_ACCESS_API
448	bool "Enable kprobes-based dynamic events"
449	select TRACING
450	select PROBE_EVENTS
 
451	default y
452	help
453	  This allows the user to add tracing events (similar to tracepoints)
454	  on the fly via the ftrace interface. See
455	  Documentation/trace/kprobetrace.txt for more details.
456
457	  Those events can be inserted wherever kprobes can probe, and record
458	  various register and memory values.
459
460	  This option is also required by perf-probe subcommand of perf tools.
461	  If you want to use perf tools, this option is strongly recommended.
462
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
463config UPROBE_EVENTS
464	bool "Enable uprobes-based dynamic events"
465	depends on ARCH_SUPPORTS_UPROBES
466	depends on MMU
467	depends on PERF_EVENTS
468	select UPROBES
469	select PROBE_EVENTS
 
470	select TRACING
471	default y
472	help
473	  This allows the user to add tracing events on top of userspace
474	  dynamic events (similar to tracepoints) on the fly via the trace
475	  events interface. Those events can be inserted wherever uprobes
476	  can probe, and record various registers.
477	  This option is required if you plan to use perf-probe subcommand
478	  of perf tools on user space applications.
479
480config BPF_EVENTS
481	depends on BPF_SYSCALL
482	depends on (KPROBE_EVENTS || UPROBE_EVENTS) && PERF_EVENTS
483	bool
484	default y
485	help
486	  This allows the user to attach BPF programs to kprobe events.
 
 
 
 
487
488config PROBE_EVENTS
489	def_bool n
490
491config DYNAMIC_FTRACE
492	bool "enable/disable function tracing dynamically"
493	depends on FUNCTION_TRACER
494	depends on HAVE_DYNAMIC_FTRACE
495	default y
496	help
497	  This option will modify all the calls to function tracing
498	  dynamically (will patch them out of the binary image and
499	  replace them with a No-Op instruction) on boot up. During
500	  compile time, a table is made of all the locations that ftrace
501	  can function trace, and this table is linked into the kernel
502	  image. When this is enabled, functions can be individually
503	  enabled, and the functions not enabled will not affect
504	  performance of the system.
505
506	  See the files in /sys/kernel/debug/tracing:
507	    available_filter_functions
508	    set_ftrace_filter
509	    set_ftrace_notrace
510
511	  This way a CONFIG_FUNCTION_TRACER kernel is slightly larger, but
512	  otherwise has native performance as long as no tracing is active.
513
514config DYNAMIC_FTRACE_WITH_REGS
515	def_bool y
516	depends on DYNAMIC_FTRACE
517	depends on HAVE_DYNAMIC_FTRACE_WITH_REGS
518
519config FUNCTION_PROFILER
520	bool "Kernel function profiler"
521	depends on FUNCTION_TRACER
522	default n
523	help
524	  This option enables the kernel function profiler. A file is created
525	  in debugfs called function_profile_enabled which defaults to zero.
526	  When a 1 is echoed into this file profiling begins, and when a
527	  zero is entered, profiling stops. A "functions" file is created in
528	  the trace_stats directory; this file shows the list of functions that
529	  have been hit and their counters.
530
531	  If in doubt, say N.
532
533config BPF_KPROBE_OVERRIDE
534	bool "Enable BPF programs to override a kprobed function"
535	depends on BPF_EVENTS
536	depends on FUNCTION_ERROR_INJECTION
537	default n
538	help
539	 Allows BPF to override the execution of a probed function and
540	 set a different return value.  This is used for error injection.
541
542config FTRACE_MCOUNT_RECORD
543	def_bool y
544	depends on DYNAMIC_FTRACE
545	depends on HAVE_FTRACE_MCOUNT_RECORD
546
547config FTRACE_SELFTEST
548	bool
549
550config FTRACE_STARTUP_TEST
551	bool "Perform a startup test on ftrace"
552	depends on GENERIC_TRACER
553	select FTRACE_SELFTEST
554	help
555	  This option performs a series of startup tests on ftrace. On bootup
556	  a series of tests are made to verify that the tracer is
557	  functioning properly. It will do tests on all the configured
558	  tracers of ftrace.
559
 
 
 
 
 
 
 
 
 
 
560config EVENT_TRACE_TEST_SYSCALLS
561	bool "Run selftest on syscall events"
562	depends on FTRACE_STARTUP_TEST
563	help
564	 This option will also enable testing every syscall event.
565	 It only enables the event and disables it and runs various loads
566	 with the event enabled. This adds a bit more time for kernel boot
567	 up since it runs this on every system call defined.
568
569	 TBD - enable a way to actually call the syscalls as we test their
570	       events
571
572config MMIOTRACE
573	bool "Memory mapped IO tracing"
574	depends on HAVE_MMIOTRACE_SUPPORT && PCI
575	select GENERIC_TRACER
576	help
577	  Mmiotrace traces Memory Mapped I/O access and is meant for
578	  debugging and reverse engineering. It is called from the ioremap
579	  implementation and works via page faults. Tracing is disabled by
580	  default and can be enabled at run-time.
581
582	  See Documentation/trace/mmiotrace.txt.
583	  If you are not helping to develop drivers, say N.
584
585config TRACING_MAP
586	bool
587	depends on ARCH_HAVE_NMI_SAFE_CMPXCHG
588	help
589	  tracing_map is a special-purpose lock-free map for tracing,
590	  separated out as a stand-alone facility in order to allow it
591	  to be shared between multiple tracers.  It isn't meant to be
592	  generally used outside of that context, and is normally
593	  selected by tracers that use it.
594
595config HIST_TRIGGERS
596	bool "Histogram triggers"
597	depends on ARCH_HAVE_NMI_SAFE_CMPXCHG
598	select TRACING_MAP
599	select TRACING
 
600	default n
601	help
602	  Hist triggers allow one or more arbitrary trace event fields
603	  to be aggregated into hash tables and dumped to stdout by
604	  reading a debugfs/tracefs file.  They're useful for
605	  gathering quick and dirty (though precise) summaries of
606	  event activity as an initial guide for further investigation
607	  using more advanced tools.
608
609	  Inter-event tracing of quantities such as latencies is also
610	  supported using hist triggers under this option.
611
612	  See Documentation/trace/histogram.txt.
613	  If in doubt, say N.
614
615config MMIOTRACE_TEST
616	tristate "Test module for mmiotrace"
617	depends on MMIOTRACE && m
618	help
619	  This is a dumb module for testing mmiotrace. It is very dangerous
620	  as it will write garbage to IO memory starting at a given address.
621	  However, it should be safe to use on e.g. unused portion of VRAM.
622
623	  Say N, unless you absolutely know what you are doing.
624
625config TRACEPOINT_BENCHMARK
626        bool "Add tracepoint that benchmarks tracepoints"
627	help
628	 This option creates the tracepoint "benchmark:benchmark_event".
629	 When the tracepoint is enabled, it kicks off a kernel thread that
630	 goes into an infinite loop (calling cond_sched() to let other tasks
631	 run), and calls the tracepoint. Each iteration will record the time
632	 it took to write to the tracepoint and the next iteration that
633	 data will be passed to the tracepoint itself. That is, the tracepoint
634	 will report the time it took to do the previous tracepoint.
635	 The string written to the tracepoint is a static string of 128 bytes
636	 to keep the time the same. The initial string is simply a write of
637	 "START". The second string records the cold cache time of the first
638	 write which is not added to the rest of the calculations.
639
640	 As it is a tight loop, it benchmarks as hot cache. That's fine because
641	 we care most about hot paths that are probably in cache already.
642
643	 An example of the output:
644
645	      START
646	      first=3672 [COLD CACHED]
647	      last=632 first=3672 max=632 min=632 avg=316 std=446 std^2=199712
648	      last=278 first=3672 max=632 min=278 avg=303 std=316 std^2=100337
649	      last=277 first=3672 max=632 min=277 avg=296 std=258 std^2=67064
650	      last=273 first=3672 max=632 min=273 avg=292 std=224 std^2=50411
651	      last=273 first=3672 max=632 min=273 avg=288 std=200 std^2=40389
652	      last=281 first=3672 max=632 min=273 avg=287 std=183 std^2=33666
653
654
655config RING_BUFFER_BENCHMARK
656	tristate "Ring buffer benchmark stress tester"
657	depends on RING_BUFFER
658	help
659	  This option creates a test to stress the ring buffer and benchmark it.
660	  It creates its own ring buffer such that it will not interfere with
661	  any other users of the ring buffer (such as ftrace). It then creates
662	  a producer and consumer that will run for 10 seconds and sleep for
663	  10 seconds. Each interval it will print out the number of events
664	  it recorded and give a rough estimate of how long each iteration took.
665
666	  It does not disable interrupts or raise its priority, so it may be
667	  affected by processes that are running.
668
669	  If unsure, say N.
670
671config RING_BUFFER_STARTUP_TEST
672       bool "Ring buffer startup self test"
673       depends on RING_BUFFER
674       help
675         Run a simple self test on the ring buffer on boot up. Late in the
676	 kernel boot sequence, the test will start that kicks off
677	 a thread per cpu. Each thread will write various size events
678	 into the ring buffer. Another thread is created to send IPIs
679	 to each of the threads, where the IPI handler will also write
680	 to the ring buffer, to test/stress the nesting ability.
681	 If any anomalies are discovered, a warning will be displayed
682	 and all ring buffers will be disabled.
683
684	 The test runs for 10 seconds. This will slow your boot time
685	 by at least 10 more seconds.
686
687	 At the end of the test, statics and more checks are done.
688	 It will output the stats of each per cpu buffer. What
689	 was written, the sizes, what was read, what was lost, and
690	 other similar details.
691
692	 If unsure, say N
693
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
694config TRACE_EVAL_MAP_FILE
695       bool "Show eval mappings for trace events"
696       depends on TRACING
697       help
698	The "print fmt" of the trace events will show the enum/sizeof names
699	instead	of their values. This can cause problems for user space tools
700	that use this string to parse the raw data as user space does not know
701	how to convert the string to its value.
702
703	To fix this, there's a special macro in the kernel that can be used
704	to convert an enum/sizeof into its value. If this macro is used, then
705	the print fmt strings will be converted to their values.
706
707	If something does not get converted properly, this option can be
708	used to show what enums/sizeof the kernel tried to convert.
709
710	This option is for debugging the conversions. A file is created
711	in the tracing directory called "eval_map" that will show the
712	names matched with their values and what trace event system they
713	belong too.
714
715	Normally, the mapping of the strings to values will be freed after
716	boot up or module load. With this option, they will not be freed, as
717	they are needed for the "eval_map" file. Enabling this option will
718	increase the memory footprint of the running kernel.
719
720	If unsure, say N
721
722config TRACING_EVENTS_GPIO
723	bool "Trace gpio events"
724	depends on GPIOLIB
725	default y
726	help
727	  Enable tracing events for gpio subsystem
 
 
 
 
 
 
728
729endif # FTRACE
730
731endif # TRACING_SUPPORT
732