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.
215 Set a "trigger" function where tracing should start
216 with the function graph tracer (See the section
222 has processed and can trace. These are the function
230 in seeing if any function has a callback attached to it.
231 Not only does the trace infrastructure use ftrace function
238 If the callback registered to be traced by a function with
240 will be displayed on the same line as the function that
243 If the callback registered to be traced by a function with
245 an 'I' will be displayed on the same line as the function that
250 When set it will enable all functions with either the function
251 tracer, or if enabled, the function graph tracer. It will
253 and if run with the function graph tracer, it will also keep
257 trace_stats/function<cpu> ( function0, function1, etc).
273 Used with the function graph tracer. This is the max depth
274 it will trace into a function. Setting this to a value of
275 one will show only the first kernel function that is called
498 "function"
504 Similar to the function tracer except that the
505 function tracer probes the functions on their entry
506 whereas the function graph tracer traces on both entry
508 to draw a graph of function calls similar to C code
563 # tracer: function
587 the trace. In this case the tracer is "function". Then it shows the
596 function name that was traced "sys_close" and the parent function that
597 called this function "system_call_fastpath". The timestamp is the time
598 at which the function was entered.
745 function-trace
758 print-parent - On function traces, display the calling (parent)
759 function as well as the function being traced.
768 sym-offset - Display not only the function name, but also the
769 offset in the function. For example, instead of
776 sym-addr - this will also display the function address as well
777 as the function name.
855 sleep-time - When running function graph tracer, to include
856 the time a task schedules out in its function.
858 scheduled out as part of the function call.
860 graph-time - When running function graph tracer, to include the
862 the time reported for the function will only include
863 the time the function itself executed for, not the time
885 # tracer: function
901 function-trace - The latency tracers will enable function tracing
930 # echo 0 > options/function-trace
982 recording the function that had that latency.
984 Note the above example had function-trace not set. If we set
985 function-trace, we get a much larger output:
987 with echo 1 > options/function-trace
1058 enabling function tracing, we incur an added overhead. This
1076 # echo 0 > options/function-trace
1186 function-trace set. Here we see that interrupts were not disabled
1226 # echo 0 > options/function-trace
1281 function tracing, we do not know if interrupts were enabled
1285 Here is a trace with function-trace set:
1394 Without function tracing:
1396 # echo 0 > options/function-trace
1462 # echo 0 > options/function-trace
1514 Doing the same with chrt -r 5 and function-trace set.
1516 echo 1 > options/function-trace
1621 This isn't that big of a trace, even with function tracing enabled,
1630 As function tracing can induce a much larger latency, but without
1635 # echo 0 > options/function-trace
1667 …<idle>-0 2dN.3 4us : hrtimer_start: hrtimer=ffff88007d50d5e0 function=tick_sched_timer ex…
1674 function
1677 This tracer is the function tracer. Enabling the function tracer
1683 # echo function > current_tracer
1688 # tracer: function
1710 Note: function tracer uses ring buffers to store the above
1744 # echo function > current_tracer
1746 # tracer: function
1758 # tracer: function
1769 If you want to trace a function when executing, you could use
1845 write(ffd, "function", 8);
1865 echo function > $debugfs/tracing/current_tracer
1871 function graph tracer
1874 This tracer is similar to the function tracer except that it
1875 probes a function on its entry and its exit. This is done by
1877 task_struct. On function entry the tracer overwrites the return
1878 address of each function traced to set a custom probe. Thus the
1882 Probing on both ends of a function leads to special features
1885 - measure of a function's time execution
1886 - having a reliable call stack to draw function calls graph
1898 function
1930 - The cpu number on which the function executed is default
1933 function calls while cpu tracing switch.
1938 - The duration (function's time of execution) is displayed on
1939 the closing bracket line of a function or on the same line
1940 than the current function in case of a leaf one. It is default
1993 + means that the function exceeded 10 usecs.
1994 ! means that the function exceeded 100 usecs.
1995 # means that the function exceeded 1000 usecs.
1996 * means that the function exceeded 10 msecs.
1997 @ means that the function exceeded 100 msecs.
1998 $ means that the function exceeded 1 sec.
2002 executed the function. It is default disabled.
2051 The function name is always displayed after the closing bracket
2052 for a function if the start of that function is not in the
2055 Display of the function name after the closing bracket may be
2057 allowing easier searching with grep for function durations.
2079 the __might_sleep() function, you just have to include
2099 virtually no overhead when function tracing is disabled. The way
2100 this works is the mcount function call (placed at the start of
2101 every kernel function, produced by the -pg switch in gcc),
2124 unloaded, it also removes its functions from the ftrace function
2128 When tracing is enabled, the process of modifying the function
2134 (which is just a function stub). They now call into the ftrace
2137 The new method of modifying the function tracepoints is to place
2178 # echo function > current_tracer
2183 # tracer: function
2226 # tracer: function
2311 # tracer: function
2338 Dynamic ftrace with the function graph tracer
2342 function tracer and the function-graph-tracer, there are some
2343 special features only available in the function-graph tracer.
2345 If you want to trace only one function and all of its children,
2351 function:
2403 function tracer. By default it is enabled (when function tracing is
2404 enabled in the kernel). If it is disabled, all function tracing is
2405 disabled. This includes not only the function tracers for ftrace, but
2427 <function>:<command>:<parameter>
2432 This command enables function filtering per module. The
2439 filtering based on function names. Thus, adding more functions
2488 Will cause a snapshot to be triggered when the function is hit.
2503 function tracing callbacks are very sensitive, when these commands
2514 <function>:enable_event:<system>:<event>[:count]
2515 <function>:disable_event:<system>:<event>[:count]
2526 When the function is hit, it will dump the contents of the ftrace
2528 something, and want to dump the trace when a certain function
2529 is hit. Perhaps its a function that is called before a tripple
2533 When the function is hit, it will dump the contents of the ftrace
2536 CPU that executed the function that triggered the dump.
2546 # echo function > current_tracer
2553 # tracer: function
2743 Notice that none of the function tracer files are there, nor is
2753 # echo function > current_trace
2827 the function tracing. The foo instance displays wakeups and task
2850 at every function call that will become very useful. As ftrace provides
2851 a function tracer, it makes it convenient to check the stack size
2852 at every function call. This is enabled via the stack tracer.