Merge branch 'tracing-fixes-for-linus' of...

For example, if the function foo() calls bar(), when the bar() function calls

mcount(), the arguments mcount() will pass to the tracer are:

	"frompc" - the address bar() will use to return to foo()

	"selfpc" - the address bar() (with _mcount() size adjustment)

	"selfpc" - the address bar() (with mcount() size adjustment)

Also keep in mind that this mcount function will be called *a lot*, so

optimizing for the default case of no tracer will help the smooth running of

your system when tracing is disabled.  So the start of the mcount function is

typically the bare min with checking things before returning.  That also means

the code flow should usually kept linear (i.e. no branching in the nop case).

This is of course an optimization and not a hard requirement.

typically the bare minimum with checking things before returning.  That also

means the code flow should usually be kept linear (i.e. no branching in the nop

case).  This is of course an optimization and not a hard requirement.

Here is some pseudo code that should help (these functions should actually be

implemented in assembly):

The mcount function should check the function pointers ftrace_graph_return

(compare to ftrace_stub) and ftrace_graph_entry (compare to

ftrace_graph_entry_stub).  If either of those are not set to the relevant stub

ftrace_graph_entry_stub).  If either of those is not set to the relevant stub

function, call the arch-specific function ftrace_graph_caller which in turn

calls the arch-specific function prepare_ftrace_return.  Neither of these

function names are strictly required, but you should use them anyways to stay

function names is strictly required, but you should use them anyway to stay

consistent across the architecture ports -- easier to compare & contrast

things.

located on the stack.  This allows the function to hijack the return address

temporarily to have it point to the arch-specific function return_to_handler.

That function will simply call the common ftrace_return_to_handler function and

that will return the original return address with which, you can return to the

that will return the original return address with which you can return to the

original call site.

Here is the updated mcount pseudo code:

Usage

-----

Make sure debugfs is mounted to /sys/kernel/debug. If not, (requires root privileges)

Make sure debugfs is mounted to /sys/kernel/debug.

If not (requires root privileges):

$ mount -t debugfs debugfs /sys/kernel/debug

Check that the driver you are about to trace is not loaded.

Access to hardware IO-memory is gained by mapping addresses from PCI bus by

calling one of the ioremap_*() functions. Mmiotrace is hooked into the

__ioremap() function and gets called whenever a mapping is created. Mapping is

an event that is recorded into the trace log. Note, that ISA range mappings

an event that is recorded into the trace log. Note that ISA range mappings

are not caught, since the mapping always exists and is returned directly.

MMIO accesses are recorded via page faults. Just before __ioremap() returns,

----------------

The raw log is text and easily filtered with e.g. grep and awk. One record is

one line in the log. A record starts with a keyword, followed by keyword

dependant arguments. Arguments are separated by a space, or continue until the

one line in the log. A record starts with a keyword, followed by keyword-

dependent arguments. Arguments are separated by a space, or continue until the

end of line. The format for version 20070824 is as follows:

Explanation	Keyword	Space separated arguments

Explanation	Keyword	Space-separated arguments

---------------------------------------------------------------------------

read event	R	width, timestamp, map id, physical, value, PC, PID

marker		MARK	timestamp, text

version		VERSION	the string "20070824"

info for reader	LSPCI	one line from lspci -v

PCI address map	PCIDEV	space separated /proc/bus/pci/devices data

PCI address map	PCIDEV	space-separated /proc/bus/pci/devices data

unk. opcode	UNKNOWN	timestamp, map id, physical, data, PC, PID

Timestamp is in seconds with decimals. Physical is a PCI bus address, virtual

creating custom kernel modules to register probe functions using the event

tracing infrastructure.

Simplistically, tracepoints will represent an important event that when can

be taken in conjunction with other tracepoints to build a "Big Picture" of

Simplistically, tracepoints represent important events that can be

taken in conjunction with other tracepoints to build a "Big Picture" of

what is going on within the system. There are a large number of methods for

gathering and interpreting these events. Lacking any current Best Practises,

this document describes some of the methods that can be used.

will give a fair indication of the number of events available.

2.2 PCL

2.2 PCL (Performance Counters for Linux)

-------

Discovery and enumeration of all counters and events, including tracepoints

Discovery and enumeration of all counters and events, including tracepoints,

are available with the perf tool. Getting a list of available events is a

simple case of

simple case of:

  $ perf list 2>&1 | grep Tracepoint

  ext4:ext4_free_inode                     [Tracepoint event]

  [ .... remaining output snipped .... ]

2. Enabling Events

3. Enabling Events

==================

2.1 System-Wide Event Enabling

3.1 System-Wide Event Enabling

------------------------------

See Documentation/trace/events.txt for a proper description on how events

can be enabled system-wide. A short example of enabling all events related

to page allocation would look something like

to page allocation would look something like:

  $ for i in `find /sys/kernel/debug/tracing/events -name "enable" | grep mm_`; do echo 1 > $i; done

2.2 System-Wide Event Enabling with SystemTap

3.2 System-Wide Event Enabling with SystemTap

---------------------------------------------

In SystemTap, tracepoints are accessible using the kernel.trace() function

          print_count()

  }

2.3 System-Wide Event Enabling with PCL

3.3 System-Wide Event Enabling with PCL

---------------------------------------

By specifying the -a switch and analysing sleep, the system-wide events

