Lines Matching refs:function
21 Although ftrace is typically considered the function tracer, it
187 function profiler (mcount). This lets tracing be configured
199 set_ftrace_filter. Any function that is added here will not
200 be traced. If a function exists in both set_ftrace_filter
201 and set_ftrace_notrace, the function will _not_ be traced.
205 Have the function tracer only trace a single thread.
209 Set a "trigger" function where tracing should start
210 with the function graph tracer (See the section
216 has processed and can trace. These are the function
224 in seeing if any function has a callback attached to it.
225 Not only does the trace infrastructure use ftrace function
232 If the callback registered to be traced by a function with
234 will be displayed on the same line as the function that
237 If the callback registered to be traced by a function with
239 an 'I' will be displayed on the same line as the function that
244 When set it will enable all functions with either the function
245 tracer, or if enabled, the function graph tracer. It will
247 and if run with the function graph tracer, it will also keep
251 trace_stats/function<cpu> ( function0, function1, etc).
267 Used with the function graph tracer. This is the max depth
268 it will trace into a function. Setting this to a value of
269 one will show only the first kernel function that is called
487 "function"
493 Similar to the function tracer except that the
494 function tracer probes the functions on their entry
495 whereas the function graph tracer traces on both entry
497 to draw a graph of function calls similar to C code
552 # tracer: function
576 the trace. In this case the tracer is "function". Then it shows the
585 function name that was traced "sys_close" and the parent function that
586 called this function "system_call_fastpath". The timestamp is the time
587 at which the function was entered.
732 function-trace
745 print-parent - On function traces, display the calling (parent)
746 function as well as the function being traced.
755 sym-offset - Display not only the function name, but also the
756 offset in the function. For example, instead of
763 sym-addr - this will also display the function address as well
764 as the function name.
842 sleep-time - When running function graph tracer, to include
843 the time a task schedules out in its function.
845 scheduled out as part of the function call.
847 graph-time - When running function graph tracer, to include the
849 the time reported for the function will only include
850 the time the function itself executed for, not the time
872 # tracer: function
888 function-trace - The latency tracers will enable function tracing
917 # echo 0 > options/function-trace
969 recording the function that had that latency.
971 Note the above example had function-trace not set. If we set
972 function-trace, we get a much larger output:
974 with echo 1 > options/function-trace
1045 enabling function tracing, we incur an added overhead. This
1063 # echo 0 > options/function-trace
1173 function-trace set. Here we see that interrupts were not disabled
1213 # echo 0 > options/function-trace
1268 function tracing, we do not know if interrupts were enabled
1272 Here is a trace with function-trace set:
1381 Without function tracing:
1383 # echo 0 > options/function-trace
1449 # echo 0 > options/function-trace
1501 Doing the same with chrt -r 5 and function-trace set.
1503 echo 1 > options/function-trace
1608 This isn't that big of a trace, even with function tracing enabled,
1617 As function tracing can induce a much larger latency, but without
1622 # echo 0 > options/function-trace
1654 …<idle>-0 2dN.3 4us : hrtimer_start: hrtimer=ffff88007d50d5e0 function=tick_sched_timer ex…
1661 function
1664 This tracer is the function tracer. Enabling the function tracer
1670 # echo function > current_tracer
1675 # tracer: function
1697 Note: function tracer uses ring buffers to store the above
1731 # echo function > current_tracer
1733 # tracer: function
1745 # tracer: function
1756 If you want to trace a function when executing, you could use
1832 write(ffd, "function", 8);
1852 echo function > $debugfs/tracing/current_tracer
1858 function graph tracer
1861 This tracer is similar to the function tracer except that it
1862 probes a function on its entry and its exit. This is done by
1864 task_struct. On function entry the tracer overwrites the return
1865 address of each function traced to set a custom probe. Thus the
1869 Probing on both ends of a function leads to special features
1872 - measure of a function's time execution
1873 - having a reliable call stack to draw function calls graph
1885 function
1917 - The cpu number on which the function executed is default
1920 function calls while cpu tracing switch.
1925 - The duration (function's time of execution) is displayed on
1926 the closing bracket line of a function or on the same line
1927 than the current function in case of a leaf one. It is default
1959 + means that the function exceeded 10 usecs.
1960 ! means that the function exceeded 100 usecs.
1961 # means that the function exceeded 1000 usecs.
1962 $ means that the function exceeded 1 sec.
1966 executed the function. It is default disabled.
2015 The function name is always displayed after the closing bracket
2016 for a function if the start of that function is not in the
2019 Display of the function name after the closing bracket may be
2021 allowing easier searching with grep for function durations.
2043 the __might_sleep() function, you just have to include
2063 virtually no overhead when function tracing is disabled. The way
2064 this works is the mcount function call (placed at the start of
2065 every kernel function, produced by the -pg switch in gcc),
2088 unloaded, it also removes its functions from the ftrace function
2092 When tracing is enabled, the process of modifying the function
2098 (which is just a function stub). They now call into the ftrace
2101 The new method of modifying the function tracepoints is to place
2142 # echo function > current_tracer
2147 # tracer: function
2190 # tracer: function
2275 # tracer: function
2302 Dynamic ftrace with the function graph tracer
2306 function tracer and the function-graph-tracer, there are some
2307 special features only available in the function-graph tracer.
2309 If you want to trace only one function and all of its children,
2315 function:
2367 function tracer. By default it is enabled (when function tracing is
2368 enabled in the kernel). If it is disabled, all function tracing is
2369 disabled. This includes not only the function tracers for ftrace, but
2391 <function>:<command>:<parameter>
2396 This command enables function filtering per module. The
2403 filtering based on function names. Thus, adding more functions
2435 Will cause a snapshot to be triggered when the function is hit.
2450 function tracing callbacks are very sensitive, when these commands
2461 <function>:enable_event:<system>:<event>[:count]
2462 <function>:disable_event:<system>:<event>[:count]
2473 When the function is hit, it will dump the contents of the ftrace
2475 something, and want to dump the trace when a certain function
2476 is hit. Perhaps its a function that is called before a tripple
2480 When the function is hit, it will dump the contents of the ftrace
2483 CPU that executed the function that triggered the dump.
2493 # echo function > current_tracer
2500 # tracer: function
2690 Notice that none of the function tracer files are there, nor is
2700 # echo function > current_trace
2774 the function tracing. The foo instance displays wakeups and task
2797 at every function call that will become very useful. As ftrace provides
2798 a function tracer, it makes it convenient to check the stack size
2799 at every function call. This is enabled via the stack tracer.