Similarly, one could execute a shell and exit it as desired to get a report

at that point.

2.4 Local Event Enabling

3.4 Local Event Enabling

------------------------

Documentation/trace/ftrace.txt describes how to enable events on a per-thread

basis using set_ftrace_pid.

2.5 Local Event Enablement with PCL

3.5 Local Event Enablement with PCL

-----------------------------------

Events can be activate and tracked for the duration of a process on a local

Events can be activated and tracked for the duration of a process on a local

basis using PCL such as follows.

  $ perf stat -e kmem:mm_page_alloc -e kmem:mm_page_free_direct \

    0.973913387  seconds time elapsed

3. Event Filtering

4. Event Filtering

==================

Documentation/trace/ftrace.txt covers in-depth how to filter events in

ftrace.  Obviously using grep and awk of trace_pipe is an option as well

as any script reading trace_pipe.

4. Analysing Event Variances with PCL

5. Analysing Event Variances with PCL

=====================================

Any workload can exhibit variances between runs and it can be important

to know what the standard deviation in. By and large, this is left to the

to know what the standard deviation is. By and large, this is left to the

performance analyst to do it by hand. In the event that the discrete event

occurrences are useful to the performance analyst, then perf can be used.

aggregation of discrete events, then a script would need to be developed.

Using --repeat, it is also possible to view how events are fluctuating over

time on a system wide basis using -a and sleep.

time on a system-wide basis using -a and sleep.

  $ perf stat -e kmem:mm_page_alloc -e kmem:mm_page_free_direct \

		-e kmem:mm_pagevec_free \

    1.002251757  seconds time elapsed   ( +-   0.005% )

5. Higher-Level Analysis with Helper Scripts

6. Higher-Level Analysis with Helper Scripts

============================================

When events are enabled the events that are triggering can be read from

  o Reading information from /proc for the PID that triggered the event

  o Deriving a higher-level event from a series of lower-level events.

  o Calculate latencies between two events

  o Calculating latencies between two events

Documentation/trace/postprocess/trace-pagealloc-postprocess.pl is an example

script that can read trace_pipe from STDIN or a copy of a trace. When used

on-line, it can be interrupted once to generate a report without existing

on-line, it can be interrupted once to generate a report without exiting

and twice to exit.

Simplistically, the script just reads STDIN and counts up events but it

    processes, the parent process responsible for creating all the helpers

    can be identified

6. Lower-Level Analysis with PCL

7. Lower-Level Analysis with PCL

================================

There may also be a requirement to identify what functions with a program

There may also be a requirement to identify what functions within a program

were generating events within the kernel. To begin this sort of analysis, the

data must be recorded. At the time of writing, this required root

data must be recorded. At the time of writing, this required root:

  $ perf record -c 1 \

	-e kmem:mm_page_alloc -e kmem:mm_page_free_direct \

  # (For more details, try: perf report --sort comm,dso,symbol)

  #

According to this, the vast majority of events occured triggered on events

within the VDSO. With simple binaries, this will often be the case so lets

According to this, the vast majority of events triggered on events

within the VDSO. With simple binaries, this will often be the case so let's

take a slightly different example. In the course of writing this, it was

noticed that X was generating an insane amount of page allocations so lets look

at it

noticed that X was generating an insane amount of page allocations so let's look

at it:

  $ perf record -c 1 -f \

		-e kmem:mm_page_alloc -e kmem:mm_page_free_direct \

  # (For more details, try: perf report --sort comm,dso,symbol)

  #

So, almost half of the events are occuring in a library. To get an idea which

symbol.

So, almost half of the events are occurring in a library. To get an idea which

symbol:

  $ perf report --sort comm,dso,symbol

  # Samples: 27666

       0.01%     Xorg  /opt/gfx-test/lib/libpixman-1.so.0.13.1  [.] get_fast_path

       0.00%     Xorg  [kernel]                                 [k] ftrace_trace_userstack

To see where within the function pixmanFillsse2 things are going wrong

To see where within the function pixmanFillsse2 things are going wrong:

  $ perf annotate pixmanFillsse2

  [ ... ]

	static const struct syscall_metadata __used		\

	  __attribute__((__aligned__(4)))			\

	  __attribute__((section("__syscalls_metadata")))	\

	  __syscall_meta_##sname = {				\

	  __syscall_meta__##sname = {				\

		.name 		= "sys_"#sname,			\

		.nb_args 	= 0,				\

		.enter_event	= &event_enter__##sname,	\

	BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);				\

	ret = trace_define_field(event_call, #type "[" #len "]", #item,	\

				 offsetof(typeof(field), item),		\

				 sizeof(field.item), 0, FILTER_OTHER);	\

				 sizeof(field.item),			\

				 is_signed_type(type), FILTER_OTHER);	\

	if (ret)							\

		return ret;

#define __dynamic_array(type, item, len)				       \

	ret = trace_define_field(event_call, "__data_loc " #type "[]", #item,  \

				 offsetof(typeof(field), __data_loc_##item),   \

				 sizeof(field.__data_loc_##item), 0,	       \

				 FILTER_OTHER);

				 sizeof(field.__data_loc_##item),	       \

				 is_signed_type(type), FILTER_OTHER);

#undef __string

#define __string(item, src) __dynamic_array(char, item, -1)