161 files changed, 18800 insertions, 5193 deletions

diff --git a/tools/perf/.gitignore b/tools/perf/.gitignore
index 0854f110bf7f..e1d60d780784 100644
--- a/tools/perf/.gitignore
+++ b/tools/perf/.gitignore
@@ -12,6 +12,9 @@ perf*.1
 perf*.xml
 perf*.html
 common-cmds.h
+perf.data
+perf.data.old
+perf-archive
 tags
 TAGS
 cscope*
diff --git a/tools/perf/Documentation/Makefile b/tools/perf/Documentation/Makefile
index bdd3b7ecad0a..bd498d496952 100644
--- a/tools/perf/Documentation/Makefile
+++ b/tools/perf/Documentation/Makefile
@@ -24,7 +24,10 @@ DOC_MAN1=$(patsubst %.txt,%.1,$(MAN1_TXT))
 DOC_MAN5=$(patsubst %.txt,%.5,$(MAN5_TXT))
 DOC_MAN7=$(patsubst %.txt,%.7,$(MAN7_TXT))
 
+# Make the path relative to DESTDIR, not prefix
+ifndef DESTDIR
 prefix?=$(HOME)
+endif
 bindir?=$(prefix)/bin
 htmldir?=$(prefix)/share/doc/perf-doc
 pdfdir?=$(prefix)/share/doc/perf-doc
@@ -32,7 +35,6 @@ mandir?=$(prefix)/share/man
 man1dir=$(mandir)/man1
 man5dir=$(mandir)/man5
 man7dir=$(mandir)/man7
-# DESTDIR=
 
 ASCIIDOC=asciidoc
 ASCIIDOC_EXTRA = --unsafe
diff --git a/tools/perf/Documentation/perf-archive.txt b/tools/perf/Documentation/perf-archive.txt
new file mode 100644
index 000000000000..fae174dc7d01
--- /dev/null
+++ b/tools/perf/Documentation/perf-archive.txt
@@ -0,0 +1,22 @@
+perf-archive(1)
+===============
+
+NAME
+----
+perf-archive - Create archive with object files with build-ids found in perf.data file
+
+SYNOPSIS
+--------
+[verse]
+'perf archive' [file]
+
+DESCRIPTION
+-----------
+This command runs runs perf-buildid-list --with-hits, and collects the files
+with the buildids found so that analisys of perf.data contents can be possible
+on another machine.
+
+
+SEE ALSO
+--------
+linkperf:perf-record[1], linkperf:perf-buildid-list[1], linkperf:perf-report[1]
diff --git a/tools/perf/Documentation/perf-bench.txt b/tools/perf/Documentation/perf-bench.txt
new file mode 100644
index 000000000000..ae525ac5a2ce
--- /dev/null
+++ b/tools/perf/Documentation/perf-bench.txt
@@ -0,0 +1,120 @@
+perf-bench(1)
+============
+
+NAME
+----
+perf-bench - General framework for benchmark suites
+
+SYNOPSIS
+--------
+[verse]
+'perf bench' [<common options>] <subsystem> <suite> [<options>]
+
+DESCRIPTION
+-----------
+This 'perf bench' command is general framework for benchmark suites.
+
+COMMON OPTIONS
+--------------
+-f::
+--format=::
+Specify format style.
+Current available format styles are,
+
+'default'::
+Default style. This is mainly for human reading.
+---------------------
+% perf bench sched pipe                      # with no style specify
+(executing 1000000 pipe operations between two tasks)
+        Total time:5.855 sec
+                5.855061 usecs/op
+                170792 ops/sec
+---------------------
+
+'simple'::
+This simple style is friendly for automated
+processing by scripts.
+---------------------
+% perf bench --format=simple sched pipe      # specified simple
+5.988
+---------------------
+
+SUBSYSTEM
+---------
+
+'sched'::
+        Scheduler and IPC mechanisms.
+
+SUITES FOR 'sched'
+~~~~~~~~~~~~~~~~~~
+*messaging*::
+Suite for evaluating performance of scheduler and IPC mechanisms.
+Based on hackbench by Rusty Russell.
+
+Options of *pipe*
+^^^^^^^^^^^^^^^^^
+-p::
+--pipe::
+Use pipe() instead of socketpair()
+
+-t::
+--thread::
+Be multi thread instead of multi process
+
+-g::
+--group=::
+Specify number of groups
+
+-l::
+--loop=::
+Specify number of loops
+
+Example of *messaging*
+^^^^^^^^^^^^^^^^^^^^^^
+
+---------------------
+% perf bench sched messaging                 # run with default
+options (20 sender and receiver processes per group)
+(10 groups == 400 processes run)
+
+      Total time:0.308 sec
+
+% perf bench sched messaging -t -g 20        # be multi-thread,with 20 groups
+(20 sender and receiver threads per group)
+(20 groups == 800 threads run)
+
+      Total time:0.582 sec
+---------------------
+
+*pipe*::
+Suite for pipe() system call.
+Based on pipe-test-1m.c by Ingo Molnar.
+
+Options of *pipe*
+^^^^^^^^^^^^^^^^^
+-l::
+--loop=::
+Specify number of loops.
+
+Example of *pipe*
+^^^^^^^^^^^^^^^^^
+
+---------------------
+% perf bench sched pipe
+(executing 1000000 pipe operations between two tasks)
+
+        Total time:8.091 sec
+                8.091833 usecs/op
+                123581 ops/sec
+
+% perf bench sched pipe -l 1000              # loop 1000
+(executing 1000 pipe operations between two tasks)
+
+        Total time:0.016 sec
+                16.948000 usecs/op
+                59004 ops/sec
+---------------------
+
+SEE ALSO
+--------
+linkperf:perf[1]
diff --git a/tools/perf/Documentation/perf-buildid-cache.txt b/tools/perf/Documentation/perf-buildid-cache.txt
new file mode 100644
index 000000000000..88bc3b519746
--- /dev/null
+++ b/tools/perf/Documentation/perf-buildid-cache.txt
@@ -0,0 +1,33 @@
+perf-buildid-cache(1)
+=====================
+
+NAME
+----
+perf-buildid-cache - Manage build-id cache.
+
+SYNOPSIS
+--------
+[verse]
+'perf buildid-list <options>'
+
+DESCRIPTION
+-----------
+This command manages the build-id cache. It can add and remove files to the
+cache. In the future it should as well purge older entries, set upper limits
+for the space used by the cache, etc.
+
+OPTIONS
+-------
+-a::
+--add=::
+        Add specified file to the cache.
+-r::
+--remove=::
+        Remove specified file to the cache.
+-v::
+--verbose::
+        Be more verbose.
+
+SEE ALSO
+--------
+linkperf:perf-record[1], linkperf:perf-report[1]
diff --git a/tools/perf/Documentation/perf-buildid-list.txt b/tools/perf/Documentation/perf-buildid-list.txt
new file mode 100644
index 000000000000..01b642c0bf8f
--- /dev/null
+++ b/tools/perf/Documentation/perf-buildid-list.txt
@@ -0,0 +1,34 @@
+perf-buildid-list(1)
+====================
+
+NAME
+----
+perf-buildid-list - List the buildids in a perf.data file
+
+SYNOPSIS
+--------
+[verse]
+'perf buildid-list <options>'
+
+DESCRIPTION
+-----------
+This command displays the buildids found in a perf.data file, so that other
+tools can be used to fetch packages with matching symbol tables for use by
+perf report.
+
+OPTIONS
+-------
+-i::
+--input=::
+        Input file name. (default: perf.data)
+-f::
+--force::
+        Don't do ownership validation.
+-v::
+--verbose::
+        Be more verbose.
+
+SEE ALSO
+--------
+linkperf:perf-record[1], linkperf:perf-top[1],
+linkperf:perf-report[1]
diff --git a/tools/perf/Documentation/perf-diff.txt b/tools/perf/Documentation/perf-diff.txt
new file mode 100644
index 000000000000..8974e208cba6
--- /dev/null
+++ b/tools/perf/Documentation/perf-diff.txt
@@ -0,0 +1,55 @@
+perf-diff(1)
+==============
+
+NAME
+----
+perf-diff - Read two perf.data files and display the differential profile
+
+SYNOPSIS
+--------
+[verse]
+'perf diff' [oldfile] [newfile]
+
+DESCRIPTION
+-----------
+This command displays the performance difference amongst two perf.data files
+captured via perf record.
+
+If no parameters are passed it will assume perf.data.old and perf.data.
+
+OPTIONS
+-------
+-d::
+--dsos=::
+        Only consider symbols in these dsos. CSV that understands
+        file://filename entries.
+
+-C::
+--comms=::
+        Only consider symbols in these comms. CSV that understands
+        file://filename entries.
+
+-S::
+--symbols=::
+        Only consider these symbols. CSV that understands
+        file://filename entries.
+
+-s::
+--sort=::
+        Sort by key(s): pid, comm, dso, symbol.
+
+-t::
+--field-separator=::
+
+        Use a special separator character and don't pad with spaces, replacing
+        all occurances of this separator in symbol names (and other output)
+        with a '.' character, that thus it's the only non valid separator.
+
+-v::
+--verbose::
+        Be verbose, for instance, show the raw counts in addition to the
+        diff.
+
+SEE ALSO
+--------
+linkperf:perf-record[1]
diff --git a/tools/perf/Documentation/perf-kmem.txt b/tools/perf/Documentation/perf-kmem.txt
new file mode 100644
index 000000000000..eac4d852e7cd
--- /dev/null
+++ b/tools/perf/Documentation/perf-kmem.txt
@@ -0,0 +1,47 @@
+perf-kmem(1)
+==============
+
+NAME
+----
+perf-kmem - Tool to trace/measure kernel memory(slab) properties
+
+SYNOPSIS
+--------
+[verse]
+'perf kmem' {record|stat} [<options>]
+
+DESCRIPTION
+-----------
+There are two variants of perf kmem:
+
+  'perf kmem record <command>' to record the kmem events
+  of an arbitrary workload.
+
+  'perf kmem stat' to report kernel memory statistics.
+
+OPTIONS
+-------
+-i <file>::
+--input=<file>::
+        Select the input file (default: perf.data)
+
+--caller::
+        Show per-callsite statistics
+
+--alloc::
+        Show per-allocation statistics
+
+-s <key[,key2...]>::
+--sort=<key[,key2...]>::
+        Sort the output (default: frag,hit,bytes)
+
+-l <num>::
+--line=<num>::
+        Print n lines only
+
+--raw-ip::
+        Print raw ip instead of symbol
+
+SEE ALSO
+--------
+linkperf:perf-record[1]
diff --git a/tools/perf/Documentation/perf-lock.txt b/tools/perf/Documentation/perf-lock.txt
new file mode 100644
index 000000000000..b317102138c8
--- /dev/null
+++ b/tools/perf/Documentation/perf-lock.txt
@@ -0,0 +1,29 @@
+perf-lock(1)
+============
+
+NAME
+----
+perf-lock - Analyze lock events
+
+SYNOPSIS
+--------
+[verse]
+'perf lock' {record|report|trace}
+
+DESCRIPTION
+-----------
+You can analyze various lock behaviours
+and statistics with this 'perf lock' command.
+
+  'perf lock record <command>' records lock events
+  between start and end <command>. And this command
+  produces the file "perf.data" which contains tracing
+  results of lock events.
+
+  'perf lock trace' shows raw lock events.
+
+  'perf lock report' reports statistical data.
+
+SEE ALSO
+--------
+linkperf:perf[1]
diff --git a/tools/perf/Documentation/perf-probe.txt b/tools/perf/Documentation/perf-probe.txt
new file mode 100644
index 000000000000..34202b1be0bb
--- /dev/null
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -0,0 +1,129 @@
+perf-probe(1)
+=============
+
+NAME
+----
+perf-probe - Define new dynamic tracepoints
+
+SYNOPSIS
+--------
+[verse]
+'perf probe' [options] --add='PROBE' [...]
+or
+'perf probe' [options] PROBE
+or
+'perf probe' [options] --del='[GROUP:]EVENT' [...]
+or
+'perf probe' --list
+or
+'perf probe' --line='FUNC[:RLN[+NUM|:RLN2]]|SRC:ALN[+NUM|:ALN2]'
+
+DESCRIPTION
+-----------
+This command defines dynamic tracepoint events, by symbol and registers
+without debuginfo, or by C expressions (C line numbers, C function names,
+and C local variables) with debuginfo.
+
+
+OPTIONS
+-------
+-k::
+--vmlinux=PATH::
+        Specify vmlinux path which has debuginfo (Dwarf binary).
+
+-v::
+--verbose::
+        Be more verbose (show parsed arguments, etc).
+
+-a::
+--add=::
+        Define a probe event (see PROBE SYNTAX for detail).
+
+-d::
+--del=::
+        Delete probe events. This accepts glob wildcards('*', '?') and character
+        classes(e.g. [a-z], [!A-Z]).
+
+-l::
+--list::
+        List up current probe events.
+
+-L::
+--line=::
+        Show source code lines which can be probed. This needs an argument
+        which specifies a range of the source code. (see LINE SYNTAX for detail)
+
+-f::
+--force::
+        Forcibly add events with existing name.
+
+PROBE SYNTAX
+------------
+Probe points are defined by following syntax.
+
+    1) Define event based on function name
+     [EVENT=]FUNC[@SRC][:RLN|+OFFS|%return|;PTN] [ARG ...]
+
+    2) Define event based on source file with line number
+     [EVENT=]SRC:ALN [ARG ...]
+
+    3) Define event based on source file with lazy pattern
+     [EVENT=]SRC;PTN [ARG ...]
+
+
+'EVENT' specifies the name of new event, if omitted, it will be set the name of the probed function. Currently, event group name is set as 'probe'.
+'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, ':RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. And ';PTN' means lazy matching pattern (see LAZY MATCHING). Note that ';PTN' must be the end of the probe point definition.  In addition, '@SRC' specifies a source file which has that function.
+It is also possible to specify a probe point by the source line number or lazy matching by using 'SRC:ALN' or 'SRC;PTN' syntax, where 'SRC' is the source file path, ':ALN' is the line number and ';PTN' is the lazy matching pattern.
+'ARG' specifies the arguments of this probe point. You can use the name of local variable, or kprobe-tracer argument format (e.g. $retval, %ax, etc).
+
+LINE SYNTAX
+-----------
+Line range is descripted by following syntax.
+
+ "FUNC[:RLN[+NUM|:RLN2]]|SRC:ALN[+NUM|:ALN2]"
+
+FUNC specifies the function name of showing lines. 'RLN' is the start line
+number from function entry line, and 'RLN2' is the end line number. As same as
+probe syntax, 'SRC' means the source file path, 'ALN' is start line number,
+and 'ALN2' is end line number in the file. It is also possible to specify how
+many lines to show by using 'NUM'.
+So, "source.c:100-120" shows lines between 100th to l20th in source.c file. And "func:10+20" shows 20 lines from 10th line of func function.
+
+LAZY MATCHING
+-------------
+ The lazy line matching is similar to glob matching but ignoring spaces in both of pattern and target. So this accepts wildcards('*', '?') and character classes(e.g. [a-z], [!A-Z]).
+
+e.g.
+ 'a=*' can matches 'a=b', 'a = b', 'a == b' and so on.
+
+This provides some sort of flexibility and robustness to probe point definitions against minor code changes. For example, actual 10th line of schedule() can be moved easily by modifying schedule(), but the same line matching 'rq=cpu_rq*' may still exist in the function.)
+
+
+EXAMPLES
+--------
+Display which lines in schedule() can be probed:
+
+ ./perf probe --line schedule
+
+Add a probe on schedule() function 12th line with recording cpu local variable:
+
+ ./perf probe schedule:12 cpu
+ or
+ ./perf probe --add='schedule:12 cpu'
+
+ this will add one or more probes which has the name start with "schedule".
+
+ Add probes on lines in schedule() function which calls update_rq_clock().
+
+ ./perf probe 'schedule;update_rq_clock*'
+ or
+ ./perf probe --add='schedule;update_rq_clock*'
+
+Delete all probes on schedule().
+
+ ./perf probe --del='schedule*'
+
+
+SEE ALSO
+--------
+linkperf:perf-trace[1], linkperf:perf-record[1]
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index 0ff23de9e453..fc46c0b40f6e 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -26,11 +26,19 @@ OPTIONS
 
 -e::
 --event=::
-        Select the PMU event. Selection can be a symbolic event name
-        (use 'perf list' to list all events) or a raw PMU
-        event (eventsel+umask) in the form of rNNN where NNN is a
-        hexadecimal event descriptor.
+        Select the PMU event. Selection can be:
 
+        - a symbolic event name (use 'perf list' to list all events)
+
+        - a raw PMU event (eventsel+umask) in the form of rNNN where NNN is a
+          hexadecimal event descriptor.
+
+        - a hardware breakpoint event in the form of '\mem:addr[:access]'
+          where addr is the address in memory you want to break in.
+          Access is the memory access type (read, write, execute) it can
+          be passed as follows: '\mem:addr[:[r][w][x]]'.
+          If you want to profile read-write accesses in 0x1000, just set
+          'mem:0x1000:rw'.
 -a::
         System-wide collection.
 
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index 59f0b846cd71..abfabe9147a4 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -24,11 +24,11 @@ OPTIONS
 --dsos=::
         Only consider symbols in these dsos. CSV that understands
         file://filename entries.
--n
---show-nr-samples
+-n::
+--show-nr-samples::
         Show the number of samples for each symbol
--T
---threads
+-T::
+--threads::
         Show per-thread event counters
 -C::
 --comms=::
@@ -39,6 +39,10 @@ OPTIONS
         Only consider these symbols. CSV that understands
         file://filename entries.
 
+-s::
+--sort=::
+        Sort by key(s): pid, comm, dso, symbol, parent.
+
 -w::
 --field-width=::
         Force each column width to the provided list, for large terminal
diff --git a/tools/perf/Documentation/perf-timechart.txt b/tools/perf/Documentation/perf-timechart.txt
index a7910099d6fd..4b1788355eca 100644
--- a/tools/perf/Documentation/perf-timechart.txt
+++ b/tools/perf/Documentation/perf-timechart.txt
@@ -31,9 +31,12 @@ OPTIONS
 -w::
 --width=::
         Select the width of the SVG file (default: 1000)
--p::
+-P::
 --power-only::
         Only output the CPU power section of the diagram
+-p::
+--process::
+        Select the processes to display, by name or PID
 
 
 SEE ALSO
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index 4a7d558dc309..785b9fc32a46 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -74,7 +74,7 @@ OPTIONS
 
 -s <symbol>::
 --sym-annotate=<symbol>::
-        Annotate this symbol.  Requires -k option.
+        Annotate this symbol.
 
 -v::
 --verbose::
diff --git a/tools/perf/Documentation/perf-trace-perl.txt b/tools/perf/Documentation/perf-trace-perl.txt
new file mode 100644
index 000000000000..d729cee8d987
--- /dev/null
+++ b/tools/perf/Documentation/perf-trace-perl.txt
@@ -0,0 +1,219 @@
+perf-trace-perl(1)
+==================
+
+NAME
+----
+perf-trace-perl - Process trace data with a Perl script
+
+SYNOPSIS
+--------
+[verse]
+'perf trace' [-s [Perl]:script[.pl] ]
+
+DESCRIPTION
+-----------
+
+This perf trace option is used to process perf trace data using perf's
+built-in Perl interpreter.  It reads and processes the input file and
+displays the results of the trace analysis implemented in the given
+Perl script, if any.
+
+STARTER SCRIPTS
+---------------
+
+You can avoid reading the rest of this document by running 'perf trace
+-g perl' in the same directory as an existing perf.data trace file.
+That will generate a starter script containing a handler for each of
+the event types in the trace file; it simply prints every available
+field for each event in the trace file.
+
+You can also look at the existing scripts in
+~/libexec/perf-core/scripts/perl for typical examples showing how to
+do basic things like aggregate event data, print results, etc.  Also,
+the check-perf-trace.pl script, while not interesting for its results,
+attempts to exercise all of the main scripting features.
+
+EVENT HANDLERS
+--------------
+
+When perf trace is invoked using a trace script, a user-defined
+'handler function' is called for each event in the trace.  If there's
+no handler function defined for a given event type, the event is
+ignored (or passed to a 'trace_handled' function, see below) and the
+next event is processed.
+
+Most of the event's field values are passed as arguments to the
+handler function; some of the less common ones aren't - those are
+available as calls back into the perf executable (see below).
+
+As an example, the following perf record command can be used to record
+all sched_wakeup events in the system:
+
+ # perf record -c 1 -f -a -M -R -e sched:sched_wakeup
+
+Traces meant to be processed using a script should be recorded with
+the above options: -c 1 says to sample every event, -a to enable
+system-wide collection, -M to multiplex the output, and -R to collect
+raw samples.
+
+The format file for the sched_wakep event defines the following fields
+(see /sys/kernel/debug/tracing/events/sched/sched_wakeup/format):
+
+----
+ format:
+        field:unsigned short common_type;
+        field:unsigned char common_flags;
+        field:unsigned char common_preempt_count;
+        field:int common_pid;
+        field:int common_lock_depth;
+
+        field:char comm[TASK_COMM_LEN];
+        field:pid_t pid;
+        field:int prio;
+        field:int success;
+        field:int target_cpu;
+----
+
+The handler function for this event would be defined as:
+
+----
+sub sched::sched_wakeup
+{
+   my ($event_name, $context, $common_cpu, $common_secs,
+       $common_nsecs, $common_pid, $common_comm,
+       $comm, $pid, $prio, $success, $target_cpu) = @_;
+}
+----
+
+The handler function takes the form subsystem::event_name.
+
+The $common_* arguments in the handler's argument list are the set of
+arguments passed to all event handlers; some of the fields correspond
+to the common_* fields in the format file, but some are synthesized,
+and some of the common_* fields aren't common enough to to be passed
+to every event as arguments but are available as library functions.
+
+Here's a brief description of each of the invariant event args:
+
+ $event_name                the name of the event as text
+ $context                   an opaque 'cookie' used in calls back into perf
+ $common_cpu                the cpu the event occurred on
+ $common_secs               the secs portion of the event timestamp
+ $common_nsecs              the nsecs portion of the event timestamp
+ $common_pid                the pid of the current task
+ $common_comm               the name of the current process
+
+All of the remaining fields in the event's format file have
+counterparts as handler function arguments of the same name, as can be
+seen in the example above.
+
+The above provides the basics needed to directly access every field of
+every event in a trace, which covers 90% of what you need to know to
+write a useful trace script.  The sections below cover the rest.
+
+SCRIPT LAYOUT
+-------------
+
+Every perf trace Perl script should start by setting up a Perl module
+search path and 'use'ing a few support modules (see module
+descriptions below):
+
+----
+ use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
+ use lib "./Perf-Trace-Util/lib";
+ use Perf::Trace::Core;
+ use Perf::Trace::Context;
+ use Perf::Trace::Util;
+----
+
+The rest of the script can contain handler functions and support
+functions in any order.
+
+Aside from the event handler functions discussed above, every script
+can implement a set of optional functions:
+
+*trace_begin*, if defined, is called before any event is processed and
+gives scripts a chance to do setup tasks:
+
+----
+ sub trace_begin
+ {
+ }
+----
+
+*trace_end*, if defined, is called after all events have been
+ processed and gives scripts a chance to do end-of-script tasks, such
+ as display results:
+
+----
+sub trace_end
+{
+}
+----
+
+*trace_unhandled*, if defined, is called after for any event that
+ doesn't have a handler explicitly defined for it.  The standard set
+ of common arguments are passed into it:
+
+----
+sub trace_unhandled
+{
+    my ($event_name, $context, $common_cpu, $common_secs,
+        $common_nsecs, $common_pid, $common_comm) = @_;
+}
+----
+
+The remaining sections provide descriptions of each of the available
+built-in perf trace Perl modules and their associated functions.
+
+AVAILABLE MODULES AND FUNCTIONS
+-------------------------------
+
+The following sections describe the functions and variables available
+via the various Perf::Trace::* Perl modules.  To use the functions and
+variables from the given module, add the corresponding 'use
+Perf::Trace::XXX' line to your perf trace script.
+
+Perf::Trace::Core Module
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+These functions provide some essential functions to user scripts.
+
+The *flag_str* and *symbol_str* functions provide human-readable
+strings for flag and symbolic fields.  These correspond to the strings
+and values parsed from the 'print fmt' fields of the event format
+files:
+
+  flag_str($event_name, $field_name, $field_value) - returns the string represention corresponding to $field_value for the flag field $field_name of event $event_name
+  symbol_str($event_name, $field_name, $field_value) - returns the string represention corresponding to $field_value for the symbolic field $field_name of event $event_name
+
+Perf::Trace::Context Module
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Some of the 'common' fields in the event format file aren't all that
+common, but need to be made accessible to user scripts nonetheless.
+
+Perf::Trace::Context defines a set of functions that can be used to
+access this data in the context of the current event.  Each of these
+functions expects a $context variable, which is the same as the
+$context variable passed into every event handler as the second
+argument.
+
+ common_pc($context) - returns common_preempt count for the current event
+ common_flags($context) - returns common_flags for the current event
+ common_lock_depth($context) - returns common_lock_depth for the current event
+
+Perf::Trace::Util Module
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+Various utility functions for use with perf trace:
+
+  nsecs($secs, $nsecs) - returns total nsecs given secs/nsecs pair
+  nsecs_secs($nsecs) - returns whole secs portion given nsecs
+  nsecs_nsecs($nsecs) - returns nsecs remainder given nsecs
+  nsecs_str($nsecs) - returns printable string in the form secs.nsecs
+  avg($total, $n) - returns average given a sum and a total number of values
+
+SEE ALSO
+--------
+linkperf:perf-trace[1]
diff --git a/tools/perf/Documentation/perf-trace-python.txt b/tools/perf/Documentation/perf-trace-python.txt
new file mode 100644
index 000000000000..a241aca77184
--- /dev/null
+++ b/tools/perf/Documentation/perf-trace-python.txt
@@ -0,0 +1,625 @@
+perf-trace-python(1)
+==================
+
+NAME
+----
+perf-trace-python - Process trace data with a Python script
+
+SYNOPSIS
+--------
+[verse]
+'perf trace' [-s [Python]:script[.py] ]
+
+DESCRIPTION
+-----------
+
+This perf trace option is used to process perf trace data using perf's
+built-in Python interpreter.  It reads and processes the input file and
+displays the results of the trace analysis implemented in the given
+Python script, if any.
+
+A QUICK EXAMPLE
+---------------
+
+This section shows the process, start to finish, of creating a working
+Python script that aggregates and extracts useful information from a
+raw perf trace stream.  You can avoid reading the rest of this
+document if an example is enough for you; the rest of the document
+provides more details on each step and lists the library functions
+available to script writers.
+
+This example actually details the steps that were used to create the
+'syscall-counts' script you see when you list the available perf trace
+scripts via 'perf trace -l'.  As such, this script also shows how to
+integrate your script into the list of general-purpose 'perf trace'
+scripts listed by that command.
+
+The syscall-counts script is a simple script, but demonstrates all the
+basic ideas necessary to create a useful script.  Here's an example
+of its output (syscall names are not yet supported, they will appear
+as numbers):
+
+----
+syscall events:
+
+event                                          count
+----------------------------------------  -----------
+sys_write                                     455067
+sys_getdents                                    4072
+sys_close                                       3037
+sys_swapoff                                     1769
+sys_read                                         923
+sys_sched_setparam                               826
+sys_open                                         331
+sys_newfstat                                     326
+sys_mmap                                         217
+sys_munmap                                       216
+sys_futex                                        141
+sys_select                                       102
+sys_poll                                          84
+sys_setitimer                                     12
+sys_writev                                         8
+15                                                 8
+sys_lseek                                          7
+sys_rt_sigprocmask                                 6
+sys_wait4                                          3
+sys_ioctl                                          3
+sys_set_robust_list                                1
+sys_exit                                           1
+56                                                 1
+sys_access                                         1
+----
+
+Basically our task is to keep a per-syscall tally that gets updated
+every time a system call occurs in the system.  Our script will do
+that, but first we need to record the data that will be processed by
+that script.  Theoretically, there are a couple of ways we could do
+that:
+
+- we could enable every event under the tracing/events/syscalls
+  directory, but this is over 600 syscalls, well beyond the number
+  allowable by perf.  These individual syscall events will however be
+  useful if we want to later use the guidance we get from the
+  general-purpose scripts to drill down and get more detail about
+  individual syscalls of interest.
+
+- we can enable the sys_enter and/or sys_exit syscalls found under
+  tracing/events/raw_syscalls.  These are called for all syscalls; the
+  'id' field can be used to distinguish between individual syscall
+  numbers.
+
+For this script, we only need to know that a syscall was entered; we
+don't care how it exited, so we'll use 'perf record' to record only
+the sys_enter events:
+
+----
+# perf record -c 1 -f -a -M -R -e raw_syscalls:sys_enter
+
+^C[ perf record: Woken up 1 times to write data ]
+[ perf record: Captured and wrote 56.545 MB perf.data (~2470503 samples) ]
+----
+
+The options basically say to collect data for every syscall event
+system-wide and multiplex the per-cpu output into a single stream.
+That single stream will be recorded in a file in the current directory
+called perf.data.
+
+Once we have a perf.data file containing our data, we can use the -g
+'perf trace' option to generate a Python script that will contain a
+callback handler for each event type found in the perf.data trace
+stream (for more details, see the STARTER SCRIPTS section).
+
+----
+# perf trace -g python
+generated Python script: perf-trace.py
+
+The output file created also in the current directory is named
+perf-trace.py.  Here's the file in its entirety:
+
+# perf trace event handlers, generated by perf trace -g python
+# Licensed under the terms of the GNU GPL License version 2
+
+# The common_* event handler fields are the most useful fields common to
+# all events.  They don't necessarily correspond to the 'common_*' fields
+# in the format files.  Those fields not available as handler params can
+# be retrieved using Python functions of the form common_*(context).
+# See the perf-trace-python Documentation for the list of available functions.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+
+def trace_begin():
+        print "in trace_begin"
+
+def trace_end():
+        print "in trace_end"
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+                print_header(event_name, common_cpu, common_secs, common_nsecs,
+                        common_pid, common_comm)
+
+                print "id=%d, args=%s\n" % \
+                (id, args),
+
+def trace_unhandled(event_name, context, common_cpu, common_secs, common_nsecs,
+                common_pid, common_comm):
+                print_header(event_name, common_cpu, common_secs, common_nsecs,
+                common_pid, common_comm)
+
+def print_header(event_name, cpu, secs, nsecs, pid, comm):
+        print "%-20s %5u %05u.%09u %8u %-20s " % \
+        (event_name, cpu, secs, nsecs, pid, comm),
+----
+
+At the top is a comment block followed by some import statements and a
+path append which every perf trace script should include.
+
+Following that are a couple generated functions, trace_begin() and
+trace_end(), which are called at the beginning and the end of the
+script respectively (for more details, see the SCRIPT_LAYOUT section
+below).
+
+Following those are the 'event handler' functions generated one for
+every event in the 'perf record' output.  The handler functions take
+the form subsystem__event_name, and contain named parameters, one for
+each field in the event; in this case, there's only one event,
+raw_syscalls__sys_enter().  (see the EVENT HANDLERS section below for
+more info on event handlers).
+
+The final couple of functions are, like the begin and end functions,
+generated for every script.  The first, trace_unhandled(), is called
+every time the script finds an event in the perf.data file that
+doesn't correspond to any event handler in the script.  This could
+mean either that the record step recorded event types that it wasn't
+really interested in, or the script was run against a trace file that
+doesn't correspond to the script.
+
+The script generated by -g option option simply prints a line for each
+event found in the trace stream i.e. it basically just dumps the event
+and its parameter values to stdout.  The print_header() function is
+simply a utility function used for that purpose.  Let's rename the
+script and run it to see the default output:
+
+----
+# mv perf-trace.py syscall-counts.py
+# perf trace -s syscall-counts.py
+
+raw_syscalls__sys_enter     1 00840.847582083     7506 perf                  id=1, args=
+raw_syscalls__sys_enter     1 00840.847595764     7506 perf                  id=1, args=
+raw_syscalls__sys_enter     1 00840.847620860     7506 perf                  id=1, args=
+raw_syscalls__sys_enter     1 00840.847710478     6533 npviewer.bin          id=78, args=
+raw_syscalls__sys_enter     1 00840.847719204     6533 npviewer.bin          id=142, args=
+raw_syscalls__sys_enter     1 00840.847755445     6533 npviewer.bin          id=3, args=
+raw_syscalls__sys_enter     1 00840.847775601     6533 npviewer.bin          id=3, args=
+raw_syscalls__sys_enter     1 00840.847781820     6533 npviewer.bin          id=3, args=
+.
+.
+.
+----
+
+Of course, for this script, we're not interested in printing every
+trace event, but rather aggregating it in a useful way.  So we'll get
+rid of everything to do with printing as well as the trace_begin() and
+trace_unhandled() functions, which we won't be using.  That leaves us
+with this minimalistic skeleton:
+
+----
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+
+def trace_end():
+        print "in trace_end"
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+----
+
+In trace_end(), we'll simply print the results, but first we need to
+generate some results to print.  To do that we need to have our
+sys_enter() handler do the necessary tallying until all events have
+been counted.  A hash table indexed by syscall id is a good way to
+store that information; every time the sys_enter() handler is called,
+we simply increment a count associated with that hash entry indexed by
+that syscall id:
+
+----
+  syscalls = autodict()
+
+  try:
+    syscalls[id] += 1
+  except TypeError:
+    syscalls[id] = 1
+----
+
+The syscalls 'autodict' object is a special kind of Python dictionary
+(implemented in Core.py) that implements Perl's 'autovivifying' hashes
+in Python i.e. with autovivifying hashes, you can assign nested hash
+values without having to go to the trouble of creating intermediate
+levels if they don't exist e.g syscalls[comm][pid][id] = 1 will create
+the intermediate hash levels and finally assign the value 1 to the
+hash entry for 'id' (because the value being assigned isn't a hash
+object itself, the initial value is assigned in the TypeError
+exception.  Well, there may be a better way to do this in Python but
+that's what works for now).
+
+Putting that code into the raw_syscalls__sys_enter() handler, we
+effectively end up with a single-level dictionary keyed on syscall id
+and having the counts we've tallied as values.
+
+The print_syscall_totals() function iterates over the entries in the
+dictionary and displays a line for each entry containing the syscall
+name (the dictonary keys contain the syscall ids, which are passed to
+the Util function syscall_name(), which translates the raw syscall
+numbers to the corresponding syscall name strings).  The output is
+displayed after all the events in the trace have been processed, by
+calling the print_syscall_totals() function from the trace_end()
+handler called at the end of script processing.
+
+The final script producing the output shown above is shown in its
+entirety below (syscall_name() helper is not yet available, you can
+only deal with id's for now):
+
+----
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+from Util import *
+
+syscalls = autodict()
+
+def trace_end():
+        print_syscall_totals()
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+        try:
+                syscalls[id] += 1
+        except TypeError:
+                syscalls[id] = 1
+
+def print_syscall_totals():
+    if for_comm is not None:
+            print "\nsyscall events for %s:\n\n" % (for_comm),
+    else:
+            print "\nsyscall events:\n\n",
+
+    print "%-40s  %10s\n" % ("event", "count"),
+    print "%-40s  %10s\n" % ("----------------------------------------", \
+                                 "-----------"),
+
+    for id, val in sorted(syscalls.iteritems(), key = lambda(k, v): (v, k), \
+                                  reverse = True):
+            print "%-40s  %10d\n" % (syscall_name(id), val),
+----
+
+The script can be run just as before:
+
+  # perf trace -s syscall-counts.py
+
+So those are the essential steps in writing and running a script.  The
+process can be generalized to any tracepoint or set of tracepoints
+you're interested in - basically find the tracepoint(s) you're
+interested in by looking at the list of available events shown by
+'perf list' and/or look in /sys/kernel/debug/tracing events for
+detailed event and field info, record the corresponding trace data
+using 'perf record', passing it the list of interesting events,
+generate a skeleton script using 'perf trace -g python' and modify the
+code to aggregate and display it for your particular needs.
+
+After you've done that you may end up with a general-purpose script
+that you want to keep around and have available for future use.  By
+writing a couple of very simple shell scripts and putting them in the
+right place, you can have your script listed alongside the other
+scripts listed by the 'perf trace -l' command e.g.:
+
+----
+root@tropicana:~# perf trace -l
+List of available trace scripts:
+  workqueue-stats                      workqueue stats (ins/exe/create/destroy)
+  wakeup-latency                       system-wide min/max/avg wakeup latency
+  rw-by-file <comm>                    r/w activity for a program, by file
+  rw-by-pid                            system-wide r/w activity
+----
+
+A nice side effect of doing this is that you also then capture the
+probably lengthy 'perf record' command needed to record the events for
+the script.
+
+To have the script appear as a 'built-in' script, you write two simple
+scripts, one for recording and one for 'reporting'.
+
+The 'record' script is a shell script with the same base name as your
+script, but with -record appended.  The shell script should be put
+into the perf/scripts/python/bin directory in the kernel source tree.
+In that script, you write the 'perf record' command-line needed for
+your script:
+
+----
+# cat kernel-source/tools/perf/scripts/python/bin/syscall-counts-record
+
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e raw_syscalls:sys_enter
+----
+
+The 'report' script is also a shell script with the same base name as
+your script, but with -report appended.  It should also be located in
+the perf/scripts/python/bin directory.  In that script, you write the
+'perf trace -s' command-line needed for running your script:
+
+----
+# cat kernel-source/tools/perf/scripts/python/bin/syscall-counts-report
+
+#!/bin/bash
+# description: system-wide syscall counts
+perf trace -s ~/libexec/perf-core/scripts/python/syscall-counts.py
+----
+
+Note that the location of the Python script given in the shell script
+is in the libexec/perf-core/scripts/python directory - this is where
+the script will be copied by 'make install' when you install perf.
+For the installation to install your script there, your script needs
+to be located in the perf/scripts/python directory in the kernel
+source tree:
+
+----
+# ls -al kernel-source/tools/perf/scripts/python
+
+root@tropicana:/home/trz/src/tip# ls -al tools/perf/scripts/python
+total 32
+drwxr-xr-x 4 trz trz 4096 2010-01-26 22:30 .
+drwxr-xr-x 4 trz trz 4096 2010-01-26 22:29 ..
+drwxr-xr-x 2 trz trz 4096 2010-01-26 22:29 bin
+-rw-r--r-- 1 trz trz 2548 2010-01-26 22:29 check-perf-trace.py
+drwxr-xr-x 3 trz trz 4096 2010-01-26 22:49 Perf-Trace-Util
+-rw-r--r-- 1 trz trz 1462 2010-01-26 22:30 syscall-counts.py
+----
+
+Once you've done that (don't forget to do a new 'make install',
+otherwise your script won't show up at run-time), 'perf trace -l'
+should show a new entry for your script:
+
+----
+root@tropicana:~# perf trace -l
+List of available trace scripts:
+  workqueue-stats                      workqueue stats (ins/exe/create/destroy)
+  wakeup-latency                       system-wide min/max/avg wakeup latency
+  rw-by-file <comm>                    r/w activity for a program, by file
+  rw-by-pid                            system-wide r/w activity
+  syscall-counts                       system-wide syscall counts
+----
+
+You can now perform the record step via 'perf trace record':
+
+  # perf trace record syscall-counts
+
+and display the output using 'perf trace report':
+
+  # perf trace report syscall-counts
+
+STARTER SCRIPTS
+---------------
+
+You can quickly get started writing a script for a particular set of
+trace data by generating a skeleton script using 'perf trace -g
+python' in the same directory as an existing perf.data trace file.
+That will generate a starter script containing a handler for each of
+the event types in the trace file; it simply prints every available
+field for each event in the trace file.
+
+You can also look at the existing scripts in
+~/libexec/perf-core/scripts/python for typical examples showing how to
+do basic things like aggregate event data, print results, etc.  Also,
+the check-perf-trace.py script, while not interesting for its results,
+attempts to exercise all of the main scripting features.
+
+EVENT HANDLERS
+--------------
+
+When perf trace is invoked using a trace script, a user-defined
+'handler function' is called for each event in the trace.  If there's
+no handler function defined for a given event type, the event is
+ignored (or passed to a 'trace_handled' function, see below) and the
+next event is processed.
+
+Most of the event's field values are passed as arguments to the
+handler function; some of the less common ones aren't - those are
+available as calls back into the perf executable (see below).
+
+As an example, the following perf record command can be used to record
+all sched_wakeup events in the system:
+
+ # perf record -c 1 -f -a -M -R -e sched:sched_wakeup
+
+Traces meant to be processed using a script should be recorded with
+the above options: -c 1 says to sample every event, -a to enable
+system-wide collection, -M to multiplex the output, and -R to collect
+raw samples.
+
+The format file for the sched_wakep event defines the following fields
+(see /sys/kernel/debug/tracing/events/sched/sched_wakeup/format):
+
+----
+ format:
+        field:unsigned short common_type;
+        field:unsigned char common_flags;
+        field:unsigned char common_preempt_count;
+        field:int common_pid;
+        field:int common_lock_depth;
+
+        field:char comm[TASK_COMM_LEN];
+        field:pid_t pid;
+        field:int prio;
+        field:int success;
+        field:int target_cpu;
+----
+
+The handler function for this event would be defined as:
+
+----
+def sched__sched_wakeup(event_name, context, common_cpu, common_secs,
+       common_nsecs, common_pid, common_comm,
+       comm, pid, prio, success, target_cpu):
+       pass
+----
+
+The handler function takes the form subsystem__event_name.
+
+The common_* arguments in the handler's argument list are the set of
+arguments passed to all event handlers; some of the fields correspond
+to the common_* fields in the format file, but some are synthesized,
+and some of the common_* fields aren't common enough to to be passed
+to every event as arguments but are available as library functions.
+
+Here's a brief description of each of the invariant event args:
+
+ event_name                 the name of the event as text
+ context                    an opaque 'cookie' used in calls back into perf
+ common_cpu                 the cpu the event occurred on
+ common_secs                the secs portion of the event timestamp
+ common_nsecs               the nsecs portion of the event timestamp
+ common_pid                 the pid of the current task
+ common_comm                the name of the current process
+
+All of the remaining fields in the event's format file have
+counterparts as handler function arguments of the same name, as can be
+seen in the example above.
+
+The above provides the basics needed to directly access every field of
+every event in a trace, which covers 90% of what you need to know to
+write a useful trace script.  The sections below cover the rest.
+
+SCRIPT LAYOUT
+-------------
+
+Every perf trace Python script should start by setting up a Python
+module search path and 'import'ing a few support modules (see module
+descriptions below):
+
+----
+ import os
+ import sys
+
+ sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+              '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+ from perf_trace_context import *
+ from Core import *
+----
+
+The rest of the script can contain handler functions and support
+functions in any order.
+
+Aside from the event handler functions discussed above, every script
+can implement a set of optional functions:
+
+*trace_begin*, if defined, is called before any event is processed and
+gives scripts a chance to do setup tasks:
+
+----
+def trace_begin:
+    pass
+----
+
+*trace_end*, if defined, is called after all events have been
+ processed and gives scripts a chance to do end-of-script tasks, such
+ as display results:
+
+----
+def trace_end:
+    pass
+----
+
+*trace_unhandled*, if defined, is called after for any event that
+ doesn't have a handler explicitly defined for it.  The standard set
+ of common arguments are passed into it:
+
+----
+def trace_unhandled(event_name, context, common_cpu, common_secs,
+        common_nsecs, common_pid, common_comm):
+    pass
+----
+
+The remaining sections provide descriptions of each of the available
+built-in perf trace Python modules and their associated functions.
+
+AVAILABLE MODULES AND FUNCTIONS
+-------------------------------
+
+The following sections describe the functions and variables available
+via the various perf trace Python modules.  To use the functions and
+variables from the given module, add the corresponding 'from XXXX
+import' line to your perf trace script.
+
+Core.py Module
+~~~~~~~~~~~~~~
+
+These functions provide some essential functions to user scripts.
+
+The *flag_str* and *symbol_str* functions provide human-readable
+strings for flag and symbolic fields.  These correspond to the strings
+and values parsed from the 'print fmt' fields of the event format
+files:
+
+  flag_str(event_name, field_name, field_value) - returns the string represention corresponding to field_value for the flag field field_name of event event_name
+  symbol_str(event_name, field_name, field_value) - returns the string represention corresponding to field_value for the symbolic field field_name of event event_name
+
+The *autodict* function returns a special special kind of Python
+dictionary that implements Perl's 'autovivifying' hashes in Python
+i.e. with autovivifying hashes, you can assign nested hash values
+without having to go to the trouble of creating intermediate levels if
+they don't exist.
+
+  autodict() - returns an autovivifying dictionary instance
+
+
+perf_trace_context Module
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Some of the 'common' fields in the event format file aren't all that
+common, but need to be made accessible to user scripts nonetheless.
+
+perf_trace_context defines a set of functions that can be used to
+access this data in the context of the current event.  Each of these
+functions expects a context variable, which is the same as the
+context variable passed into every event handler as the second
+argument.
+
+ common_pc(context) - returns common_preempt count for the current event
+ common_flags(context) - returns common_flags for the current event
+ common_lock_depth(context) - returns common_lock_depth for the current event
+
+Util.py Module
+~~~~~~~~~~~~~~
+
+Various utility functions for use with perf trace:
+
+  nsecs(secs, nsecs) - returns total nsecs given secs/nsecs pair
+  nsecs_secs(nsecs) - returns whole secs portion given nsecs
+  nsecs_nsecs(nsecs) - returns nsecs remainder given nsecs
+  nsecs_str(nsecs) - returns printable string in the form secs.nsecs
+  avg(total, n) - returns average given a sum and a total number of values
+
+SEE ALSO
+--------
+linkperf:perf-trace[1]
diff --git a/tools/perf/Documentation/perf-trace.txt b/tools/perf/Documentation/perf-trace.txt
index 41ed75398ca9..8879299cd9df 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -8,18 +8,63 @@ perf-trace - Read perf.data (created by perf record) and display trace output
 SYNOPSIS
 --------
 [verse]
-'perf trace' [-i <file> | --input=file] symbol_name
+'perf trace' {record <script> | report <script> [args] }
 
 DESCRIPTION
 -----------
 This command reads the input file and displays the trace recorded.
 
+There are several variants of perf trace:
+
+  'perf trace' to see a detailed trace of the workload that was
+  recorded.
+
+  You can also run a set of pre-canned scripts that aggregate and
+  summarize the raw trace data in various ways (the list of scripts is
+  available via 'perf trace -l').  The following variants allow you to
+  record and run those scripts:
+
+  'perf trace record <script>' to record the events required for 'perf
+  trace report'.  <script> is the name displayed in the output of
+  'perf trace --list' i.e. the actual script name minus any language
+  extension.
+
+  'perf trace report <script>' to run and display the results of
+  <script>.  <script> is the name displayed in the output of 'perf
+  trace --list' i.e. the actual script name minus any language
+  extension.  The perf.data output from a previous run of 'perf trace
+  record <script>' is used and should be present for this command to
+  succeed.
+
+  See the 'SEE ALSO' section for links to language-specific
+  information on how to write and run your own trace scripts.
+
 OPTIONS
 -------
 -D::
 --dump-raw-trace=::
         Display verbose dump of the trace data.
 
+-L::
+--Latency=::
+        Show latency attributes (irqs/preemption disabled, etc).
+
+-l::
+--list=::
+        Display a list of available trace scripts.
+
+-s ['lang']::
+--script=::
+        Process trace data with the given script ([lang]:script[.ext]).
+        If the string 'lang' is specified in place of a script name, a
+        list of supported languages will be displayed instead.
+
+-g::
+--gen-script=::
+        Generate perf-trace.[ext] starter script for given language,
+        using current perf.data.
+
 SEE ALSO
 --------
-linkperf:perf-record[1]
+linkperf:perf-record[1], linkperf:perf-trace-perl[1],
+linkperf:perf-trace-python[1]
diff --git a/tools/perf/Documentation/perf.txt b/tools/perf/Documentation/perf.txt
index 69c832557199..0eeb247dc7d2 100644
--- a/tools/perf/Documentation/perf.txt
+++ b/tools/perf/Documentation/perf.txt
@@ -12,7 +12,7 @@ SYNOPSIS
 
 DESCRIPTION
 -----------
-Performance counters for Linux are are a new kernel-based subsystem
+Performance counters for Linux are a new kernel-based subsystem
 that provide a framework for all things performance analysis. It
 covers hardware level (CPU/PMU, Performance Monitoring Unit) features
 and software features (software counters, tracepoints) as well.
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 7e190d522cd5..bc0f670a8338 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -2,6 +2,7 @@
 all::
 
 # Define V=1 to have a more verbose compile.
+# Define V=2 to have an even more verbose compile.
 #
 # Define SNPRINTF_RETURNS_BOGUS if your are on a system which snprintf()
 # or vsnprintf() return -1 instead of number of characters which would
@@ -145,6 +146,10 @@ all::
 # Define NO_EXTERNAL_GREP if you don't want "perf grep" to ever call
 # your external grep (e.g., if your system lacks grep, if its grep is
 # broken, or spawning external process is slower than built-in grep perf has).
+#
+# Define LDFLAGS=-static to build a static binary.
+#
+# Define EXTRA_CFLAGS=-m64 or EXTRA_CFLAGS=-m32 as appropriate for cross-builds.
 
 PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
         @$(SHELL_PATH) util/PERF-VERSION-GEN
@@ -157,20 +162,6 @@ uname_R := $(shell sh -c 'uname -r 2>/dev/null || echo not')
 uname_P := $(shell sh -c 'uname -p 2>/dev/null || echo not')
 uname_V := $(shell sh -c 'uname -v 2>/dev/null || echo not')
 
-#
-# Add -m32 for cross-builds:
-#
-ifdef NO_64BIT
-  MBITS := -m32
-else
-  #
-  # If we're on a 64-bit kernel, use -m64:
-  #
-  ifneq ($(patsubst %64,%,$(uname_M)),$(uname_M))
-    MBITS := -m64
-  endif
-endif
-
 # CFLAGS and LDFLAGS are for the users to override from the command line.
 
 #
@@ -200,9 +191,16 @@ EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wold-style-definition
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-prototypes
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wdeclaration-after-statement
 
-CFLAGS = $(MBITS) -ggdb3 -Wall -Wextra -std=gnu99 -Werror -O6 -fstack-protector-all -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS)
-LDFLAGS = -lpthread -lrt -lelf -lm
-ALL_CFLAGS = $(CFLAGS)
+ifeq ("$(origin DEBUG)", "command line")
+  PERF_DEBUG = $(DEBUG)
+endif
+ifndef PERF_DEBUG
+  CFLAGS_OPTIMIZE = -O6
+endif
+
+CFLAGS = -ggdb3 -Wall -Wextra -std=gnu99 -Werror $(CFLAGS_OPTIMIZE) -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
+EXTLIBS = -lpthread -lrt -lelf -lm
+ALL_CFLAGS = $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
 ALL_LDFLAGS = $(LDFLAGS)
 STRIP ?= strip
 
@@ -218,7 +216,10 @@ STRIP ?= strip
 # runtime figures out where they are based on the path to the executable.
 # This can help installing the suite in a relocatable way.
 
+# Make the path relative to DESTDIR, not to prefix
+ifndef DESTDIR
 prefix = $(HOME)
+endif
 bindir_relative = bin
 bindir = $(prefix)/$(bindir_relative)
 mandir = share/man
@@ -235,12 +236,11 @@ sysconfdir = $(prefix)/etc
 ETC_PERFCONFIG = etc/perfconfig
 endif
 lib = lib
-# DESTDIR=
 
 export prefix bindir sharedir sysconfdir
 
-CC = gcc
-AR = ar
+CC = $(CROSS_COMPILE)gcc
+AR = $(CROSS_COMPILE)ar
 RM = rm -f
 TAR = tar
 FIND = find
@@ -252,6 +252,21 @@ PTHREAD_LIBS = -lpthread
 # explicitly what architecture to check for. Fix this up for yours..
 SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
 
+ifeq ($(V), 2)
+        QUIET_STDERR = ">/dev/null"
+else
+        QUIET_STDERR = ">/dev/null 2>&1"
+endif
+
+BITBUCKET = "/dev/null"
+
+ifneq ($(shell sh -c "(echo '\#include <stdio.h>'; echo 'int main(void) { return puts(\"hi\"); }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) "$(QUIET_STDERR)" && echo y"), y)
+        BITBUCKET = .perf.dev.null
+endif
+
+ifeq ($(shell sh -c "echo 'int foo(void) {char X[2]; return 3;}' | $(CC) -x c -c -Werror -fstack-protector-all - -o $(BITBUCKET) "$(QUIET_STDERR)" && echo y"), y)
+  CFLAGS := $(CFLAGS) -fstack-protector-all
+endif
 
 
 ### --- END CONFIGURATION SECTION ---
@@ -273,11 +288,7 @@ SCRIPT_PERL =
 SCRIPT_SH =
 TEST_PROGRAMS =
 
-#
-# No scripts right now:
-#
-
-# SCRIPT_SH += perf-am.sh
+SCRIPT_SH += perf-archive.sh
 
 #
 # No Perl scripts right now:
@@ -302,9 +313,6 @@ PROGRAMS += perf
 # List built-in command $C whose implementation cmd_$C() is not in
 # builtin-$C.o but is linked in as part of some other command.
 #
-# None right now:
-#
-# BUILT_INS += perf-init $X
 
 # what 'all' will build and 'install' will install, in perfexecdir
 ALL_PROGRAMS = $(PROGRAMS) $(SCRIPTS)
@@ -327,30 +335,70 @@ LIB_FILE=libperf.a
 LIB_H += ../../include/linux/perf_event.h
 LIB_H += ../../include/linux/rbtree.h
 LIB_H += ../../include/linux/list.h
+LIB_H += ../../include/linux/hash.h
+LIB_H += ../../include/linux/stringify.h
+LIB_H += util/include/linux/bitmap.h
+LIB_H += util/include/linux/bitops.h
+LIB_H += util/include/linux/compiler.h
+LIB_H += util/include/linux/ctype.h
+LIB_H += util/include/linux/kernel.h
 LIB_H += util/include/linux/list.h
+LIB_H += util/include/linux/module.h
+LIB_H += util/include/linux/poison.h
+LIB_H += util/include/linux/prefetch.h
+LIB_H += util/include/linux/rbtree.h
+LIB_H += util/include/linux/string.h
+LIB_H += util/include/linux/types.h
+LIB_H += util/include/asm/asm-offsets.h
+LIB_H += util/include/asm/bitops.h
+LIB_H += util/include/asm/bug.h
+LIB_H += util/include/asm/byteorder.h
+LIB_H += util/include/asm/swab.h
+LIB_H += util/include/asm/system.h
+LIB_H += util/include/asm/uaccess.h
 LIB_H += perf.h
+LIB_H += util/cache.h
+LIB_H += util/callchain.h
+LIB_H += util/build-id.h
+LIB_H += util/debug.h
+LIB_H += util/debugfs.h
+LIB_H += util/event.h
+LIB_H += util/exec_cmd.h
 LIB_H += util/types.h
 LIB_H += util/levenshtein.h
+LIB_H += util/map.h
 LIB_H += util/parse-options.h
 LIB_H += util/parse-events.h
 LIB_H += util/quote.h
 LIB_H += util/util.h
+LIB_H += util/header.h
 LIB_H += util/help.h
+LIB_H += util/session.h
 LIB_H += util/strbuf.h
 LIB_H += util/string.h
 LIB_H += util/strlist.h
+LIB_H += util/svghelper.h
 LIB_H += util/run-command.h
 LIB_H += util/sigchain.h
 LIB_H += util/symbol.h
-LIB_H += util/module.h
 LIB_H += util/color.h
 LIB_H += util/values.h
+LIB_H += util/sort.h
+LIB_H += util/hist.h
+LIB_H += util/thread.h
+LIB_H += util/trace-event.h
+LIB_H += util/probe-finder.h
+LIB_H += util/probe-event.h
+LIB_H += util/cpumap.h
 
 LIB_OBJS += util/abspath.o
 LIB_OBJS += util/alias.o
+LIB_OBJS += util/build-id.o
 LIB_OBJS += util/config.o
 LIB_OBJS += util/ctype.o
+LIB_OBJS += util/debugfs.o
 LIB_OBJS += util/environment.o
+LIB_OBJS += util/event.o
 LIB_OBJS += util/exec_cmd.o
 LIB_OBJS += util/help.o
 LIB_OBJS += util/levenshtein.o
@@ -358,6 +406,9 @@ LIB_OBJS += util/parse-options.o
 LIB_OBJS += util/parse-events.o
 LIB_OBJS += util/path.o
 LIB_OBJS += util/rbtree.o
+LIB_OBJS += util/bitmap.o
+LIB_OBJS += util/hweight.o
+LIB_OBJS += util/find_next_bit.o
 LIB_OBJS += util/run-command.o
 LIB_OBJS += util/quote.o
 LIB_OBJS += util/strbuf.o
@@ -367,7 +418,6 @@ LIB_OBJS += util/usage.o
 LIB_OBJS += util/wrapper.o
 LIB_OBJS += util/sigchain.o
 LIB_OBJS += util/symbol.o
-LIB_OBJS += util/module.o
 LIB_OBJS += util/color.o
 LIB_OBJS += util/pager.o
 LIB_OBJS += util/header.o
@@ -375,15 +425,33 @@ LIB_OBJS += util/callchain.o
 LIB_OBJS += util/values.o
 LIB_OBJS += util/debug.o
 LIB_OBJS += util/map.o
+LIB_OBJS += util/session.o
 LIB_OBJS += util/thread.o
 LIB_OBJS += util/trace-event-parse.o
 LIB_OBJS += util/trace-event-read.o
 LIB_OBJS += util/trace-event-info.o
+LIB_OBJS += util/trace-event-scripting.o
 LIB_OBJS += util/svghelper.o
+LIB_OBJS += util/sort.o
+LIB_OBJS += util/hist.o
+LIB_OBJS += util/probe-event.o
+LIB_OBJS += util/util.o
+LIB_OBJS += util/cpumap.o
 
 BUILTIN_OBJS += builtin-annotate.o
+
+BUILTIN_OBJS += builtin-bench.o
+
+# Benchmark modules
+BUILTIN_OBJS += bench/sched-messaging.o
+BUILTIN_OBJS += bench/sched-pipe.o
+BUILTIN_OBJS += bench/mem-memcpy.o
+
+BUILTIN_OBJS += builtin-diff.o
 BUILTIN_OBJS += builtin-help.o
 BUILTIN_OBJS += builtin-sched.o
+BUILTIN_OBJS += builtin-buildid-list.o
+BUILTIN_OBJS += builtin-buildid-cache.o
 BUILTIN_OBJS += builtin-list.o
 BUILTIN_OBJS += builtin-record.o
 BUILTIN_OBJS += builtin-report.o
@@ -391,6 +459,9 @@ BUILTIN_OBJS += builtin-stat.o
 BUILTIN_OBJS += builtin-timechart.o
 BUILTIN_OBJS += builtin-top.o
 BUILTIN_OBJS += builtin-trace.o
+BUILTIN_OBJS += builtin-probe.o
+BUILTIN_OBJS += builtin-kmem.o
+BUILTIN_OBJS += builtin-lock.o
 
 PERFLIBS = $(LIB_FILE)
 
@@ -421,36 +492,75 @@ ifeq ($(uname_S),Darwin)
         PTHREAD_LIBS =
 endif
 
-ifeq ($(shell sh -c "(echo '\#include <libelf.h>'; echo 'int main(void) { Elf * elf = elf_begin(0, ELF_C_READ, 0); return (long)elf; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o /dev/null $(ALL_LDFLAGS) > /dev/null 2>&1 && echo y"), y)
-        ifneq ($(shell sh -c "(echo '\#include <libelf.h>'; echo 'int main(void) { Elf * elf = elf_begin(0, ELF_C_READ_MMAP, 0); return (long)elf; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o /dev/null $(ALL_LDFLAGS) > /dev/null 2>&1 && echo y"), y)
+ifeq ($(shell sh -c "(echo '\#include <libelf.h>'; echo 'int main(void) { Elf * elf = elf_begin(0, ELF_C_READ, 0); return (long)elf; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y)
+ifneq ($(shell sh -c "(echo '\#include <gnu/libc-version.h>'; echo 'int main(void) { const char * version = gnu_get_libc_version(); return (long)version; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y)
+        msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]/glibc-static);
+endif
+
+        ifneq ($(shell sh -c "(echo '\#include <libelf.h>'; echo 'int main(void) { Elf * elf = elf_begin(0, ELF_C_READ_MMAP, 0); return (long)elf; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y)
                 BASIC_CFLAGS += -DLIBELF_NO_MMAP
         endif
 else
         msg := $(error No libelf.h/libelf found, please install libelf-dev/elfutils-libelf-devel and glibc-dev[el]);
 endif
 
+ifneq ($(shell sh -c "(echo '\#include <dwarf.h>'; echo '\#include <libdw.h>'; echo 'int main(void) { Dwarf *dbg; dbg = dwarf_begin(0, DWARF_C_READ); return (long)dbg; }') | $(CC) -x c - $(ALL_CFLAGS) -I/usr/include/elfutils -ldw -lelf -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y)
+        msg := $(warning No libdw.h found or old libdw.h found, disables dwarf support. Please install elfutils-devel/elfutils-dev);
+        BASIC_CFLAGS += -DNO_DWARF_SUPPORT
+else
+        BASIC_CFLAGS += -I/usr/include/elfutils
+        EXTLIBS += -lelf -ldw
+        LIB_OBJS += util/probe-finder.o
+endif
+
+ifndef NO_LIBPERL
+PERL_EMBED_LDOPTS = `perl -MExtUtils::Embed -e ldopts 2>/dev/null`
+PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`
+endif
+
+ifneq ($(shell sh -c "(echo '\#include <EXTERN.h>'; echo '\#include <perl.h>'; echo 'int main(void) { perl_alloc(); return 0; }') | $(CC) -x c - $(PERL_EMBED_CCOPTS) -o $(BITBUCKET) $(PERL_EMBED_LDOPTS) > /dev/null 2>&1 && echo y"), y)
+        BASIC_CFLAGS += -DNO_LIBPERL
+else
+        ALL_LDFLAGS += $(PERL_EMBED_LDOPTS)
+        LIB_OBJS += util/scripting-engines/trace-event-perl.o
+        LIB_OBJS += scripts/perl/Perf-Trace-Util/Context.o
+endif
+
+ifndef NO_LIBPYTHON
+PYTHON_EMBED_LDOPTS = `python-config --ldflags 2>/dev/null`
+PYTHON_EMBED_CCOPTS = `python-config --cflags 2>/dev/null`
+endif
+
+ifneq ($(shell sh -c "(echo '\#include <Python.h>'; echo 'int main(void) { Py_Initialize(); return 0; }') | $(CC) -x c - $(PYTHON_EMBED_CCOPTS) -o /dev/null $(PYTHON_EMBED_LDOPTS) > /dev/null 2>&1 && echo y"), y)
+        BASIC_CFLAGS += -DNO_LIBPYTHON
+else
+        ALL_LDFLAGS += $(PYTHON_EMBED_LDOPTS)
+        LIB_OBJS += util/scripting-engines/trace-event-python.o
+        LIB_OBJS += scripts/python/Perf-Trace-Util/Context.o
+endif
+
 ifdef NO_DEMANGLE
         BASIC_CFLAGS += -DNO_DEMANGLE
 else
-        has_bfd := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd > /dev/null 2>&1 && echo y")
+        has_bfd := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) -lbfd "$(QUIET_STDERR)" && echo y")
 
         ifeq ($(has_bfd),y)
                 EXTLIBS += -lbfd
         else
-                has_bfd_iberty := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd -liberty > /dev/null 2>&1 && echo y")
+                has_bfd_iberty := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) -lbfd -liberty "$(QUIET_STDERR)" && echo y")
                 ifeq ($(has_bfd_iberty),y)
                         EXTLIBS += -lbfd -liberty
                 else
-                        has_bfd_iberty_z := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -lbfd -liberty -lz > /dev/null 2>&1 && echo y")
+                        has_bfd_iberty_z := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) -lbfd -liberty -lz "$(QUIET_STDERR)" && echo y")
                         ifeq ($(has_bfd_iberty_z),y)
                                 EXTLIBS += -lbfd -liberty -lz
                         else
-                                has_cplus_demangle := $(shell sh -c "(echo 'extern char *cplus_demangle(const char *, int);'; echo 'int main(void) { cplus_demangle(0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o /dev/null $(ALL_LDFLAGS) -liberty > /dev/null 2>&1 && echo y")
+                                has_cplus_demangle := $(shell sh -c "(echo 'extern char *cplus_demangle(const char *, int);'; echo 'int main(void) { cplus_demangle(0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) -liberty "$(QUIET_STDERR)" && echo y")
                                 ifeq ($(has_cplus_demangle),y)
                                         EXTLIBS += -liberty
                                         BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
                                 else
-                                        msg := $(warning No bfd.h/libbfd found, install binutils-dev[el] to gain symbol demangling)
+                                        msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
                                         BASIC_CFLAGS += -DNO_DEMANGLE
                                 endif
                         endif
@@ -693,7 +803,7 @@ export TAR INSTALL DESTDIR SHELL_PATH
 
 SHELL = $(SHELL_PATH)
 
-all:: shell_compatibility_test $(ALL_PROGRAMS) $(BUILT_INS) $(OTHER_PROGRAMS) PERF-BUILD-OPTIONS
+all:: .perf.dev.null shell_compatibility_test $(ALL_PROGRAMS) $(BUILT_INS) $(OTHER_PROGRAMS) PERF-BUILD-OPTIONS
 ifneq (,$X)
         $(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) perf$X)), test '$p' -ef '$p$X' || $(RM) '$p';)
 endif
@@ -787,6 +897,31 @@ util/config.o: util/config.c PERF-CFLAGS
 util/rbtree.o: ../../lib/rbtree.c PERF-CFLAGS
         $(QUIET_CC)$(CC) -o util/rbtree.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
+# some perf warning policies can't fit to lib/bitmap.c, eg: it warns about variable shadowing
+# from <string.h> that comes from kernel headers wrapping.
+KBITMAP_FLAGS=`echo $(ALL_CFLAGS) | sed s/-Wshadow// | sed s/-Wswitch-default// | sed s/-Wextra//`
+
+util/bitmap.o: ../../lib/bitmap.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o util/bitmap.o -c $(KBITMAP_FLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+
+util/hweight.o: ../../lib/hweight.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o util/hweight.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+
+util/find_next_bit.o: ../../lib/find_next_bit.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o util/find_next_bit.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+
+util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o util/scripting-engines/trace-event-perl.o -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
+
+scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o scripts/perl/Perf-Trace-Util/Context.o -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
+
+util/scripting-engines/trace-event-python.o: util/scripting-engines/trace-event-python.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o util/scripting-engines/trace-event-python.o -c $(ALL_CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
+
+scripts/python/Perf-Trace-Util/Context.o: scripts/python/Perf-Trace-Util/Context.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o scripts/python/Perf-Trace-Util/Context.o -c $(ALL_CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
+
 perf-%$X: %.o $(PERFLIBS)
         $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)
 
@@ -894,6 +1029,18 @@ export perfexec_instdir
 install: all
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'
         $(INSTALL) perf$X '$(DESTDIR_SQ)$(bindir_SQ)'
+        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'
+        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
+        $(INSTALL) perf-archive -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
+        $(INSTALL) scripts/perl/Perf-Trace-Util/lib/Perf/Trace/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'
+        $(INSTALL) scripts/perl/*.pl -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl'
+        $(INSTALL) scripts/perl/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
+        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/Perf-Trace-Util/lib/Perf/Trace'
+        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
+        $(INSTALL) scripts/python/Perf-Trace-Util/lib/Perf/Trace/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/Perf-Trace-Util/lib/Perf/Trace'
+        $(INSTALL) scripts/python/*.py -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python'
+        $(INSTALL) scripts/python/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
+
 ifdef BUILT_INS
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
         $(INSTALL) $(BUILT_INS) '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
@@ -979,7 +1126,7 @@ distclean: clean
 #       $(RM) configure
 
 clean:
-        $(RM) *.o */*.o $(LIB_FILE)
+        $(RM) *.o */*.o */*/*.o */*/*/*.o $(LIB_FILE)
         $(RM) $(ALL_PROGRAMS) $(BUILT_INS) perf$X
         $(RM) $(TEST_PROGRAMS)
         $(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo common-cmds.h TAGS tags cscope*
@@ -996,6 +1143,11 @@ clean:
 .PHONY: .FORCE-PERF-VERSION-FILE TAGS tags cscope .FORCE-PERF-CFLAGS
 .PHONY: .FORCE-PERF-BUILD-OPTIONS
 
+.perf.dev.null:
+                touch .perf.dev.null
+
+.INTERMEDIATE:  .perf.dev.null
+
 ### Make sure built-ins do not have dups and listed in perf.c
 #
 check-builtins::
diff --git a/tools/perf/bench/bench.h b/tools/perf/bench/bench.h
new file mode 100644
index 000000000000..f7781c6267c0
--- /dev/null
+++ b/tools/perf/bench/bench.h
@@ -0,0 +1,17 @@
+#ifndef BENCH_H
+#define BENCH_H
+
+extern int bench_sched_messaging(int argc, const char **argv, const char *prefix);
+extern int bench_sched_pipe(int argc, const char **argv, const char *prefix);
+extern int bench_mem_memcpy(int argc, const char **argv, const char *prefix __used);
+
+#define BENCH_FORMAT_DEFAULT_STR        "default"
+#define BENCH_FORMAT_DEFAULT            0
+#define BENCH_FORMAT_SIMPLE_STR         "simple"
+#define BENCH_FORMAT_SIMPLE             1
+
+#define BENCH_FORMAT_UNKNOWN            -1
+
+extern int bench_format;
+
+#endif
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
new file mode 100644
index 000000000000..89773178e894
--- /dev/null
+++ b/tools/perf/bench/mem-memcpy.c
@@ -0,0 +1,193 @@
+/*
+ * mem-memcpy.c
+ *
+ * memcpy: Simple memory copy in various ways
+ *
+ * Written by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
+ */
+#include <ctype.h>
+
+#include "../perf.h"
+#include "../util/util.h"
+#include "../util/parse-options.h"
+#include "../util/string.h"
+#include "../util/header.h"
+#include "bench.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <errno.h>
+
+#define K 1024
+
+static const char       *length_str     = "1MB";
+static const char       *routine        = "default";
+static int              use_clock       = 0;
+static int              clock_fd;
+
+static const struct option options[] = {
+        OPT_STRING('l', "length", &length_str, "1MB",
+                    "Specify length of memory to copy. "
+                    "available unit: B, MB, GB (upper and lower)"),
+        OPT_STRING('r', "routine", &routine, "default",
+                    "Specify routine to copy"),
+        OPT_BOOLEAN('c', "clock", &use_clock,
+                    "Use CPU clock for measuring"),
+        OPT_END()
+};
+
+struct routine {
+        const char *name;
+        const char *desc;
+        void * (*fn)(void *dst, const void *src, size_t len);
+};
+
+struct routine routines[] = {
+        { "default",
+          "Default memcpy() provided by glibc",
+          memcpy },
+        { NULL,
+          NULL,
+          NULL   }
+};
+
+static const char * const bench_mem_memcpy_usage[] = {
+        "perf bench mem memcpy <options>",
+        NULL
+};
+
+static struct perf_event_attr clock_attr = {
+        .type           = PERF_TYPE_HARDWARE,
+        .config         = PERF_COUNT_HW_CPU_CYCLES
+};
+
+static void init_clock(void)
+{
+        clock_fd = sys_perf_event_open(&clock_attr, getpid(), -1, -1, 0);
+
+        if (clock_fd < 0 && errno == ENOSYS)
+                die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
+        else
+                BUG_ON(clock_fd < 0);
+}
+
+static u64 get_clock(void)
+{
+        int ret;
+        u64 clk;
+
+        ret = read(clock_fd, &clk, sizeof(u64));
+        BUG_ON(ret != sizeof(u64));
+
+        return clk;
+}
+
+static double timeval2double(struct timeval *ts)
+{
+        return (double)ts->tv_sec +
+                (double)ts->tv_usec / (double)1000000;
+}
+
+int bench_mem_memcpy(int argc, const char **argv,
+                     const char *prefix __used)
+{
+        int i;
+        void *dst, *src;
+        size_t length;
+        double bps = 0.0;
+        struct timeval tv_start, tv_end, tv_diff;
+        u64 clock_start, clock_end, clock_diff;
+
+        clock_start = clock_end = clock_diff = 0ULL;
+        argc = parse_options(argc, argv, options,
+                             bench_mem_memcpy_usage, 0);
+
+        tv_diff.tv_sec = 0;
+        tv_diff.tv_usec = 0;
+        length = (size_t)perf_atoll((char *)length_str);
+
+        if ((s64)length <= 0) {
+                fprintf(stderr, "Invalid length:%s\n", length_str);
+                return 1;
+        }
+
+        for (i = 0; routines[i].name; i++) {
+                if (!strcmp(routines[i].name, routine))
+                        break;
+        }
+        if (!routines[i].name) {
+                printf("Unknown routine:%s\n", routine);
+                printf("Available routines...\n");
+                for (i = 0; routines[i].name; i++) {
+                        printf("\t%s ... %s\n",
+                               routines[i].name, routines[i].desc);
+                }
+                return 1;
+        }
+
+        dst = zalloc(length);
+        if (!dst)
+                die("memory allocation failed - maybe length is too large?\n");
+
+        src = zalloc(length);
+        if (!src)
+                die("memory allocation failed - maybe length is too large?\n");
+
+        if (bench_format == BENCH_FORMAT_DEFAULT) {
+                printf("# Copying %s Bytes from %p to %p ...\n\n",
+                       length_str, src, dst);
+        }
+
+        if (use_clock) {
+                init_clock();
+                clock_start = get_clock();
+        } else {
+                BUG_ON(gettimeofday(&tv_start, NULL));
+        }
+
+        routines[i].fn(dst, src, length);
+
+        if (use_clock) {
+                clock_end = get_clock();
+                clock_diff = clock_end - clock_start;
+        } else {
+                BUG_ON(gettimeofday(&tv_end, NULL));
+                timersub(&tv_end, &tv_start, &tv_diff);
+                bps = (double)((double)length / timeval2double(&tv_diff));
+        }
+
+        switch (bench_format) {
+        case BENCH_FORMAT_DEFAULT:
+                if (use_clock) {
+                        printf(" %14lf Clock/Byte\n",
+                               (double)clock_diff / (double)length);
+                } else {
+                        if (bps < K)
+                                printf(" %14lf B/Sec\n", bps);
+                        else if (bps < K * K)
+                                printf(" %14lfd KB/Sec\n", bps / 1024);
+                        else if (bps < K * K * K)
+                                printf(" %14lf MB/Sec\n", bps / 1024 / 1024);
+                        else {
+                                printf(" %14lf GB/Sec\n",
+                                       bps / 1024 / 1024 / 1024);
+                        }
+                }
+                break;
+        case BENCH_FORMAT_SIMPLE:
+                if (use_clock) {
+                        printf("%14lf\n",
+                               (double)clock_diff / (double)length);
+                } else
+                        printf("%lf\n", bps);
+                break;
+        default:
+                /* reaching this means there's some disaster: */
+                die("unknown format: %d\n", bench_format);
+                break;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/bench/sched-messaging.c b/tools/perf/bench/sched-messaging.c
new file mode 100644
index 000000000000..81cee78181fa
--- /dev/null
+++ b/tools/perf/bench/sched-messaging.c
@@ -0,0 +1,338 @@
+/*
+ *
+ * sched-messaging.c
+ *
+ * messaging: Benchmark for scheduler and IPC mechanisms
+ *
+ * Based on hackbench by Rusty Russell <rusty@rustcorp.com.au>
+ * Ported to perf by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
+ *
+ */
+
+#include "../perf.h"
+#include "../util/util.h"
+#include "../util/parse-options.h"
+#include "../builtin.h"
+#include "bench.h"
+
+/* Test groups of 20 processes spraying to 20 receivers */
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <sys/time.h>
+#include <sys/poll.h>
+#include <limits.h>
+
+#define DATASIZE 100
+
+static int use_pipes = 0;
+static unsigned int loops = 100;
+static unsigned int thread_mode = 0;
+static unsigned int num_groups = 10;
+
+struct sender_context {
+        unsigned int num_fds;
+        int ready_out;
+        int wakefd;
+        int out_fds[0];
+};
+
+struct receiver_context {
+        unsigned int num_packets;
+        int in_fds[2];
+        int ready_out;
+        int wakefd;
+};
+
+static void barf(const char *msg)
+{
+        fprintf(stderr, "%s (error: %s)\n", msg, strerror(errno));
+        exit(1);
+}
+
+static void fdpair(int fds[2])
+{
+        if (use_pipes) {
+                if (pipe(fds) == 0)
+                        return;
+        } else {
+                if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == 0)
+                        return;
+        }
+
+        barf(use_pipes ? "pipe()" : "socketpair()");
+}
+
+/* Block until we're ready to go */
+static void ready(int ready_out, int wakefd)
+{
+        char dummy;
+        struct pollfd pollfd = { .fd = wakefd, .events = POLLIN };
+
+        /* Tell them we're ready. */
+        if (write(ready_out, &dummy, 1) != 1)
+                barf("CLIENT: ready write");
+
+        /* Wait for "GO" signal */
+        if (poll(&pollfd, 1, -1) != 1)
+                barf("poll");
+}
+
+/* Sender sprays loops messages down each file descriptor */
+static void *sender(struct sender_context *ctx)
+{
+        char data[DATASIZE];
+        unsigned int i, j;
+
+        ready(ctx->ready_out, ctx->wakefd);
+
+        /* Now pump to every receiver. */
+        for (i = 0; i < loops; i++) {
+                for (j = 0; j < ctx->num_fds; j++) {
+                        int ret, done = 0;
+
+again:
+                        ret = write(ctx->out_fds[j], data + done,
+                                    sizeof(data)-done);
+                        if (ret < 0)
+                                barf("SENDER: write");
+                        done += ret;
+                        if (done < DATASIZE)
+                                goto again;
+                }
+        }
+
+        return NULL;
+}
+
+
+/* One receiver per fd */
+static void *receiver(struct receiver_context* ctx)
+{
+        unsigned int i;
+
+        if (!thread_mode)
+                close(ctx->in_fds[1]);
+
+        /* Wait for start... */
+        ready(ctx->ready_out, ctx->wakefd);
+
+        /* Receive them all */
+        for (i = 0; i < ctx->num_packets; i++) {
+                char data[DATASIZE];
+                int ret, done = 0;
+
+again:
+                ret = read(ctx->in_fds[0], data + done, DATASIZE - done);
+                if (ret < 0)
+                        barf("SERVER: read");
+                done += ret;
+                if (done < DATASIZE)
+                        goto again;
+        }
+
+        return NULL;
+}
+
+static pthread_t create_worker(void *ctx, void *(*func)(void *))
+{
+        pthread_attr_t attr;
+        pthread_t childid;
+        int err;
+
+        if (!thread_mode) {
+                /* process mode */
+                /* Fork the receiver. */
+                switch (fork()) {
+                case -1:
+                        barf("fork()");
+                        break;
+                case 0:
+                        (*func) (ctx);
+                        exit(0);
+                        break;
+                default:
+                        break;
+                }
+
+                return (pthread_t)0;
+        }
+
+        if (pthread_attr_init(&attr) != 0)
+                barf("pthread_attr_init:");
+
+#ifndef __ia64__
+        if (pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN) != 0)
+                barf("pthread_attr_setstacksize");
+#endif
+
+        err = pthread_create(&childid, &attr, func, ctx);
+        if (err != 0) {
+                fprintf(stderr, "pthread_create failed: %s (%d)\n",
+                        strerror(err), err);
+                exit(-1);
+        }
+        return childid;
+}
+
+static void reap_worker(pthread_t id)
+{
+        int proc_status;
+        void *thread_status;
+
+        if (!thread_mode) {
+                /* process mode */
+                wait(&proc_status);
+                if (!WIFEXITED(proc_status))
+                        exit(1);
+        } else {
+                pthread_join(id, &thread_status);
+        }
+}
+
+/* One group of senders and receivers */
+static unsigned int group(pthread_t *pth,
+                unsigned int num_fds,
+                int ready_out,
+                int wakefd)
+{
+        unsigned int i;
+        struct sender_context *snd_ctx = malloc(sizeof(struct sender_context)
+                        + num_fds * sizeof(int));
+
+        if (!snd_ctx)
+                barf("malloc()");
+
+        for (i = 0; i < num_fds; i++) {
+                int fds[2];
+                struct receiver_context *ctx = malloc(sizeof(*ctx));
+
+                if (!ctx)
+                        barf("malloc()");
+
+
+                /* Create the pipe between client and server */
+                fdpair(fds);
+
+                ctx->num_packets = num_fds * loops;
+                ctx->in_fds[0] = fds[0];
+                ctx->in_fds[1] = fds[1];
+                ctx->ready_out = ready_out;
+                ctx->wakefd = wakefd;
+
+                pth[i] = create_worker(ctx, (void *)receiver);
+
+                snd_ctx->out_fds[i] = fds[1];
+                if (!thread_mode)
+                        close(fds[0]);
+        }
+
+        /* Now we have all the fds, fork the senders */
+        for (i = 0; i < num_fds; i++) {
+                snd_ctx->ready_out = ready_out;
+                snd_ctx->wakefd = wakefd;
+                snd_ctx->num_fds = num_fds;
+
+                pth[num_fds+i] = create_worker(snd_ctx, (void *)sender);
+        }
+
+        /* Close the fds we have left */
+        if (!thread_mode)
+                for (i = 0; i < num_fds; i++)
+                        close(snd_ctx->out_fds[i]);
+
+        /* Return number of children to reap */
+        return num_fds * 2;
+}
+
+static const struct option options[] = {
+        OPT_BOOLEAN('p', "pipe", &use_pipes,
+                    "Use pipe() instead of socketpair()"),
+        OPT_BOOLEAN('t', "thread", &thread_mode,
+                    "Be multi thread instead of multi process"),
+        OPT_INTEGER('g', "group", &num_groups,
+                    "Specify number of groups"),
+        OPT_INTEGER('l', "loop", &loops,
+                    "Specify number of loops"),
+        OPT_END()
+};
+
+static const char * const bench_sched_message_usage[] = {
+        "perf bench sched messaging <options>",
+        NULL
+};
+
+int bench_sched_messaging(int argc, const char **argv,
+                    const char *prefix __used)
+{
+        unsigned int i, total_children;
+        struct timeval start, stop, diff;
+        unsigned int num_fds = 20;
+        int readyfds[2], wakefds[2];
+        char dummy;
+        pthread_t *pth_tab;
+
+        argc = parse_options(argc, argv, options,
+                             bench_sched_message_usage, 0);
+
+        pth_tab = malloc(num_fds * 2 * num_groups * sizeof(pthread_t));
+        if (!pth_tab)
+                barf("main:malloc()");
+
+        fdpair(readyfds);
+        fdpair(wakefds);
+
+        total_children = 0;
+        for (i = 0; i < num_groups; i++)
+                total_children += group(pth_tab+total_children, num_fds,
+                                        readyfds[1], wakefds[0]);
+
+        /* Wait for everyone to be ready */
+        for (i = 0; i < total_children; i++)
+                if (read(readyfds[0], &dummy, 1) != 1)
+                        barf("Reading for readyfds");
+
+        gettimeofday(&start, NULL);
+
+        /* Kick them off */
+        if (write(wakefds[1], &dummy, 1) != 1)
+                barf("Writing to start them");
+
+        /* Reap them all */
+        for (i = 0; i < total_children; i++)
+                reap_worker(pth_tab[i]);
+
+        gettimeofday(&stop, NULL);
+
+        timersub(&stop, &start, &diff);
+
+        switch (bench_format) {
+        case BENCH_FORMAT_DEFAULT:
+                printf("# %d sender and receiver %s per group\n",
+                       num_fds, thread_mode ? "threads" : "processes");
+                printf("# %d groups == %d %s run\n\n",
+                       num_groups, num_groups * 2 * num_fds,
+                       thread_mode ? "threads" : "processes");
+                printf(" %14s: %lu.%03lu [sec]\n", "Total time",
+                       diff.tv_sec,
+                       (unsigned long) (diff.tv_usec/1000));
+                break;
+        case BENCH_FORMAT_SIMPLE:
+                printf("%lu.%03lu\n", diff.tv_sec,
+                       (unsigned long) (diff.tv_usec/1000));
+                break;
+        default:
+                /* reaching here is something disaster */
+                fprintf(stderr, "Unknown format:%d\n", bench_format);
+                exit(1);
+                break;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/bench/sched-pipe.c b/tools/perf/bench/sched-pipe.c
new file mode 100644
index 000000000000..4f77c7c27640
--- /dev/null
+++ b/tools/perf/bench/sched-pipe.c
@@ -0,0 +1,127 @@
+/*
+ *
+ * sched-pipe.c
+ *
+ * pipe: Benchmark for pipe()
+ *
+ * Based on pipe-test-1m.c by Ingo Molnar <mingo@redhat.com>
+ *  http://people.redhat.com/mingo/cfs-scheduler/tools/pipe-test-1m.c
+ * Ported to perf by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
+ *
+ */
+
+#include "../perf.h"
+#include "../util/util.h"
+#include "../util/parse-options.h"
+#include "../builtin.h"
+#include "bench.h"
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <linux/unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#define LOOPS_DEFAULT 1000000
+static int loops = LOOPS_DEFAULT;
+
+static const struct option options[] = {
+        OPT_INTEGER('l', "loop", &loops,
+                    "Specify number of loops"),
+        OPT_END()
+};
+
+static const char * const bench_sched_pipe_usage[] = {
+        "perf bench sched pipe <options>",
+        NULL
+};
+
+int bench_sched_pipe(int argc, const char **argv,
+                     const char *prefix __used)
+{
+        int pipe_1[2], pipe_2[2];
+        int m = 0, i;
+        struct timeval start, stop, diff;
+        unsigned long long result_usec = 0;
+
+        /*
+         * why does "ret" exist?
+         * discarding returned value of read(), write()
+         * causes error in building environment for perf
+         */
+        int ret, wait_stat;
+        pid_t pid, retpid;
+
+        argc = parse_options(argc, argv, options,
+                             bench_sched_pipe_usage, 0);
+
+        assert(!pipe(pipe_1));
+        assert(!pipe(pipe_2));
+
+        pid = fork();
+        assert(pid >= 0);
+
+        gettimeofday(&start, NULL);
+
+        if (!pid) {
+                for (i = 0; i < loops; i++) {
+                        ret = read(pipe_1[0], &m, sizeof(int));
+                        ret = write(pipe_2[1], &m, sizeof(int));
+                }
+        } else {
+                for (i = 0; i < loops; i++) {
+                        ret = write(pipe_1[1], &m, sizeof(int));
+                        ret = read(pipe_2[0], &m, sizeof(int));
+                }
+        }
+
+        gettimeofday(&stop, NULL);
+        timersub(&stop, &start, &diff);
+
+        if (pid) {
+                retpid = waitpid(pid, &wait_stat, 0);
+                assert((retpid == pid) && WIFEXITED(wait_stat));
+        } else {
+                exit(0);
+        }
+
+        switch (bench_format) {
+        case BENCH_FORMAT_DEFAULT:
+                printf("# Extecuted %d pipe operations between two tasks\n\n",
+                        loops);
+
+                result_usec = diff.tv_sec * 1000000;
+                result_usec += diff.tv_usec;
+
+                printf(" %14s: %lu.%03lu [sec]\n\n", "Total time",
+                       diff.tv_sec,
+                       (unsigned long) (diff.tv_usec/1000));
+
+                printf(" %14lf usecs/op\n",
+                       (double)result_usec / (double)loops);
+                printf(" %14d ops/sec\n",
+                       (int)((double)loops /
+                             ((double)result_usec / (double)1000000)));
+                break;
+
+        case BENCH_FORMAT_SIMPLE:
+                printf("%lu.%03lu\n",
+                       diff.tv_sec,
+                       (unsigned long) (diff.tv_usec / 1000));
+                break;
+
+        default:
+                /* reaching here is something disaster */
+                fprintf(stderr, "Unknown format:%d\n", bench_format);
+                exit(1);
+                break;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 1ec741615814..6ad7148451c5 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -19,29 +19,26 @@
 #include "perf.h"
 #include "util/debug.h"
 
+#include "util/event.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 #include "util/thread.h"
+#include "util/sort.h"
+#include "util/hist.h"
+#include "util/session.h"
 
 static char             const *input_name = "perf.data";
 
-static char             default_sort_order[] = "comm,symbol";
-static char             *sort_order = default_sort_order;
-
 static int              force;
-static int              input;
-static int              show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
 
 static int              full_paths;
 
 static int              print_line;
 
-static unsigned long    page_size;
-static unsigned long    mmap_window = 32;
-
-static struct rb_root   threads;
-static struct thread    *last_match;
-
+struct sym_hist {
+        u64             sum;
+        u64             ip[0];
+};
 
 struct sym_ext {
         struct rb_node  node;
@@ -49,636 +46,157 @@ struct sym_ext {
         char            *path;
 };
 
-/*
- * histogram, sorted on item, collects counts
- */
-
-static struct rb_root hist;
-
-struct hist_entry {
-        struct rb_node   rb_node;
-
-        struct thread    *thread;
-        struct map       *map;
-        struct dso       *dso;
-        struct symbol    *sym;
-        u64      ip;
-        char             level;
-
-        uint32_t         count;
-};
-
-/*
- * configurable sorting bits
- */
-
-struct sort_entry {
-        struct list_head list;
-
-        const char *header;
-
-        int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
-        int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
-        size_t  (*print)(FILE *fp, struct hist_entry *);
-};
-
-/* --sort pid */
-
-static int64_t
-sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        return right->thread->pid - left->thread->pid;
-}
-
-static size_t
-sort__thread_print(FILE *fp, struct hist_entry *self)
-{
-        return fprintf(fp, "%16s:%5d", self->thread->comm ?: "", self->thread->pid);
-}
-
-static struct sort_entry sort_thread = {
-        .header = "         Command:  Pid",
-        .cmp    = sort__thread_cmp,
-        .print  = sort__thread_print,
-};
-
-/* --sort comm */
-
-static int64_t
-sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        return right->thread->pid - left->thread->pid;
-}
-
-static int64_t
-sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
-{
-        char *comm_l = left->thread->comm;
-        char *comm_r = right->thread->comm;
-
-        if (!comm_l || !comm_r) {
-                if (!comm_l && !comm_r)
-                        return 0;
-                else if (!comm_l)
-                        return -1;
-                else
-                        return 1;
-        }
-
-        return strcmp(comm_l, comm_r);
-}
-
-static size_t
-sort__comm_print(FILE *fp, struct hist_entry *self)
-{
-        return fprintf(fp, "%16s", self->thread->comm);
-}
-
-static struct sort_entry sort_comm = {
-        .header         = "         Command",
-        .cmp            = sort__comm_cmp,
-        .collapse       = sort__comm_collapse,
-        .print          = sort__comm_print,
-};
-
-/* --sort dso */
-
-static int64_t
-sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        struct dso *dso_l = left->dso;
-        struct dso *dso_r = right->dso;
-
-        if (!dso_l || !dso_r) {
-                if (!dso_l && !dso_r)
-                        return 0;
-                else if (!dso_l)
-                        return -1;
-                else
-                        return 1;
-        }
-
-        return strcmp(dso_l->name, dso_r->name);
-}
-
-static size_t
-sort__dso_print(FILE *fp, struct hist_entry *self)
-{
-        if (self->dso)
-                return fprintf(fp, "%-25s", self->dso->name);
-
-        return fprintf(fp, "%016llx         ", (u64)self->ip);
-}
-
-static struct sort_entry sort_dso = {
-        .header = "Shared Object            ",
-        .cmp    = sort__dso_cmp,
-        .print  = sort__dso_print,
-};
-
-/* --sort symbol */
-
-static int64_t
-sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        u64 ip_l, ip_r;
-
-        if (left->sym == right->sym)
-                return 0;
-
-        ip_l = left->sym ? left->sym->start : left->ip;
-        ip_r = right->sym ? right->sym->start : right->ip;
-
-        return (int64_t)(ip_r - ip_l);
-}
-
-static size_t
-sort__sym_print(FILE *fp, struct hist_entry *self)
-{
-        size_t ret = 0;
-
-        if (verbose)
-                ret += fprintf(fp, "%#018llx  ", (u64)self->ip);
-
-        if (self->sym) {
-                ret += fprintf(fp, "[%c] %s",
-                        self->dso == kernel_dso ? 'k' : '.', self->sym->name);
-        } else {
-                ret += fprintf(fp, "%#016llx", (u64)self->ip);
-        }
-
-        return ret;
-}
-
-static struct sort_entry sort_sym = {
-        .header = "Symbol",
-        .cmp    = sort__sym_cmp,
-        .print  = sort__sym_print,
-};
-
-static int sort__need_collapse = 0;
-
-struct sort_dimension {
-        const char              *name;
-        struct sort_entry       *entry;
-        int                     taken;
+struct sym_priv {
+        struct sym_hist *hist;
+        struct sym_ext  *ext;
 };
 
-static struct sort_dimension sort_dimensions[] = {
-        { .name = "pid",        .entry = &sort_thread,  },
-        { .name = "comm",       .entry = &sort_comm,    },
-        { .name = "dso",        .entry = &sort_dso,     },
-        { .name = "symbol",     .entry = &sort_sym,     },
-};
-
-static LIST_HEAD(hist_entry__sort_list);
-
-static int sort_dimension__add(char *tok)
-{
-        unsigned int i;
-
-        for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
-                struct sort_dimension *sd = &sort_dimensions[i];
-
-                if (sd->taken)
-                        continue;
-
-                if (strncasecmp(tok, sd->name, strlen(tok)))
-                        continue;
-
-                if (sd->entry->collapse)
-                        sort__need_collapse = 1;
-
-                list_add_tail(&sd->entry->list, &hist_entry__sort_list);
-                sd->taken = 1;
-
-                return 0;
-        }
-
-        return -ESRCH;
-}
-
-static int64_t
-hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        struct sort_entry *se;
-        int64_t cmp = 0;
-
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                cmp = se->cmp(left, right);
-                if (cmp)
-                        break;
-        }
-
-        return cmp;
-}
+static const char *sym_hist_filter;
 
-static int64_t
-hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
+static int sym__alloc_hist(struct symbol *self)
 {
-        struct sort_entry *se;
-        int64_t cmp = 0;
+        struct sym_priv *priv = symbol__priv(self);
+        const int size = (sizeof(*priv->hist) +
+                          (self->end - self->start) * sizeof(u64));
 
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                int64_t (*f)(struct hist_entry *, struct hist_entry *);
-
-                f = se->collapse ?: se->cmp;
-
-                cmp = f(left, right);
-                if (cmp)
-                        break;
-        }
-
-        return cmp;
+        priv->hist = zalloc(size);
+        return priv->hist == NULL ? -1 : 0;
 }
 
 /*
  * collect histogram counts
  */
-static void hist_hit(struct hist_entry *he, u64 ip)
+static int annotate__hist_hit(struct hist_entry *he, u64 ip)
 {
         unsigned int sym_size, offset;
         struct symbol *sym = he->sym;
+        struct sym_priv *priv;
+        struct sym_hist *h;
 
         he->count++;
 
-        if (!sym || !sym->hist)
-                return;
+        if (!sym || !he->map)
+                return 0;
+
+        priv = symbol__priv(sym);
+        if (priv->hist == NULL && sym__alloc_hist(sym) < 0)
+                return -ENOMEM;
 
         sym_size = sym->end - sym->start;
         offset = ip - sym->start;
 
+        pr_debug3("%s: ip=%#Lx\n", __func__, he->map->unmap_ip(he->map, ip));
+
         if (offset >= sym_size)
-                return;
+                return 0;
 
-        sym->hist_sum++;
-        sym->hist[offset]++;
+        h = priv->hist;
+        h->sum++;
+        h->ip[offset]++;
 
-        if (verbose >= 3)
-                printf("%p %s: count++ [ip: %p, %08Lx] => %Ld\n",
-                        (void *)(unsigned long)he->sym->start,
-                        he->sym->name,
-                        (void *)(unsigned long)ip, ip - he->sym->start,
-                        sym->hist[offset]);
+        pr_debug3("%#Lx %s: count++ [ip: %#Lx, %#Lx] => %Ld\n", he->sym->start,
+                  he->sym->name, ip, ip - he->sym->start, h->ip[offset]);
+        return 0;
 }
 
-static int
-hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
-                struct symbol *sym, u64 ip, char level)
+static int perf_session__add_hist_entry(struct perf_session *self,
+                                        struct addr_location *al, u64 count)
 {
-        struct rb_node **p = &hist.rb_node;
-        struct rb_node *parent = NULL;
+        bool hit;
         struct hist_entry *he;
-        struct hist_entry entry = {
-                .thread = thread,
-                .map    = map,
-                .dso    = dso,
-                .sym    = sym,
-                .ip     = ip,
-                .level  = level,
-                .count  = 1,
-        };
-        int cmp;
-
-        while (*p != NULL) {
-                parent = *p;
-                he = rb_entry(parent, struct hist_entry, rb_node);
-
-                cmp = hist_entry__cmp(&entry, he);
-
-                if (!cmp) {
-                        hist_hit(he, ip);
 
-                        return 0;
+        if (sym_hist_filter != NULL &&
+            (al->sym == NULL || strcmp(sym_hist_filter, al->sym->name) != 0)) {
+                /* We're only interested in a symbol named sym_hist_filter */
+                if (al->sym != NULL) {
+                        rb_erase(&al->sym->rb_node,
+                                 &al->map->dso->symbols[al->map->type]);
+                        symbol__delete(al->sym);
                 }
-
-                if (cmp < 0)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
+                return 0;
         }
 
-        he = malloc(sizeof(*he));
-        if (!he)
+        he = __perf_session__add_hist_entry(&self->hists, al, NULL, count, &hit);
+        if (he == NULL)
                 return -ENOMEM;
-        *he = entry;
-        rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, &hist);
-
-        return 0;
-}
-
-static void hist_entry__free(struct hist_entry *he)
-{
-        free(he);
-}
-
-/*
- * collapse the histogram
- */
-
-static struct rb_root collapse_hists;
-
-static void collapse__insert_entry(struct hist_entry *he)
-{
-        struct rb_node **p = &collapse_hists.rb_node;
-        struct rb_node *parent = NULL;
-        struct hist_entry *iter;
-        int64_t cmp;
-
-        while (*p != NULL) {
-                parent = *p;
-                iter = rb_entry(parent, struct hist_entry, rb_node);
-
-                cmp = hist_entry__collapse(iter, he);
-
-                if (!cmp) {
-                        iter->count += he->count;
-                        hist_entry__free(he);
-                        return;
-                }
-
-                if (cmp < 0)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-
-        rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, &collapse_hists);
-}
-
-static void collapse__resort(void)
-{
-        struct rb_node *next;
-        struct hist_entry *n;
-
-        if (!sort__need_collapse)
-                return;
-
-        next = rb_first(&hist);
-        while (next) {
-                n = rb_entry(next, struct hist_entry, rb_node);
-                next = rb_next(&n->rb_node);
-
-                rb_erase(&n->rb_node, &hist);
-                collapse__insert_entry(n);
-        }
-}
-
-/*
- * reverse the map, sort on count.
- */
-
-static struct rb_root output_hists;
-
-static void output__insert_entry(struct hist_entry *he)
-{
-        struct rb_node **p = &output_hists.rb_node;
-        struct rb_node *parent = NULL;
-        struct hist_entry *iter;
-
-        while (*p != NULL) {
-                parent = *p;
-                iter = rb_entry(parent, struct hist_entry, rb_node);
-
-                if (he->count > iter->count)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
 
-        rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, &output_hists);
+        return annotate__hist_hit(he, al->addr);
 }
 
-static void output__resort(void)
+static int process_sample_event(event_t *event, struct perf_session *session)
 {
-        struct rb_node *next;
-        struct hist_entry *n;
-        struct rb_root *tree = &hist;
-
-        if (sort__need_collapse)
-                tree = &collapse_hists;
-
-        next = rb_first(tree);
-
-        while (next) {
-                n = rb_entry(next, struct hist_entry, rb_node);
-                next = rb_next(&n->rb_node);
-
-                rb_erase(&n->rb_node, tree);
-                output__insert_entry(n);
-        }
-}
+        struct addr_location al;
 
-static unsigned long total = 0,
-                     total_mmap = 0,
-                     total_comm = 0,
-                     total_fork = 0,
-                     total_unknown = 0;
+        dump_printf("(IP, %d): %d: %#Lx\n", event->header.misc,
+                    event->ip.pid, event->ip.ip);
 
-static int
-process_sample_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        char level;
-        int show = 0;
-        struct dso *dso = NULL;
-        struct thread *thread;
-        u64 ip = event->ip.ip;
-        struct map *map = NULL;
-
-        thread = threads__findnew(event->ip.pid, &threads, &last_match);
-
-        dump_printf("%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->header.misc,
-                event->ip.pid,
-                (void *)(long)ip);
-
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
-
-        if (thread == NULL) {
-                fprintf(stderr, "problem processing %d event, skipping it.\n",
-                        event->header.type);
+        if (event__preprocess_sample(event, session, &al, NULL) < 0) {
+                pr_warning("problem processing %d event, skipping it.\n",
+                           event->header.type);
                 return -1;
         }
 
-        if (event->header.misc & PERF_RECORD_MISC_KERNEL) {
-                show = SHOW_KERNEL;
-                level = 'k';
-
-                dso = kernel_dso;
-
-                dump_printf(" ...... dso: %s\n", dso->name);
-
-        } else if (event->header.misc & PERF_RECORD_MISC_USER) {
-
-                show = SHOW_USER;
-                level = '.';
-
-                map = thread__find_map(thread, ip);
-                if (map != NULL) {
-                        ip = map->map_ip(map, ip);
-                        dso = map->dso;
-                } else {
-                        /*
-                         * If this is outside of all known maps,
-                         * and is a negative address, try to look it
-                         * up in the kernel dso, as it might be a
-                         * vsyscall (which executes in user-mode):
-                         */
-                        if ((long long)ip < 0)
-                                dso = kernel_dso;
-                }
-                dump_printf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
-
-        } else {
-                show = SHOW_HV;
-                level = 'H';
-                dump_printf(" ...... dso: [hypervisor]\n");
-        }
-
-        if (show & show_mask) {
-                struct symbol *sym = NULL;
-
-                if (dso)
-                        sym = dso->find_symbol(dso, ip);
-
-                if (hist_entry__add(thread, map, dso, sym, ip, level)) {
-                        fprintf(stderr,
-                "problem incrementing symbol count, skipping event\n");
-                        return -1;
-                }
+        if (!al.filtered && perf_session__add_hist_entry(session, &al, 1)) {
+                pr_warning("problem incrementing symbol count, "
+                           "skipping event\n");
+                return -1;
         }
-        total++;
 
         return 0;
 }
 
-static int
-process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        struct thread *thread;
-        struct map *map = map__new(&event->mmap, NULL, 0);
-
-        thread = threads__findnew(event->mmap.pid, &threads, &last_match);
-
-        dump_printf("%p [%p]: PERF_RECORD_MMAP %d: [%p(%p) @ %p]: %s\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->mmap.pid,
-                (void *)(long)event->mmap.start,
-                (void *)(long)event->mmap.len,
-                (void *)(long)event->mmap.pgoff,
-                event->mmap.filename);
-
-        if (thread == NULL || map == NULL) {
-                dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
-                return 0;
-        }
-
-        thread__insert_map(thread, map);
-        total_mmap++;
-
-        return 0;
-}
+struct objdump_line {
+        struct list_head node;
+        s64              offset;
+        char             *line;
+};
 
-static int
-process_comm_event(event_t *event, unsigned long offset, unsigned long head)
+static struct objdump_line *objdump_line__new(s64 offset, char *line)
 {
-        struct thread *thread;
+        struct objdump_line *self = malloc(sizeof(*self));
 
-        thread = threads__findnew(event->comm.pid, &threads, &last_match);
-        dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->comm.comm, event->comm.pid);
-
-        if (thread == NULL ||
-            thread__set_comm(thread, event->comm.comm)) {
-                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
-                return -1;
+        if (self != NULL) {
+                self->offset = offset;
+                self->line = line;
         }
-        total_comm++;
 
-        return 0;
+        return self;
 }
 
-static int
-process_fork_event(event_t *event, unsigned long offset, unsigned long head)
+static void objdump_line__free(struct objdump_line *self)
 {
-        struct thread *thread;
-        struct thread *parent;
-
-        thread = threads__findnew(event->fork.pid, &threads, &last_match);
-        parent = threads__findnew(event->fork.ppid, &threads, &last_match);
-        dump_printf("%p [%p]: PERF_RECORD_FORK: %d:%d\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->fork.pid, event->fork.ppid);
-
-        /*
-         * A thread clone will have the same PID for both
-         * parent and child.
-         */
-        if (thread == parent)
-                return 0;
-
-        if (!thread || !parent || thread__fork(thread, parent)) {
-                dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
-                return -1;
-        }
-        total_fork++;
-
-        return 0;
+        free(self->line);
+        free(self);
 }
 
-static int
-process_event(event_t *event, unsigned long offset, unsigned long head)
+static void objdump__add_line(struct list_head *head, struct objdump_line *line)
 {
-        switch (event->header.type) {
-        case PERF_RECORD_SAMPLE:
-                return process_sample_event(event, offset, head);
-
-        case PERF_RECORD_MMAP:
-                return process_mmap_event(event, offset, head);
-
-        case PERF_RECORD_COMM:
-                return process_comm_event(event, offset, head);
-
-        case PERF_RECORD_FORK:
-                return process_fork_event(event, offset, head);
-        /*
-         * We dont process them right now but they are fine:
-         */
-
-        case PERF_RECORD_THROTTLE:
-        case PERF_RECORD_UNTHROTTLE:
-                return 0;
+        list_add_tail(&line->node, head);
+}
 
-        default:
-                return -1;
-        }
+static struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
+                                                      struct objdump_line *pos)
+{
+        list_for_each_entry_continue(pos, head, node)
+                if (pos->offset >= 0)
+                        return pos;
 
-        return 0;
+        return NULL;
 }
 
-static int
-parse_line(FILE *file, struct symbol *sym, u64 start, u64 len)
+static int parse_line(FILE *file, struct hist_entry *he,
+                      struct list_head *head)
 {
+        struct symbol *sym = he->sym;
+        struct objdump_line *objdump_line;
         char *line = NULL, *tmp, *tmp2;
-        static const char *prev_line;
-        static const char *prev_color;
-        unsigned int offset;
         size_t line_len;
-        s64 line_ip;
-        int ret;
+        s64 line_ip, offset = -1;
         char *c;
 
         if (getline(&line, &line_len, file) < 0)
                 return -1;
+
         if (!line)
                 return -1;
 
@@ -687,8 +205,6 @@ parse_line(FILE *file, struct symbol *sym, u64 start, u64 len)
                 *c = 0;
 
         line_ip = -1;
-        offset = 0;
-        ret = -2;
 
         /*
          * Strip leading spaces:
@@ -710,21 +226,53 @@ parse_line(FILE *file, struct symbol *sym, u64 start, u64 len)
         }
 
         if (line_ip != -1) {
+                u64 start = map__rip_2objdump(he->map, sym->start);
+                offset = line_ip - start;
+        }
+
+        objdump_line = objdump_line__new(offset, line);
+        if (objdump_line == NULL) {
+                free(line);
+                return -1;
+        }
+        objdump__add_line(head, objdump_line);
+
+        return 0;
+}
+
+static int objdump_line__print(struct objdump_line *self,
+                               struct list_head *head,
+                               struct hist_entry *he, u64 len)
+{
+        struct symbol *sym = he->sym;
+        static const char *prev_line;
+        static const char *prev_color;
+
+        if (self->offset != -1) {
                 const char *path = NULL;
                 unsigned int hits = 0;
                 double percent = 0.0;
                 const char *color;
-                struct sym_ext *sym_ext = sym->priv;
-
-                offset = line_ip - start;
-                if (offset < len)
-                        hits = sym->hist[offset];
+                struct sym_priv *priv = symbol__priv(sym);
+                struct sym_ext *sym_ext = priv->ext;
+                struct sym_hist *h = priv->hist;
+                s64 offset = self->offset;
+                struct objdump_line *next = objdump__get_next_ip_line(head, self);
+
+                while (offset < (s64)len &&
+                       (next == NULL || offset < next->offset)) {
+                        if (sym_ext) {
+                                if (path == NULL)
+                                        path = sym_ext[offset].path;
+                                percent += sym_ext[offset].percent;
+                        } else
+                                hits += h->ip[offset];
+
+                        ++offset;
+                }
 
-                if (offset < len && sym_ext) {
-                        path = sym_ext[offset].path;
-                        percent = sym_ext[offset].percent;
-                } else if (sym->hist_sum)
-                        percent = 100.0 * hits / sym->hist_sum;
+                if (sym_ext == NULL && h->sum)
+                        percent = 100.0 * hits / h->sum;
 
                 color = get_percent_color(percent);
 
@@ -744,12 +292,12 @@ parse_line(FILE *file, struct symbol *sym, u64 start, u64 len)
 
                 color_fprintf(stdout, color, " %7.2f", percent);
                 printf(" :      ");
-                color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", line);
+                color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", self->line);
         } else {
-                if (!*line)
+                if (!*self->line)
                         printf("         :\n");
                 else
-                        printf("         :      %s\n", line);
+                        printf("         :      %s\n", self->line);
         }
 
         return 0;
@@ -777,9 +325,10 @@ static void insert_source_line(struct sym_ext *sym_ext)
         rb_insert_color(&sym_ext->node, &root_sym_ext);
 }
 
-static void free_source_line(struct symbol *sym, int len)
+static void free_source_line(struct hist_entry *he, int len)
 {
-        struct sym_ext *sym_ext = sym->priv;
+        struct sym_priv *priv = symbol__priv(he->sym);
+        struct sym_ext *sym_ext = priv->ext;
         int i;
 
         if (!sym_ext)
@@ -789,26 +338,30 @@ static void free_source_line(struct symbol *sym, int len)
                 free(sym_ext[i].path);
         free(sym_ext);
 
-        sym->priv = NULL;
+        priv->ext = NULL;
         root_sym_ext = RB_ROOT;
 }
 
 /* Get the filename:line for the colored entries */
 static void
-get_source_line(struct symbol *sym, u64 start, int len, const char *filename)
+get_source_line(struct hist_entry *he, int len, const char *filename)
 {
+        struct symbol *sym = he->sym;
+        u64 start;
         int i;
         char cmd[PATH_MAX * 2];
         struct sym_ext *sym_ext;
+        struct sym_priv *priv = symbol__priv(sym);
+        struct sym_hist *h = priv->hist;
 
-        if (!sym->hist_sum)
+        if (!h->sum)
                 return;
 
-        sym->priv = calloc(len, sizeof(struct sym_ext));
-        if (!sym->priv)
+        sym_ext = priv->ext = calloc(len, sizeof(struct sym_ext));
+        if (!priv->ext)
                 return;
 
-        sym_ext = sym->priv;
+        start = he->map->unmap_ip(he->map, sym->start);
 
         for (i = 0; i < len; i++) {
                 char *path = NULL;
@@ -816,7 +369,7 @@ get_source_line(struct symbol *sym, u64 start, int len, const char *filename)
                 u64 offset;
                 FILE *fp;
 
-                sym_ext[i].percent = 100.0 * sym->hist[i] / sym->hist_sum;
+                sym_ext[i].percent = 100.0 * h->ip[i] / h->sum;
                 if (sym_ext[i].percent <= 0.5)
                         continue;
 
@@ -870,33 +423,48 @@ static void print_summary(const char *filename)
         }
 }
 
-static void annotate_sym(struct dso *dso, struct symbol *sym)
+static void hist_entry__print_hits(struct hist_entry *self)
+{
+        struct symbol *sym = self->sym;
+        struct sym_priv *priv = symbol__priv(sym);
+        struct sym_hist *h = priv->hist;
+        u64 len = sym->end - sym->start, offset;
+
+        for (offset = 0; offset < len; ++offset)
+                if (h->ip[offset] != 0)
+                        printf("%*Lx: %Lu\n", BITS_PER_LONG / 2,
+                               sym->start + offset, h->ip[offset]);
+        printf("%*s: %Lu\n", BITS_PER_LONG / 2, "h->sum", h->sum);
+}
+
+static void annotate_sym(struct hist_entry *he)
 {
-        const char *filename = dso->name, *d_filename;
-        u64 start, end, len;
+        struct map *map = he->map;
+        struct dso *dso = map->dso;
+        struct symbol *sym = he->sym;
+        const char *filename = dso->long_name, *d_filename;
+        u64 len;
         char command[PATH_MAX*2];
         FILE *file;
+        LIST_HEAD(head);
+        struct objdump_line *pos, *n;
 
         if (!filename)
                 return;
-        if (sym->module)
-                filename = sym->module->path;
-        else if (dso == kernel_dso)
-                filename = vmlinux_name;
-
-        start = sym->obj_start;
-        if (!start)
-                start = sym->start;
+
+        pr_debug("%s: filename=%s, sym=%s, start=%#Lx, end=%#Lx\n", __func__,
+                 filename, sym->name, map->unmap_ip(map, sym->start),
+                 map->unmap_ip(map, sym->end));
+
         if (full_paths)
                 d_filename = filename;
         else
                 d_filename = basename(filename);
 
-        end = start + sym->end - sym->start + 1;
         len = sym->end - sym->start;
 
         if (print_line) {
-                get_source_line(sym, start, len, filename);
+                get_source_line(he, len, filename);
                 print_summary(filename);
         }
 
@@ -905,10 +473,13 @@ static void annotate_sym(struct dso *dso, struct symbol *sym)
         printf("------------------------------------------------\n");
 
         if (verbose >= 2)
-                printf("annotating [%p] %30s : [%p] %30s\n", dso, dso->name, sym, sym->name);
+                printf("annotating [%p] %30s : [%p] %30s\n",
+                       dso, dso->long_name, sym, sym->name);
 
         sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s|grep -v %s",
-                        (u64)start, (u64)end, filename, filename);
+                map__rip_2objdump(map, sym->start),
+                map__rip_2objdump(map, sym->end),
+                filename, filename);
 
         if (verbose >= 3)
                 printf("doing: %s\n", command);
@@ -918,159 +489,88 @@ static void annotate_sym(struct dso *dso, struct symbol *sym)
                 return;
 
         while (!feof(file)) {
-                if (parse_line(file, sym, start, len) < 0)
+                if (parse_line(file, he, &head) < 0)
                         break;
         }
 
         pclose(file);
-        if (print_line)
-                free_source_line(sym, len);
-}
 
-static void find_annotations(void)
-{
-        struct rb_node *nd;
-        struct dso *dso;
-        int count = 0;
-
-        list_for_each_entry(dso, &dsos, node) {
-
-                for (nd = rb_first(&dso->syms); nd; nd = rb_next(nd)) {
-                        struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
+        if (verbose)
+                hist_entry__print_hits(he);
 
-                        if (sym->hist) {
-                                annotate_sym(dso, sym);
-                                count++;
-                        }
-                }
+        list_for_each_entry_safe(pos, n, &head, node) {
+                objdump_line__print(pos, &head, he, len);
+                list_del(&pos->node);
+                objdump_line__free(pos);
         }
 
-        if (!count)
-                printf(" Error: symbol '%s' not present amongst the samples.\n", sym_hist_filter);
+        if (print_line)
+                free_source_line(he, len);
 }
 
-static int __cmd_annotate(void)
+static void perf_session__find_annotations(struct perf_session *self)
 {
-        int ret, rc = EXIT_FAILURE;
-        unsigned long offset = 0;
-        unsigned long head = 0;
-        struct stat input_stat;
-        event_t *event;
-        uint32_t size;
-        char *buf;
-
-        register_idle_thread(&threads, &last_match);
-
-        input = open(input_name, O_RDONLY);
-        if (input < 0) {
-                perror("failed to open file");
-                exit(-1);
-        }
-
-        ret = fstat(input, &input_stat);
-        if (ret < 0) {
-                perror("failed to stat file");
-                exit(-1);
-        }
-
-        if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
-                fprintf(stderr, "file: %s not owned by current user or root\n", input_name);
-                exit(-1);
-        }
-
-        if (!input_stat.st_size) {
-                fprintf(stderr, "zero-sized file, nothing to do!\n");
-                exit(0);
-        }
-
-        if (load_kernel() < 0) {
-                perror("failed to load kernel symbols");
-                return EXIT_FAILURE;
-        }
-
-remap:
-        buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
-                           MAP_SHARED, input, offset);
-        if (buf == MAP_FAILED) {
-                perror("failed to mmap file");
-                exit(-1);
-        }
-
-more:
-        event = (event_t *)(buf + head);
-
-        size = event->header.size;
-        if (!size)
-                size = 8;
-
-        if (head + event->header.size >= page_size * mmap_window) {
-                unsigned long shift = page_size * (head / page_size);
-                int munmap_ret;
-
-                munmap_ret = munmap(buf, page_size * mmap_window);
-                assert(munmap_ret == 0);
-
-                offset += shift;
-                head -= shift;
-                goto remap;
-        }
-
-        size = event->header.size;
-
-        dump_printf("%p [%p]: event: %d\n",
-                        (void *)(offset + head),
-                        (void *)(long)event->header.size,
-                        event->header.type);
+        struct rb_node *nd;
 
-        if (!size || process_event(event, offset, head) < 0) {
+        for (nd = rb_first(&self->hists); nd; nd = rb_next(nd)) {
+                struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
+                struct sym_priv *priv;
 
-                dump_printf("%p [%p]: skipping unknown header type: %d\n",
-                        (void *)(offset + head),
-                        (void *)(long)(event->header.size),
-                        event->header.type);
+                if (he->sym == NULL)
+                        continue;
 
-                total_unknown++;
+                priv = symbol__priv(he->sym);
+                if (priv->hist == NULL)
+                        continue;
 
+                annotate_sym(he);
                 /*
-                 * assume we lost track of the stream, check alignment, and
-                 * increment a single u64 in the hope to catch on again 'soon'.
+                 * Since we have a hist_entry per IP for the same symbol, free
+                 * he->sym->hist to signal we already processed this symbol.
                  */
-
-                if (unlikely(head & 7))
-                        head &= ~7ULL;
-
-                size = 8;
+                free(priv->hist);
+                priv->hist = NULL;
         }
+}
 
-        head += size;
+static struct perf_event_ops event_ops = {
+        .sample = process_sample_event,
+        .mmap   = event__process_mmap,
+        .comm   = event__process_comm,
+        .fork   = event__process_task,
+};
 
-        if (offset + head < (unsigned long)input_stat.st_size)
-                goto more;
+static int __cmd_annotate(void)
+{
+        int ret;
+        struct perf_session *session;
 
-        rc = EXIT_SUCCESS;
-        close(input);
+        session = perf_session__new(input_name, O_RDONLY, force);
+        if (session == NULL)
+                return -ENOMEM;
 
-        dump_printf("      IP events: %10ld\n", total);
-        dump_printf("    mmap events: %10ld\n", total_mmap);
-        dump_printf("    comm events: %10ld\n", total_comm);
-        dump_printf("    fork events: %10ld\n", total_fork);
-        dump_printf(" unknown events: %10ld\n", total_unknown);
+        ret = perf_session__process_events(session, &event_ops);
+        if (ret)
+                goto out_delete;
 
-        if (dump_trace)
-                return 0;
+        if (dump_trace) {
+                event__print_totals();
+                goto out_delete;
+        }
 
-        if (verbose >= 3)
-                threads__fprintf(stdout, &threads);
+        if (verbose > 3)
+                perf_session__fprintf(session, stdout);
 
-        if (verbose >= 2)
+        if (verbose > 2)
                 dsos__fprintf(stdout);
 
-        collapse__resort();
-        output__resort();
+        perf_session__collapse_resort(&session->hists);
+        perf_session__output_resort(&session->hists, session->event_total[0]);
+        perf_session__find_annotations(session);
+out_delete:
+        perf_session__delete(session);
 
-        find_annotations();
-
-        return rc;
+        return ret;
 }
 
 static const char * const annotate_usage[] = {
@@ -1088,8 +588,9 @@ static const struct option options[] = {
                     "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
-        OPT_STRING('k', "vmlinux", &vmlinux_name, "file", "vmlinux pathname"),
-        OPT_BOOLEAN('m', "modules", &modules,
+        OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
+                   "file", "vmlinux pathname"),
+        OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
         OPT_BOOLEAN('l', "print-line", &print_line,
                     "print matching source lines (may be slow)"),
@@ -1098,30 +599,17 @@ static const struct option options[] = {
         OPT_END()
 };
 
-static void setup_sorting(void)
-{
-        char *tmp, *tok, *str = strdup(sort_order);
-
-        for (tok = strtok_r(str, ", ", &tmp);
-                        tok; tok = strtok_r(NULL, ", ", &tmp)) {
-                if (sort_dimension__add(tok) < 0) {
-                        error("Unknown --sort key: `%s'", tok);
-                        usage_with_options(annotate_usage, options);
-                }
-        }
-
-        free(str);
-}
-
 int cmd_annotate(int argc, const char **argv, const char *prefix __used)
 {
-        symbol__init();
+        argc = parse_options(argc, argv, options, annotate_usage, 0);
 
-        page_size = getpagesize();
+        symbol_conf.priv_size = sizeof(struct sym_priv);
+        symbol_conf.try_vmlinux_path = true;
 
-        argc = parse_options(argc, argv, options, annotate_usage, 0);
+        if (symbol__init() < 0)
+                return -1;
 
-        setup_sorting();
+        setup_sorting(annotate_usage, options);
 
         if (argc) {
                 /*
@@ -1134,10 +622,12 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __used)
                 sym_hist_filter = argv[0];
         }
 
-        if (!sym_hist_filter)
-                usage_with_options(annotate_usage, options);
-
         setup_pager();
 
+        if (field_sep && *field_sep == '.') {
+                pr_err("'.' is the only non valid --field-separator argument\n");
+                return -1;
+        }
+
         return __cmd_annotate();
 }
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
new file mode 100644
index 000000000000..46996774e559
--- /dev/null
+++ b/tools/perf/builtin-bench.c
@@ -0,0 +1,245 @@
+/*
+ *
+ * builtin-bench.c
+ *
+ * General benchmarking subsystem provided by perf
+ *
+ * Copyright (C) 2009, Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
+ *
+ */
+
+/*
+ *
+ * Available subsystem list:
+ *  sched ... scheduler and IPC mechanism
+ *  mem   ... memory access performance
+ *
+ */
+
+#include "perf.h"
+#include "util/util.h"
+#include "util/parse-options.h"
+#include "builtin.h"
+#include "bench/bench.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct bench_suite {
+        const char *name;
+        const char *summary;
+        int (*fn)(int, const char **, const char *);
+};
+                                                \
+/* sentinel: easy for help */
+#define suite_all { "all", "test all suite (pseudo suite)", NULL }
+
+static struct bench_suite sched_suites[] = {
+        { "messaging",
+          "Benchmark for scheduler and IPC mechanisms",
+          bench_sched_messaging },
+        { "pipe",
+          "Flood of communication over pipe() between two processes",
+          bench_sched_pipe      },
+        suite_all,
+        { NULL,
+          NULL,
+          NULL                  }
+};
+
+static struct bench_suite mem_suites[] = {
+        { "memcpy",
+          "Simple memory copy in various ways",
+          bench_mem_memcpy },
+        suite_all,
+        { NULL,
+          NULL,
+          NULL             }
+};
+
+struct bench_subsys {
+        const char *name;
+        const char *summary;
+        struct bench_suite *suites;
+};
+
+static struct bench_subsys subsystems[] = {
+        { "sched",
+          "scheduler and IPC mechanism",
+          sched_suites },
+        { "mem",
+          "memory access performance",
+          mem_suites },
+        { "all",                /* sentinel: easy for help */
+          "test all subsystem (pseudo subsystem)",
+          NULL },
+        { NULL,
+          NULL,
+          NULL       }
+};
+
+static void dump_suites(int subsys_index)
+{
+        int i;
+
+        printf("# List of available suites for %s...\n\n",
+               subsystems[subsys_index].name);
+
+        for (i = 0; subsystems[subsys_index].suites[i].name; i++)
+                printf("%14s: %s\n",
+                       subsystems[subsys_index].suites[i].name,
+                       subsystems[subsys_index].suites[i].summary);
+
+        printf("\n");
+        return;
+}
+
+static char *bench_format_str;
+int bench_format = BENCH_FORMAT_DEFAULT;
+
+static const struct option bench_options[] = {
+        OPT_STRING('f', "format", &bench_format_str, "default",
+                    "Specify format style"),
+        OPT_END()
+};
+
+static const char * const bench_usage[] = {
+        "perf bench [<common options>] <subsystem> <suite> [<options>]",
+        NULL
+};
+
+static void print_usage(void)
+{
+        int i;
+
+        printf("Usage: \n");
+        for (i = 0; bench_usage[i]; i++)
+                printf("\t%s\n", bench_usage[i]);
+        printf("\n");
+
+        printf("# List of available subsystems...\n\n");
+
+        for (i = 0; subsystems[i].name; i++)
+                printf("%14s: %s\n",
+                       subsystems[i].name, subsystems[i].summary);
+        printf("\n");
+}
+
+static int bench_str2int(char *str)
+{
+        if (!str)
+                return BENCH_FORMAT_DEFAULT;
+
+        if (!strcmp(str, BENCH_FORMAT_DEFAULT_STR))
+                return BENCH_FORMAT_DEFAULT;
+        else if (!strcmp(str, BENCH_FORMAT_SIMPLE_STR))
+                return BENCH_FORMAT_SIMPLE;
+
+        return BENCH_FORMAT_UNKNOWN;
+}
+
+static void all_suite(struct bench_subsys *subsys)        /* FROM HERE */
+{
+        int i;
+        const char *argv[2];
+        struct bench_suite *suites = subsys->suites;
+
+        argv[1] = NULL;
+        /*
+         * TODO:
+         * preparing preset parameters for
+         * embedded, ordinary PC, HPC, etc...
+         * will be helpful
+         */
+        for (i = 0; suites[i].fn; i++) {
+                printf("# Running %s/%s benchmark...\n",
+                       subsys->name,
+                       suites[i].name);
+
+                argv[1] = suites[i].name;
+                suites[i].fn(1, argv, NULL);
+                printf("\n");
+        }
+}
+
+static void all_subsystem(void)
+{
+        int i;
+        for (i = 0; subsystems[i].suites; i++)
+                all_suite(&subsystems[i]);
+}
+
+int cmd_bench(int argc, const char **argv, const char *prefix __used)
+{
+        int i, j, status = 0;
+
+        if (argc < 2) {
+                /* No subsystem specified. */
+                print_usage();
+                goto end;
+        }
+
+        argc = parse_options(argc, argv, bench_options, bench_usage,
+                             PARSE_OPT_STOP_AT_NON_OPTION);
+
+        bench_format = bench_str2int(bench_format_str);
+        if (bench_format == BENCH_FORMAT_UNKNOWN) {
+                printf("Unknown format descriptor:%s\n", bench_format_str);
+                goto end;
+        }
+
+        if (argc < 1) {
+                print_usage();
+                goto end;
+        }
+
+        if (!strcmp(argv[0], "all")) {
+                all_subsystem();
+                goto end;
+        }
+
+        for (i = 0; subsystems[i].name; i++) {
+                if (strcmp(subsystems[i].name, argv[0]))
+                        continue;
+
+                if (argc < 2) {
+                        /* No suite specified. */
+                        dump_suites(i);
+                        goto end;
+                }
+
+                if (!strcmp(argv[1], "all")) {
+                        all_suite(&subsystems[i]);
+                        goto end;
+                }
+
+                for (j = 0; subsystems[i].suites[j].name; j++) {
+                        if (strcmp(subsystems[i].suites[j].name, argv[1]))
+                                continue;
+
+                        if (bench_format == BENCH_FORMAT_DEFAULT)
+                                printf("# Running %s/%s benchmark...\n",
+                                       subsystems[i].name,
+                                       subsystems[i].suites[j].name);
+                        status = subsystems[i].suites[j].fn(argc - 1,
+                                                            argv + 1, prefix);
+                        goto end;
+                }
+
+                if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
+                        dump_suites(i);
+                        goto end;
+                }
+
+                printf("Unknown suite:%s for %s\n", argv[1], argv[0]);
+                status = 1;
+                goto end;
+        }
+
+        printf("Unknown subsystem:%s\n", argv[0]);
+        status = 1;
+
+end:
+        return status;
+}
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
new file mode 100644
index 000000000000..30a05f552c96
--- /dev/null
+++ b/tools/perf/builtin-buildid-cache.c
@@ -0,0 +1,133 @@
+/*
+ * builtin-buildid-cache.c
+ *
+ * Builtin buildid-cache command: Manages build-id cache
+ *
+ * Copyright (C) 2010, Red Hat Inc.
+ * Copyright (C) 2010, Arnaldo Carvalho de Melo <acme@redhat.com>
+ */
+#include "builtin.h"
+#include "perf.h"
+#include "util/cache.h"
+#include "util/debug.h"
+#include "util/header.h"
+#include "util/parse-options.h"
+#include "util/strlist.h"
+#include "util/symbol.h"
+
+static char const *add_name_list_str, *remove_name_list_str;
+
+static const char * const buildid_cache_usage[] = {
+        "perf buildid-cache [<options>]",
+        NULL
+};
+
+static const struct option buildid_cache_options[] = {
+        OPT_STRING('a', "add", &add_name_list_str,
+                   "file list", "file(s) to add"),
+        OPT_STRING('r', "remove", &remove_name_list_str, "file list",
+                    "file(s) to remove"),
+        OPT_BOOLEAN('v', "verbose", &verbose, "be more verbose"),
+        OPT_END()
+};
+
+static int build_id_cache__add_file(const char *filename, const char *debugdir)
+{
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+        u8 build_id[BUILD_ID_SIZE];
+        int err;
+
+        if (filename__read_build_id(filename, &build_id, sizeof(build_id)) < 0) {
+                pr_debug("Couldn't read a build-id in %s\n", filename);
+                return -1;
+        }
+
+        build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
+        err = build_id_cache__add_s(sbuild_id, debugdir, filename, false);
+        if (verbose)
+                pr_info("Adding %s %s: %s\n", sbuild_id, filename,
+                        err ? "FAIL" : "Ok");
+        return err;
+}
+
+static int build_id_cache__remove_file(const char *filename __used,
+                                       const char *debugdir __used)
+{
+        u8 build_id[BUILD_ID_SIZE];
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        int err;
+
+        if (filename__read_build_id(filename, &build_id, sizeof(build_id)) < 0) {
+                pr_debug("Couldn't read a build-id in %s\n", filename);
+                return -1;
+        }
+
+        build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
+        err = build_id_cache__remove_s(sbuild_id, debugdir);
+        if (verbose)
+                pr_info("Removing %s %s: %s\n", sbuild_id, filename,
+                        err ? "FAIL" : "Ok");
+
+        return err;
+}
+
+static int __cmd_buildid_cache(void)
+{
+        struct strlist *list;
+        struct str_node *pos;
+        char debugdir[PATH_MAX];
+
+        snprintf(debugdir, sizeof(debugdir), "%s/%s", getenv("HOME"),
+                 DEBUG_CACHE_DIR);
+
+        if (add_name_list_str) {
+                list = strlist__new(true, add_name_list_str);
+                if (list) {
+                        strlist__for_each(pos, list)
+                                if (build_id_cache__add_file(pos->s, debugdir)) {
+                                        if (errno == EEXIST) {
+                                                pr_debug("%s already in the cache\n",
+                                                         pos->s);
+                                                continue;
+                                        }
+                                        pr_warning("Couldn't add %s: %s\n",
+                                                   pos->s, strerror(errno));
+                                }
+
+                        strlist__delete(list);
+                }
+        }
+
+        if (remove_name_list_str) {
+                list = strlist__new(true, remove_name_list_str);
+                if (list) {
+                        strlist__for_each(pos, list)
+                                if (build_id_cache__remove_file(pos->s, debugdir)) {
+                                        if (errno == ENOENT) {
+                                                pr_debug("%s wasn't in the cache\n",
+                                                         pos->s);
+                                                continue;
+                                        }
+                                        pr_warning("Couldn't remove %s: %s\n",
+                                                   pos->s, strerror(errno));
+                                }
+
+                        strlist__delete(list);
+                }
+        }
+
+        return 0;
+}
+
+int cmd_buildid_cache(int argc, const char **argv, const char *prefix __used)
+{
+        argc = parse_options(argc, argv, buildid_cache_options,
+                             buildid_cache_usage, 0);
+
+        if (symbol__init() < 0)
+                return -1;
+
+        setup_pager();
+        return __cmd_buildid_cache();
+}
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
new file mode 100644
index 000000000000..d0675c02f81e
--- /dev/null
+++ b/tools/perf/builtin-buildid-list.c
@@ -0,0 +1,60 @@
+/*
+ * builtin-buildid-list.c
+ *
+ * Builtin buildid-list command: list buildids in perf.data
+ *
+ * Copyright (C) 2009, Red Hat Inc.
+ * Copyright (C) 2009, Arnaldo Carvalho de Melo <acme@redhat.com>
+ */
+#include "builtin.h"
+#include "perf.h"
+#include "util/build-id.h"
+#include "util/cache.h"
+#include "util/debug.h"
+#include "util/parse-options.h"
+#include "util/session.h"
+#include "util/symbol.h"
+
+static char const *input_name = "perf.data";
+static int force;
+static bool with_hits;
+
+static const char * const buildid_list_usage[] = {
+        "perf buildid-list [<options>]",
+        NULL
+};
+
+static const struct option options[] = {
+        OPT_BOOLEAN('H', "with-hits", &with_hits, "Show only DSOs with hits"),
+        OPT_STRING('i', "input", &input_name, "file",
+                    "input file name"),
+        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose"),
+        OPT_END()
+};
+
+static int __cmd_buildid_list(void)
+{
+        int err = -1;
+        struct perf_session *session;
+
+        session = perf_session__new(input_name, O_RDONLY, force);
+        if (session == NULL)
+                return -1;
+
+        if (with_hits)
+                perf_session__process_events(session, &build_id__mark_dso_hit_ops);
+
+        dsos__fprintf_buildid(stdout, with_hits);
+
+        perf_session__delete(session);
+        return err;
+}
+
+int cmd_buildid_list(int argc, const char **argv, const char *prefix __used)
+{
+        argc = parse_options(argc, argv, options, buildid_list_usage, 0);
+        setup_pager();
+        return __cmd_buildid_list();
+}
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
new file mode 100644
index 000000000000..1ea15d8aeed1
--- /dev/null
+++ b/tools/perf/builtin-diff.c
@@ -0,0 +1,242 @@
+/*
+ * builtin-diff.c
+ *
+ * Builtin diff command: Analyze two perf.data input files, look up and read
+ * DSOs and symbol information, sort them and produce a diff.
+ */
+#include "builtin.h"
+
+#include "util/debug.h"
+#include "util/event.h"
+#include "util/hist.h"
+#include "util/session.h"
+#include "util/sort.h"
+#include "util/symbol.h"
+#include "util/util.h"
+
+#include <stdlib.h>
+
+static char const *input_old = "perf.data.old",
+                  *input_new = "perf.data";
+static char       diff__default_sort_order[] = "dso,symbol";
+static int  force;
+static bool show_displacement;
+
+static int perf_session__add_hist_entry(struct perf_session *self,
+                                        struct addr_location *al, u64 count)
+{
+        bool hit;
+        struct hist_entry *he = __perf_session__add_hist_entry(&self->hists,
+                                                               al, NULL,
+                                                               count, &hit);
+        if (he == NULL)
+                return -ENOMEM;
+
+        if (hit)
+                he->count += count;
+
+        return 0;
+}
+
+static int diff__process_sample_event(event_t *event, struct perf_session *session)
+{
+        struct addr_location al;
+        struct sample_data data = { .period = 1, };
+
+        dump_printf("(IP, %d): %d: %#Lx\n", event->header.misc,
+                    event->ip.pid, event->ip.ip);
+
+        if (event__preprocess_sample(event, session, &al, NULL) < 0) {
+                pr_warning("problem processing %d event, skipping it.\n",
+                           event->header.type);
+                return -1;
+        }
+
+        if (al.filtered || al.sym == NULL)
+                return 0;
+
+        event__parse_sample(event, session->sample_type, &data);
+
+        if (perf_session__add_hist_entry(session, &al, data.period)) {
+                pr_warning("problem incrementing symbol count, skipping event\n");
+                return -1;
+        }
+
+        session->events_stats.total += data.period;
+        return 0;
+}
+
+static struct perf_event_ops event_ops = {
+        .sample = diff__process_sample_event,
+        .mmap   = event__process_mmap,
+        .comm   = event__process_comm,
+        .exit   = event__process_task,
+        .fork   = event__process_task,
+        .lost   = event__process_lost,
+};
+
+static void perf_session__insert_hist_entry_by_name(struct rb_root *root,
+                                                    struct hist_entry *he)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *iter;
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct hist_entry, rb_node);
+                if (hist_entry__cmp(he, iter) < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, root);
+}
+
+static void perf_session__resort_hist_entries(struct perf_session *self)
+{
+        unsigned long position = 1;
+        struct rb_root tmp = RB_ROOT;
+        struct rb_node *next = rb_first(&self->hists);
+
+        while (next != NULL) {
+                struct hist_entry *n = rb_entry(next, struct hist_entry, rb_node);
+
+                next = rb_next(&n->rb_node);
+                rb_erase(&n->rb_node, &self->hists);
+                n->position = position++;
+                perf_session__insert_hist_entry_by_name(&tmp, n);
+        }
+
+        self->hists = tmp;
+}
+
+static void perf_session__set_hist_entries_positions(struct perf_session *self)
+{
+        perf_session__output_resort(&self->hists, self->events_stats.total);
+        perf_session__resort_hist_entries(self);
+}
+
+static struct hist_entry *
+perf_session__find_hist_entry(struct perf_session *self,
+                              struct hist_entry *he)
+{
+        struct rb_node *n = self->hists.rb_node;
+
+        while (n) {
+                struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node);
+                int64_t cmp = hist_entry__cmp(he, iter);
+
+                if (cmp < 0)
+                        n = n->rb_left;
+                else if (cmp > 0)
+                        n = n->rb_right;
+                else 
+                        return iter;
+        }
+
+        return NULL;
+}
+
+static void perf_session__match_hists(struct perf_session *old_session,
+                                      struct perf_session *new_session)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(&new_session->hists); nd; nd = rb_next(nd)) {
+                struct hist_entry *pos = rb_entry(nd, struct hist_entry, rb_node);
+                pos->pair = perf_session__find_hist_entry(old_session, pos);
+        }
+}
+
+static int __cmd_diff(void)
+{
+        int ret, i;
+        struct perf_session *session[2];
+
+        session[0] = perf_session__new(input_old, O_RDONLY, force);
+        session[1] = perf_session__new(input_new, O_RDONLY, force);
+        if (session[0] == NULL || session[1] == NULL)
+                return -ENOMEM;
+
+        for (i = 0; i < 2; ++i) {
+                ret = perf_session__process_events(session[i], &event_ops);
+                if (ret)
+                        goto out_delete;
+        }
+
+        perf_session__output_resort(&session[1]->hists,
+                                    session[1]->events_stats.total);
+        if (show_displacement)
+                perf_session__set_hist_entries_positions(session[0]);
+
+        perf_session__match_hists(session[0], session[1]);
+        perf_session__fprintf_hists(&session[1]->hists, session[0],
+                                    show_displacement, stdout,
+                                    session[1]->events_stats.total);
+out_delete:
+        for (i = 0; i < 2; ++i)
+                perf_session__delete(session[i]);
+        return ret;
+}
+
+static const char * const diff_usage[] = {
+        "perf diff [<options>] [old_file] [new_file]",
+        NULL,
+};
+
+static const struct option options[] = {
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose (show symbol address, etc)"),
+        OPT_BOOLEAN('m', "displacement", &show_displacement,
+                    "Show position displacement relative to baseline"),
+        OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
+                    "dump raw trace in ASCII"),
+        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
+        OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
+                    "load module symbols - WARNING: use only with -k and LIVE kernel"),
+        OPT_BOOLEAN('P', "full-paths", &symbol_conf.full_paths,
+                    "Don't shorten the pathnames taking into account the cwd"),
+        OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
+                   "only consider symbols in these dsos"),
+        OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
+                   "only consider symbols in these comms"),
+        OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
+                   "only consider these symbols"),
+        OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
+                   "sort by key(s): pid, comm, dso, symbol, parent"),
+        OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
+                   "separator for columns, no spaces will be added between "
+                   "columns '.' is reserved."),
+        OPT_END()
+};
+
+int cmd_diff(int argc, const char **argv, const char *prefix __used)
+{
+        sort_order = diff__default_sort_order;
+        argc = parse_options(argc, argv, options, diff_usage, 0);
+        if (argc) {
+                if (argc > 2)
+                        usage_with_options(diff_usage, options);
+                if (argc == 2) {
+                        input_old = argv[0];
+                        input_new = argv[1];
+                } else
+                        input_new = argv[0];
+        }
+
+        symbol_conf.exclude_other = false;
+        if (symbol__init() < 0)
+                return -1;
+
+        setup_sorting(diff_usage, options);
+        setup_pager();
+
+        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", NULL);
+        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", NULL);
+        sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", NULL);
+
+        return __cmd_diff();
+}
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index 4fb8734a796e..215b584007b1 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -61,8 +61,7 @@ static const char *get_man_viewer_info(const char *name)
 {
         struct man_viewer_info_list *viewer;
 
-        for (viewer = man_viewer_info_list; viewer; viewer = viewer->next)
-        {
+        for (viewer = man_viewer_info_list; viewer; viewer = viewer->next) {
                 if (!strcasecmp(name, viewer->name))
                         return viewer->info;
         }
@@ -115,7 +114,7 @@ static int check_emacsclient_version(void)
         return 0;
 }
 
-static void exec_woman_emacs(const char* path, const char *page)
+static void exec_woman_emacs(const char *path, const char *page)
 {
         if (!check_emacsclient_version()) {
                 /* This works only with emacsclient version >= 22. */
@@ -129,7 +128,7 @@ static void exec_woman_emacs(const char* path, const char *page)
         }
 }
 
-static void exec_man_konqueror(const char* path, const char *page)
+static void exec_man_konqueror(const char *path, const char *page)
 {
         const char *display = getenv("DISPLAY");
         if (display && *display) {
@@ -157,7 +156,7 @@ static void exec_man_konqueror(const char* path, const char *page)
         }
 }
 
-static void exec_man_man(const char* path, const char *page)
+static void exec_man_man(const char *path, const char *page)
 {
         if (!path)
                 path = "man";
@@ -180,7 +179,7 @@ static void add_man_viewer(const char *name)
 
         while (*p)
                 p = &((*p)->next);
-        *p = calloc(1, (sizeof(**p) + len + 1));
+        *p = zalloc(sizeof(**p) + len + 1);
         strncpy((*p)->name, name, len);
 }
 
@@ -195,7 +194,7 @@ static void do_add_man_viewer_info(const char *name,
                                    size_t len,
                                    const char *value)
 {
-        struct man_viewer_info_list *new = calloc(1, sizeof(*new) + len + 1);
+        struct man_viewer_info_list *new = zalloc(sizeof(*new) + len + 1);
 
         strncpy(new->name, name, len);
         new->info = strdup(value);
@@ -287,8 +286,7 @@ void list_common_cmds_help(void)
 
         puts(" The most commonly used perf commands are:");
         for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
-                printf("   %s   ", common_cmds[i].name);
-                mput_char(' ', longest - strlen(common_cmds[i].name));
+                printf("   %-*s   ", longest, common_cmds[i].name);
                 puts(common_cmds[i].help);
         }
 }
@@ -315,8 +313,6 @@ static const char *cmd_to_page(const char *perf_cmd)
                 return "perf";
         else if (!prefixcmp(perf_cmd, "perf"))
                 return perf_cmd;
-        else if (is_perf_command(perf_cmd))
-                return prepend("perf-", perf_cmd);
         else
                 return prepend("perf-", perf_cmd);
 }
@@ -364,9 +360,8 @@ static void show_man_page(const char *perf_cmd)
 
         setup_man_path();
         for (viewer = man_viewer_list; viewer; viewer = viewer->next)
-        {
                 exec_viewer(viewer->name, page); /* will return when unable */
-        }
+
         if (fallback)
                 exec_viewer(fallback, page);
         exec_viewer("man", page);
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
new file mode 100644
index 000000000000..924a9518931a
--- /dev/null
+++ b/tools/perf/builtin-kmem.c
@@ -0,0 +1,774 @@
+#include "builtin.h"
+#include "perf.h"
+
+#include "util/util.h"
+#include "util/cache.h"
+#include "util/symbol.h"
+#include "util/thread.h"
+#include "util/header.h"
+#include "util/session.h"
+
+#include "util/parse-options.h"
+#include "util/trace-event.h"
+
+#include "util/debug.h"
+
+#include <linux/rbtree.h>
+
+struct alloc_stat;
+typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);
+
+static char const               *input_name = "perf.data";
+
+static int                      alloc_flag;
+static int                      caller_flag;
+
+static int                      alloc_lines = -1;
+static int                      caller_lines = -1;
+
+static bool                     raw_ip;
+
+static char                     default_sort_order[] = "frag,hit,bytes";
+
+static int                      *cpunode_map;
+static int                      max_cpu_num;
+
+struct alloc_stat {
+        u64     call_site;
+        u64     ptr;
+        u64     bytes_req;
+        u64     bytes_alloc;
+        u32     hit;
+        u32     pingpong;
+
+        short   alloc_cpu;
+
+        struct rb_node node;
+};
+
+static struct rb_root root_alloc_stat;
+static struct rb_root root_alloc_sorted;
+static struct rb_root root_caller_stat;
+static struct rb_root root_caller_sorted;
+
+static unsigned long total_requested, total_allocated;
+static unsigned long nr_allocs, nr_cross_allocs;
+
+#define PATH_SYS_NODE   "/sys/devices/system/node"
+
+static void init_cpunode_map(void)
+{
+        FILE *fp;
+        int i;
+
+        fp = fopen("/sys/devices/system/cpu/kernel_max", "r");
+        if (!fp) {
+                max_cpu_num = 4096;
+                return;
+        }
+
+        if (fscanf(fp, "%d", &max_cpu_num) < 1)
+                die("Failed to read 'kernel_max' from sysfs");
+        max_cpu_num++;
+
+        cpunode_map = calloc(max_cpu_num, sizeof(int));
+        if (!cpunode_map)
+                die("calloc");
+        for (i = 0; i < max_cpu_num; i++)
+                cpunode_map[i] = -1;
+        fclose(fp);
+}
+
+static void setup_cpunode_map(void)
+{
+        struct dirent *dent1, *dent2;
+        DIR *dir1, *dir2;
+        unsigned int cpu, mem;
+        char buf[PATH_MAX];
+
+        init_cpunode_map();
+
+        dir1 = opendir(PATH_SYS_NODE);
+        if (!dir1)
+                return;
+
+        while ((dent1 = readdir(dir1)) != NULL) {
+                if (dent1->d_type != DT_DIR ||
+                    sscanf(dent1->d_name, "node%u", &mem) < 1)
+                        continue;
+
+                snprintf(buf, PATH_MAX, "%s/%s", PATH_SYS_NODE, dent1->d_name);
+                dir2 = opendir(buf);
+                if (!dir2)
+                        continue;
+                while ((dent2 = readdir(dir2)) != NULL) {
+                        if (dent2->d_type != DT_LNK ||
+                            sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
+                                continue;
+                        cpunode_map[cpu] = mem;
+                }
+        }
+}
+
+static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
+                              int bytes_req, int bytes_alloc, int cpu)
+{
+        struct rb_node **node = &root_alloc_stat.rb_node;
+        struct rb_node *parent = NULL;
+        struct alloc_stat *data = NULL;
+
+        while (*node) {
+                parent = *node;
+                data = rb_entry(*node, struct alloc_stat, node);
+
+                if (ptr > data->ptr)
+                        node = &(*node)->rb_right;
+                else if (ptr < data->ptr)
+                        node = &(*node)->rb_left;
+                else
+                        break;
+        }
+
+        if (data && data->ptr == ptr) {
+                data->hit++;
+                data->bytes_req += bytes_req;
+                data->bytes_alloc += bytes_alloc;
+        } else {
+                data = malloc(sizeof(*data));
+                if (!data)
+                        die("malloc");
+                data->ptr = ptr;
+                data->pingpong = 0;
+                data->hit = 1;
+                data->bytes_req = bytes_req;
+                data->bytes_alloc = bytes_alloc;
+
+                rb_link_node(&data->node, parent, node);
+                rb_insert_color(&data->node, &root_alloc_stat);
+        }
+        data->call_site = call_site;
+        data->alloc_cpu = cpu;
+}
+
+static void insert_caller_stat(unsigned long call_site,
+                              int bytes_req, int bytes_alloc)
+{
+        struct rb_node **node = &root_caller_stat.rb_node;
+        struct rb_node *parent = NULL;
+        struct alloc_stat *data = NULL;
+
+        while (*node) {
+                parent = *node;
+                data = rb_entry(*node, struct alloc_stat, node);
+
+                if (call_site > data->call_site)
+                        node = &(*node)->rb_right;
+                else if (call_site < data->call_site)
+                        node = &(*node)->rb_left;
+                else
+                        break;
+        }
+
+        if (data && data->call_site == call_site) {
+                data->hit++;
+                data->bytes_req += bytes_req;
+                data->bytes_alloc += bytes_alloc;
+        } else {
+                data = malloc(sizeof(*data));
+                if (!data)
+                        die("malloc");
+                data->call_site = call_site;
+                data->pingpong = 0;
+                data->hit = 1;
+                data->bytes_req = bytes_req;
+                data->bytes_alloc = bytes_alloc;
+
+                rb_link_node(&data->node, parent, node);
+                rb_insert_color(&data->node, &root_caller_stat);
+        }
+}
+
+static void process_alloc_event(void *data,
+                                struct event *event,
+                                int cpu,
+                                u64 timestamp __used,
+                                struct thread *thread __used,
+                                int node)
+{
+        unsigned long call_site;
+        unsigned long ptr;
+        int bytes_req;
+        int bytes_alloc;
+        int node1, node2;
+
+        ptr = raw_field_value(event, "ptr", data);
+        call_site = raw_field_value(event, "call_site", data);
+        bytes_req = raw_field_value(event, "bytes_req", data);
+        bytes_alloc = raw_field_value(event, "bytes_alloc", data);
+
+        insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
+        insert_caller_stat(call_site, bytes_req, bytes_alloc);
+
+        total_requested += bytes_req;
+        total_allocated += bytes_alloc;
+
+        if (node) {
+                node1 = cpunode_map[cpu];
+                node2 = raw_field_value(event, "node", data);
+                if (node1 != node2)
+                        nr_cross_allocs++;
+        }
+        nr_allocs++;
+}
+
+static int ptr_cmp(struct alloc_stat *, struct alloc_stat *);
+static int callsite_cmp(struct alloc_stat *, struct alloc_stat *);
+
+static struct alloc_stat *search_alloc_stat(unsigned long ptr,
+                                            unsigned long call_site,
+                                            struct rb_root *root,
+                                            sort_fn_t sort_fn)
+{
+        struct rb_node *node = root->rb_node;
+        struct alloc_stat key = { .ptr = ptr, .call_site = call_site };
+
+        while (node) {
+                struct alloc_stat *data;
+                int cmp;
+
+                data = rb_entry(node, struct alloc_stat, node);
+
+                cmp = sort_fn(&key, data);
+                if (cmp < 0)
+                        node = node->rb_left;
+                else if (cmp > 0)
+                        node = node->rb_right;
+                else
+                        return data;
+        }
+        return NULL;
+}
+
+static void process_free_event(void *data,
+                               struct event *event,
+                               int cpu,
+                               u64 timestamp __used,
+                               struct thread *thread __used)
+{
+        unsigned long ptr;
+        struct alloc_stat *s_alloc, *s_caller;
+
+        ptr = raw_field_value(event, "ptr", data);
+
+        s_alloc = search_alloc_stat(ptr, 0, &root_alloc_stat, ptr_cmp);
+        if (!s_alloc)
+                return;
+
+        if (cpu != s_alloc->alloc_cpu) {
+                s_alloc->pingpong++;
+
+                s_caller = search_alloc_stat(0, s_alloc->call_site,
+                                             &root_caller_stat, callsite_cmp);
+                assert(s_caller);
+                s_caller->pingpong++;
+        }
+        s_alloc->alloc_cpu = -1;
+}
+
+static void
+process_raw_event(event_t *raw_event __used, void *data,
+                  int cpu, u64 timestamp, struct thread *thread)
+{
+        struct event *event;
+        int type;
+
+        type = trace_parse_common_type(data);
+        event = trace_find_event(type);
+
+        if (!strcmp(event->name, "kmalloc") ||
+            !strcmp(event->name, "kmem_cache_alloc")) {
+                process_alloc_event(data, event, cpu, timestamp, thread, 0);
+                return;
+        }
+
+        if (!strcmp(event->name, "kmalloc_node") ||
+            !strcmp(event->name, "kmem_cache_alloc_node")) {
+                process_alloc_event(data, event, cpu, timestamp, thread, 1);
+                return;
+        }
+
+        if (!strcmp(event->name, "kfree") ||
+            !strcmp(event->name, "kmem_cache_free")) {
+                process_free_event(data, event, cpu, timestamp, thread);
+                return;
+        }
+}
+
+static int process_sample_event(event_t *event, struct perf_session *session)
+{
+        struct sample_data data;
+        struct thread *thread;
+
+        memset(&data, 0, sizeof(data));
+        data.time = -1;
+        data.cpu = -1;
+        data.period = 1;
+
+        event__parse_sample(event, session->sample_type, &data);
+
+        dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
+                    data.pid, data.tid, data.ip, data.period);
+
+        thread = perf_session__findnew(session, event->ip.pid);
+        if (thread == NULL) {
+                pr_debug("problem processing %d event, skipping it.\n",
+                         event->header.type);
+                return -1;
+        }
+
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
+        process_raw_event(event, data.raw_data, data.cpu,
+                          data.time, thread);
+
+        return 0;
+}
+
+static struct perf_event_ops event_ops = {
+        .sample = process_sample_event,
+        .comm   = event__process_comm,
+};
+
+static double fragmentation(unsigned long n_req, unsigned long n_alloc)
+{
+        if (n_alloc == 0)
+                return 0.0;
+        else
+                return 100.0 - (100.0 * n_req / n_alloc);
+}
+
+static void __print_result(struct rb_root *root, struct perf_session *session,
+                           int n_lines, int is_caller)
+{
+        struct rb_node *next;
+
+        printf("%.102s\n", graph_dotted_line);
+        printf(" %-34s |",  is_caller ? "Callsite": "Alloc Ptr");
+        printf(" Total_alloc/Per | Total_req/Per   | Hit      | Ping-pong | Frag\n");
+        printf("%.102s\n", graph_dotted_line);
+
+        next = rb_first(root);
+
+        while (next && n_lines--) {
+                struct alloc_stat *data = rb_entry(next, struct alloc_stat,
+                                                   node);
+                struct symbol *sym = NULL;
+                char buf[BUFSIZ];
+                u64 addr;
+
+                if (is_caller) {
+                        addr = data->call_site;
+                        if (!raw_ip)
+                                sym = map_groups__find_function(&session->kmaps, addr, NULL);
+                } else
+                        addr = data->ptr;
+
+                if (sym != NULL)
+                        snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
+                                 addr - sym->start);
+                else
+                        snprintf(buf, sizeof(buf), "%#Lx", addr);
+                printf(" %-34s |", buf);
+
+                printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %8lu | %6.3f%%\n",
+                       (unsigned long long)data->bytes_alloc,
+                       (unsigned long)data->bytes_alloc / data->hit,
+                       (unsigned long long)data->bytes_req,
+                       (unsigned long)data->bytes_req / data->hit,
+                       (unsigned long)data->hit,
+                       (unsigned long)data->pingpong,
+                       fragmentation(data->bytes_req, data->bytes_alloc));
+
+                next = rb_next(next);
+        }
+
+        if (n_lines == -1)
+                printf(" ...                                | ...             | ...             | ...    | ...      | ...   \n");
+
+        printf("%.102s\n", graph_dotted_line);
+}
+
+static void print_summary(void)
+{
+        printf("\nSUMMARY\n=======\n");
+        printf("Total bytes requested: %lu\n", total_requested);
+        printf("Total bytes allocated: %lu\n", total_allocated);
+        printf("Total bytes wasted on internal fragmentation: %lu\n",
+               total_allocated - total_requested);
+        printf("Internal fragmentation: %f%%\n",
+               fragmentation(total_requested, total_allocated));
+        printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
+}
+
+static void print_result(struct perf_session *session)
+{
+        if (caller_flag)
+                __print_result(&root_caller_sorted, session, caller_lines, 1);
+        if (alloc_flag)
+                __print_result(&root_alloc_sorted, session, alloc_lines, 0);
+        print_summary();
+}
+
+struct sort_dimension {
+        const char              name[20];
+        sort_fn_t               cmp;
+        struct list_head        list;
+};
+
+static LIST_HEAD(caller_sort);
+static LIST_HEAD(alloc_sort);
+
+static void sort_insert(struct rb_root *root, struct alloc_stat *data,
+                        struct list_head *sort_list)
+{
+        struct rb_node **new = &(root->rb_node);
+        struct rb_node *parent = NULL;
+        struct sort_dimension *sort;
+
+        while (*new) {
+                struct alloc_stat *this;
+                int cmp = 0;
+
+                this = rb_entry(*new, struct alloc_stat, node);
+                parent = *new;
+
+                list_for_each_entry(sort, sort_list, list) {
+                        cmp = sort->cmp(data, this);
+                        if (cmp)
+                                break;
+                }
+
+                if (cmp > 0)
+                        new = &((*new)->rb_left);
+                else
+                        new = &((*new)->rb_right);
+        }
+
+        rb_link_node(&data->node, parent, new);
+        rb_insert_color(&data->node, root);
+}
+
+static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
+                          struct list_head *sort_list)
+{
+        struct rb_node *node;
+        struct alloc_stat *data;
+
+        for (;;) {
+                node = rb_first(root);
+                if (!node)
+                        break;
+
+                rb_erase(node, root);
+                data = rb_entry(node, struct alloc_stat, node);
+                sort_insert(root_sorted, data, sort_list);
+        }
+}
+
+static void sort_result(void)
+{
+        __sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
+        __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
+}
+
+static int __cmd_kmem(void)
+{
+        int err = -EINVAL;
+        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
+        if (session == NULL)
+                return -ENOMEM;
+
+        if (!perf_session__has_traces(session, "kmem record"))
+                goto out_delete;
+
+        setup_pager();
+        err = perf_session__process_events(session, &event_ops);
+        if (err != 0)
+                goto out_delete;
+        sort_result();
+        print_result(session);
+out_delete:
+        perf_session__delete(session);
+        return err;
+}
+
+static const char * const kmem_usage[] = {
+        "perf kmem [<options>] {record|stat}",
+        NULL
+};
+
+static int ptr_cmp(struct alloc_stat *l, struct alloc_stat *r)
+{
+        if (l->ptr < r->ptr)
+                return -1;
+        else if (l->ptr > r->ptr)
+                return 1;
+        return 0;
+}
+
+static struct sort_dimension ptr_sort_dimension = {
+        .name   = "ptr",
+        .cmp    = ptr_cmp,
+};
+
+static int callsite_cmp(struct alloc_stat *l, struct alloc_stat *r)
+{
+        if (l->call_site < r->call_site)
+                return -1;
+        else if (l->call_site > r->call_site)
+                return 1;
+        return 0;
+}
+
+static struct sort_dimension callsite_sort_dimension = {
+        .name   = "callsite",
+        .cmp    = callsite_cmp,
+};
+
+static int hit_cmp(struct alloc_stat *l, struct alloc_stat *r)
+{
+        if (l->hit < r->hit)
+                return -1;
+        else if (l->hit > r->hit)
+                return 1;
+        return 0;
+}
+
+static struct sort_dimension hit_sort_dimension = {
+        .name   = "hit",
+        .cmp    = hit_cmp,
+};
+
+static int bytes_cmp(struct alloc_stat *l, struct alloc_stat *r)
+{
+        if (l->bytes_alloc < r->bytes_alloc)
+                return -1;
+        else if (l->bytes_alloc > r->bytes_alloc)
+                return 1;
+        return 0;
+}
+
+static struct sort_dimension bytes_sort_dimension = {
+        .name   = "bytes",
+        .cmp    = bytes_cmp,
+};
+
+static int frag_cmp(struct alloc_stat *l, struct alloc_stat *r)
+{
+        double x, y;
+
+        x = fragmentation(l->bytes_req, l->bytes_alloc);
+        y = fragmentation(r->bytes_req, r->bytes_alloc);
+
+        if (x < y)
+                return -1;
+        else if (x > y)
+                return 1;
+        return 0;
+}
+
+static struct sort_dimension frag_sort_dimension = {
+        .name   = "frag",
+        .cmp    = frag_cmp,
+};
+
+static int pingpong_cmp(struct alloc_stat *l, struct alloc_stat *r)
+{
+        if (l->pingpong < r->pingpong)
+                return -1;
+        else if (l->pingpong > r->pingpong)
+                return 1;
+        return 0;
+}
+
+static struct sort_dimension pingpong_sort_dimension = {
+        .name   = "pingpong",
+        .cmp    = pingpong_cmp,
+};
+
+static struct sort_dimension *avail_sorts[] = {
+        &ptr_sort_dimension,
+        &callsite_sort_dimension,
+        &hit_sort_dimension,
+        &bytes_sort_dimension,
+        &frag_sort_dimension,
+        &pingpong_sort_dimension,
+};
+
+#define NUM_AVAIL_SORTS \
+        (int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))
+
+static int sort_dimension__add(const char *tok, struct list_head *list)
+{
+        struct sort_dimension *sort;
+        int i;
+
+        for (i = 0; i < NUM_AVAIL_SORTS; i++) {
+                if (!strcmp(avail_sorts[i]->name, tok)) {
+                        sort = malloc(sizeof(*sort));
+                        if (!sort)
+                                die("malloc");
+                        memcpy(sort, avail_sorts[i], sizeof(*sort));
+                        list_add_tail(&sort->list, list);
+                        return 0;
+                }
+        }
+
+        return -1;
+}
+
+static int setup_sorting(struct list_head *sort_list, const char *arg)
+{
+        char *tok;
+        char *str = strdup(arg);
+
+        if (!str)
+                die("strdup");
+
+        while (true) {
+                tok = strsep(&str, ",");
+                if (!tok)
+                        break;
+                if (sort_dimension__add(tok, sort_list) < 0) {
+                        error("Unknown --sort key: '%s'", tok);
+                        return -1;
+                }
+        }
+
+        free(str);
+        return 0;
+}
+
+static int parse_sort_opt(const struct option *opt __used,
+                          const char *arg, int unset __used)
+{
+        if (!arg)
+                return -1;
+
+        if (caller_flag > alloc_flag)
+                return setup_sorting(&caller_sort, arg);
+        else
+                return setup_sorting(&alloc_sort, arg);
+
+        return 0;
+}
+
+static int parse_caller_opt(const struct option *opt __used,
+                          const char *arg __used, int unset __used)
+{
+        caller_flag = (alloc_flag + 1);
+        return 0;
+}
+
+static int parse_alloc_opt(const struct option *opt __used,
+                          const char *arg __used, int unset __used)
+{
+        alloc_flag = (caller_flag + 1);
+        return 0;
+}
+
+static int parse_line_opt(const struct option *opt __used,
+                          const char *arg, int unset __used)
+{
+        int lines;
+
+        if (!arg)
+                return -1;
+
+        lines = strtoul(arg, NULL, 10);
+
+        if (caller_flag > alloc_flag)
+                caller_lines = lines;
+        else
+                alloc_lines = lines;
+
+        return 0;
+}
+
+static const struct option kmem_options[] = {
+        OPT_STRING('i', "input", &input_name, "file",
+                   "input file name"),
+        OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
+                           "show per-callsite statistics",
+                           parse_caller_opt),
+        OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
+                           "show per-allocation statistics",
+                           parse_alloc_opt),
+        OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
+                     "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
+                     parse_sort_opt),
+        OPT_CALLBACK('l', "line", NULL, "num",
+                     "show n lines",
+                     parse_line_opt),
+        OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
+        OPT_END()
+};
+
+static const char *record_args[] = {
+        "record",
+        "-a",
+        "-R",
+        "-M",
+        "-f",
+        "-c", "1",
+        "-e", "kmem:kmalloc",
+        "-e", "kmem:kmalloc_node",
+        "-e", "kmem:kfree",
+        "-e", "kmem:kmem_cache_alloc",
+        "-e", "kmem:kmem_cache_alloc_node",
+        "-e", "kmem:kmem_cache_free",
+};
+
+static int __cmd_record(int argc, const char **argv)
+{
+        unsigned int rec_argc, i, j;
+        const char **rec_argv;
+
+        rec_argc = ARRAY_SIZE(record_args) + argc - 1;
+        rec_argv = calloc(rec_argc + 1, sizeof(char *));
+
+        for (i = 0; i < ARRAY_SIZE(record_args); i++)
+                rec_argv[i] = strdup(record_args[i]);
+
+        for (j = 1; j < (unsigned int)argc; j++, i++)
+                rec_argv[i] = argv[j];
+
+        return cmd_record(i, rec_argv, NULL);
+}
+
+int cmd_kmem(int argc, const char **argv, const char *prefix __used)
+{
+        argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
+
+        if (!argc)
+                usage_with_options(kmem_usage, kmem_options);
+
+        symbol__init();
+
+        if (!strncmp(argv[0], "rec", 3)) {
+                return __cmd_record(argc, argv);
+        } else if (!strcmp(argv[0], "stat")) {
+                setup_cpunode_map();
+
+                if (list_empty(&caller_sort))
+                        setup_sorting(&caller_sort, default_sort_order);
+                if (list_empty(&alloc_sort))
+                        setup_sorting(&alloc_sort, default_sort_order);
+
+                return __cmd_kmem();
+        } else
+                usage_with_options(kmem_usage, kmem_options);
+
+        return 0;
+}
+
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
new file mode 100644
index 000000000000..e12c844df1e2
--- /dev/null
+++ b/tools/perf/builtin-lock.c
@@ -0,0 +1,822 @@
+#include "builtin.h"
+#include "perf.h"
+
+#include "util/util.h"
+#include "util/cache.h"
+#include "util/symbol.h"
+#include "util/thread.h"
+#include "util/header.h"
+
+#include "util/parse-options.h"
+#include "util/trace-event.h"
+
+#include "util/debug.h"
+#include "util/session.h"
+
+#include <sys/types.h>
+#include <sys/prctl.h>
+#include <semaphore.h>
+#include <pthread.h>
+#include <math.h>
+#include <limits.h>
+
+#include <linux/list.h>
+#include <linux/hash.h>
+
+/* based on kernel/lockdep.c */
+#define LOCKHASH_BITS           12
+#define LOCKHASH_SIZE           (1UL << LOCKHASH_BITS)
+
+static struct list_head lockhash_table[LOCKHASH_SIZE];
+
+#define __lockhashfn(key)       hash_long((unsigned long)key, LOCKHASH_BITS)
+#define lockhashentry(key)      (lockhash_table + __lockhashfn((key)))
+
+#define LOCK_STATE_UNLOCKED     0              /* initial state */
+#define LOCK_STATE_LOCKED       1
+
+struct lock_stat {
+        struct list_head        hash_entry;
+        struct rb_node          rb;             /* used for sorting */
+
+        /*
+         * FIXME: raw_field_value() returns unsigned long long,
+         * so address of lockdep_map should be dealed as 64bit.
+         * Is there more better solution?
+         */
+        void                    *addr;          /* address of lockdep_map, used as ID */
+        char                    *name;          /* for strcpy(), we cannot use const */
+
+        int                     state;
+        u64                     prev_event_time; /* timestamp of previous event */
+
+        unsigned int            nr_acquired;
+        unsigned int            nr_acquire;
+        unsigned int            nr_contended;
+        unsigned int            nr_release;
+
+        /* these times are in nano sec. */
+        u64                     wait_time_total;
+        u64                     wait_time_min;
+        u64                     wait_time_max;
+};
+
+/* build simple key function one is bigger than two */
+#define SINGLE_KEY(member)                                              \
+        static int lock_stat_key_ ## member(struct lock_stat *one,      \
+                                         struct lock_stat *two)         \
+        {                                                               \
+                return one->member > two->member;                       \
+        }
+
+SINGLE_KEY(nr_acquired)
+SINGLE_KEY(nr_contended)
+SINGLE_KEY(wait_time_total)
+SINGLE_KEY(wait_time_min)
+SINGLE_KEY(wait_time_max)
+
+struct lock_key {
+        /*
+         * name: the value for specify by user
+         * this should be simpler than raw name of member
+         * e.g. nr_acquired -> acquired, wait_time_total -> wait_total
+         */
+        const char              *name;
+        int                     (*key)(struct lock_stat*, struct lock_stat*);
+};
+
+static const char               *sort_key = "acquired";
+
+static int                      (*compare)(struct lock_stat *, struct lock_stat *);
+
+static struct rb_root           result; /* place to store sorted data */
+
+#define DEF_KEY_LOCK(name, fn_suffix)   \
+        { #name, lock_stat_key_ ## fn_suffix }
+struct lock_key keys[] = {
+        DEF_KEY_LOCK(acquired, nr_acquired),
+        DEF_KEY_LOCK(contended, nr_contended),
+        DEF_KEY_LOCK(wait_total, wait_time_total),
+        DEF_KEY_LOCK(wait_min, wait_time_min),
+        DEF_KEY_LOCK(wait_max, wait_time_max),
+
+        /* extra comparisons much complicated should be here */
+
+        { NULL, NULL }
+};
+
+static void select_key(void)
+{
+        int i;
+
+        for (i = 0; keys[i].name; i++) {
+                if (!strcmp(keys[i].name, sort_key)) {
+                        compare = keys[i].key;
+                        return;
+                }
+        }
+
+        die("Unknown compare key:%s\n", sort_key);
+}
+
+static void insert_to_result(struct lock_stat *st,
+                             int (*bigger)(struct lock_stat *, struct lock_stat *))
+{
+        struct rb_node **rb = &result.rb_node;
+        struct rb_node *parent = NULL;
+        struct lock_stat *p;
+
+        while (*rb) {
+                p = container_of(*rb, struct lock_stat, rb);
+                parent = *rb;
+
+                if (bigger(st, p))
+                        rb = &(*rb)->rb_left;
+                else
+                        rb = &(*rb)->rb_right;
+        }
+
+        rb_link_node(&st->rb, parent, rb);
+        rb_insert_color(&st->rb, &result);
+}
+
+/* returns left most element of result, and erase it */
+static struct lock_stat *pop_from_result(void)
+{
+        struct rb_node *node = result.rb_node;
+
+        if (!node)
+                return NULL;
+
+        while (node->rb_left)
+                node = node->rb_left;
+
+        rb_erase(node, &result);
+        return container_of(node, struct lock_stat, rb);
+}
+
+static struct lock_stat *lock_stat_findnew(void *addr, const char *name)
+{
+        struct list_head *entry = lockhashentry(addr);
+        struct lock_stat *ret, *new;
+
+        list_for_each_entry(ret, entry, hash_entry) {
+                if (ret->addr == addr)
+                        return ret;
+        }
+
+        new = zalloc(sizeof(struct lock_stat));
+        if (!new)
+                goto alloc_failed;
+
+        new->addr = addr;
+        new->name = zalloc(sizeof(char) * strlen(name) + 1);
+        if (!new->name)
+                goto alloc_failed;
+        strcpy(new->name, name);
+
+        /* LOCK_STATE_UNLOCKED == 0 isn't guaranteed forever */
+        new->state = LOCK_STATE_UNLOCKED;
+        new->wait_time_min = ULLONG_MAX;
+
+        list_add(&new->hash_entry, entry);
+        return new;
+
+alloc_failed:
+        die("memory allocation failed\n");
+}
+
+static char                     const *input_name = "perf.data";
+
+static int                      profile_cpu = -1;
+
+struct raw_event_sample {
+        u32                     size;
+        char                    data[0];
+};
+
+struct trace_acquire_event {
+        void                    *addr;
+        const char              *name;
+};
+
+struct trace_acquired_event {
+        void                    *addr;
+        const char              *name;
+};
+
+struct trace_contended_event {
+        void                    *addr;
+        const char              *name;
+};
+
+struct trace_release_event {
+        void                    *addr;
+        const char              *name;
+};
+
+struct trace_lock_handler {
+        void (*acquire_event)(struct trace_acquire_event *,
+                              struct event *,
+                              int cpu,
+                              u64 timestamp,
+                              struct thread *thread);
+
+        void (*acquired_event)(struct trace_acquired_event *,
+                               struct event *,
+                               int cpu,
+                               u64 timestamp,
+                               struct thread *thread);
+
+        void (*contended_event)(struct trace_contended_event *,
+                                struct event *,
+                                int cpu,
+                                u64 timestamp,
+                                struct thread *thread);
+
+        void (*release_event)(struct trace_release_event *,
+                              struct event *,
+                              int cpu,
+                              u64 timestamp,
+                              struct thread *thread);
+};
+
+static void
+report_lock_acquire_event(struct trace_acquire_event *acquire_event,
+                        struct event *__event __used,
+                        int cpu __used,
+                        u64 timestamp,
+                        struct thread *thread __used)
+{
+        struct lock_stat *st;
+
+        st = lock_stat_findnew(acquire_event->addr, acquire_event->name);
+
+        switch (st->state) {
+        case LOCK_STATE_UNLOCKED:
+                break;
+        case LOCK_STATE_LOCKED:
+                break;
+        default:
+                BUG_ON(1);
+                break;
+        }
+
+        st->prev_event_time = timestamp;
+}
+
+static void
+report_lock_acquired_event(struct trace_acquired_event *acquired_event,
+                         struct event *__event __used,
+                         int cpu __used,
+                         u64 timestamp,
+                         struct thread *thread __used)
+{
+        struct lock_stat *st;
+
+        st = lock_stat_findnew(acquired_event->addr, acquired_event->name);
+
+        switch (st->state) {
+        case LOCK_STATE_UNLOCKED:
+                st->state = LOCK_STATE_LOCKED;
+                st->nr_acquired++;
+                break;
+        case LOCK_STATE_LOCKED:
+                break;
+        default:
+                BUG_ON(1);
+                break;
+        }
+
+        st->prev_event_time = timestamp;
+}
+
+static void
+report_lock_contended_event(struct trace_contended_event *contended_event,
+                          struct event *__event __used,
+                          int cpu __used,
+                          u64 timestamp,
+                          struct thread *thread __used)
+{
+        struct lock_stat *st;
+
+        st = lock_stat_findnew(contended_event->addr, contended_event->name);
+
+        switch (st->state) {
+        case LOCK_STATE_UNLOCKED:
+                break;
+        case LOCK_STATE_LOCKED:
+                st->nr_contended++;
+                break;
+        default:
+                BUG_ON(1);
+                break;
+        }
+
+        st->prev_event_time = timestamp;
+}
+
+static void
+report_lock_release_event(struct trace_release_event *release_event,
+                        struct event *__event __used,
+                        int cpu __used,
+                        u64 timestamp,
+                        struct thread *thread __used)
+{
+        struct lock_stat *st;
+        u64 hold_time;
+
+        st = lock_stat_findnew(release_event->addr, release_event->name);
+
+        switch (st->state) {
+        case LOCK_STATE_UNLOCKED:
+                break;
+        case LOCK_STATE_LOCKED:
+                st->state = LOCK_STATE_UNLOCKED;
+                hold_time = timestamp - st->prev_event_time;
+
+                if (timestamp < st->prev_event_time) {
+                        /* terribly, this can happen... */
+                        goto end;
+                }
+
+                if (st->wait_time_min > hold_time)
+                        st->wait_time_min = hold_time;
+                if (st->wait_time_max < hold_time)
+                        st->wait_time_max = hold_time;
+                st->wait_time_total += hold_time;
+
+                st->nr_release++;
+                break;
+        default:
+                BUG_ON(1);
+                break;
+        }
+
+end:
+        st->prev_event_time = timestamp;
+}
+
+/* lock oriented handlers */
+/* TODO: handlers for CPU oriented, thread oriented */
+static struct trace_lock_handler report_lock_ops  = {
+        .acquire_event          = report_lock_acquire_event,
+        .acquired_event         = report_lock_acquired_event,
+        .contended_event        = report_lock_contended_event,
+        .release_event          = report_lock_release_event,
+};
+
+static struct trace_lock_handler *trace_handler;
+
+static void
+process_lock_acquire_event(void *data,
+                           struct event *event __used,
+                           int cpu __used,
+                           u64 timestamp __used,
+                           struct thread *thread __used)
+{
+        struct trace_acquire_event acquire_event;
+        u64 tmp;                /* this is required for casting... */
+
+        tmp = raw_field_value(event, "lockdep_addr", data);
+        memcpy(&acquire_event.addr, &tmp, sizeof(void *));
+        acquire_event.name = (char *)raw_field_ptr(event, "name", data);
+
+        if (trace_handler->acquire_event)
+                trace_handler->acquire_event(&acquire_event, event, cpu, timestamp, thread);
+}
+
+static void
+process_lock_acquired_event(void *data,
+                            struct event *event __used,
+                            int cpu __used,
+                            u64 timestamp __used,
+                            struct thread *thread __used)
+{
+        struct trace_acquired_event acquired_event;
+        u64 tmp;                /* this is required for casting... */
+
+        tmp = raw_field_value(event, "lockdep_addr", data);
+        memcpy(&acquired_event.addr, &tmp, sizeof(void *));
+        acquired_event.name = (char *)raw_field_ptr(event, "name", data);
+
+        if (trace_handler->acquire_event)
+                trace_handler->acquired_event(&acquired_event, event, cpu, timestamp, thread);
+}
+
+static void
+process_lock_contended_event(void *data,
+                             struct event *event __used,
+                             int cpu __used,
+                             u64 timestamp __used,
+                             struct thread *thread __used)
+{
+        struct trace_contended_event contended_event;
+        u64 tmp;                /* this is required for casting... */
+
+        tmp = raw_field_value(event, "lockdep_addr", data);
+        memcpy(&contended_event.addr, &tmp, sizeof(void *));
+        contended_event.name = (char *)raw_field_ptr(event, "name", data);
+
+        if (trace_handler->acquire_event)
+                trace_handler->contended_event(&contended_event, event, cpu, timestamp, thread);
+}
+
+static void
+process_lock_release_event(void *data,
+                           struct event *event __used,
+                           int cpu __used,
+                           u64 timestamp __used,
+                           struct thread *thread __used)
+{
+        struct trace_release_event release_event;
+        u64 tmp;                /* this is required for casting... */
+
+        tmp = raw_field_value(event, "lockdep_addr", data);
+        memcpy(&release_event.addr, &tmp, sizeof(void *));
+        release_event.name = (char *)raw_field_ptr(event, "name", data);
+
+        if (trace_handler->acquire_event)
+                trace_handler->release_event(&release_event, event, cpu, timestamp, thread);
+}
+
+static void
+process_raw_event(void *data, int cpu,
+                  u64 timestamp, struct thread *thread)
+{
+        struct event *event;
+        int type;
+
+        type = trace_parse_common_type(data);
+        event = trace_find_event(type);
+
+        if (!strcmp(event->name, "lock_acquire"))
+                process_lock_acquire_event(data, event, cpu, timestamp, thread);
+        if (!strcmp(event->name, "lock_acquired"))
+                process_lock_acquired_event(data, event, cpu, timestamp, thread);
+        if (!strcmp(event->name, "lock_contended"))
+                process_lock_contended_event(data, event, cpu, timestamp, thread);
+        if (!strcmp(event->name, "lock_release"))
+                process_lock_release_event(data, event, cpu, timestamp, thread);
+}
+
+struct raw_event_queue {
+        u64                     timestamp;
+        int                     cpu;
+        void                    *data;
+        struct thread           *thread;
+        struct list_head        list;
+};
+
+static LIST_HEAD(raw_event_head);
+
+#define FLUSH_PERIOD    (5 * NSEC_PER_SEC)
+
+static u64 flush_limit = ULLONG_MAX;
+static u64 last_flush = 0;
+struct raw_event_queue *last_inserted;
+
+static void flush_raw_event_queue(u64 limit)
+{
+        struct raw_event_queue *tmp, *iter;
+
+        list_for_each_entry_safe(iter, tmp, &raw_event_head, list) {
+                if (iter->timestamp > limit)
+                        return;
+
+                if (iter == last_inserted)
+                        last_inserted = NULL;
+
+                process_raw_event(iter->data, iter->cpu, iter->timestamp,
+                                  iter->thread);
+
+                last_flush = iter->timestamp;
+                list_del(&iter->list);
+                free(iter->data);
+                free(iter);
+        }
+}
+
+static void __queue_raw_event_end(struct raw_event_queue *new)
+{
+        struct raw_event_queue *iter;
+
+        list_for_each_entry_reverse(iter, &raw_event_head, list) {
+                if (iter->timestamp < new->timestamp) {
+                        list_add(&new->list, &iter->list);
+                        return;
+                }
+        }
+
+        list_add(&new->list, &raw_event_head);
+}
+
+static void __queue_raw_event_before(struct raw_event_queue *new,
+                                     struct raw_event_queue *iter)
+{
+        list_for_each_entry_continue_reverse(iter, &raw_event_head, list) {
+                if (iter->timestamp < new->timestamp) {
+                        list_add(&new->list, &iter->list);
+                        return;
+                }
+        }
+
+        list_add(&new->list, &raw_event_head);
+}
+
+static void __queue_raw_event_after(struct raw_event_queue *new,
+                                     struct raw_event_queue *iter)
+{
+        list_for_each_entry_continue(iter, &raw_event_head, list) {
+                if (iter->timestamp > new->timestamp) {
+                        list_add_tail(&new->list, &iter->list);
+                        return;
+                }
+        }
+        list_add_tail(&new->list, &raw_event_head);
+}
+
+/* The queue is ordered by time */
+static void __queue_raw_event(struct raw_event_queue *new)
+{
+        if (!last_inserted) {
+                __queue_raw_event_end(new);
+                return;
+        }
+
+        /*
+         * Most of the time the current event has a timestamp
+         * very close to the last event inserted, unless we just switched
+         * to another event buffer. Having a sorting based on a list and
+         * on the last inserted event that is close to the current one is
+         * probably more efficient than an rbtree based sorting.
+         */
+        if (last_inserted->timestamp >= new->timestamp)
+                __queue_raw_event_before(new, last_inserted);
+        else
+                __queue_raw_event_after(new, last_inserted);
+}
+
+static void queue_raw_event(void *data, int raw_size, int cpu,
+                            u64 timestamp, struct thread *thread)
+{
+        struct raw_event_queue *new;
+
+        if (flush_limit == ULLONG_MAX)
+                flush_limit = timestamp + FLUSH_PERIOD;
+
+        if (timestamp < last_flush) {
+                printf("Warning: Timestamp below last timeslice flush\n");
+                return;
+        }
+
+        new = malloc(sizeof(*new));
+        if (!new)
+                die("Not enough memory\n");
+
+        new->timestamp = timestamp;
+        new->cpu = cpu;
+        new->thread = thread;
+
+        new->data = malloc(raw_size);
+        if (!new->data)
+                die("Not enough memory\n");
+
+        memcpy(new->data, data, raw_size);
+
+        __queue_raw_event(new);
+        last_inserted = new;
+
+        /*
+         * We want to have a slice of events covering 2 * FLUSH_PERIOD
+         * If FLUSH_PERIOD is big enough, it ensures every events that occured
+         * in the first half of the timeslice have all been buffered and there
+         * are none remaining (we need that because of the weakly ordered
+         * event recording we have). Then once we reach the 2 * FLUSH_PERIOD
+         * timeslice, we flush the first half to be gentle with the memory
+         * (the second half can still get new events in the middle, so wait
+         * another period to flush it)
+         */
+        if (new->timestamp > flush_limit &&
+                new->timestamp - flush_limit > FLUSH_PERIOD) {
+                flush_limit += FLUSH_PERIOD;
+                flush_raw_event_queue(flush_limit);
+        }
+}
+
+static int process_sample_event(event_t *event, struct perf_session *session)
+{
+        struct thread *thread;
+        struct sample_data data;
+
+        bzero(&data, sizeof(struct sample_data));
+        event__parse_sample(event, session->sample_type, &data);
+        thread = perf_session__findnew(session, data.pid);
+
+        if (thread == NULL) {
+                pr_debug("problem processing %d event, skipping it.\n",
+                         event->header.type);
+                return -1;
+        }
+
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
+        if (profile_cpu != -1 && profile_cpu != (int) data.cpu)
+                return 0;
+
+        queue_raw_event(data.raw_data, data.raw_size, data.cpu, data.time, thread);
+
+        return 0;
+}
+
+/* TODO: various way to print, coloring, nano or milli sec */
+static void print_result(void)
+{
+        struct lock_stat *st;
+        char cut_name[20];
+
+        printf("%18s ", "ID");
+        printf("%20s ", "Name");
+        printf("%10s ", "acquired");
+        printf("%10s ", "contended");
+
+        printf("%15s ", "total wait (ns)");
+        printf("%15s ", "max wait (ns)");
+        printf("%15s ", "min wait (ns)");
+
+        printf("\n\n");
+
+        while ((st = pop_from_result())) {
+                bzero(cut_name, 20);
+
+                printf("%p ", st->addr);
+
+                if (strlen(st->name) < 16) {
+                        /* output raw name */
+                        printf("%20s ", st->name);
+                } else {
+                        strncpy(cut_name, st->name, 16);
+                        cut_name[16] = '.';
+                        cut_name[17] = '.';
+                        cut_name[18] = '.';
+                        cut_name[19] = '\0';
+                        /* cut off name for saving output style */
+                        printf("%20s ", cut_name);
+                }
+
+                printf("%10u ", st->nr_acquired);
+                printf("%10u ", st->nr_contended);
+
+                printf("%15llu ", st->wait_time_total);
+                printf("%15llu ", st->wait_time_max);
+                printf("%15llu ", st->wait_time_min == ULLONG_MAX ?
+                       0 : st->wait_time_min);
+                printf("\n");
+        }
+}
+
+static void dump_map(void)
+{
+        unsigned int i;
+        struct lock_stat *st;
+
+        for (i = 0; i < LOCKHASH_SIZE; i++) {
+                list_for_each_entry(st, &lockhash_table[i], hash_entry) {
+                        printf("%p: %s\n", st->addr, st->name);
+                }
+        }
+}
+
+static struct perf_event_ops eops = {
+        .sample                 = process_sample_event,
+        .comm                   = event__process_comm,
+};
+
+static struct perf_session *session;
+
+static int read_events(void)
+{
+        session = perf_session__new(input_name, O_RDONLY, 0);
+        if (!session)
+                die("Initializing perf session failed\n");
+
+        return perf_session__process_events(session, &eops);
+}
+
+static void sort_result(void)
+{
+        unsigned int i;
+        struct lock_stat *st;
+
+        for (i = 0; i < LOCKHASH_SIZE; i++) {
+                list_for_each_entry(st, &lockhash_table[i], hash_entry) {
+                        insert_to_result(st, compare);
+                }
+        }
+}
+
+static void __cmd_report(void)
+{
+        setup_pager();
+        select_key();
+        read_events();
+        flush_raw_event_queue(ULLONG_MAX);
+        sort_result();
+        print_result();
+}
+
+static const char * const report_usage[] = {
+        "perf lock report [<options>]",
+        NULL
+};
+
+static const struct option report_options[] = {
+        OPT_STRING('k', "key", &sort_key, "acquired",
+                    "key for sorting"),
+        /* TODO: type */
+        OPT_END()
+};
+
+static const char * const lock_usage[] = {
+        "perf lock [<options>] {record|trace|report}",
+        NULL
+};
+
+static const struct option lock_options[] = {
+        OPT_STRING('i', "input", &input_name, "file", "input file name"),
+        OPT_BOOLEAN('v', "verbose", &verbose, "be more verbose (show symbol address, etc)"),
+        OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, "dump raw trace in ASCII"),
+        OPT_END()
+};
+
+static const char *record_args[] = {
+        "record",
+        "-a",
+        "-R",
+        "-f",
+        "-m", "1024",
+        "-c", "1",
+        "-e", "lock:lock_acquire:r",
+        "-e", "lock:lock_acquired:r",
+        "-e", "lock:lock_contended:r",
+        "-e", "lock:lock_release:r",
+};
+
+static int __cmd_record(int argc, const char **argv)
+{
+        unsigned int rec_argc, i, j;
+        const char **rec_argv;
+
+        rec_argc = ARRAY_SIZE(record_args) + argc - 1;
+        rec_argv = calloc(rec_argc + 1, sizeof(char *));
+
+        for (i = 0; i < ARRAY_SIZE(record_args); i++)
+                rec_argv[i] = strdup(record_args[i]);
+
+        for (j = 1; j < (unsigned int)argc; j++, i++)
+                rec_argv[i] = argv[j];
+
+        BUG_ON(i != rec_argc);
+
+        return cmd_record(i, rec_argv, NULL);
+}
+
+int cmd_lock(int argc, const char **argv, const char *prefix __used)
+{
+        unsigned int i;
+
+        symbol__init();
+        for (i = 0; i < LOCKHASH_SIZE; i++)
+                INIT_LIST_HEAD(lockhash_table + i);
+
+        argc = parse_options(argc, argv, lock_options, lock_usage,
+                             PARSE_OPT_STOP_AT_NON_OPTION);
+        if (!argc)
+                usage_with_options(lock_usage, lock_options);
+
+        if (!strncmp(argv[0], "rec", 3)) {
+                return __cmd_record(argc, argv);
+        } else if (!strncmp(argv[0], "report", 6)) {
+                trace_handler = &report_lock_ops;
+                if (argc) {
+                        argc = parse_options(argc, argv,
+                                             report_options, report_usage, 0);
+                        if (argc)
+                                usage_with_options(report_usage, report_options);
+                }
+                __cmd_report();
+        } else if (!strcmp(argv[0], "trace")) {
+                /* Aliased to 'perf trace' */
+                return cmd_trace(argc, argv, prefix);
+        } else if (!strcmp(argv[0], "map")) {
+                /* recycling report_lock_ops */
+                trace_handler = &report_lock_ops;
+                setup_pager();
+                read_events();
+                dump_map();
+        } else {
+                usage_with_options(lock_usage, lock_options);
+        }
+
+        return 0;
+}
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
new file mode 100644
index 000000000000..152d6c9b1fa4
--- /dev/null
+++ b/tools/perf/builtin-probe.c
@@ -0,0 +1,360 @@
+/*
+ * builtin-probe.c
+ *
+ * Builtin probe command: Set up probe events by C expression
+ *
+ * Written by Masami Hiramatsu <mhiramat@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+#define _GNU_SOURCE
+#include <sys/utsname.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+#undef _GNU_SOURCE
+#include "perf.h"
+#include "builtin.h"
+#include "util/util.h"
+#include "util/strlist.h"
+#include "util/event.h"
+#include "util/debug.h"
+#include "util/debugfs.h"
+#include "util/symbol.h"
+#include "util/thread.h"
+#include "util/parse-options.h"
+#include "util/parse-events.h"  /* For debugfs_path */
+#include "util/probe-finder.h"
+#include "util/probe-event.h"
+
+#define MAX_PATH_LEN 256
+
+/* Session management structure */
+static struct {
+        bool need_dwarf;
+        bool list_events;
+        bool force_add;
+        bool show_lines;
+        int nr_probe;
+        struct probe_point probes[MAX_PROBES];
+        struct strlist *dellist;
+        struct map_groups kmap_groups;
+        struct map *kmaps[MAP__NR_TYPES];
+        struct line_range line_range;
+} session;
+
+
+/* Parse an event definition. Note that any error must die. */
+static void parse_probe_event(const char *str)
+{
+        struct probe_point *pp = &session.probes[session.nr_probe];
+
+        pr_debug("probe-definition(%d): %s\n", session.nr_probe, str);
+        if (++session.nr_probe == MAX_PROBES)
+                die("Too many probes (> %d) are specified.", MAX_PROBES);
+
+        /* Parse perf-probe event into probe_point */
+        parse_perf_probe_event(str, pp, &session.need_dwarf);
+
+        pr_debug("%d arguments\n", pp->nr_args);
+}
+
+static void parse_probe_event_argv(int argc, const char **argv)
+{
+        int i, len;
+        char *buf;
+
+        /* Bind up rest arguments */
+        len = 0;
+        for (i = 0; i < argc; i++)
+                len += strlen(argv[i]) + 1;
+        buf = zalloc(len + 1);
+        if (!buf)
+                die("Failed to allocate memory for binding arguments.");
+        len = 0;
+        for (i = 0; i < argc; i++)
+                len += sprintf(&buf[len], "%s ", argv[i]);
+        parse_probe_event(buf);
+        free(buf);
+}
+
+static int opt_add_probe_event(const struct option *opt __used,
+                              const char *str, int unset __used)
+{
+        if (str)
+                parse_probe_event(str);
+        return 0;
+}
+
+static int opt_del_probe_event(const struct option *opt __used,
+                               const char *str, int unset __used)
+{
+        if (str) {
+                if (!session.dellist)
+                        session.dellist = strlist__new(true, NULL);
+                strlist__add(session.dellist, str);
+        }
+        return 0;
+}
+
+/* Currently just checking function name from symbol map */
+static void evaluate_probe_point(struct probe_point *pp)
+{
+        struct symbol *sym;
+        sym = map__find_symbol_by_name(session.kmaps[MAP__FUNCTION],
+                                       pp->function, NULL);
+        if (!sym)
+                die("Kernel symbol \'%s\' not found - probe not added.",
+                    pp->function);
+}
+
+#ifndef NO_DWARF_SUPPORT
+static int open_vmlinux(void)
+{
+        if (map__load(session.kmaps[MAP__FUNCTION], NULL) < 0) {
+                pr_debug("Failed to load kernel map.\n");
+                return -EINVAL;
+        }
+        pr_debug("Try to open %s\n",
+                 session.kmaps[MAP__FUNCTION]->dso->long_name);
+        return open(session.kmaps[MAP__FUNCTION]->dso->long_name, O_RDONLY);
+}
+
+static int opt_show_lines(const struct option *opt __used,
+                          const char *str, int unset __used)
+{
+        if (str)
+                parse_line_range_desc(str, &session.line_range);
+        INIT_LIST_HEAD(&session.line_range.line_list);
+        session.show_lines = true;
+        return 0;
+}
+#endif
+
+static const char * const probe_usage[] = {
+        "perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
+        "perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
+        "perf probe [<options>] --del '[GROUP:]EVENT' ...",
+        "perf probe --list",
+#ifndef NO_DWARF_SUPPORT
+        "perf probe --line 'LINEDESC'",
+#endif
+        NULL
+};
+
+static const struct option options[] = {
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose (show parsed arguments, etc)"),
+#ifndef NO_DWARF_SUPPORT
+        OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
+                   "file", "vmlinux pathname"),
+#endif
+        OPT_BOOLEAN('l', "list", &session.list_events,
+                    "list up current probe events"),
+        OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
+                opt_del_probe_event),
+        OPT_CALLBACK('a', "add", NULL,
+#ifdef NO_DWARF_SUPPORT
+                "[EVENT=]FUNC[+OFF|%return] [ARG ...]",
+#else
+                "[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT"
+                " [ARG ...]",
+#endif
+                "probe point definition, where\n"
+                "\t\tGROUP:\tGroup name (optional)\n"
+                "\t\tEVENT:\tEvent name\n"
+                "\t\tFUNC:\tFunction name\n"
+                "\t\tOFF:\tOffset from function entry (in byte)\n"
+                "\t\t%return:\tPut the probe at function return\n"
+#ifdef NO_DWARF_SUPPORT
+                "\t\tARG:\tProbe argument (only \n"
+#else
+                "\t\tSRC:\tSource code path\n"
+                "\t\tRL:\tRelative line number from function entry.\n"
+                "\t\tAL:\tAbsolute line number in file.\n"
+                "\t\tPT:\tLazy expression of line code.\n"
+                "\t\tARG:\tProbe argument (local variable name or\n"
+#endif
+                "\t\t\tkprobe-tracer argument format.)\n",
+                opt_add_probe_event),
+        OPT_BOOLEAN('f', "force", &session.force_add, "forcibly add events"
+                    " with existing name"),
+#ifndef NO_DWARF_SUPPORT
+        OPT_CALLBACK('L', "line", NULL,
+                     "FUNC[:RLN[+NUM|:RLN2]]|SRC:ALN[+NUM|:ALN2]",
+                     "Show source code lines.", opt_show_lines),
+#endif
+        OPT_END()
+};
+
+/* Initialize symbol maps for vmlinux */
+static void init_vmlinux(void)
+{
+        symbol_conf.sort_by_name = true;
+        if (symbol_conf.vmlinux_name == NULL)
+                symbol_conf.try_vmlinux_path = true;
+        else
+                pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
+        if (symbol__init() < 0)
+                die("Failed to init symbol map.");
+
+        map_groups__init(&session.kmap_groups);
+        if (map_groups__create_kernel_maps(&session.kmap_groups,
+                                           session.kmaps) < 0)
+                die("Failed to create kernel maps.");
+}
+
+int cmd_probe(int argc, const char **argv, const char *prefix __used)
+{
+        int i, ret;
+#ifndef NO_DWARF_SUPPORT
+        int fd;
+#endif
+        struct probe_point *pp;
+
+        argc = parse_options(argc, argv, options, probe_usage,
+                             PARSE_OPT_STOP_AT_NON_OPTION);
+        if (argc > 0) {
+                if (strcmp(argv[0], "-") == 0) {
+                        pr_warning("  Error: '-' is not supported.\n");
+                        usage_with_options(probe_usage, options);
+                }
+                parse_probe_event_argv(argc, argv);
+        }
+
+        if ((!session.nr_probe && !session.dellist && !session.list_events &&
+             !session.show_lines))
+                usage_with_options(probe_usage, options);
+
+        if (debugfs_valid_mountpoint(debugfs_path) < 0)
+                die("Failed to find debugfs path.");
+
+        if (session.list_events) {
+                if (session.nr_probe != 0 || session.dellist) {
+                        pr_warning("  Error: Don't use --list with"
+                                   " --add/--del.\n");
+                        usage_with_options(probe_usage, options);
+                }
+                if (session.show_lines) {
+                        pr_warning("  Error: Don't use --list with --line.\n");
+                        usage_with_options(probe_usage, options);
+                }
+                show_perf_probe_events();
+                return 0;
+        }
+
+#ifndef NO_DWARF_SUPPORT
+        if (session.show_lines) {
+                if (session.nr_probe != 0 || session.dellist) {
+                        pr_warning("  Error: Don't use --line with"
+                                   " --add/--del.\n");
+                        usage_with_options(probe_usage, options);
+                }
+                init_vmlinux();
+                fd = open_vmlinux();
+                if (fd < 0)
+                        die("Could not open debuginfo file.");
+                ret = find_line_range(fd, &session.line_range);
+                if (ret <= 0)
+                        die("Source line is not found.\n");
+                close(fd);
+                show_line_range(&session.line_range);
+                return 0;
+        }
+#endif
+
+        if (session.dellist) {
+                del_trace_kprobe_events(session.dellist);
+                strlist__delete(session.dellist);
+                if (session.nr_probe == 0)
+                        return 0;
+        }
+
+        /* Add probes */
+        init_vmlinux();
+
+        if (session.need_dwarf)
+#ifdef NO_DWARF_SUPPORT
+                die("Debuginfo-analysis is not supported");
+#else   /* !NO_DWARF_SUPPORT */
+                pr_debug("Some probes require debuginfo.\n");
+
+        fd = open_vmlinux();
+        if (fd < 0) {
+                if (session.need_dwarf)
+                        die("Could not open debuginfo file.");
+
+                pr_debug("Could not open vmlinux/module file."
+                         " Try to use symbols.\n");
+                goto end_dwarf;
+        }
+
+        /* Searching probe points */
+        for (i = 0; i < session.nr_probe; i++) {
+                pp = &session.probes[i];
+                if (pp->found)
+                        continue;
+
+                lseek(fd, SEEK_SET, 0);
+                ret = find_probe_point(fd, pp);
+                if (ret > 0)
+                        continue;
+                if (ret == 0) { /* No error but failed to find probe point. */
+                        synthesize_perf_probe_point(pp);
+                        die("Probe point '%s' not found. - probe not added.",
+                            pp->probes[0]);
+                }
+                /* Error path */
+                if (session.need_dwarf) {
+                        if (ret == -ENOENT)
+                                pr_warning("No dwarf info found in the vmlinux - please rebuild with CONFIG_DEBUG_INFO=y.\n");
+                        die("Could not analyze debuginfo.");
+                }
+                pr_debug("An error occurred in debuginfo analysis."
+                         " Try to use symbols.\n");
+                break;
+        }
+        close(fd);
+
+end_dwarf:
+#endif /* !NO_DWARF_SUPPORT */
+
+        /* Synthesize probes without dwarf */
+        for (i = 0; i < session.nr_probe; i++) {
+                pp = &session.probes[i];
+                if (pp->found)  /* This probe is already found. */
+                        continue;
+
+                evaluate_probe_point(pp);
+                ret = synthesize_trace_kprobe_event(pp);
+                if (ret == -E2BIG)
+                        die("probe point definition becomes too long.");
+                else if (ret < 0)
+                        die("Failed to synthesize a probe point.");
+        }
+
+        /* Settng up probe points */
+        add_trace_kprobe_events(session.probes, session.nr_probe,
+                                session.force_add);
+        return 0;
+}
+
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index a4be453fc8a9..f1411e9cdf47 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -5,10 +5,13 @@
  * (or a CPU, or a PID) into the perf.data output file - for
  * later analysis via perf report.
  */
+#define _FILE_OFFSET_BITS 64
+
 #include "builtin.h"
 
 #include "perf.h"
 
+#include "util/build-id.h"
 #include "util/util.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
@@ -17,55 +20,55 @@
 #include "util/header.h"
 #include "util/event.h"
 #include "util/debug.h"
-#include "util/trace-event.h"
+#include "util/session.h"
+#include "util/symbol.h"
+#include "util/cpumap.h"
 
 #include <unistd.h>
 #include <sched.h>
 
-#define ALIGN(x, a)             __ALIGN_MASK(x, (typeof(x))(a)-1)
-#define __ALIGN_MASK(x, mask)   (((x)+(mask))&~(mask))
-
 static int                      fd[MAX_NR_CPUS][MAX_COUNTERS];
 
-static long                     default_interval                = 100000;
+static long                     default_interval                =      0;
 
-static int                      nr_cpus                         = 0;
+static int                      nr_cpus                         =      0;
 static unsigned int             page_size;
-static unsigned int             mmap_pages                      = 128;
-static int                      freq                            = 0;
+static unsigned int             mmap_pages                      =    128;
+static int                      freq                            =   1000;
 static int                      output;
 static const char               *output_name                    = "perf.data";
-static int                      group                           = 0;
-static unsigned int             realtime_prio                   = 0;
-static int                      raw_samples                     = 0;
-static int                      system_wide                     = 0;
-static int                      profile_cpu                     = -1;
-static pid_t                    target_pid                      = -1;
-static pid_t                    child_pid                       = -1;
-static int                      inherit                         = 1;
-static int                      force                           = 0;
-static int                      append_file                     = 0;
-static int                      call_graph                      = 0;
-static int                      inherit_stat                    = 0;
-static int                      no_samples                      = 0;
-static int                      sample_address                  = 0;
-static int                      multiplex                       = 0;
-static int                      multiplex_fd                    = -1;
-
-static long                     samples;
+static int                      group                           =      0;
+static unsigned int             realtime_prio                   =      0;
+static int                      raw_samples                     =      0;
+static int                      system_wide                     =      0;
+static int                      profile_cpu                     =     -1;
+static pid_t                    target_pid                      =     -1;
+static pid_t                    child_pid                       =     -1;
+static int                      inherit                         =      1;
+static int                      force                           =      0;
+static int                      append_file                     =      0;
+static int                      call_graph                      =      0;
+static int                      inherit_stat                    =      0;
+static int                      no_samples                      =      0;
+static int                      sample_address                  =      0;
+static int                      multiplex                       =      0;
+static int                      multiplex_fd                    =     -1;
+
+static long                     samples                         =      0;
 static struct timeval           last_read;
 static struct timeval           this_read;
 
-static u64                      bytes_written;
+static u64                      bytes_written                   =      0;
 
 static struct pollfd            event_array[MAX_NR_CPUS * MAX_COUNTERS];
 
-static int                      nr_poll;
-static int                      nr_cpu;
+static int                      nr_poll                         =      0;
+static int                      nr_cpu                          =      0;
 
-static int                      file_new = 1;
+static int                      file_new                        =      1;
+static off_t                    post_processing_offset;
 
-struct perf_header              *header;
+static struct perf_session      *session;
 
 struct mmap_data {
         int                     counter;
@@ -113,6 +116,13 @@ static void write_output(void *buf, size_t size)
         }
 }
 
+static int process_synthesized_event(event_t *event,
+                                     struct perf_session *self __used)
+{
+        write_output(event, event->header.size);
+        return 0;
+}
+
 static void mmap_read(struct mmap_data *md)
 {
         unsigned int head = mmap_read_head(md);
@@ -195,179 +205,21 @@ static void sig_atexit(void)
         kill(getpid(), signr);
 }
 
-static pid_t pid_synthesize_comm_event(pid_t pid, int full)
-{
-        struct comm_event comm_ev;
-        char filename[PATH_MAX];
-        char bf[BUFSIZ];
-        FILE *fp;
-        size_t size = 0;
-        DIR *tasks;
-        struct dirent dirent, *next;
-        pid_t tgid = 0;
-
-        snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
-
-        fp = fopen(filename, "r");
-        if (fp == NULL) {
-                /*
-                 * We raced with a task exiting - just return:
-                 */
-                if (verbose)
-                        fprintf(stderr, "couldn't open %s\n", filename);
-                return 0;
-        }
-
-        memset(&comm_ev, 0, sizeof(comm_ev));
-        while (!comm_ev.comm[0] || !comm_ev.pid) {
-                if (fgets(bf, sizeof(bf), fp) == NULL)
-                        goto out_failure;
-
-                if (memcmp(bf, "Name:", 5) == 0) {
-                        char *name = bf + 5;
-                        while (*name && isspace(*name))
-                                ++name;
-                        size = strlen(name) - 1;
-                        memcpy(comm_ev.comm, name, size++);
-                } else if (memcmp(bf, "Tgid:", 5) == 0) {
-                        char *tgids = bf + 5;
-                        while (*tgids && isspace(*tgids))
-                                ++tgids;
-                        tgid = comm_ev.pid = atoi(tgids);
-                }
-        }
-
-        comm_ev.header.type = PERF_RECORD_COMM;
-        size = ALIGN(size, sizeof(u64));
-        comm_ev.header.size = sizeof(comm_ev) - (sizeof(comm_ev.comm) - size);
-
-        if (!full) {
-                comm_ev.tid = pid;
-
-                write_output(&comm_ev, comm_ev.header.size);
-                goto out_fclose;
-        }
-
-        snprintf(filename, sizeof(filename), "/proc/%d/task", pid);
-
-        tasks = opendir(filename);
-        while (!readdir_r(tasks, &dirent, &next) && next) {
-                char *end;
-                pid = strtol(dirent.d_name, &end, 10);
-                if (*end)
-                        continue;
-
-                comm_ev.tid = pid;
-
-                write_output(&comm_ev, comm_ev.header.size);
-        }
-        closedir(tasks);
-
-out_fclose:
-        fclose(fp);
-        return tgid;
-
-out_failure:
-        fprintf(stderr, "couldn't get COMM and pgid, malformed %s\n",
-                filename);
-        exit(EXIT_FAILURE);
-}
-
-static void pid_synthesize_mmap_samples(pid_t pid, pid_t tgid)
-{
-        char filename[PATH_MAX];
-        FILE *fp;
-
-        snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
-
-        fp = fopen(filename, "r");
-        if (fp == NULL) {
-                /*
-                 * We raced with a task exiting - just return:
-                 */
-                if (verbose)
-                        fprintf(stderr, "couldn't open %s\n", filename);
-                return;
-        }
-        while (1) {
-                char bf[BUFSIZ], *pbf = bf;
-                struct mmap_event mmap_ev = {
-                        .header = { .type = PERF_RECORD_MMAP },
-                };
-                int n;
-                size_t size;
-                if (fgets(bf, sizeof(bf), fp) == NULL)
-                        break;
-
-                /* 00400000-0040c000 r-xp 00000000 fd:01 41038  /bin/cat */
-                n = hex2u64(pbf, &mmap_ev.start);
-                if (n < 0)
-                        continue;
-                pbf += n + 1;
-                n = hex2u64(pbf, &mmap_ev.len);
-                if (n < 0)
-                        continue;
-                pbf += n + 3;
-                if (*pbf == 'x') { /* vm_exec */
-                        char *execname = strchr(bf, '/');
-
-                        /* Catch VDSO */
-                        if (execname == NULL)
-                                execname = strstr(bf, "[vdso]");
-
-                        if (execname == NULL)
-                                continue;
-
-                        size = strlen(execname);
-                        execname[size - 1] = '\0'; /* Remove \n */
-                        memcpy(mmap_ev.filename, execname, size);
-                        size = ALIGN(size, sizeof(u64));
-                        mmap_ev.len -= mmap_ev.start;
-                        mmap_ev.header.size = (sizeof(mmap_ev) -
-                                               (sizeof(mmap_ev.filename) - size));
-                        mmap_ev.pid = tgid;
-                        mmap_ev.tid = pid;
-
-                        write_output(&mmap_ev, mmap_ev.header.size);
-                }
-        }
-
-        fclose(fp);
-}
-
-static void synthesize_all(void)
-{
-        DIR *proc;
-        struct dirent dirent, *next;
-
-        proc = opendir("/proc");
-
-        while (!readdir_r(proc, &dirent, &next) && next) {
-                char *end;
-                pid_t pid, tgid;
-
-                pid = strtol(dirent.d_name, &end, 10);
-                if (*end) /* only interested in proper numerical dirents */
-                        continue;
-
-                tgid = pid_synthesize_comm_event(pid, 1);
-                pid_synthesize_mmap_samples(pid, tgid);
-        }
-
-        closedir(proc);
-}
-
 static int group_fd;
 
 static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int nr)
 {
         struct perf_header_attr *h_attr;
 
-        if (nr < header->attrs) {
-                h_attr = header->attr[nr];
+        if (nr < session->header.attrs) {
+                h_attr = session->header.attr[nr];
         } else {
                 h_attr = perf_header_attr__new(a);
-                perf_header__add_attr(header, h_attr);
+                if (h_attr != NULL)
+                        if (perf_header__add_attr(&session->header, h_attr) < 0) {
+                                perf_header_attr__delete(h_attr);
+                                h_attr = NULL;
+                        }
         }
 
         return h_attr;
@@ -375,9 +227,11 @@ static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int n
 
 static void create_counter(int counter, int cpu, pid_t pid)
 {
+        char *filter = filters[counter];
         struct perf_event_attr *attr = attrs + counter;
         struct perf_header_attr *h_attr;
         int track = !counter; /* only the first counter needs these */
+        int ret;
         struct {
                 u64 count;
                 u64 time_enabled;
@@ -391,6 +245,9 @@ static void create_counter(int counter, int cpu, pid_t pid)
 
         attr->sample_type       |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
 
+        if (nr_counters > 1)
+                attr->sample_type |= PERF_SAMPLE_ID;
+
         if (freq) {
                 attr->sample_type       |= PERF_SAMPLE_PERIOD;
                 attr->freq              = 1;
@@ -417,7 +274,7 @@ static void create_counter(int counter, int cpu, pid_t pid)
 
         attr->mmap              = track;
         attr->comm              = track;
-        attr->inherit           = (cpu < 0) && inherit;
+        attr->inherit           = inherit;
         attr->disabled          = 1;
 
 try_again:
@@ -448,11 +305,19 @@ try_again:
                 printf("\n");
                 error("perfcounter syscall returned with %d (%s)\n",
                         fd[nr_cpu][counter], strerror(err));
+
+#if defined(__i386__) || defined(__x86_64__)
+                if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
+                        die("No hardware sampling interrupt available. No APIC? If so then you can boot the kernel with the \"lapic\" boot parameter to force-enable it.\n");
+#endif
+
                 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
                 exit(-1);
         }
 
         h_attr = get_header_attr(attr, counter);
+        if (h_attr == NULL)
+                die("nomem\n");
 
         if (!file_new) {
                 if (memcmp(&h_attr->attr, attr, sizeof(*attr))) {
@@ -466,7 +331,10 @@ try_again:
                 exit(-1);
         }
 
-        perf_header_attr__add_id(h_attr, read_data.id);
+        if (perf_header_attr__add_id(h_attr, read_data.id) < 0) {
+                pr_warning("Not enough memory to add id\n");
+                exit(-1);
+        }
 
         assert(fd[nr_cpu][counter] >= 0);
         fcntl(fd[nr_cpu][counter], F_SETFL, O_NONBLOCK);
@@ -480,7 +348,6 @@ try_again:
                 multiplex_fd = fd[nr_cpu][counter];
 
         if (multiplex && fd[nr_cpu][counter] != multiplex_fd) {
-                int ret;
 
                 ret = ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_SET_OUTPUT, multiplex_fd);
                 assert(ret != -1);
@@ -500,6 +367,16 @@ try_again:
                 }
         }
 
+        if (filter != NULL) {
+                ret = ioctl(fd[nr_cpu][counter],
+                            PERF_EVENT_IOC_SET_FILTER, filter);
+                if (ret) {
+                        error("failed to set filter with %d (%s)\n", errno,
+                              strerror(errno));
+                        exit(-1);
+                }
+        }
+
         ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_ENABLE);
 }
 
@@ -514,11 +391,25 @@ static void open_counters(int cpu, pid_t pid)
         nr_cpu++;
 }
 
+static int process_buildids(void)
+{
+        u64 size = lseek(output, 0, SEEK_CUR);
+
+        if (size == 0)
+                return 0;
+
+        session->fd = output;
+        return __perf_session__process_events(session, post_processing_offset,
+                                              size - post_processing_offset,
+                                              size, &build_id__mark_dso_hit_ops);
+}
+
 static void atexit_header(void)
 {
-        header->data_size += bytes_written;
+        session->header.data_size += bytes_written;
 
-        perf_header__write(header, output);
+        process_buildids();
+        perf_header__write(&session->header, output, true);
 }
 
 static int __cmd_record(int argc, const char **argv)
@@ -527,23 +418,37 @@ static int __cmd_record(int argc, const char **argv)
         struct stat st;
         pid_t pid = 0;
         int flags;
-        int ret;
+        int err;
         unsigned long waking = 0;
+        int child_ready_pipe[2], go_pipe[2];
+        const bool forks = target_pid == -1 && argc > 0;
+        char buf;
 
         page_size = sysconf(_SC_PAGE_SIZE);
-        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
-        assert(nr_cpus <= MAX_NR_CPUS);
-        assert(nr_cpus >= 0);
 
         atexit(sig_atexit);
         signal(SIGCHLD, sig_handler);
         signal(SIGINT, sig_handler);
 
+        if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
+                perror("failed to create pipes");
+                exit(-1);
+        }
+
         if (!stat(output_name, &st) && st.st_size) {
-                if (!force && !append_file) {
-                        fprintf(stderr, "Error, output file %s exists, use -A to append or -f to overwrite.\n",
-                                        output_name);
-                        exit(-1);
+                if (!force) {
+                        if (!append_file) {
+                                pr_err("Error, output file %s exists, use -A "
+                                       "to append or -f to overwrite.\n",
+                                       output_name);
+                                exit(-1);
+                        }
+                } else {
+                        char oldname[PATH_MAX];
+                        snprintf(oldname, sizeof(oldname), "%s.old",
+                                 output_name);
+                        unlink(oldname);
+                        rename(output_name, oldname);
                 }
         } else {
                 append_file = 0;
@@ -561,73 +466,139 @@ static int __cmd_record(int argc, const char **argv)
                 exit(-1);
         }
 
-        if (!file_new)
-                header = perf_header__read(output);
-        else
-                header = perf_header__new();
+        session = perf_session__new(output_name, O_WRONLY, force);
+        if (session == NULL) {
+                pr_err("Not enough memory for reading perf file header\n");
+                return -1;
+        }
 
+        if (!file_new) {
+                err = perf_header__read(&session->header, output);
+                if (err < 0)
+                        return err;
+        }
 
         if (raw_samples) {
-                read_tracing_data(attrs, nr_counters);
+                perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
         } else {
                 for (i = 0; i < nr_counters; i++) {
                         if (attrs[i].sample_type & PERF_SAMPLE_RAW) {
-                                read_tracing_data(attrs, nr_counters);
+                                perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
                                 break;
                         }
                 }
         }
+
         atexit(atexit_header);
 
-        if (!system_wide) {
-                pid = target_pid;
-                if (pid == -1)
-                        pid = getpid();
+        if (forks) {
+                pid = fork();
+                if (pid < 0) {
+                        perror("failed to fork");
+                        exit(-1);
+                }
 
-                open_counters(profile_cpu, pid);
-        } else {
-                if (profile_cpu != -1) {
-                        open_counters(profile_cpu, target_pid);
-                } else {
-                        for (i = 0; i < nr_cpus; i++)
-                                open_counters(i, target_pid);
+                if (!pid) {
+                        close(child_ready_pipe[0]);
+                        close(go_pipe[1]);
+                        fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
+
+                        /*
+                         * Do a dummy execvp to get the PLT entry resolved,
+                         * so we avoid the resolver overhead on the real
+                         * execvp call.
+                         */
+                        execvp("", (char **)argv);
+
+                        /*
+                         * Tell the parent we're ready to go
+                         */
+                        close(child_ready_pipe[1]);
+
+                        /*
+                         * Wait until the parent tells us to go.
+                         */
+                        if (read(go_pipe[0], &buf, 1) == -1)
+                                perror("unable to read pipe");
+
+                        execvp(argv[0], (char **)argv);
+
+                        perror(argv[0]);
+                        exit(-1);
+                }
+
+                child_pid = pid;
+
+                if (!system_wide)
+                        target_pid = pid;
+
+                close(child_ready_pipe[1]);
+                close(go_pipe[0]);
+                /*
+                 * wait for child to settle
+                 */
+                if (read(child_ready_pipe[0], &buf, 1) == -1) {
+                        perror("unable to read pipe");
+                        exit(-1);
                 }
+                close(child_ready_pipe[0]);
         }
 
-        if (file_new)
-                perf_header__write(header, output);
 
-        if (!system_wide) {
-                pid_t tgid = pid_synthesize_comm_event(pid, 0);
-                pid_synthesize_mmap_samples(pid, tgid);
-        } else
-                synthesize_all();
+        if ((!system_wide && !inherit) || profile_cpu != -1) {
+                open_counters(profile_cpu, target_pid);
+        } else {
+                nr_cpus = read_cpu_map();
+                for (i = 0; i < nr_cpus; i++)
+                        open_counters(cpumap[i], target_pid);
+        }
 
-        if (target_pid == -1 && argc) {
-                pid = fork();
-                if (pid < 0)
-                        perror("failed to fork");
+        if (file_new) {
+                err = perf_header__write(&session->header, output, false);
+                if (err < 0)
+                        return err;
+        }
 
-                if (!pid) {
-                        if (execvp(argv[0], (char **)argv)) {
-                                perror(argv[0]);
-                                exit(-1);
-                        }
-                }
+        post_processing_offset = lseek(output, 0, SEEK_CUR);
 
-                child_pid = pid;
+        err = event__synthesize_kernel_mmap(process_synthesized_event,
+                                            session, "_text");
+        if (err < 0)
+                err = event__synthesize_kernel_mmap(process_synthesized_event,
+                                                    session, "_stext");
+        if (err < 0) {
+                pr_err("Couldn't record kernel reference relocation symbol.\n");
+                return err;
+        }
+
+        err = event__synthesize_modules(process_synthesized_event, session);
+        if (err < 0) {
+                pr_err("Couldn't record kernel reference relocation symbol.\n");
+                return err;
         }
 
+        if (!system_wide && profile_cpu == -1)
+                event__synthesize_thread(target_pid, process_synthesized_event,
+                                         session);
+        else
+                event__synthesize_threads(process_synthesized_event, session);
+
         if (realtime_prio) {
                 struct sched_param param;
 
                 param.sched_priority = realtime_prio;
                 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
-                        printf("Could not set realtime priority.\n");
+                        pr_err("Could not set realtime priority.\n");
                         exit(-1);
                 }
         }
 
+        /*
+         * Let the child rip
+         */
+        if (forks)
+                close(go_pipe[1]);
+
         for (;;) {
                 int hits = samples;
 
@@ -641,7 +612,7 @@ static int __cmd_record(int argc, const char **argv)
                 if (hits == samples) {
                         if (done)
                                 break;
-                        ret = poll(event_array, nr_poll, -1);
+                        err = poll(event_array, nr_poll, -1);
                         waking++;
                 }
 
@@ -677,6 +648,8 @@ static const struct option options[] = {
         OPT_CALLBACK('e', "event", NULL, "event",
                      "event selector. use 'perf list' to list available events",
                      parse_events),
+        OPT_CALLBACK(0, "filter", NULL, "filter",
+                     "event filter", parse_filter),
         OPT_INTEGER('p', "pid", &target_pid,
                     "record events on existing pid"),
         OPT_INTEGER('r', "realtime", &realtime_prio,
@@ -721,16 +694,30 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
         int counter;
 
         argc = parse_options(argc, argv, options, record_usage,
-                PARSE_OPT_STOP_AT_NON_OPTION);
-        if (!argc && target_pid == -1 && !system_wide)
+                            PARSE_OPT_STOP_AT_NON_OPTION);
+        if (!argc && target_pid == -1 && !system_wide && profile_cpu == -1)
                 usage_with_options(record_usage, options);
 
+        symbol__init();
+
         if (!nr_counters) {
                 nr_counters     = 1;
                 attrs[0].type   = PERF_TYPE_HARDWARE;
                 attrs[0].config = PERF_COUNT_HW_CPU_CYCLES;
         }
 
+        /*
+         * User specified count overrides default frequency.
+         */
+        if (default_interval)
+                freq = 0;
+        else if (freq) {
+                default_interval = freq;
+        } else {
+                fprintf(stderr, "frequency and count are zero, aborting\n");
+                exit(EXIT_FAILURE);
+        }
+
         for (counter = 0; counter < nr_counters; counter++) {
                 if (attrs[counter].sample_period)
                         continue;
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 19669c20088e..f815de25d0fc 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -22,27 +22,20 @@
 #include "perf.h"
 #include "util/debug.h"
 #include "util/header.h"
+#include "util/session.h"
 
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 
 #include "util/thread.h"
+#include "util/sort.h"
+#include "util/hist.h"
 
 static char             const *input_name = "perf.data";
 
-static char             default_sort_order[] = "comm,dso,symbol";
-static char             *sort_order = default_sort_order;
-static char             *dso_list_str, *comm_list_str, *sym_list_str,
-                        *col_width_list_str;
-static struct strlist   *dso_list, *comm_list, *sym_list;
-static char             *field_sep;
-
 static int              force;
-static int              input;
-static int              show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
-
-static int              full_paths;
-static int              show_nr_samples;
+static bool             hide_unresolved;
+static bool             dont_use_callchains;
 
 static int              show_threads;
 static struct perf_read_values  show_threads_values;
@@ -50,1043 +43,79 @@ static struct perf_read_values	show_threads_values;
 static char             default_pretty_printing_style[] = "normal";
 static char             *pretty_printing_style = default_pretty_printing_style;
 
-static unsigned long    page_size;
-static unsigned long    mmap_window = 32;
-
-static char             default_parent_pattern[] = "^sys_|^do_page_fault";
-static char             *parent_pattern = default_parent_pattern;
-static regex_t          parent_regex;
-
-static int              exclude_other = 1;
-
 static char             callchain_default_opt[] = "fractal,0.5";
 
-static int              callchain;
-
-static char             __cwd[PATH_MAX];
-static char             *cwd = __cwd;
-static int              cwdlen;
-
-static struct rb_root   threads;
-static struct thread    *last_match;
-
-static struct perf_header *header;
-
-static
-struct callchain_param  callchain_param = {
-        .mode   = CHAIN_GRAPH_REL,
-        .min_percent = 0.5
-};
-
-static u64              sample_type;
-
-static int repsep_fprintf(FILE *fp, const char *fmt, ...)
-{
-        int n;
-        va_list ap;
-
-        va_start(ap, fmt);
-        if (!field_sep)
-                n = vfprintf(fp, fmt, ap);
-        else {
-                char *bf = NULL;
-                n = vasprintf(&bf, fmt, ap);
-                if (n > 0) {
-                        char *sep = bf;
-
-                        while (1) {
-                                sep = strchr(sep, *field_sep);
-                                if (sep == NULL)
-                                        break;
-                                *sep = '.';
-                        }
-                }
-                fputs(bf, fp);
-                free(bf);
-        }
-        va_end(ap);
-        return n;
-}
-
-static unsigned int dsos__col_width,
-                    comms__col_width,
-                    threads__col_width;
-
-/*
- * histogram, sorted on item, collects counts
- */
-
-static struct rb_root hist;
-
-struct hist_entry {
-        struct rb_node          rb_node;
-
-        struct thread           *thread;
-        struct map              *map;
-        struct dso              *dso;
-        struct symbol           *sym;
-        struct symbol           *parent;
-        u64                     ip;
-        char                    level;
-        struct callchain_node   callchain;
-        struct rb_root          sorted_chain;
-
-        u64                     count;
-};
-
-/*
- * configurable sorting bits
- */
-
-struct sort_entry {
-        struct list_head list;
-
-        const char *header;
-
-        int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
-        int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
-        size_t  (*print)(FILE *fp, struct hist_entry *, unsigned int width);
-        unsigned int *width;
-        bool    elide;
-};
-
-static int64_t cmp_null(void *l, void *r)
-{
-        if (!l && !r)
-                return 0;
-        else if (!l)
-                return -1;
-        else
-                return 1;
-}
-
-/* --sort pid */
-
-static int64_t
-sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        return right->thread->pid - left->thread->pid;
-}
-
-static size_t
-sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width)
-{
-        return repsep_fprintf(fp, "%*s:%5d", width - 6,
-                              self->thread->comm ?: "", self->thread->pid);
-}
-
-static struct sort_entry sort_thread = {
-        .header = "Command:  Pid",
-        .cmp    = sort__thread_cmp,
-        .print  = sort__thread_print,
-        .width  = &threads__col_width,
-};
-
-/* --sort comm */
-
-static int64_t
-sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        return right->thread->pid - left->thread->pid;
-}
-
-static int64_t
-sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
+static struct event_stat_id *get_stats(struct perf_session *self,
+                                       u64 event_stream, u32 type, u64 config)
 {
-        char *comm_l = left->thread->comm;
-        char *comm_r = right->thread->comm;
-
-        if (!comm_l || !comm_r)
-                return cmp_null(comm_l, comm_r);
-
-        return strcmp(comm_l, comm_r);
-}
-
-static size_t
-sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
-{
-        return repsep_fprintf(fp, "%*s", width, self->thread->comm);
-}
-
-static struct sort_entry sort_comm = {
-        .header         = "Command",
-        .cmp            = sort__comm_cmp,
-        .collapse       = sort__comm_collapse,
-        .print          = sort__comm_print,
-        .width          = &comms__col_width,
-};
-
-/* --sort dso */
-
-static int64_t
-sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        struct dso *dso_l = left->dso;
-        struct dso *dso_r = right->dso;
-
-        if (!dso_l || !dso_r)
-                return cmp_null(dso_l, dso_r);
-
-        return strcmp(dso_l->name, dso_r->name);
-}
-
-static size_t
-sort__dso_print(FILE *fp, struct hist_entry *self, unsigned int width)
-{
-        if (self->dso)
-                return repsep_fprintf(fp, "%-*s", width, self->dso->name);
-
-        return repsep_fprintf(fp, "%*llx", width, (u64)self->ip);
-}
-
-static struct sort_entry sort_dso = {
-        .header = "Shared Object",
-        .cmp    = sort__dso_cmp,
-        .print  = sort__dso_print,
-        .width  = &dsos__col_width,
-};
-
-/* --sort symbol */
-
-static int64_t
-sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        u64 ip_l, ip_r;
-
-        if (left->sym == right->sym)
-                return 0;
-
-        ip_l = left->sym ? left->sym->start : left->ip;
-        ip_r = right->sym ? right->sym->start : right->ip;
-
-        return (int64_t)(ip_r - ip_l);
-}
-
-static size_t
-sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
-{
-        size_t ret = 0;
-
-        if (verbose)
-                ret += repsep_fprintf(fp, "%#018llx %c ", (u64)self->ip,
-                                      dso__symtab_origin(self->dso));
-
-        ret += repsep_fprintf(fp, "[%c] ", self->level);
-        if (self->sym) {
-                ret += repsep_fprintf(fp, "%s", self->sym->name);
-
-                if (self->sym->module)
-                        ret += repsep_fprintf(fp, "\t[%s]",
-                                             self->sym->module->name);
-        } else {
-                ret += repsep_fprintf(fp, "%#016llx", (u64)self->ip);
-        }
-
-        return ret;
-}
-
-static struct sort_entry sort_sym = {
-        .header = "Symbol",
-        .cmp    = sort__sym_cmp,
-        .print  = sort__sym_print,
-};
-
-/* --sort parent */
-
-static int64_t
-sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        struct symbol *sym_l = left->parent;
-        struct symbol *sym_r = right->parent;
-
-        if (!sym_l || !sym_r)
-                return cmp_null(sym_l, sym_r);
-
-        return strcmp(sym_l->name, sym_r->name);
-}
-
-static size_t
-sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width)
-{
-        return repsep_fprintf(fp, "%-*s", width,
-                              self->parent ? self->parent->name : "[other]");
-}
-
-static unsigned int parent_symbol__col_width;
-
-static struct sort_entry sort_parent = {
-        .header = "Parent symbol",
-        .cmp    = sort__parent_cmp,
-        .print  = sort__parent_print,
-        .width  = &parent_symbol__col_width,
-};
-
-static int sort__need_collapse = 0;
-static int sort__has_parent = 0;
-
-struct sort_dimension {
-        const char              *name;
-        struct sort_entry       *entry;
-        int                     taken;
-};
-
-static struct sort_dimension sort_dimensions[] = {
-        { .name = "pid",        .entry = &sort_thread,  },
-        { .name = "comm",       .entry = &sort_comm,    },
-        { .name = "dso",        .entry = &sort_dso,     },
-        { .name = "symbol",     .entry = &sort_sym,     },
-        { .name = "parent",     .entry = &sort_parent,  },
-};
-
-static LIST_HEAD(hist_entry__sort_list);
-
-static int sort_dimension__add(const char *tok)
-{
-        unsigned int i;
-
-        for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
-                struct sort_dimension *sd = &sort_dimensions[i];
-
-                if (sd->taken)
-                        continue;
-
-                if (strncasecmp(tok, sd->name, strlen(tok)))
-                        continue;
-
-                if (sd->entry->collapse)
-                        sort__need_collapse = 1;
-
-                if (sd->entry == &sort_parent) {
-                        int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
-                        if (ret) {
-                                char err[BUFSIZ];
-
-                                regerror(ret, &parent_regex, err, sizeof(err));
-                                fprintf(stderr, "Invalid regex: %s\n%s",
-                                        parent_pattern, err);
-                                exit(-1);
-                        }
-                        sort__has_parent = 1;
-                }
-
-                list_add_tail(&sd->entry->list, &hist_entry__sort_list);
-                sd->taken = 1;
-
-                return 0;
-        }
-
-        return -ESRCH;
-}
-
-static int64_t
-hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
-{
-        struct sort_entry *se;
-        int64_t cmp = 0;
-
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                cmp = se->cmp(left, right);
-                if (cmp)
-                        break;
-        }
-
-        return cmp;
-}
-
-static int64_t
-hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
-{
-        struct sort_entry *se;
-        int64_t cmp = 0;
-
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                int64_t (*f)(struct hist_entry *, struct hist_entry *);
-
-                f = se->collapse ?: se->cmp;
-
-                cmp = f(left, right);
-                if (cmp)
-                        break;
-        }
-
-        return cmp;
-}
-
-static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask)
-{
-        int i;
-        size_t ret = 0;
-
-        ret += fprintf(fp, "%s", "                ");
-
-        for (i = 0; i < depth; i++)
-                if (depth_mask & (1 << i))
-                        ret += fprintf(fp, "|          ");
-                else
-                        ret += fprintf(fp, "           ");
-
-        ret += fprintf(fp, "\n");
-
-        return ret;
-}
-static size_t
-ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain, int depth,
-                       int depth_mask, int count, u64 total_samples,
-                       int hits)
-{
-        int i;
-        size_t ret = 0;
-
-        ret += fprintf(fp, "%s", "                ");
-        for (i = 0; i < depth; i++) {
-                if (depth_mask & (1 << i))
-                        ret += fprintf(fp, "|");
-                else
-                        ret += fprintf(fp, " ");
-                if (!count && i == depth - 1) {
-                        double percent;
-
-                        percent = hits * 100.0 / total_samples;
-                        ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
-                } else
-                        ret += fprintf(fp, "%s", "          ");
-        }
-        if (chain->sym)
-                ret += fprintf(fp, "%s\n", chain->sym->name);
-        else
-                ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
-
-        return ret;
-}
-
-static struct symbol *rem_sq_bracket;
-static struct callchain_list rem_hits;
-
-static void init_rem_hits(void)
-{
-        rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
-        if (!rem_sq_bracket) {
-                fprintf(stderr, "Not enough memory to display remaining hits\n");
-                return;
-        }
-
-        strcpy(rem_sq_bracket->name, "[...]");
-        rem_hits.sym = rem_sq_bracket;
-}
-
-static size_t
-callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
-                        u64 total_samples, int depth, int depth_mask)
-{
-        struct rb_node *node, *next;
-        struct callchain_node *child;
-        struct callchain_list *chain;
-        int new_depth_mask = depth_mask;
-        u64 new_total;
-        u64 remaining;
-        size_t ret = 0;
-        int i;
-
-        if (callchain_param.mode == CHAIN_GRAPH_REL)
-                new_total = self->children_hit;
-        else
-                new_total = total_samples;
-
-        remaining = new_total;
-
-        node = rb_first(&self->rb_root);
-        while (node) {
-                u64 cumul;
-
-                child = rb_entry(node, struct callchain_node, rb_node);
-                cumul = cumul_hits(child);
-                remaining -= cumul;
-
-                /*
-                 * The depth mask manages the output of pipes that show
-                 * the depth. We don't want to keep the pipes of the current
-                 * level for the last child of this depth.
-                 * Except if we have remaining filtered hits. They will
-                 * supersede the last child
-                 */
-                next = rb_next(node);
-                if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
-                        new_depth_mask &= ~(1 << (depth - 1));
-
-                /*
-                 * But we keep the older depth mask for the line seperator
-                 * to keep the level link until we reach the last child
-                 */
-                ret += ipchain__fprintf_graph_line(fp, depth, depth_mask);
-                i = 0;
-                list_for_each_entry(chain, &child->val, list) {
-                        if (chain->ip >= PERF_CONTEXT_MAX)
-                                continue;
-                        ret += ipchain__fprintf_graph(fp, chain, depth,
-                                                      new_depth_mask, i++,
-                                                      new_total,
-                                                      cumul);
-                }
-                ret += callchain__fprintf_graph(fp, child, new_total,
-                                                depth + 1,
-                                                new_depth_mask | (1 << depth));
-                node = next;
-        }
-
-        if (callchain_param.mode == CHAIN_GRAPH_REL &&
-                remaining && remaining != new_total) {
-
-                if (!rem_sq_bracket)
-                        return ret;
-
-                new_depth_mask &= ~(1 << (depth - 1));
-
-                ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
-                                              new_depth_mask, 0, new_total,
-                                              remaining);
-        }
-
-        return ret;
-}
-
-static size_t
-callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
-                        u64 total_samples)
-{
-        struct callchain_list *chain;
-        size_t ret = 0;
-
-        if (!self)
-                return 0;
-
-        ret += callchain__fprintf_flat(fp, self->parent, total_samples);
-
-
-        list_for_each_entry(chain, &self->val, list) {
-                if (chain->ip >= PERF_CONTEXT_MAX)
-                        continue;
-                if (chain->sym)
-                        ret += fprintf(fp, "                %s\n", chain->sym->name);
-                else
-                        ret += fprintf(fp, "                %p\n",
-                                        (void *)(long)chain->ip);
-        }
-
-        return ret;
-}
-
-static size_t
-hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
-                              u64 total_samples)
-{
-        struct rb_node *rb_node;
-        struct callchain_node *chain;
-        size_t ret = 0;
-
-        rb_node = rb_first(&self->sorted_chain);
-        while (rb_node) {
-                double percent;
-
-                chain = rb_entry(rb_node, struct callchain_node, rb_node);
-                percent = chain->hit * 100.0 / total_samples;
-                switch (callchain_param.mode) {
-                case CHAIN_FLAT:
-                        ret += percent_color_fprintf(fp, "           %6.2f%%\n",
-                                                     percent);
-                        ret += callchain__fprintf_flat(fp, chain, total_samples);
-                        break;
-                case CHAIN_GRAPH_ABS: /* Falldown */
-                case CHAIN_GRAPH_REL:
-                        ret += callchain__fprintf_graph(fp, chain,
-                                                        total_samples, 1, 1);
-                case CHAIN_NONE:
-                default:
-                        break;
-                }
-                ret += fprintf(fp, "\n");
-                rb_node = rb_next(rb_node);
-        }
-
-        return ret;
-}
-
-
-static size_t
-hist_entry__fprintf(FILE *fp, struct hist_entry *self, u64 total_samples)
-{
-        struct sort_entry *se;
-        size_t ret;
-
-        if (exclude_other && !self->parent)
-                return 0;
-
-        if (total_samples)
-                ret = percent_color_fprintf(fp,
-                                            field_sep ? "%.2f" : "   %6.2f%%",
-                                        (self->count * 100.0) / total_samples);
-        else
-                ret = fprintf(fp, field_sep ? "%lld" : "%12lld ", self->count);
-
-        if (show_nr_samples) {
-                if (field_sep)
-                        fprintf(fp, "%c%lld", *field_sep, self->count);
-                else
-                        fprintf(fp, "%11lld", self->count);
-        }
-
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                if (se->elide)
-                        continue;
-
-                fprintf(fp, "%s", field_sep ?: "  ");
-                ret += se->print(fp, self, se->width ? *se->width : 0);
-        }
-
-        ret += fprintf(fp, "\n");
-
-        if (callchain)
-                hist_entry_callchain__fprintf(fp, self, total_samples);
-
-        return ret;
-}
-
-/*
- *
- */
-
-static void dso__calc_col_width(struct dso *self)
-{
-        if (!col_width_list_str && !field_sep &&
-            (!dso_list || strlist__has_entry(dso_list, self->name))) {
-                unsigned int slen = strlen(self->name);
-                if (slen > dsos__col_width)
-                        dsos__col_width = slen;
-        }
-
-        self->slen_calculated = 1;
-}
-
-static void thread__comm_adjust(struct thread *self)
-{
-        char *comm = self->comm;
-
-        if (!col_width_list_str && !field_sep &&
-            (!comm_list || strlist__has_entry(comm_list, comm))) {
-                unsigned int slen = strlen(comm);
-
-                if (slen > comms__col_width) {
-                        comms__col_width = slen;
-                        threads__col_width = slen + 6;
-                }
-        }
-}
-
-static int thread__set_comm_adjust(struct thread *self, const char *comm)
-{
-        int ret = thread__set_comm(self, comm);
-
-        if (ret)
-                return ret;
-
-        thread__comm_adjust(self);
-
-        return 0;
-}
-
-
-static struct symbol *
-resolve_symbol(struct thread *thread, struct map **mapp,
-               struct dso **dsop, u64 *ipp)
-{
-        struct dso *dso = dsop ? *dsop : NULL;
-        struct map *map = mapp ? *mapp : NULL;
-        u64 ip = *ipp;
-
-        if (!thread)
-                return NULL;
-
-        if (dso)
-                goto got_dso;
-
-        if (map)
-                goto got_map;
-
-        map = thread__find_map(thread, ip);
-        if (map != NULL) {
-                /*
-                 * We have to do this here as we may have a dso
-                 * with no symbol hit that has a name longer than
-                 * the ones with symbols sampled.
-                 */
-                if (!sort_dso.elide && !map->dso->slen_calculated)
-                        dso__calc_col_width(map->dso);
-
-                if (mapp)
-                        *mapp = map;
-got_map:
-                ip = map->map_ip(map, ip);
-
-                dso = map->dso;
-        } else {
-                /*
-                 * If this is outside of all known maps,
-                 * and is a negative address, try to look it
-                 * up in the kernel dso, as it might be a
-                 * vsyscall (which executes in user-mode):
-                 */
-                if ((long long)ip < 0)
-                dso = kernel_dso;
-        }
-        dump_printf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
-        dump_printf(" ...... map: %Lx -> %Lx\n", *ipp, ip);
-        *ipp  = ip;
-
-        if (dsop)
-                *dsop = dso;
-
-        if (!dso)
-                return NULL;
-got_dso:
-        return dso->find_symbol(dso, ip);
-}
-
-static int call__match(struct symbol *sym)
-{
-        if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
-                return 1;
-
-        return 0;
-}
-
-static struct symbol **
-resolve_callchain(struct thread *thread, struct map *map __used,
-                    struct ip_callchain *chain, struct hist_entry *entry)
-{
-        u64 context = PERF_CONTEXT_MAX;
-        struct symbol **syms = NULL;
-        unsigned int i;
-
-        if (callchain) {
-                syms = calloc(chain->nr, sizeof(*syms));
-                if (!syms) {
-                        fprintf(stderr, "Can't allocate memory for symbols\n");
-                        exit(-1);
-                }
-        }
-
-        for (i = 0; i < chain->nr; i++) {
-                u64 ip = chain->ips[i];
-                struct dso *dso = NULL;
-                struct symbol *sym;
-
-                if (ip >= PERF_CONTEXT_MAX) {
-                        context = ip;
-                        continue;
-                }
-
-                switch (context) {
-                case PERF_CONTEXT_HV:
-                        dso = hypervisor_dso;
-                        break;
-                case PERF_CONTEXT_KERNEL:
-                        dso = kernel_dso;
-                        break;
-                default:
-                        break;
-                }
-
-                sym = resolve_symbol(thread, NULL, &dso, &ip);
-
-                if (sym) {
-                        if (sort__has_parent && call__match(sym) &&
-                            !entry->parent)
-                                entry->parent = sym;
-                        if (!callchain)
-                                break;
-                        syms[i] = sym;
-                }
-        }
-
-        return syms;
-}
-
-/*
- * collect histogram counts
- */
-
-static int
-hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
-                struct symbol *sym, u64 ip, struct ip_callchain *chain,
-                char level, u64 count)
-{
-        struct rb_node **p = &hist.rb_node;
+        struct rb_node **p = &self->stats_by_id.rb_node;
         struct rb_node *parent = NULL;
-        struct hist_entry *he;
-        struct symbol **syms = NULL;
-        struct hist_entry entry = {
-                .thread = thread,
-                .map    = map,
-                .dso    = dso,
-                .sym    = sym,
-                .ip     = ip,
-                .level  = level,
-                .count  = count,
-                .parent = NULL,
-                .sorted_chain = RB_ROOT
-        };
-        int cmp;
-
-        if ((sort__has_parent || callchain) && chain)
-                syms = resolve_callchain(thread, map, chain, &entry);
+        struct event_stat_id *iter, *new;
 
         while (*p != NULL) {
                 parent = *p;
-                he = rb_entry(parent, struct hist_entry, rb_node);
+                iter = rb_entry(parent, struct event_stat_id, rb_node);
+                if (iter->config == config)
+                        return iter;
 
-                cmp = hist_entry__cmp(&entry, he);
-
-                if (!cmp) {
-                        he->count += count;
-                        if (callchain) {
-                                append_chain(&he->callchain, chain, syms);
-                                free(syms);
-                        }
-                        return 0;
-                }
 
-                if (cmp < 0)
-                        p = &(*p)->rb_left;
-                else
+                if (config > iter->config)
                         p = &(*p)->rb_right;
-        }
-
-        he = malloc(sizeof(*he));
-        if (!he)
-                return -ENOMEM;
-        *he = entry;
-        if (callchain) {
-                callchain_init(&he->callchain);
-                append_chain(&he->callchain, chain, syms);
-                free(syms);
-        }
-        rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, &hist);
-
-        return 0;
-}
-
-static void hist_entry__free(struct hist_entry *he)
-{
-        free(he);
-}
-
-/*
- * collapse the histogram
- */
-
-static struct rb_root collapse_hists;
-
-static void collapse__insert_entry(struct hist_entry *he)
-{
-        struct rb_node **p = &collapse_hists.rb_node;
-        struct rb_node *parent = NULL;
-        struct hist_entry *iter;
-        int64_t cmp;
-
-        while (*p != NULL) {
-                parent = *p;
-                iter = rb_entry(parent, struct hist_entry, rb_node);
-
-                cmp = hist_entry__collapse(iter, he);
-
-                if (!cmp) {
-                        iter->count += he->count;
-                        hist_entry__free(he);
-                        return;
-                }
-
-                if (cmp < 0)
-                        p = &(*p)->rb_left;
                 else
-                        p = &(*p)->rb_right;
-        }
-
-        rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, &collapse_hists);
-}
-
-static void collapse__resort(void)
-{
-        struct rb_node *next;
-        struct hist_entry *n;
-
-        if (!sort__need_collapse)
-                return;
-
-        next = rb_first(&hist);
-        while (next) {
-                n = rb_entry(next, struct hist_entry, rb_node);
-                next = rb_next(&n->rb_node);
-
-                rb_erase(&n->rb_node, &hist);
-                collapse__insert_entry(n);
-        }
-}
-
-/*
- * reverse the map, sort on count.
- */
-
-static struct rb_root output_hists;
-
-static void output__insert_entry(struct hist_entry *he, u64 min_callchain_hits)
-{
-        struct rb_node **p = &output_hists.rb_node;
-        struct rb_node *parent = NULL;
-        struct hist_entry *iter;
-
-        if (callchain)
-                callchain_param.sort(&he->sorted_chain, &he->callchain,
-                                      min_callchain_hits, &callchain_param);
-
-        while (*p != NULL) {
-                parent = *p;
-                iter = rb_entry(parent, struct hist_entry, rb_node);
-
-                if (he->count > iter->count)
                         p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
         }
 
-        rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, &output_hists);
-}
-
-static void output__resort(u64 total_samples)
-{
-        struct rb_node *next;
-        struct hist_entry *n;
-        struct rb_root *tree = &hist;
-        u64 min_callchain_hits;
-
-        min_callchain_hits = total_samples * (callchain_param.min_percent / 100);
-
-        if (sort__need_collapse)
-                tree = &collapse_hists;
-
-        next = rb_first(tree);
-
-        while (next) {
-                n = rb_entry(next, struct hist_entry, rb_node);
-                next = rb_next(&n->rb_node);
-
-                rb_erase(&n->rb_node, tree);
-                output__insert_entry(n, min_callchain_hits);
-        }
+        new = malloc(sizeof(struct event_stat_id));
+        if (new == NULL)
+                return NULL;
+        memset(new, 0, sizeof(struct event_stat_id));
+        new->event_stream = event_stream;
+        new->config = config;
+        new->type = type;
+        rb_link_node(&new->rb_node, parent, p);
+        rb_insert_color(&new->rb_node, &self->stats_by_id);
+        return new;
 }
 
-static size_t output__fprintf(FILE *fp, u64 total_samples)
+static int perf_session__add_hist_entry(struct perf_session *self,
+                                        struct addr_location *al,
+                                        struct sample_data *data)
 {
-        struct hist_entry *pos;
-        struct sort_entry *se;
-        struct rb_node *nd;
-        size_t ret = 0;
-        unsigned int width;
-        char *col_width = col_width_list_str;
-        int raw_printing_style;
-
-        raw_printing_style = !strcmp(pretty_printing_style, "raw");
-
-        init_rem_hits();
-
-        fprintf(fp, "# Samples: %Ld\n", (u64)total_samples);
-        fprintf(fp, "#\n");
-
-        fprintf(fp, "# Overhead");
-        if (show_nr_samples) {
-                if (field_sep)
-                        fprintf(fp, "%cSamples", *field_sep);
-                else
-                        fputs("  Samples  ", fp);
-        }
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                if (se->elide)
-                        continue;
-                if (field_sep) {
-                        fprintf(fp, "%c%s", *field_sep, se->header);
-                        continue;
-                }
-                width = strlen(se->header);
-                if (se->width) {
-                        if (col_width_list_str) {
-                                if (col_width) {
-                                        *se->width = atoi(col_width);
-                                        col_width = strchr(col_width, ',');
-                                        if (col_width)
-                                                ++col_width;
-                                }
-                        }
-                        width = *se->width = max(*se->width, width);
-                }
-                fprintf(fp, "  %*s", width, se->header);
-        }
-        fprintf(fp, "\n");
-
-        if (field_sep)
-                goto print_entries;
-
-        fprintf(fp, "# ........");
-        if (show_nr_samples)
-                fprintf(fp, " ..........");
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                unsigned int i;
-
-                if (se->elide)
-                        continue;
+        struct symbol **syms = NULL, *parent = NULL;
+        bool hit;
+        struct hist_entry *he;
+        struct event_stat_id *stats;
+        struct perf_event_attr *attr;
 
-                fprintf(fp, "  ");
-                if (se->width)
-                        width = *se->width;
-                else
-                        width = strlen(se->header);
-                for (i = 0; i < width; i++)
-                        fprintf(fp, ".");
-        }
-        fprintf(fp, "\n");
+        if ((sort__has_parent || symbol_conf.use_callchain) && data->callchain)
+                syms = perf_session__resolve_callchain(self, al->thread,
+                                                       data->callchain, &parent);
 
-        fprintf(fp, "#\n");
+        attr = perf_header__find_attr(data->id, &self->header);
+        if (attr)
+                stats = get_stats(self, data->id, attr->type, attr->config);
+        else
+                stats = get_stats(self, data->id, 0, 0);
+        if (stats == NULL)
+                return -ENOMEM;
+        he = __perf_session__add_hist_entry(&stats->hists, al, parent,
+                                            data->period, &hit);
+        if (he == NULL)
+                return -ENOMEM;
 
-print_entries:
-        for (nd = rb_first(&output_hists); nd; nd = rb_next(nd)) {
-                pos = rb_entry(nd, struct hist_entry, rb_node);
-                ret += hist_entry__fprintf(fp, pos, total_samples);
-        }
+        if (hit)
+                he->count += data->period;
 
-        if (sort_order == default_sort_order &&
-                        parent_pattern == default_parent_pattern) {
-                fprintf(fp, "#\n");
-                fprintf(fp, "# (For a higher level overview, try: perf report --sort comm,dso)\n");
-                fprintf(fp, "#\n");
+        if (symbol_conf.use_callchain) {
+                if (!hit)
+                        callchain_init(&he->callchain);
+                append_chain(&he->callchain, data->callchain, syms);
+                free(syms);
         }
-        fprintf(fp, "\n");
-
-        free(rem_sq_bracket);
-
-        if (show_threads)
-                perf_read_values_display(fp, &show_threads_values,
-                                         raw_printing_style);
 
-        return ret;
+        return 0;
 }
 
-static unsigned long total = 0,
-                     total_mmap = 0,
-                     total_comm = 0,
-                     total_fork = 0,
-                     total_unknown = 0,
-                     total_lost = 0;
-
 static int validate_chain(struct ip_callchain *chain, event_t *event)
 {
         unsigned int chain_size;
@@ -1100,214 +129,83 @@ static int validate_chain(struct ip_callchain *chain, event_t *event)
         return 0;
 }
 
-static int
-process_sample_event(event_t *event, unsigned long offset, unsigned long head)
+static int add_event_total(struct perf_session *session,
+                           struct sample_data *data,
+                           struct perf_event_attr *attr)
 {
-        char level;
-        int show = 0;
-        struct dso *dso = NULL;
-        struct thread *thread;
-        u64 ip = event->ip.ip;
-        u64 period = 1;
-        struct map *map = NULL;
-        void *more_data = event->ip.__more_data;
-        struct ip_callchain *chain = NULL;
-        int cpumode;
-
-        thread = threads__findnew(event->ip.pid, &threads, &last_match);
-
-        if (sample_type & PERF_SAMPLE_PERIOD) {
-                period = *(u64 *)more_data;
-                more_data += sizeof(u64);
-        }
+        struct event_stat_id *stats;
 
-        dump_printf("%p [%p]: PERF_RECORD_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->header.misc,
-                event->ip.pid, event->ip.tid,
-                (void *)(long)ip,
-                (long long)period);
+        if (attr)
+                stats = get_stats(session, data->id, attr->type, attr->config);
+        else
+                stats = get_stats(session, data->id, 0, 0);
 
-        if (sample_type & PERF_SAMPLE_CALLCHAIN) {
-                unsigned int i;
+        if (!stats)
+                return -ENOMEM;
 
-                chain = (void *)more_data;
+        stats->stats.total += data->period;
+        session->events_stats.total += data->period;
+        return 0;
+}
+
+static int process_sample_event(event_t *event, struct perf_session *session)
+{
+        struct sample_data data = { .period = 1, };
+        struct addr_location al;
+        struct perf_event_attr *attr;
+
+        event__parse_sample(event, session->sample_type, &data);
+
+        dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
+                    data.pid, data.tid, data.ip, data.period);
+
+        if (session->sample_type & PERF_SAMPLE_CALLCHAIN) {
+                unsigned int i;
 
-                dump_printf("... chain: nr:%Lu\n", chain->nr);
+                dump_printf("... chain: nr:%Lu\n", data.callchain->nr);
 
-                if (validate_chain(chain, event) < 0) {
-                        eprintf("call-chain problem with event, skipping it.\n");
+                if (validate_chain(data.callchain, event) < 0) {
+                        pr_debug("call-chain problem with event, "
+                                 "skipping it.\n");
                         return 0;
                 }
 
                 if (dump_trace) {
-                        for (i = 0; i < chain->nr; i++)
-                                dump_printf("..... %2d: %016Lx\n", i, chain->ips[i]);
+                        for (i = 0; i < data.callchain->nr; i++)
+                                dump_printf("..... %2d: %016Lx\n",
+                                            i, data.callchain->ips[i]);
                 }
         }
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
-
-        if (thread == NULL) {
-                eprintf("problem processing %d event, skipping it.\n",
+        if (event__preprocess_sample(event, session, &al, NULL) < 0) {
+                fprintf(stderr, "problem processing %d event, skipping it.\n",
                         event->header.type);
                 return -1;
         }
 
-        if (comm_list && !strlist__has_entry(comm_list, thread->comm))
+        if (al.filtered || (hide_unresolved && al.sym == NULL))
                 return 0;
 
-        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-
-        if (cpumode == PERF_RECORD_MISC_KERNEL) {
-                show = SHOW_KERNEL;
-                level = 'k';
-
-                dso = kernel_dso;
-
-                dump_printf(" ...... dso: %s\n", dso->name);
-
-        } else if (cpumode == PERF_RECORD_MISC_USER) {
-
-                show = SHOW_USER;
-                level = '.';
-
-        } else {
-                show = SHOW_HV;
-                level = 'H';
-
-                dso = hypervisor_dso;
-
-                dump_printf(" ...... dso: [hypervisor]\n");
-        }
-
-        if (show & show_mask) {
-                struct symbol *sym = resolve_symbol(thread, &map, &dso, &ip);
-
-                if (dso_list && (!dso || !dso->name ||
-                                 !strlist__has_entry(dso_list, dso->name)))
-                        return 0;
-
-                if (sym_list && (!sym || !strlist__has_entry(sym_list, sym->name)))
-                        return 0;
-
-                if (hist_entry__add(thread, map, dso, sym, ip, chain, level, period)) {
-                        eprintf("problem incrementing symbol count, skipping event\n");
-                        return -1;
-                }
-        }
-        total += period;
-
-        return 0;
-}
-
-static int
-process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        struct thread *thread;
-        struct map *map = map__new(&event->mmap, cwd, cwdlen);
-
-        thread = threads__findnew(event->mmap.pid, &threads, &last_match);
-
-        dump_printf("%p [%p]: PERF_RECORD_MMAP %d/%d: [%p(%p) @ %p]: %s\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->mmap.pid,
-                event->mmap.tid,
-                (void *)(long)event->mmap.start,
-                (void *)(long)event->mmap.len,
-                (void *)(long)event->mmap.pgoff,
-                event->mmap.filename);
-
-        if (thread == NULL || map == NULL) {
-                dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
-                return 0;
-        }
-
-        thread__insert_map(thread, map);
-        total_mmap++;
-
-        return 0;
-}
-
-static int
-process_comm_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        struct thread *thread;
-
-        thread = threads__findnew(event->comm.pid, &threads, &last_match);
-
-        dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->comm.comm, event->comm.pid);
-
-        if (thread == NULL ||
-            thread__set_comm_adjust(thread, event->comm.comm)) {
-                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
+        if (perf_session__add_hist_entry(session, &al, &data)) {
+                pr_debug("problem incrementing symbol count, skipping event\n");
                 return -1;
         }
-        total_comm++;
-
-        return 0;
-}
-
-static int
-process_task_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        struct thread *thread;
-        struct thread *parent;
 
-        thread = threads__findnew(event->fork.pid, &threads, &last_match);
-        parent = threads__findnew(event->fork.ppid, &threads, &last_match);
+        attr = perf_header__find_attr(data.id, &session->header);
 
-        dump_printf("%p [%p]: PERF_RECORD_%s: (%d:%d):(%d:%d)\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->header.type == PERF_RECORD_FORK ? "FORK" : "EXIT",
-                event->fork.pid, event->fork.tid,
-                event->fork.ppid, event->fork.ptid);
-
-        /*
-         * A thread clone will have the same PID for both
-         * parent and child.
-         */
-        if (thread == parent)
-                return 0;
-
-        if (event->header.type == PERF_RECORD_EXIT)
-                return 0;
-
-        if (!thread || !parent || thread__fork(thread, parent)) {
-                dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
+        if (add_event_total(session, &data, attr)) {
+                pr_debug("problem adding event count\n");
                 return -1;
         }
-        total_fork++;
 
         return 0;
 }
 
-static int
-process_lost_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        dump_printf("%p [%p]: PERF_RECORD_LOST: id:%Ld: lost:%Ld\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->lost.id,
-                event->lost.lost);
-
-        total_lost += event->lost.lost;
-
-        return 0;
-}
-
-static int
-process_read_event(event_t *event, unsigned long offset, unsigned long head)
+static int process_read_event(event_t *event, struct perf_session *session __used)
 {
         struct perf_event_attr *attr;
 
-        attr = perf_header__find_attr(event->read.id, header);
+        attr = perf_header__find_attr(event->read.id, &session->header);
 
         if (show_threads) {
                 const char *name = attr ? __event_name(attr->type, attr->config)
@@ -1319,248 +217,136 @@ process_read_event(event_t *event, unsigned long offset, unsigned long head)
                                            event->read.value);
         }
 
-        dump_printf("%p [%p]: PERF_RECORD_READ: %d %d %s %Lu\n",
-                        (void *)(offset + head),
-                        (void *)(long)(event->header.size),
-                        event->read.pid,
-                        event->read.tid,
-                        attr ? __event_name(attr->type, attr->config)
-                             : "FAIL",
-                        event->read.value);
+        dump_printf(": %d %d %s %Lu\n", event->read.pid, event->read.tid,
+                    attr ? __event_name(attr->type, attr->config) : "FAIL",
+                    event->read.value);
 
         return 0;
 }
 
-static int
-process_event(event_t *event, unsigned long offset, unsigned long head)
+static int perf_session__setup_sample_type(struct perf_session *self)
 {
-        trace_event(event);
-
-        switch (event->header.type) {
-        case PERF_RECORD_SAMPLE:
-                return process_sample_event(event, offset, head);
-
-        case PERF_RECORD_MMAP:
-                return process_mmap_event(event, offset, head);
-
-        case PERF_RECORD_COMM:
-                return process_comm_event(event, offset, head);
-
-        case PERF_RECORD_FORK:
-        case PERF_RECORD_EXIT:
-                return process_task_event(event, offset, head);
-
-        case PERF_RECORD_LOST:
-                return process_lost_event(event, offset, head);
-
-        case PERF_RECORD_READ:
-                return process_read_event(event, offset, head);
-
-        /*
-         * We dont process them right now but they are fine:
-         */
-
-        case PERF_RECORD_THROTTLE:
-        case PERF_RECORD_UNTHROTTLE:
-                return 0;
-
-        default:
-                return -1;
-        }
-
-        return 0;
-}
-
-static int __cmd_report(void)
-{
-        int ret, rc = EXIT_FAILURE;
-        unsigned long offset = 0;
-        unsigned long head, shift;
-        struct stat input_stat;
-        struct thread *idle;
-        event_t *event;
-        uint32_t size;
-        char *buf;
-
-        idle = register_idle_thread(&threads, &last_match);
-        thread__comm_adjust(idle);
-
-        if (show_threads)
-                perf_read_values_init(&show_threads_values);
-
-        input = open(input_name, O_RDONLY);
-        if (input < 0) {
-                fprintf(stderr, " failed to open file: %s", input_name);
-                if (!strcmp(input_name, "perf.data"))
-                        fprintf(stderr, "  (try 'perf record' first)");
-                fprintf(stderr, "\n");
-                exit(-1);
-        }
-
-        ret = fstat(input, &input_stat);
-        if (ret < 0) {
-                perror("failed to stat file");
-                exit(-1);
-        }
-
-        if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
-                fprintf(stderr, "file: %s not owned by current user or root\n", input_name);
-                exit(-1);
-        }
-
-        if (!input_stat.st_size) {
-                fprintf(stderr, "zero-sized file, nothing to do!\n");
-                exit(0);
-        }
-
-        header = perf_header__read(input);
-        head = header->data_offset;
-
-        sample_type = perf_header__sample_type(header);
-
-        if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {
+        if (!(self->sample_type & PERF_SAMPLE_CALLCHAIN)) {
                 if (sort__has_parent) {
                         fprintf(stderr, "selected --sort parent, but no"
                                         " callchain data. Did you call"
                                         " perf record without -g?\n");
-                        exit(-1);
+                        return -EINVAL;
                 }
-                if (callchain) {
+                if (symbol_conf.use_callchain) {
                         fprintf(stderr, "selected -g but no callchain data."
                                         " Did you call perf record without"
                                         " -g?\n");
-                        exit(-1);
+                        return -1;
                 }
-        } else if (callchain_param.mode != CHAIN_NONE && !callchain) {
-                        callchain = 1;
+        } else if (!dont_use_callchains && callchain_param.mode != CHAIN_NONE &&
+                   !symbol_conf.use_callchain) {
+                        symbol_conf.use_callchain = true;
                         if (register_callchain_param(&callchain_param) < 0) {
                                 fprintf(stderr, "Can't register callchain"
                                                 " params\n");
-                                exit(-1);
+                                return -EINVAL;
                         }
         }
 
-        if (load_kernel() < 0) {
-                perror("failed to load kernel symbols");
-                return EXIT_FAILURE;
-        }
-
-        if (!full_paths) {
-                if (getcwd(__cwd, sizeof(__cwd)) == NULL) {
-                        perror("failed to get the current directory");
-                        return EXIT_FAILURE;
-                }
-                cwdlen = strlen(cwd);
-        } else {
-                cwd = NULL;
-                cwdlen = 0;
-        }
-
-        shift = page_size * (head / page_size);
-        offset += shift;
-        head -= shift;
+        return 0;
+}
 
-remap:
-        buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
-                           MAP_SHARED, input, offset);
-        if (buf == MAP_FAILED) {
-                perror("failed to mmap file");
-                exit(-1);
-        }
+static struct perf_event_ops event_ops = {
+        .sample = process_sample_event,
+        .mmap   = event__process_mmap,
+        .comm   = event__process_comm,
+        .exit   = event__process_task,
+        .fork   = event__process_task,
+        .lost   = event__process_lost,
+        .read   = process_read_event,
+};
 
-more:
-        event = (event_t *)(buf + head);
+static int __cmd_report(void)
+{
+        int ret = -EINVAL;
+        struct perf_session *session;
+        struct rb_node *next;
 
-        size = event->header.size;
-        if (!size)
-                size = 8;
+        session = perf_session__new(input_name, O_RDONLY, force);
+        if (session == NULL)
+                return -ENOMEM;
 
-        if (head + event->header.size >= page_size * mmap_window) {
-                int munmap_ret;
+        if (show_threads)
+                perf_read_values_init(&show_threads_values);
 
-                shift = page_size * (head / page_size);
+        ret = perf_session__setup_sample_type(session);
+        if (ret)
+                goto out_delete;
 
-                munmap_ret = munmap(buf, page_size * mmap_window);
-                assert(munmap_ret == 0);
+        ret = perf_session__process_events(session, &event_ops);
+        if (ret)
+                goto out_delete;
 
-                offset += shift;
-                head -= shift;
-                goto remap;
+        if (dump_trace) {
+                event__print_totals();
+                goto out_delete;
         }
 
-        size = event->header.size;
+        if (verbose > 3)
+                perf_session__fprintf(session, stdout);
 
-        dump_printf("\n%p [%p]: event: %d\n",
-                        (void *)(offset + head),
-                        (void *)(long)event->header.size,
-                        event->header.type);
-
-        if (!size || process_event(event, offset, head) < 0) {
-
-                dump_printf("%p [%p]: skipping unknown header type: %d\n",
-                        (void *)(offset + head),
-                        (void *)(long)(event->header.size),
-                        event->header.type);
-
-                total_unknown++;
-
-                /*
-                 * assume we lost track of the stream, check alignment, and
-                 * increment a single u64 in the hope to catch on again 'soon'.
-                 */
+        if (verbose > 2)
+                dsos__fprintf(stdout);
 
-                if (unlikely(head & 7))
-                        head &= ~7ULL;
+        next = rb_first(&session->stats_by_id);
+        while (next) {
+                struct event_stat_id *stats;
+
+                stats = rb_entry(next, struct event_stat_id, rb_node);
+                perf_session__collapse_resort(&stats->hists);
+                perf_session__output_resort(&stats->hists, stats->stats.total);
+                if (rb_first(&session->stats_by_id) ==
+                    rb_last(&session->stats_by_id))
+                        fprintf(stdout, "# Samples: %Ld\n#\n",
+                                stats->stats.total);
+                else
+                        fprintf(stdout, "# Samples: %Ld %s\n#\n",
+                                stats->stats.total,
+                                __event_name(stats->type, stats->config));
 
-                size = 8;
+                perf_session__fprintf_hists(&stats->hists, NULL, false, stdout,
+                                            stats->stats.total);
+                fprintf(stdout, "\n\n");
+                next = rb_next(&stats->rb_node);
         }
 
-        head += size;
-
-        if (offset + head >= header->data_offset + header->data_size)
-                goto done;
-
-        if (offset + head < (unsigned long)input_stat.st_size)
-                goto more;
-
-done:
-        rc = EXIT_SUCCESS;
-        close(input);
-
-        dump_printf("      IP events: %10ld\n", total);
-        dump_printf("    mmap events: %10ld\n", total_mmap);
-        dump_printf("    comm events: %10ld\n", total_comm);
-        dump_printf("    fork events: %10ld\n", total_fork);
-        dump_printf("    lost events: %10ld\n", total_lost);
-        dump_printf(" unknown events: %10ld\n", total_unknown);
-
-        if (dump_trace)
-                return 0;
-
-        if (verbose >= 3)
-                threads__fprintf(stdout, &threads);
-
-        if (verbose >= 2)
-                dsos__fprintf(stdout);
-
-        collapse__resort();
-        output__resort(total);
-        output__fprintf(stdout, total);
+        if (sort_order == default_sort_order &&
+            parent_pattern == default_parent_pattern)
+                fprintf(stdout, "#\n# (For a higher level overview, try: perf report --sort comm,dso)\n#\n");
 
-        if (show_threads)
+        if (show_threads) {
+                bool raw_printing_style = !strcmp(pretty_printing_style, "raw");
+                perf_read_values_display(stdout, &show_threads_values,
+                                         raw_printing_style);
                 perf_read_values_destroy(&show_threads_values);
-
-        return rc;
+        }
+out_delete:
+        perf_session__delete(session);
+        return ret;
 }
 
 static int
 parse_callchain_opt(const struct option *opt __used, const char *arg,
-                    int unset __used)
+                    int unset)
 {
         char *tok;
         char *endptr;
 
-        callchain = 1;
+        /*
+         * --no-call-graph
+         */
+        if (unset) {
+                dont_use_callchains = true;
+                return 0;
+        }
+
+        symbol_conf.use_callchain = true;
 
         if (!arg)
                 return 0;
@@ -1581,7 +367,7 @@ parse_callchain_opt(const struct option *opt __used, const char *arg,
 
         else if (!strncmp(tok, "none", strlen(arg))) {
                 callchain_param.mode = CHAIN_NONE;
-                callchain = 0;
+                symbol_conf.use_callchain = false;
 
                 return 0;
         }
@@ -1618,11 +404,12 @@ static const struct option options[] = {
                     "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
-        OPT_STRING('k', "vmlinux", &vmlinux_name, "file", "vmlinux pathname"),
+        OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
+                   "file", "vmlinux pathname"),
         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
-        OPT_BOOLEAN('m', "modules", &modules,
+        OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
-        OPT_BOOLEAN('n', "show-nr-samples", &show_nr_samples,
+        OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
                     "Show a column with the number of samples"),
         OPT_BOOLEAN('T', "threads", &show_threads,
                     "Show per-thread event counters"),
@@ -1630,79 +417,48 @@ static const struct option options[] = {
                    "pretty printing style key: normal raw"),
         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
                    "sort by key(s): pid, comm, dso, symbol, parent"),
-        OPT_BOOLEAN('P', "full-paths", &full_paths,
+        OPT_BOOLEAN('P', "full-paths", &symbol_conf.full_paths,
                     "Don't shorten the pathnames taking into account the cwd"),
         OPT_STRING('p', "parent", &parent_pattern, "regex",
                    "regex filter to identify parent, see: '--sort parent'"),
-        OPT_BOOLEAN('x', "exclude-other", &exclude_other,
+        OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other,
                     "Only display entries with parent-match"),
         OPT_CALLBACK_DEFAULT('g', "call-graph", NULL, "output_type,min_percent",
                      "Display callchains using output_type and min percent threshold. "
                      "Default: fractal,0.5", &parse_callchain_opt, callchain_default_opt),
-        OPT_STRING('d', "dsos", &dso_list_str, "dso[,dso...]",
+        OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
                    "only consider symbols in these dsos"),
-        OPT_STRING('C', "comms", &comm_list_str, "comm[,comm...]",
+        OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
                    "only consider symbols in these comms"),
-        OPT_STRING('S', "symbols", &sym_list_str, "symbol[,symbol...]",
+        OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
                    "only consider these symbols"),
-        OPT_STRING('w', "column-widths", &col_width_list_str,
+        OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
                    "width[,width...]",
                    "don't try to adjust column width, use these fixed values"),
-        OPT_STRING('t', "field-separator", &field_sep, "separator",
+        OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
                    "separator for columns, no spaces will be added between "
                    "columns '.' is reserved."),
+        OPT_BOOLEAN('U', "hide-unresolved", &hide_unresolved,
+                    "Only display entries resolved to a symbol"),
         OPT_END()
 };
 
-static void setup_sorting(void)
-{
-        char *tmp, *tok, *str = strdup(sort_order);
-
-        for (tok = strtok_r(str, ", ", &tmp);
-                        tok; tok = strtok_r(NULL, ", ", &tmp)) {
-                if (sort_dimension__add(tok) < 0) {
-                        error("Unknown --sort key: `%s'", tok);
-                        usage_with_options(report_usage, options);
-                }
-        }
-
-        free(str);
-}
-
-static void setup_list(struct strlist **list, const char *list_str,
-                       struct sort_entry *se, const char *list_name,
-                       FILE *fp)
-{
-        if (list_str) {
-                *list = strlist__new(true, list_str);
-                if (!*list) {
-                        fprintf(stderr, "problems parsing %s list\n",
-                                list_name);
-                        exit(129);
-                }
-                if (strlist__nr_entries(*list) == 1) {
-                        fprintf(fp, "# %s: %s\n", list_name,
-                                strlist__entry(*list, 0)->s);
-                        se->elide = true;
-                }
-        }
-}
-
 int cmd_report(int argc, const char **argv, const char *prefix __used)
 {
-        symbol__init();
+        argc = parse_options(argc, argv, options, report_usage, 0);
 
-        page_size = getpagesize();
+        setup_pager();
 
-        argc = parse_options(argc, argv, options, report_usage, 0);
+        if (symbol__init() < 0)
+                return -1;
 
-        setup_sorting();
+        setup_sorting(report_usage, options);
 
         if (parent_pattern != default_parent_pattern) {
                 sort_dimension__add("parent");
                 sort_parent.elide = 1;
         } else
-                exclude_other = 0;
+                symbol_conf.exclude_other = false;
 
         /*
          * Any (unrecognized) arguments left?
@@ -1710,17 +466,9 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
         if (argc)
                 usage_with_options(report_usage, options);
 
-        setup_pager();
-
-        setup_list(&dso_list, dso_list_str, &sort_dso, "dso", stdout);
-        setup_list(&comm_list, comm_list_str, &sort_comm, "comm", stdout);
-        setup_list(&sym_list, sym_list_str, &sort_sym, "symbol", stdout);
-
-        if (field_sep && *field_sep == '.') {
-                fputs("'.' is the only non valid --field-separator argument\n",
-                      stderr);
-                exit(129);
-        }
+        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
+        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
+        sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
 
         return __cmd_report();
 }
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index ce2d5be4f30e..4f5a03e43444 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -6,13 +6,13 @@
 #include "util/symbol.h"
 #include "util/thread.h"
 #include "util/header.h"
+#include "util/session.h"
 
 #include "util/parse-options.h"
 #include "util/trace-event.h"
 
 #include "util/debug.h"
 
-#include <sys/types.h>
 #include <sys/prctl.h>
 
 #include <semaphore.h>
@@ -20,26 +20,15 @@
 #include <math.h>
 
 static char                     const *input_name = "perf.data";
-static int                      input;
-static unsigned long            page_size;
-static unsigned long            mmap_window = 32;
-
-static unsigned long            total_comm = 0;
-
-static struct rb_root           threads;
-static struct thread            *last_match;
-
-static struct perf_header       *header;
-static u64                      sample_type;
 
 static char                     default_sort_order[] = "avg, max, switch, runtime";
 static char                     *sort_order = default_sort_order;
 
+static int                      profile_cpu = -1;
+
 #define PR_SET_NAME             15               /* Set process name */
 #define MAX_CPUS                4096
 
-#define BUG_ON(x)               assert(!(x))
-
 static u64                      run_measurement_overhead;
 static u64                      sleep_measurement_overhead;
 
@@ -74,6 +63,7 @@ enum sched_event_type {
         SCHED_EVENT_RUN,
         SCHED_EVENT_SLEEP,
         SCHED_EVENT_WAKEUP,
+        SCHED_EVENT_MIGRATION,
 };
 
 struct sched_atom {
@@ -147,6 +137,7 @@ struct work_atoms {
         struct thread           *thread;
         struct rb_node          node;
         u64                     max_lat;
+        u64                     max_lat_at;
         u64                     total_lat;
         u64                     nb_atoms;
         u64                     total_runtime;
@@ -226,7 +217,7 @@ static void calibrate_sleep_measurement_overhead(void)
 static struct sched_atom *
 get_new_event(struct task_desc *task, u64 timestamp)
 {
-        struct sched_atom *event = calloc(1, sizeof(*event));
+        struct sched_atom *event = zalloc(sizeof(*event));
         unsigned long idx = task->nr_events;
         size_t size;
 
@@ -294,7 +285,7 @@ add_sched_event_wakeup(struct task_desc *task, u64 timestamp,
                 return;
         }
 
-        wakee_event->wait_sem = calloc(1, sizeof(*wakee_event->wait_sem));
+        wakee_event->wait_sem = zalloc(sizeof(*wakee_event->wait_sem));
         sem_init(wakee_event->wait_sem, 0, 0);
         wakee_event->specific_wait = 1;
         event->wait_sem = wakee_event->wait_sem;
@@ -324,7 +315,7 @@ static struct task_desc *register_pid(unsigned long pid, const char *comm)
         if (task)
                 return task;
 
-        task = calloc(1, sizeof(*task));
+        task = zalloc(sizeof(*task));
         task->pid = pid;
         task->nr = nr_tasks;
         strcpy(task->comm, comm);
@@ -398,6 +389,8 @@ process_sched_event(struct task_desc *this_task __used, struct sched_atom *atom)
                                 ret = sem_post(atom->wait_sem);
                         BUG_ON(ret);
                         break;
+                case SCHED_EVENT_MIGRATION:
+                        break;
                 default:
                         BUG_ON(1);
         }
@@ -418,34 +411,33 @@ static u64 get_cpu_usage_nsec_parent(void)
         return sum;
 }
 
-static u64 get_cpu_usage_nsec_self(void)
+static int self_open_counters(void)
 {
-        char filename [] = "/proc/1234567890/sched";
-        unsigned long msecs, nsecs;
-        char *line = NULL;
-        u64 total = 0;
-        size_t len = 0;
-        ssize_t chars;
-        FILE *file;
-        int ret;
+        struct perf_event_attr attr;
+        int fd;
 
-        sprintf(filename, "/proc/%d/sched", getpid());
-        file = fopen(filename, "r");
-        BUG_ON(!file);
+        memset(&attr, 0, sizeof(attr));
 
-        while ((chars = getline(&line, &len, file)) != -1) {
-                ret = sscanf(line, "se.sum_exec_runtime : %ld.%06ld\n",
-                        &msecs, &nsecs);
-                if (ret == 2) {
-                        total = msecs*1e6 + nsecs;
-                        break;
-                }
-        }
-        if (line)
-                free(line);
-        fclose(file);
+        attr.type = PERF_TYPE_SOFTWARE;
+        attr.config = PERF_COUNT_SW_TASK_CLOCK;
+
+        fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
 
-        return total;
+        if (fd < 0)
+                die("Error: sys_perf_event_open() syscall returned"
+                    "with %d (%s)\n", fd, strerror(errno));
+        return fd;
+}
+
+static u64 get_cpu_usage_nsec_self(int fd)
+{
+        u64 runtime;
+        int ret;
+
+        ret = read(fd, &runtime, sizeof(runtime));
+        BUG_ON(ret != sizeof(runtime));
+
+        return runtime;
 }
 
 static void *thread_func(void *ctx)
@@ -454,9 +446,11 @@ static void *thread_func(void *ctx)
         u64 cpu_usage_0, cpu_usage_1;
         unsigned long i, ret;
         char comm2[22];
+        int fd;
 
         sprintf(comm2, ":%s", this_task->comm);
         prctl(PR_SET_NAME, comm2);
+        fd = self_open_counters();
 
 again:
         ret = sem_post(&this_task->ready_for_work);
@@ -466,16 +460,15 @@ again:
         ret = pthread_mutex_unlock(&start_work_mutex);
         BUG_ON(ret);
 
-        cpu_usage_0 = get_cpu_usage_nsec_self();
+        cpu_usage_0 = get_cpu_usage_nsec_self(fd);
 
         for (i = 0; i < this_task->nr_events; i++) {
                 this_task->curr_event = i;
                 process_sched_event(this_task, this_task->atoms[i]);
         }
 
-        cpu_usage_1 = get_cpu_usage_nsec_self();
+        cpu_usage_1 = get_cpu_usage_nsec_self(fd);
         this_task->cpu_usage = cpu_usage_1 - cpu_usage_0;
-
         ret = sem_post(&this_task->work_done_sem);
         BUG_ON(ret);
 
@@ -632,34 +625,6 @@ static void test_calibrations(void)
         printf("the sleep test took %Ld nsecs\n", T1-T0);
 }
 
-static int
-process_comm_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        struct thread *thread;
-
-        thread = threads__findnew(event->comm.pid, &threads, &last_match);
-
-        dump_printf("%p [%p]: perf_event_comm: %s:%d\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->comm.comm, event->comm.pid);
-
-        if (thread == NULL ||
-            thread__set_comm(thread, event->comm.comm)) {
-                dump_printf("problem processing perf_event_comm, skipping event.\n");
-                return -1;
-        }
-        total_comm++;
-
-        return 0;
-}
-
-
-struct raw_event_sample {
-        u32 size;
-        char data[0];
-};
-
 #define FILL_FIELD(ptr, field, event, data)     \
         ptr.field = (typeof(ptr.field)) raw_field_value(event, #field, data)
 
@@ -745,20 +710,39 @@ struct trace_fork_event {
         u32 child_pid;
 };
 
+struct trace_migrate_task_event {
+        u32 size;
+
+        u16 common_type;
+        u8 common_flags;
+        u8 common_preempt_count;
+        u32 common_pid;
+        u32 common_tgid;
+
+        char comm[16];
+        u32 pid;
+
+        u32 prio;
+        u32 cpu;
+};
+
 struct trace_sched_handler {
         void (*switch_event)(struct trace_switch_event *,
+                             struct perf_session *,
                              struct event *,
                              int cpu,
                              u64 timestamp,
                              struct thread *thread);
 
         void (*runtime_event)(struct trace_runtime_event *,
+                              struct perf_session *,
                               struct event *,
                               int cpu,
                               u64 timestamp,
                               struct thread *thread);
 
         void (*wakeup_event)(struct trace_wakeup_event *,
+                             struct perf_session *,
                              struct event *,
                              int cpu,
                              u64 timestamp,
@@ -769,11 +753,19 @@ struct trace_sched_handler {
                            int cpu,
                            u64 timestamp,
                            struct thread *thread);
+
+        void (*migrate_task_event)(struct trace_migrate_task_event *,
+                           struct perf_session *session,
+                           struct event *,
+                           int cpu,
+                           u64 timestamp,
+                           struct thread *thread);
 };
 
 
 static void
 replay_wakeup_event(struct trace_wakeup_event *wakeup_event,
+                    struct perf_session *session __used,
                     struct event *event,
                     int cpu __used,
                     u64 timestamp __used,
@@ -800,6 +792,7 @@ static u64 cpu_last_switched[MAX_CPUS];
 
 static void
 replay_switch_event(struct trace_switch_event *switch_event,
+                    struct perf_session *session __used,
                     struct event *event,
                     int cpu,
                     u64 timestamp,
@@ -941,9 +934,7 @@ __thread_latency_insert(struct rb_root *root, struct work_atoms *data,
 
 static void thread_atoms_insert(struct thread *thread)
 {
-        struct work_atoms *atoms;
-
-        atoms = calloc(sizeof(*atoms), 1);
+        struct work_atoms *atoms = zalloc(sizeof(*atoms));
         if (!atoms)
                 die("No memory");
 
@@ -975,9 +966,7 @@ add_sched_out_event(struct work_atoms *atoms,
                     char run_state,
                     u64 timestamp)
 {
-        struct work_atom *atom;
-
-        atom = calloc(sizeof(*atom), 1);
+        struct work_atom *atom = zalloc(sizeof(*atom));
         if (!atom)
                 die("Non memory");
 
@@ -1028,13 +1017,16 @@ add_sched_in_event(struct work_atoms *atoms, u64 timestamp)
 
         delta = atom->sched_in_time - atom->wake_up_time;
         atoms->total_lat += delta;
-        if (delta > atoms->max_lat)
+        if (delta > atoms->max_lat) {
                 atoms->max_lat = delta;
+                atoms->max_lat_at = timestamp;
+        }
         atoms->nb_atoms++;
 }
 
 static void
 latency_switch_event(struct trace_switch_event *switch_event,
+                     struct perf_session *session,
                      struct event *event __used,
                      int cpu,
                      u64 timestamp,
@@ -1058,8 +1050,8 @@ latency_switch_event(struct trace_switch_event *switch_event,
                 die("hm, delta: %Ld < 0 ?\n", delta);
 
 
-        sched_out = threads__findnew(switch_event->prev_pid, &threads, &last_match);
-        sched_in = threads__findnew(switch_event->next_pid, &threads, &last_match);
+        sched_out = perf_session__findnew(session, switch_event->prev_pid);
+        sched_in = perf_session__findnew(session, switch_event->next_pid);
 
         out_events = thread_atoms_search(&atom_root, sched_out, &cmp_pid);
         if (!out_events) {
@@ -1087,18 +1079,16 @@ latency_switch_event(struct trace_switch_event *switch_event,
 
 static void
 latency_runtime_event(struct trace_runtime_event *runtime_event,
+                     struct perf_session *session,
                      struct event *event __used,
                      int cpu,
                      u64 timestamp,
                      struct thread *this_thread __used)
 {
-        struct work_atoms *atoms;
-        struct thread *thread;
+        struct thread *thread = perf_session__findnew(session, runtime_event->pid);
+        struct work_atoms *atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
 
         BUG_ON(cpu >= MAX_CPUS || cpu < 0);
-
-        thread = threads__findnew(runtime_event->pid, &threads, &last_match);
-        atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
         if (!atoms) {
                 thread_atoms_insert(thread);
                 atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
@@ -1112,6 +1102,7 @@ latency_runtime_event(struct trace_runtime_event *runtime_event,
 
 static void
 latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
+                     struct perf_session *session,
                      struct event *__event __used,
                      int cpu __used,
                      u64 timestamp,
@@ -1125,7 +1116,7 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
         if (!wakeup_event->success)
                 return;
 
-        wakee = threads__findnew(wakeup_event->pid, &threads, &last_match);
+        wakee = perf_session__findnew(session, wakeup_event->pid);
         atoms = thread_atoms_search(&atom_root, wakee, &cmp_pid);
         if (!atoms) {
                 thread_atoms_insert(wakee);
@@ -1139,7 +1130,12 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
 
         atom = list_entry(atoms->work_list.prev, struct work_atom, list);
 
-        if (atom->state != THREAD_SLEEPING)
+        /*
+         * You WILL be missing events if you've recorded only
+         * one CPU, or are only looking at only one, so don't
+         * make useless noise.
+         */
+        if (profile_cpu == -1 && atom->state != THREAD_SLEEPING)
                 nr_state_machine_bugs++;
 
         nr_timestamps++;
@@ -1152,11 +1148,52 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
         atom->wake_up_time = timestamp;
 }
 
+static void
+latency_migrate_task_event(struct trace_migrate_task_event *migrate_task_event,
+                     struct perf_session *session,
+                     struct event *__event __used,
+                     int cpu __used,
+                     u64 timestamp,
+                     struct thread *thread __used)
+{
+        struct work_atoms *atoms;
+        struct work_atom *atom;
+        struct thread *migrant;
+
+        /*
+         * Only need to worry about migration when profiling one CPU.
+         */
+        if (profile_cpu == -1)
+                return;
+
+        migrant = perf_session__findnew(session, migrate_task_event->pid);
+        atoms = thread_atoms_search(&atom_root, migrant, &cmp_pid);
+        if (!atoms) {
+                thread_atoms_insert(migrant);
+                register_pid(migrant->pid, migrant->comm);
+                atoms = thread_atoms_search(&atom_root, migrant, &cmp_pid);
+                if (!atoms)
+                        die("migration-event: Internal tree error");
+                add_sched_out_event(atoms, 'R', timestamp);
+        }
+
+        BUG_ON(list_empty(&atoms->work_list));
+
+        atom = list_entry(atoms->work_list.prev, struct work_atom, list);
+        atom->sched_in_time = atom->sched_out_time = atom->wake_up_time = timestamp;
+
+        nr_timestamps++;
+
+        if (atom->sched_out_time > timestamp)
+                nr_unordered_timestamps++;
+}
+
 static struct trace_sched_handler lat_ops  = {
         .wakeup_event           = latency_wakeup_event,
         .switch_event           = latency_switch_event,
         .runtime_event          = latency_runtime_event,
         .fork_event             = latency_fork_event,
+        .migrate_task_event     = latency_migrate_task_event,
 };
 
 static void output_lat_thread(struct work_atoms *work_list)
@@ -1183,10 +1220,11 @@ static void output_lat_thread(struct work_atoms *work_list)
 
         avg = work_list->total_lat / work_list->nb_atoms;
 
-        printf("|%11.3f ms |%9llu | avg:%9.3f ms | max:%9.3f ms |\n",
+        printf("|%11.3f ms |%9llu | avg:%9.3f ms | max:%9.3f ms | max at: %9.6f s\n",
               (double)work_list->total_runtime / 1e6,
                  work_list->nb_atoms, (double)avg / 1e6,
-                 (double)work_list->max_lat / 1e6);
+                 (double)work_list->max_lat / 1e6,
+                 (double)work_list->max_lat_at / 1e9);
 }
 
 static int pid_cmp(struct work_atoms *l, struct work_atoms *r)
@@ -1323,7 +1361,7 @@ static void sort_lat(void)
 static struct trace_sched_handler *trace_handler;
 
 static void
-process_sched_wakeup_event(struct raw_event_sample *raw,
+process_sched_wakeup_event(void *data, struct perf_session *session,
                            struct event *event,
                            int cpu __used,
                            u64 timestamp __used,
@@ -1331,16 +1369,17 @@ process_sched_wakeup_event(struct raw_event_sample *raw,
 {
         struct trace_wakeup_event wakeup_event;
 
-        FILL_COMMON_FIELDS(wakeup_event, event, raw->data);
+        FILL_COMMON_FIELDS(wakeup_event, event, data);
 
-        FILL_ARRAY(wakeup_event, comm, event, raw->data);
-        FILL_FIELD(wakeup_event, pid, event, raw->data);
-        FILL_FIELD(wakeup_event, prio, event, raw->data);
-        FILL_FIELD(wakeup_event, success, event, raw->data);
-        FILL_FIELD(wakeup_event, cpu, event, raw->data);
+        FILL_ARRAY(wakeup_event, comm, event, data);
+        FILL_FIELD(wakeup_event, pid, event, data);
+        FILL_FIELD(wakeup_event, prio, event, data);
+        FILL_FIELD(wakeup_event, success, event, data);
+        FILL_FIELD(wakeup_event, cpu, event, data);
 
         if (trace_handler->wakeup_event)
-                trace_handler->wakeup_event(&wakeup_event, event, cpu, timestamp, thread);
+                trace_handler->wakeup_event(&wakeup_event, session, event,
+                                            cpu, timestamp, thread);
 }
 
 /*
@@ -1358,6 +1397,7 @@ static char next_shortname2 = '0';
 
 static void
 map_switch_event(struct trace_switch_event *switch_event,
+                 struct perf_session *session,
                  struct event *event __used,
                  int this_cpu,
                  u64 timestamp,
@@ -1385,8 +1425,8 @@ map_switch_event(struct trace_switch_event *switch_event,
                 die("hm, delta: %Ld < 0 ?\n", delta);
 
 
-        sched_out = threads__findnew(switch_event->prev_pid, &threads, &last_match);
-        sched_in = threads__findnew(switch_event->next_pid, &threads, &last_match);
+        sched_out = perf_session__findnew(session, switch_event->prev_pid);
+        sched_in = perf_session__findnew(session, switch_event->next_pid);
 
         curr_thread[this_cpu] = sched_in;
 
@@ -1436,7 +1476,7 @@ map_switch_event(struct trace_switch_event *switch_event,
 
 
 static void
-process_sched_switch_event(struct raw_event_sample *raw,
+process_sched_switch_event(void *data, struct perf_session *session,
                            struct event *event,
                            int this_cpu,
                            u64 timestamp __used,
@@ -1444,15 +1484,15 @@ process_sched_switch_event(struct raw_event_sample *raw,
 {
         struct trace_switch_event switch_event;
 
-        FILL_COMMON_FIELDS(switch_event, event, raw->data);
+        FILL_COMMON_FIELDS(switch_event, event, data);
 
-        FILL_ARRAY(switch_event, prev_comm, event, raw->data);
-        FILL_FIELD(switch_event, prev_pid, event, raw->data);
-        FILL_FIELD(switch_event, prev_prio, event, raw->data);
-        FILL_FIELD(switch_event, prev_state, event, raw->data);
-        FILL_ARRAY(switch_event, next_comm, event, raw->data);
-        FILL_FIELD(switch_event, next_pid, event, raw->data);
-        FILL_FIELD(switch_event, next_prio, event, raw->data);
+        FILL_ARRAY(switch_event, prev_comm, event, data);
+        FILL_FIELD(switch_event, prev_pid, event, data);
+        FILL_FIELD(switch_event, prev_prio, event, data);
+        FILL_FIELD(switch_event, prev_state, event, data);
+        FILL_ARRAY(switch_event, next_comm, event, data);
+        FILL_FIELD(switch_event, next_pid, event, data);
+        FILL_FIELD(switch_event, next_prio, event, data);
 
         if (curr_pid[this_cpu] != (u32)-1) {
                 /*
@@ -1463,13 +1503,14 @@ process_sched_switch_event(struct raw_event_sample *raw,
                         nr_context_switch_bugs++;
         }
         if (trace_handler->switch_event)
-                trace_handler->switch_event(&switch_event, event, this_cpu, timestamp, thread);
+                trace_handler->switch_event(&switch_event, session, event,
+                                            this_cpu, timestamp, thread);
 
         curr_pid[this_cpu] = switch_event.next_pid;
 }
 
 static void
-process_sched_runtime_event(struct raw_event_sample *raw,
+process_sched_runtime_event(void *data, struct perf_session *session,
                            struct event *event,
                            int cpu __used,
                            u64 timestamp __used,
@@ -1477,17 +1518,17 @@ process_sched_runtime_event(struct raw_event_sample *raw,
 {
         struct trace_runtime_event runtime_event;
 
-        FILL_ARRAY(runtime_event, comm, event, raw->data);
-        FILL_FIELD(runtime_event, pid, event, raw->data);
-        FILL_FIELD(runtime_event, runtime, event, raw->data);
-        FILL_FIELD(runtime_event, vruntime, event, raw->data);
+        FILL_ARRAY(runtime_event, comm, event, data);
+        FILL_FIELD(runtime_event, pid, event, data);
+        FILL_FIELD(runtime_event, runtime, event, data);
+        FILL_FIELD(runtime_event, vruntime, event, data);
 
         if (trace_handler->runtime_event)
-                trace_handler->runtime_event(&runtime_event, event, cpu, timestamp, thread);
+                trace_handler->runtime_event(&runtime_event, session, event, cpu, timestamp, thread);
 }
 
 static void
-process_sched_fork_event(struct raw_event_sample *raw,
+process_sched_fork_event(void *data,
                          struct event *event,
                          int cpu __used,
                          u64 timestamp __used,
@@ -1495,15 +1536,16 @@ process_sched_fork_event(struct raw_event_sample *raw,
 {
         struct trace_fork_event fork_event;
 
-        FILL_COMMON_FIELDS(fork_event, event, raw->data);
+        FILL_COMMON_FIELDS(fork_event, event, data);
 
-        FILL_ARRAY(fork_event, parent_comm, event, raw->data);
-        FILL_FIELD(fork_event, parent_pid, event, raw->data);
-        FILL_ARRAY(fork_event, child_comm, event, raw->data);
-        FILL_FIELD(fork_event, child_pid, event, raw->data);
+        FILL_ARRAY(fork_event, parent_comm, event, data);
+        FILL_FIELD(fork_event, parent_pid, event, data);
+        FILL_ARRAY(fork_event, child_comm, event, data);
+        FILL_FIELD(fork_event, child_pid, event, data);
 
         if (trace_handler->fork_event)
-                trace_handler->fork_event(&fork_event, event, cpu, timestamp, thread);
+                trace_handler->fork_event(&fork_event, event,
+                                          cpu, timestamp, thread);
 }
 
 static void
@@ -1517,233 +1559,115 @@ process_sched_exit_event(struct event *event,
 }
 
 static void
-process_raw_event(event_t *raw_event __used, void *more_data,
-                  int cpu, u64 timestamp, struct thread *thread)
+process_sched_migrate_task_event(void *data, struct perf_session *session,
+                           struct event *event,
+                           int cpu __used,
+                           u64 timestamp __used,
+                           struct thread *thread __used)
+{
+        struct trace_migrate_task_event migrate_task_event;
+
+        FILL_COMMON_FIELDS(migrate_task_event, event, data);
+
+        FILL_ARRAY(migrate_task_event, comm, event, data);
+        FILL_FIELD(migrate_task_event, pid, event, data);
+        FILL_FIELD(migrate_task_event, prio, event, data);
+        FILL_FIELD(migrate_task_event, cpu, event, data);
+
+        if (trace_handler->migrate_task_event)
+                trace_handler->migrate_task_event(&migrate_task_event, session,
+                                                 event, cpu, timestamp, thread);
+}
+
+static void
+process_raw_event(event_t *raw_event __used, struct perf_session *session,
+                  void *data, int cpu, u64 timestamp, struct thread *thread)
 {
-        struct raw_event_sample *raw = more_data;
         struct event *event;
         int type;
 
-        type = trace_parse_common_type(raw->data);
+
+        type = trace_parse_common_type(data);
         event = trace_find_event(type);
 
         if (!strcmp(event->name, "sched_switch"))
-                process_sched_switch_event(raw, event, cpu, timestamp, thread);
+                process_sched_switch_event(data, session, event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_stat_runtime"))
-                process_sched_runtime_event(raw, event, cpu, timestamp, thread);
+                process_sched_runtime_event(data, session, event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_wakeup"))
-                process_sched_wakeup_event(raw, event, cpu, timestamp, thread);
+                process_sched_wakeup_event(data, session, event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_wakeup_new"))
-                process_sched_wakeup_event(raw, event, cpu, timestamp, thread);
+                process_sched_wakeup_event(data, session, event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_process_fork"))
-                process_sched_fork_event(raw, event, cpu, timestamp, thread);
+                process_sched_fork_event(data, event, cpu, timestamp, thread);
         if (!strcmp(event->name, "sched_process_exit"))
                 process_sched_exit_event(event, cpu, timestamp, thread);
+        if (!strcmp(event->name, "sched_migrate_task"))
+                process_sched_migrate_task_event(data, session, event, cpu, timestamp, thread);
 }
 
-static int
-process_sample_event(event_t *event, unsigned long offset, unsigned long head)
+static int process_sample_event(event_t *event, struct perf_session *session)
 {
-        char level;
-        int show = 0;
-        struct dso *dso = NULL;
+        struct sample_data data;
         struct thread *thread;
-        u64 ip = event->ip.ip;
-        u64 timestamp = -1;
-        u32 cpu = -1;
-        u64 period = 1;
-        void *more_data = event->ip.__more_data;
-        int cpumode;
-
-        thread = threads__findnew(event->ip.pid, &threads, &last_match);
-
-        if (sample_type & PERF_SAMPLE_TIME) {
-                timestamp = *(u64 *)more_data;
-                more_data += sizeof(u64);
-        }
 
-        if (sample_type & PERF_SAMPLE_CPU) {
-                cpu = *(u32 *)more_data;
-                more_data += sizeof(u32);
-                more_data += sizeof(u32); /* reserved */
-        }
+        if (!(session->sample_type & PERF_SAMPLE_RAW))
+                return 0;
 
-        if (sample_type & PERF_SAMPLE_PERIOD) {
-                period = *(u64 *)more_data;
-                more_data += sizeof(u64);
-        }
+        memset(&data, 0, sizeof(data));
+        data.time = -1;
+        data.cpu = -1;
+        data.period = -1;
 
-        dump_printf("%p [%p]: PERF_RECORD_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->header.misc,
-                event->ip.pid, event->ip.tid,
-                (void *)(long)ip,
-                (long long)period);
+        event__parse_sample(event, session->sample_type, &data);
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+        dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
+                    data.pid, data.tid, data.ip, data.period);
 
+        thread = perf_session__findnew(session, data.pid);
         if (thread == NULL) {
-                eprintf("problem processing %d event, skipping it.\n",
-                        event->header.type);
+                pr_debug("problem processing %d event, skipping it.\n",
+                         event->header.type);
                 return -1;
         }
 
-        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-
-        if (cpumode == PERF_RECORD_MISC_KERNEL) {
-                show = SHOW_KERNEL;
-                level = 'k';
-
-                dso = kernel_dso;
-
-                dump_printf(" ...... dso: %s\n", dso->name);
-
-        } else if (cpumode == PERF_RECORD_MISC_USER) {
-
-                show = SHOW_USER;
-                level = '.';
-
-        } else {
-                show = SHOW_HV;
-                level = 'H';
-
-                dso = hypervisor_dso;
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
 
-                dump_printf(" ...... dso: [hypervisor]\n");
-        }
+        if (profile_cpu != -1 && profile_cpu != (int)data.cpu)
+                return 0;
 
-        if (sample_type & PERF_SAMPLE_RAW)
-                process_raw_event(event, more_data, cpu, timestamp, thread);
+        process_raw_event(event, session, data.raw_data, data.cpu, data.time, thread);
 
         return 0;
 }
 
-static int
-process_event(event_t *event, unsigned long offset, unsigned long head)
+static int process_lost_event(event_t *event __used,
+                              struct perf_session *session __used)
 {
-        trace_event(event);
-
-        nr_events++;
-        switch (event->header.type) {
-        case PERF_RECORD_MMAP:
-                return 0;
-        case PERF_RECORD_LOST:
-                nr_lost_chunks++;
-                nr_lost_events += event->lost.lost;
-                return 0;
-
-        case PERF_RECORD_COMM:
-                return process_comm_event(event, offset, head);
-
-        case PERF_RECORD_EXIT ... PERF_RECORD_READ:
-                return 0;
-
-        case PERF_RECORD_SAMPLE:
-                return process_sample_event(event, offset, head);
-
-        case PERF_RECORD_MAX:
-        default:
-                return -1;
-        }
+        nr_lost_chunks++;
+        nr_lost_events += event->lost.lost;
 
         return 0;
 }
 
+static struct perf_event_ops event_ops = {
+        .sample = process_sample_event,
+        .comm   = event__process_comm,
+        .lost   = process_lost_event,
+};
+
 static int read_events(void)
 {
-        int ret, rc = EXIT_FAILURE;
-        unsigned long offset = 0;
-        unsigned long head = 0;
-        struct stat perf_stat;
-        event_t *event;
-        uint32_t size;
-        char *buf;
-
-        trace_report();
-        register_idle_thread(&threads, &last_match);
-
-        input = open(input_name, O_RDONLY);
-        if (input < 0) {
-                perror("failed to open file");
-                exit(-1);
-        }
-
-        ret = fstat(input, &perf_stat);
-        if (ret < 0) {
-                perror("failed to stat file");
-                exit(-1);
-        }
-
-        if (!perf_stat.st_size) {
-                fprintf(stderr, "zero-sized file, nothing to do!\n");
-                exit(0);
-        }
-        header = perf_header__read(input);
-        head = header->data_offset;
-        sample_type = perf_header__sample_type(header);
-
-        if (!(sample_type & PERF_SAMPLE_RAW))
-                die("No trace sample to read. Did you call perf record "
-                    "without -R?");
-
-        if (load_kernel() < 0) {
-                perror("failed to load kernel symbols");
-                return EXIT_FAILURE;
-        }
-
-remap:
-        buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
-                           MAP_SHARED, input, offset);
-        if (buf == MAP_FAILED) {
-                perror("failed to mmap file");
-                exit(-1);
-        }
-
-more:
-        event = (event_t *)(buf + head);
-
-        size = event->header.size;
-        if (!size)
-                size = 8;
-
-        if (head + event->header.size >= page_size * mmap_window) {
-                unsigned long shift = page_size * (head / page_size);
-                int res;
-
-                res = munmap(buf, page_size * mmap_window);
-                assert(res == 0);
-
-                offset += shift;
-                head -= shift;
-                goto remap;
-        }
-
-        size = event->header.size;
+        int err = -EINVAL;
+        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
+        if (session == NULL)
+                return -ENOMEM;
 
+        if (perf_session__has_traces(session, "record -R"))
+                err = perf_session__process_events(session, &event_ops);
 
-        if (!size || process_event(event, offset, head) < 0) {
-
-                /*
-                 * assume we lost track of the stream, check alignment, and
-                 * increment a single u64 in the hope to catch on again 'soon'.
-                 */
-
-                if (unlikely(head & 7))
-                        head &= ~7ULL;
-
-                size = 8;
-        }
-
-        head += size;
-
-        if (offset + head < (unsigned long)perf_stat.st_size)
-                goto more;
-
-        rc = EXIT_SUCCESS;
-        close(input);
-
-        return rc;
+        perf_session__delete(session);
+        return err;
 }
 
 static void print_bad_events(void)
@@ -1784,9 +1708,9 @@ static void __cmd_lat(void)
         read_events();
         sort_lat();
 
-        printf("\n -----------------------------------------------------------------------------------------\n");
-        printf("  Task                  |   Runtime ms  | Switches | Average delay ms | Maximum delay ms |\n");
-        printf(" -----------------------------------------------------------------------------------------\n");
+        printf("\n ---------------------------------------------------------------------------------------------------------------\n");
+        printf("  Task                  |   Runtime ms  | Switches | Average delay ms | Maximum delay ms | Maximum delay at     |\n");
+        printf(" ---------------------------------------------------------------------------------------------------------------\n");
 
         next = rb_first(&sorted_atom_root);
 
@@ -1883,6 +1807,8 @@ static const struct option latency_options[] = {
                    "sort by key(s): runtime, switch, avg, max"),
         OPT_BOOLEAN('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
+        OPT_INTEGER('C', "CPU", &profile_cpu,
+                    "CPU to profile on"),
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
         OPT_END()
@@ -1960,14 +1886,18 @@ static int __cmd_record(int argc, const char **argv)
 
 int cmd_sched(int argc, const char **argv, const char *prefix __used)
 {
-        symbol__init();
-        page_size = getpagesize();
-
         argc = parse_options(argc, argv, sched_options, sched_usage,
                              PARSE_OPT_STOP_AT_NON_OPTION);
         if (!argc)
                 usage_with_options(sched_usage, sched_options);
 
+        /*
+         * Aliased to 'perf trace' for now:
+         */
+        if (!strcmp(argv[0], "trace"))
+                return cmd_trace(argc, argv, prefix);
+
+        symbol__init();
         if (!strncmp(argv[0], "rec", 3)) {
                 return __cmd_record(argc, argv);
         } else if (!strncmp(argv[0], "lat", 3)) {
@@ -1991,11 +1921,6 @@ int cmd_sched(int argc, const char **argv, const char *prefix __used)
                                 usage_with_options(replay_usage, replay_options);
                 }
                 __cmd_replay();
-        } else if (!strcmp(argv[0], "trace")) {
-                /*
-                 * Aliased to 'perf trace' for now:
-                 */
-                return cmd_trace(argc, argv, prefix);
         } else {
                 usage_with_options(sched_usage, sched_options);
         }
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 3db31e7bf173..95db31cff6fd 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -44,21 +44,25 @@
 #include "util/parse-events.h"
 #include "util/event.h"
 #include "util/debug.h"
+#include "util/header.h"
+#include "util/cpumap.h"
 
 #include <sys/prctl.h>
 #include <math.h>
 
 static struct perf_event_attr default_attrs[] = {
 
-  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK      },
-  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES},
-  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS  },
-  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS     },
+  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK              },
+  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES        },
+  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS          },
+  { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS             },
 
-  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES      },
-  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS    },
-  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_REFERENCES},
-  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_MISSES    },
+  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES              },
+  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS            },
+  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS     },
+  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES           },
+  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_REFERENCES        },
+  { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CACHE_MISSES            },
 
 };
 
@@ -77,6 +81,8 @@ static int			fd[MAX_NR_CPUS][MAX_COUNTERS];
 
 static int                      event_scaled[MAX_COUNTERS];
 
+static volatile int done = 0;
+
 struct stats
 {
         double n, mean, M2;
@@ -125,6 +131,7 @@ struct stats			event_res_stats[MAX_COUNTERS][3];
 struct stats                    runtime_nsecs_stats;
 struct stats                    walltime_nsecs_stats;
 struct stats                    runtime_cycles_stats;
+struct stats                    runtime_branches_stats;
 
 #define MATCH_EVENT(t, c, counter)                      \
         (attrs[counter].type == PERF_TYPE_##t &&        \
@@ -145,7 +152,7 @@ static void create_perf_stat_counter(int counter, int pid)
                 unsigned int cpu;
 
                 for (cpu = 0; cpu < nr_cpus; cpu++) {
-                        fd[cpu][counter] = sys_perf_event_open(attr, -1, cpu, -1, 0);
+                        fd[cpu][counter] = sys_perf_event_open(attr, -1, cpumap[cpu], -1, 0);
                         if (fd[cpu][counter] < 0 && verbose)
                                 fprintf(stderr, ERR_PERF_OPEN, counter,
                                         fd[cpu][counter], strerror(errno));
@@ -235,6 +242,8 @@ static void read_counter(int counter)
                 update_stats(&runtime_nsecs_stats, count[0]);
         if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
                 update_stats(&runtime_cycles_stats, count[0]);
+        if (MATCH_EVENT(HARDWARE, HW_BRANCH_INSTRUCTIONS, counter))
+                update_stats(&runtime_branches_stats, count[0]);
 }
 
 static int run_perf_stat(int argc __used, const char **argv)
@@ -242,61 +251,64 @@ static int run_perf_stat(int argc __used, const char **argv)
         unsigned long long t0, t1;
         int status = 0;
         int counter;
-        int pid;
+        int pid = target_pid;
         int child_ready_pipe[2], go_pipe[2];
+        const bool forks = (target_pid == -1 && argc > 0);
         char buf;
 
         if (!system_wide)
                 nr_cpus = 1;
 
-        if (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0) {
+        if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
                 perror("failed to create pipes");
                 exit(1);
         }
 
-        if ((pid = fork()) < 0)
-                perror("failed to fork");
-
-        if (!pid) {
-                close(child_ready_pipe[0]);
-                close(go_pipe[1]);
-                fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
+        if (forks) {
+                if ((pid = fork()) < 0)
+                        perror("failed to fork");
+
+                if (!pid) {
+                        close(child_ready_pipe[0]);
+                        close(go_pipe[1]);
+                        fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
+
+                        /*
+                         * Do a dummy execvp to get the PLT entry resolved,
+                         * so we avoid the resolver overhead on the real
+                         * execvp call.
+                         */
+                        execvp("", (char **)argv);
+
+                        /*
+                         * Tell the parent we're ready to go
+                         */
+                        close(child_ready_pipe[1]);
+
+                        /*
+                         * Wait until the parent tells us to go.
+                         */
+                        if (read(go_pipe[0], &buf, 1) == -1)
+                                perror("unable to read pipe");
+
+                        execvp(argv[0], (char **)argv);
+
+                        perror(argv[0]);
+                        exit(-1);
+                }
 
-                /*
-                 * Do a dummy execvp to get the PLT entry resolved,
-                 * so we avoid the resolver overhead on the real
-                 * execvp call.
-                 */
-                execvp("", (char **)argv);
+                child_pid = pid;
 
                 /*
-                 * Tell the parent we're ready to go
+                 * Wait for the child to be ready to exec.
                  */
                 close(child_ready_pipe[1]);
-
-                /*
-                 * Wait until the parent tells us to go.
-                 */
-                if (read(go_pipe[0], &buf, 1) == -1)
+                close(go_pipe[0]);
+                if (read(child_ready_pipe[0], &buf, 1) == -1)
                         perror("unable to read pipe");
-
-                execvp(argv[0], (char **)argv);
-
-                perror(argv[0]);
-                exit(-1);
+                close(child_ready_pipe[0]);
         }
 
-        child_pid = pid;
-
-        /*
-         * Wait for the child to be ready to exec.
-         */
-        close(child_ready_pipe[1]);
-        close(go_pipe[0]);
-        if (read(child_ready_pipe[0], &buf, 1) == -1)
-                perror("unable to read pipe");
-        close(child_ready_pipe[0]);
-
         for (counter = 0; counter < nr_counters; counter++)
                 create_perf_stat_counter(counter, pid);
 
@@ -305,8 +317,12 @@ static int run_perf_stat(int argc __used, const char **argv)
          */
         t0 = rdclock();
 
-        close(go_pipe[1]);
-        wait(&status);
+        if (forks) {
+                close(go_pipe[1]);
+                wait(&status);
+        } else {
+                while(!done);
+        }
 
         t1 = rdclock();
 
@@ -352,7 +368,16 @@ static void abs_printout(int counter, double avg)
                         ratio = avg / total;
 
                 fprintf(stderr, " # %10.3f IPC  ", ratio);
-        } else {
+        } else if (MATCH_EVENT(HARDWARE, HW_BRANCH_MISSES, counter) &&
+                        runtime_branches_stats.n != 0) {
+                total = avg_stats(&runtime_branches_stats);
+
+                if (total)
+                        ratio = avg * 100 / total;
+
+                fprintf(stderr, " # %10.3f %%    ", ratio);
+
+        } else if (runtime_nsecs_stats.n != 0) {
                 total = avg_stats(&runtime_nsecs_stats);
 
                 if (total)
@@ -403,10 +428,13 @@ static void print_stat(int argc, const char **argv)
         fflush(stdout);
 
         fprintf(stderr, "\n");
-        fprintf(stderr, " Performance counter stats for \'%s", argv[0]);
-
-        for (i = 1; i < argc; i++)
-                fprintf(stderr, " %s", argv[i]);
+        fprintf(stderr, " Performance counter stats for ");
+        if(target_pid == -1) {
+                fprintf(stderr, "\'%s", argv[0]);
+                for (i = 1; i < argc; i++)
+                        fprintf(stderr, " %s", argv[i]);
+        }else
+                fprintf(stderr, "task pid \'%d", target_pid);
 
         fprintf(stderr, "\'");
         if (run_count > 1)
@@ -431,6 +459,9 @@ static volatile int signr = -1;
 
 static void skip_signal(int signo)
 {
+        if(target_pid != -1)
+                done = 1;
+
         signr = signo;
 }
 
@@ -447,7 +478,7 @@ static void sig_atexit(void)
 }
 
 static const char * const stat_usage[] = {
-        "perf stat [<options>] <command>",
+        "perf stat [<options>] [<command>]",
         NULL
 };
 
@@ -478,7 +509,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
 
         argc = parse_options(argc, argv, options, stat_usage,
                 PARSE_OPT_STOP_AT_NON_OPTION);
-        if (!argc)
+        if (!argc && target_pid == -1)
                 usage_with_options(stat_usage, options);
         if (run_count <= 0)
                 usage_with_options(stat_usage, options);
@@ -489,9 +520,10 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
                 nr_counters = ARRAY_SIZE(default_attrs);
         }
 
-        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
-        assert(nr_cpus <= MAX_NR_CPUS);
-        assert((int)nr_cpus >= 0);
+        if (system_wide)
+                nr_cpus = read_cpu_map();
+        else
+                nr_cpus = 1;
 
         /*
          * We dont want to block the signals - that would cause
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index e8a510d935e5..0d4d8ff7914b 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -29,16 +29,13 @@
 #include "util/header.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
+#include "util/event.h"
+#include "util/session.h"
 #include "util/svghelper.h"
 
 static char             const *input_name = "perf.data";
 static char             const *output_name = "output.svg";
 
-
-static unsigned long    page_size;
-static unsigned long    mmap_window = 32;
-static u64              sample_type;
-
 static unsigned int     numcpus;
 static u64              min_freq;       /* Lowest CPU frequency seen */
 static u64              max_freq;       /* Highest CPU frequency seen */
@@ -49,8 +46,6 @@ static u64		first_time, last_time;
 static int              power_only;
 
 
-static struct perf_header       *header;
-
 struct per_pid;
 struct per_pidcomm;
 
@@ -153,6 +148,17 @@ static struct wake_event     *wake_events;
 
 struct sample_wrapper *all_samples;
 
+
+struct process_filter;
+struct process_filter {
+        char                    *name;
+        int                     pid;
+        struct process_filter   *next;
+};
+
+static struct process_filter *process_filter;
+
+
 static struct per_pid *find_create_pid(int pid)
 {
         struct per_pid *cursor = all_data;
@@ -272,33 +278,30 @@ static int cpus_cstate_state[MAX_CPUS];
 static u64 cpus_pstate_start_times[MAX_CPUS];
 static u64 cpus_pstate_state[MAX_CPUS];
 
-static int
-process_comm_event(event_t *event)
+static int process_comm_event(event_t *event, struct perf_session *session __used)
 {
-        pid_set_comm(event->comm.pid, event->comm.comm);
+        pid_set_comm(event->comm.tid, event->comm.comm);
         return 0;
 }
-static int
-process_fork_event(event_t *event)
+
+static int process_fork_event(event_t *event, struct perf_session *session __used)
 {
         pid_fork(event->fork.pid, event->fork.ppid, event->fork.time);
         return 0;
 }
 
-static int
-process_exit_event(event_t *event)
+static int process_exit_event(event_t *event, struct perf_session *session __used)
 {
         pid_exit(event->fork.pid, event->fork.time);
         return 0;
 }
 
 struct trace_entry {
-        u32                     size;
         unsigned short          type;
         unsigned char           flags;
         unsigned char           preempt_count;
         int                     pid;
-        int                     tgid;
+        int                     lock_depth;
 };
 
 struct power_entry {
@@ -472,46 +475,24 @@ static void sched_switch(int cpu, u64 timestamp, struct trace_entry *te)
 }
 
 
-static int
-process_sample_event(event_t *event)
+static int process_sample_event(event_t *event, struct perf_session *session)
 {
-        int cursor = 0;
-        u64 addr = 0;
-        u64 stamp = 0;
-        u32 cpu = 0;
-        u32 pid = 0;
+        struct sample_data data;
         struct trace_entry *te;
 
-        if (sample_type & PERF_SAMPLE_IP)
-                cursor++;
-
-        if (sample_type & PERF_SAMPLE_TID) {
-                pid = event->sample.array[cursor]>>32;
-                cursor++;
-        }
-        if (sample_type & PERF_SAMPLE_TIME) {
-                stamp = event->sample.array[cursor++];
+        memset(&data, 0, sizeof(data));
 
-                if (!first_time || first_time > stamp)
-                        first_time = stamp;
-                if (last_time < stamp)
-                        last_time = stamp;
+        event__parse_sample(event, session->sample_type, &data);
 
+        if (session->sample_type & PERF_SAMPLE_TIME) {
+                if (!first_time || first_time > data.time)
+                        first_time = data.time;
+                if (last_time < data.time)
+                        last_time = data.time;
         }
-        if (sample_type & PERF_SAMPLE_ADDR)
-                addr = event->sample.array[cursor++];
-        if (sample_type & PERF_SAMPLE_ID)
-                cursor++;
-        if (sample_type & PERF_SAMPLE_STREAM_ID)
-                cursor++;
-        if (sample_type & PERF_SAMPLE_CPU)
-                cpu = event->sample.array[cursor++] & 0xFFFFFFFF;
-        if (sample_type & PERF_SAMPLE_PERIOD)
-                cursor++;
-
-        te = (void *)&event->sample.array[cursor];
 
-        if (sample_type & PERF_SAMPLE_RAW && te->size > 0) {
+        te = (void *)data.raw_data;
+        if (session->sample_type & PERF_SAMPLE_RAW && data.raw_size > 0) {
                 char *event_str;
                 struct power_entry *pe;
 
@@ -523,19 +504,19 @@ process_sample_event(event_t *event)
                         return 0;
 
                 if (strcmp(event_str, "power:power_start") == 0)
-                        c_state_start(cpu, stamp, pe->value);
+                        c_state_start(data.cpu, data.time, pe->value);
 
                 if (strcmp(event_str, "power:power_end") == 0)
-                        c_state_end(cpu, stamp);
+                        c_state_end(data.cpu, data.time);
 
                 if (strcmp(event_str, "power:power_frequency") == 0)
-                        p_state_change(cpu, stamp, pe->value);
+                        p_state_change(data.cpu, data.time, pe->value);
 
                 if (strcmp(event_str, "sched:sched_wakeup") == 0)
-                        sched_wakeup(cpu, stamp, pid, te);
+                        sched_wakeup(data.cpu, data.time, data.pid, te);
 
                 if (strcmp(event_str, "sched:sched_switch") == 0)
-                        sched_switch(cpu, stamp, te);
+                        sched_switch(data.cpu, data.time, te);
         }
         return 0;
 }
@@ -588,16 +569,16 @@ static void end_sample_processing(void)
         }
 }
 
-static u64 sample_time(event_t *event)
+static u64 sample_time(event_t *event, const struct perf_session *session)
 {
         int cursor;
 
         cursor = 0;
-        if (sample_type & PERF_SAMPLE_IP)
+        if (session->sample_type & PERF_SAMPLE_IP)
                 cursor++;
-        if (sample_type & PERF_SAMPLE_TID)
+        if (session->sample_type & PERF_SAMPLE_TID)
                 cursor++;
-        if (sample_type & PERF_SAMPLE_TIME)
+        if (session->sample_type & PERF_SAMPLE_TIME)
                 return event->sample.array[cursor];
         return 0;
 }
@@ -607,8 +588,7 @@ static u64 sample_time(event_t *event)
  * We first queue all events, sorted backwards by insertion.
  * The order will get flipped later.
  */
-static int
-queue_sample_event(event_t *event)
+static int queue_sample_event(event_t *event, struct perf_session *session)
 {
         struct sample_wrapper *copy, *prev;
         int size;
@@ -622,7 +602,7 @@ queue_sample_event(event_t *event)
         memset(copy, 0, size);
 
         copy->next = NULL;
-        copy->timestamp = sample_time(event);
+        copy->timestamp = sample_time(event, session);
 
         memcpy(&copy->data, event, event->sample.header.size);
 
@@ -763,11 +743,11 @@ static void draw_wakeups(void)
                                 c = p->all;
                                 while (c) {
                                         if (c->Y && c->start_time <= we->time && c->end_time >= we->time) {
-                                                if (p->pid == we->waker) {
+                                                if (p->pid == we->waker && !from) {
                                                         from = c->Y;
                                                         task_from = strdup(c->comm);
                                                 }
-                                                if (p->pid == we->wakee) {
+                                                if (p->pid == we->wakee && !to) {
                                                         to = c->Y;
                                                         task_to = strdup(c->comm);
                                                 }
@@ -882,12 +862,89 @@ static void draw_process_bars(void)
         }
 }
 
+static void add_process_filter(const char *string)
+{
+        struct process_filter *filt;
+        int pid;
+
+        pid = strtoull(string, NULL, 10);
+        filt = malloc(sizeof(struct process_filter));
+        if (!filt)
+                return;
+
+        filt->name = strdup(string);
+        filt->pid  = pid;
+        filt->next = process_filter;
+
+        process_filter = filt;
+}
+
+static int passes_filter(struct per_pid *p, struct per_pidcomm *c)
+{
+        struct process_filter *filt;
+        if (!process_filter)
+                return 1;
+
+        filt = process_filter;
+        while (filt) {
+                if (filt->pid && p->pid == filt->pid)
+                        return 1;
+                if (strcmp(filt->name, c->comm) == 0)
+                        return 1;
+                filt = filt->next;
+        }
+        return 0;
+}
+
+static int determine_display_tasks_filtered(void)
+{
+        struct per_pid *p;
+        struct per_pidcomm *c;
+        int count = 0;
+
+        p = all_data;
+        while (p) {
+                p->display = 0;
+                if (p->start_time == 1)
+                        p->start_time = first_time;
+
+                /* no exit marker, task kept running to the end */
+                if (p->end_time == 0)
+                        p->end_time = last_time;
+
+                c = p->all;
+
+                while (c) {
+                        c->display = 0;
+
+                        if (c->start_time == 1)
+                                c->start_time = first_time;
+
+                        if (passes_filter(p, c)) {
+                                c->display = 1;
+                                p->display = 1;
+                                count++;
+                        }
+
+                        if (c->end_time == 0)
+                                c->end_time = last_time;
+
+                        c = c->next;
+                }
+                p = p->next;
+        }
+        return count;
+}
+
 static int determine_display_tasks(u64 threshold)
 {
         struct per_pid *p;
         struct per_pidcomm *c;
         int count = 0;
 
+        if (process_filter)
+                return determine_display_tasks_filtered();
+
         p = all_data;
         while (p) {
                 p->display = 0;
@@ -957,37 +1014,7 @@ static void write_svg_file(const char *filename)
         svg_close();
 }
 
-static int
-process_event(event_t *event)
-{
-
-        switch (event->header.type) {
-
-        case PERF_RECORD_COMM:
-                return process_comm_event(event);
-        case PERF_RECORD_FORK:
-                return process_fork_event(event);
-        case PERF_RECORD_EXIT:
-                return process_exit_event(event);
-        case PERF_RECORD_SAMPLE:
-                return queue_sample_event(event);
-
-        /*
-         * We dont process them right now but they are fine:
-         */
-        case PERF_RECORD_MMAP:
-        case PERF_RECORD_THROTTLE:
-        case PERF_RECORD_UNTHROTTLE:
-                return 0;
-
-        default:
-                return -1;
-        }
-
-        return 0;
-}
-
-static void process_samples(void)
+static void process_samples(struct perf_session *session)
 {
         struct sample_wrapper *cursor;
         event_t *event;
@@ -998,113 +1025,33 @@ static void process_samples(void)
         while (cursor) {
                 event = (void *)&cursor->data;
                 cursor = cursor->next;
-                process_sample_event(event);
+                process_sample_event(event, session);
         }
 }
 
+static struct perf_event_ops event_ops = {
+        .comm   = process_comm_event,
+        .fork   = process_fork_event,
+        .exit   = process_exit_event,
+        .sample = queue_sample_event,
+};
 
 static int __cmd_timechart(void)
 {
-        int ret, rc = EXIT_FAILURE;
-        unsigned long offset = 0;
-        unsigned long head, shift;
-        struct stat statbuf;
-        event_t *event;
-        uint32_t size;
-        char *buf;
-        int input;
-
-        input = open(input_name, O_RDONLY);
-        if (input < 0) {
-                fprintf(stderr, " failed to open file: %s", input_name);
-                if (!strcmp(input_name, "perf.data"))
-                        fprintf(stderr, "  (try 'perf record' first)");
-                fprintf(stderr, "\n");
-                exit(-1);
-        }
-
-        ret = fstat(input, &statbuf);
-        if (ret < 0) {
-                perror("failed to stat file");
-                exit(-1);
-        }
-
-        if (!statbuf.st_size) {
-                fprintf(stderr, "zero-sized file, nothing to do!\n");
-                exit(0);
-        }
+        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
+        int ret = -EINVAL;
 
-        header = perf_header__read(input);
-        head = header->data_offset;
+        if (session == NULL)
+                return -ENOMEM;
 
-        sample_type = perf_header__sample_type(header);
+        if (!perf_session__has_traces(session, "timechart record"))
+                goto out_delete;
 
-        shift = page_size * (head / page_size);
-        offset += shift;
-        head -= shift;
+        ret = perf_session__process_events(session, &event_ops);
+        if (ret)
+                goto out_delete;
 
-remap:
-        buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
-                           MAP_SHARED, input, offset);
-        if (buf == MAP_FAILED) {
-                perror("failed to mmap file");
-                exit(-1);
-        }
-
-more:
-        event = (event_t *)(buf + head);
-
-        size = event->header.size;
-        if (!size)
-                size = 8;
-
-        if (head + event->header.size >= page_size * mmap_window) {
-                int ret2;
-
-                shift = page_size * (head / page_size);
-
-                ret2 = munmap(buf, page_size * mmap_window);
-                assert(ret2 == 0);
-
-                offset += shift;
-                head -= shift;
-                goto remap;
-        }
-
-        size = event->header.size;
-
-        if (!size || process_event(event) < 0) {
-
-                printf("%p [%p]: skipping unknown header type: %d\n",
-                        (void *)(offset + head),
-                        (void *)(long)(event->header.size),
-                        event->header.type);
-
-                /*
-                 * assume we lost track of the stream, check alignment, and
-                 * increment a single u64 in the hope to catch on again 'soon'.
-                 */
-
-                if (unlikely(head & 7))
-                        head &= ~7ULL;
-
-                size = 8;
-        }
-
-        head += size;
-
-        if (offset + head >= header->data_offset + header->data_size)
-                goto done;
-
-        if (offset + head < (unsigned long)statbuf.st_size)
-                goto more;
-
-done:
-        rc = EXIT_SUCCESS;
-        close(input);
-
-
-        process_samples();
+        process_samples(session);
 
         end_sample_processing();
 
@@ -1112,9 +1059,11 @@ done:
 
         write_svg_file(output_name);
 
-        printf("Written %2.1f seconds of trace to %s.\n", (last_time - first_time) / 1000000000.0, output_name);
-
-        return rc;
+        pr_info("Written %2.1f seconds of trace to %s.\n",
+                (last_time - first_time) / 1000000000.0, output_name);
+out_delete:
+        perf_session__delete(session);
+        return ret;
 }
 
 static const char * const timechart_usage[] = {
@@ -1153,6 +1102,14 @@ static int __cmd_record(int argc, const char **argv)
         return cmd_record(i, rec_argv, NULL);
 }
 
+static int
+parse_process(const struct option *opt __used, const char *arg, int __used unset)
+{
+        if (arg)
+                add_process_filter(arg);
+        return 0;
+}
+
 static const struct option options[] = {
         OPT_STRING('i', "input", &input_name, "file",
                     "input file name"),
@@ -1160,21 +1117,22 @@ static const struct option options[] = {
                     "output file name"),
         OPT_INTEGER('w', "width", &svg_page_width,
                     "page width"),
-        OPT_BOOLEAN('p', "power-only", &power_only,
+        OPT_BOOLEAN('P', "power-only", &power_only,
                     "output power data only"),
+        OPT_CALLBACK('p', "process", NULL, "process",
+                      "process selector. Pass a pid or process name.",
+                       parse_process),
         OPT_END()
 };
 
 
 int cmd_timechart(int argc, const char **argv, const char *prefix __used)
 {
-        symbol__init();
-
-        page_size = getpagesize();
-
         argc = parse_options(argc, argv, options, timechart_usage,
                         PARSE_OPT_STOP_AT_NON_OPTION);
 
+        symbol__init();
+
         if (argc && !strncmp(argv[0], "rec", 3))
                 return __cmd_record(argc, argv);
         else if (argc)
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index e23bc74e734f..1f529321607e 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -20,12 +20,15 @@
 
 #include "perf.h"
 
-#include "util/symbol.h"
 #include "util/color.h"
+#include "util/session.h"
+#include "util/symbol.h"
+#include "util/thread.h"
 #include "util/util.h"
 #include <linux/rbtree.h>
 #include "util/parse-options.h"
 #include "util/parse-events.h"
+#include "util/cpumap.h"
 
 #include "util/debug.h"
 
@@ -54,26 +57,30 @@
 
 static int                      fd[MAX_NR_CPUS][MAX_COUNTERS];
 
-static int                      system_wide                     =  0;
+static int                      system_wide                     =      0;
 
-static int                      default_interval                = 100000;
+static int                      default_interval                =      0;
 
-static int                      count_filter                    =  5;
-static int                      print_entries                   = 15;
+static int                      count_filter                    =      5;
+static int                      print_entries;
 
-static int                      target_pid                      = -1;
-static int                      inherit                         =  0;
-static int                      profile_cpu                     = -1;
-static int                      nr_cpus                         =  0;
-static unsigned int             realtime_prio                   =  0;
-static int                      group                           =  0;
+static int                      target_pid                      =     -1;
+static int                      inherit                         =      0;
+static int                      profile_cpu                     =     -1;
+static int                      nr_cpus                         =      0;
+static unsigned int             realtime_prio                   =      0;
+static int                      group                           =      0;
 static unsigned int             page_size;
-static unsigned int             mmap_pages                      = 16;
-static int                      freq                            =  0;
+static unsigned int             mmap_pages                      =     16;
+static int                      freq                            =   1000; /* 1 KHz */
 
-static int                      delay_secs                      =  2;
-static int                      zero;
-static int                      dump_symtab;
+static int                      delay_secs                      =      2;
+static int                      zero                            =      0;
+static int                      dump_symtab                     =      0;
+
+static bool                     hide_kernel_symbols             =  false;
+static bool                     hide_user_symbols               =  false;
+static struct winsize           winsize;
 
 /*
  * Source
@@ -86,87 +93,130 @@ struct source_line {
         struct source_line      *next;
 };
 
-static char                     *sym_filter                     =  NULL;
-struct sym_entry                *sym_filter_entry               =  NULL;
-static int                      sym_pcnt_filter                 =  5;
-static int                      sym_counter                     =  0;
-static int                      display_weighted                = -1;
+static char                     *sym_filter                     =   NULL;
+struct sym_entry                *sym_filter_entry               =   NULL;
+struct sym_entry                *sym_filter_entry_sched         =   NULL;
+static int                      sym_pcnt_filter                 =      5;
+static int                      sym_counter                     =      0;
+static int                      display_weighted                =     -1;
 
 /*
  * Symbols
  */
 
-static u64                      min_ip;
-static u64                      max_ip = -1ll;
+struct sym_entry_source {
+        struct source_line      *source;
+        struct source_line      *lines;
+        struct source_line      **lines_tail;
+        pthread_mutex_t         lock;
+};
 
 struct sym_entry {
         struct rb_node          rb_node;
         struct list_head        node;
-        unsigned long           count[MAX_COUNTERS];
         unsigned long           snap_count;
         double                  weight;
         int                     skip;
-        struct source_line      *source;
-        struct source_line      *lines;
-        struct source_line      **lines_tail;
-        pthread_mutex_t         source_lock;
+        u16                     name_len;
+        u8                      origin;
+        struct map              *map;
+        struct sym_entry_source *src;
+        unsigned long           count[0];
 };
 
 /*
  * Source functions
  */
 
+static inline struct symbol *sym_entry__symbol(struct sym_entry *self)
+{
+       return ((void *)self) + symbol_conf.priv_size;
+}
+
+static void get_term_dimensions(struct winsize *ws)
+{
+        char *s = getenv("LINES");
+
+        if (s != NULL) {
+                ws->ws_row = atoi(s);
+                s = getenv("COLUMNS");
+                if (s != NULL) {
+                        ws->ws_col = atoi(s);
+                        if (ws->ws_row && ws->ws_col)
+                                return;
+                }
+        }
+#ifdef TIOCGWINSZ
+        if (ioctl(1, TIOCGWINSZ, ws) == 0 &&
+            ws->ws_row && ws->ws_col)
+                return;
+#endif
+        ws->ws_row = 25;
+        ws->ws_col = 80;
+}
+
+static void update_print_entries(struct winsize *ws)
+{
+        print_entries = ws->ws_row;
+
+        if (print_entries > 9)
+                print_entries -= 9;
+}
+
+static void sig_winch_handler(int sig __used)
+{
+        get_term_dimensions(&winsize);
+        update_print_entries(&winsize);
+}
+
 static void parse_source(struct sym_entry *syme)
 {
         struct symbol *sym;
-        struct module *module;
-        struct section *section = NULL;
+        struct sym_entry_source *source;
+        struct map *map;
         FILE *file;
         char command[PATH_MAX*2];
-        const char *path = vmlinux_name;
-        u64 start, end, len;
+        const char *path;
+        u64 len;
 
         if (!syme)
                 return;
 
-        if (syme->lines) {
-                pthread_mutex_lock(&syme->source_lock);
-                goto out_assign;
+        if (syme->src == NULL) {
+                syme->src = zalloc(sizeof(*source));
+                if (syme->src == NULL)
+                        return;
+                pthread_mutex_init(&syme->src->lock, NULL);
         }
 
-        sym = (struct symbol *)(syme + 1);
-        module = sym->module;
-
-        if (module)
-                path = module->path;
-        if (!path)
-                return;
-
-        start = sym->obj_start;
-        if (!start)
-                start = sym->start;
+        source = syme->src;
 
-        if (module) {
-                section = module->sections->find_section(module->sections, ".text");
-                if (section)
-                        start -= section->vma;
+        if (source->lines) {
+                pthread_mutex_lock(&source->lock);
+                goto out_assign;
         }
 
-        end = start + sym->end - sym->start + 1;
+        sym = sym_entry__symbol(syme);
+        map = syme->map;
+        path = map->dso->long_name;
+
         len = sym->end - sym->start;
 
-        sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s", start, end, path);
+        sprintf(command,
+                "objdump --start-address=%#0*Lx --stop-address=%#0*Lx -dS %s",
+                BITS_PER_LONG / 4, map__rip_2objdump(map, sym->start),
+                BITS_PER_LONG / 4, map__rip_2objdump(map, sym->end), path);
 
         file = popen(command, "r");
         if (!file)
                 return;
 
-        pthread_mutex_lock(&syme->source_lock);
-        syme->lines_tail = &syme->lines;
+        pthread_mutex_lock(&source->lock);
+        source->lines_tail = &source->lines;
         while (!feof(file)) {
                 struct source_line *src;
                 size_t dummy = 0;
-                char *c;
+                char *c, *sep;
 
                 src = malloc(sizeof(struct source_line));
                 assert(src != NULL);
@@ -182,24 +232,19 @@ static void parse_source(struct sym_entry *syme)
                         *c = 0;
 
                 src->next = NULL;
-                *syme->lines_tail = src;
-                syme->lines_tail = &src->next;
-
-                if (strlen(src->line)>8 && src->line[8] == ':') {
-                        src->eip = strtoull(src->line, NULL, 16);
-                        if (section)
-                                src->eip += section->vma;
-                }
-                if (strlen(src->line)>8 && src->line[16] == ':') {
-                        src->eip = strtoull(src->line, NULL, 16);
-                        if (section)
-                                src->eip += section->vma;
-                }
+                *source->lines_tail = src;
+                source->lines_tail = &src->next;
+
+                src->eip = strtoull(src->line, &sep, 16);
+                if (*sep == ':')
+                        src->eip = map__objdump_2ip(map, src->eip);
+                else /* this line has no ip info (e.g. source line) */
+                        src->eip = 0;
         }
         pclose(file);
 out_assign:
         sym_filter_entry = syme;
-        pthread_mutex_unlock(&syme->source_lock);
+        pthread_mutex_unlock(&source->lock);
 }
 
 static void __zero_source_counters(struct sym_entry *syme)
@@ -207,7 +252,7 @@ static void __zero_source_counters(struct sym_entry *syme)
         int i;
         struct source_line *line;
 
-        line = syme->lines;
+        line = syme->src->lines;
         while (line) {
                 for (i = 0; i < nr_counters; i++)
                         line->count[i] = 0;
@@ -222,13 +267,16 @@ static void record_precise_ip(struct sym_entry *syme, int counter, u64 ip)
         if (syme != sym_filter_entry)
                 return;
 
-        if (pthread_mutex_trylock(&syme->source_lock))
+        if (pthread_mutex_trylock(&syme->src->lock))
                 return;
 
-        if (!syme->source)
+        if (syme->src == NULL || syme->src->source == NULL)
                 goto out_unlock;
 
-        for (line = syme->lines; line; line = line->next) {
+        for (line = syme->src->lines; line; line = line->next) {
+                /* skip lines without IP info */
+                if (line->eip == 0)
+                        continue;
                 if (line->eip == ip) {
                         line->count[counter]++;
                         break;
@@ -237,32 +285,28 @@ static void record_precise_ip(struct sym_entry *syme, int counter, u64 ip)
                         break;
         }
 out_unlock:
-        pthread_mutex_unlock(&syme->source_lock);
+        pthread_mutex_unlock(&syme->src->lock);
 }
 
+#define PATTERN_LEN             (BITS_PER_LONG / 4 + 2)
+
 static void lookup_sym_source(struct sym_entry *syme)
 {
-        struct symbol *symbol = (struct symbol *)(syme + 1);
+        struct symbol *symbol = sym_entry__symbol(syme);
         struct source_line *line;
-        char pattern[PATH_MAX];
-        char *idx;
-
-        sprintf(pattern, "<%s>:", symbol->name);
+        char pattern[PATTERN_LEN + 1];
 
-        if (symbol->module) {
-                idx = strstr(pattern, "\t");
-                if (idx)
-                        *idx = 0;
-        }
+        sprintf(pattern, "%0*Lx <", BITS_PER_LONG / 4,
+                map__rip_2objdump(syme->map, symbol->start));
 
-        pthread_mutex_lock(&syme->source_lock);
-        for (line = syme->lines; line; line = line->next) {
-                if (strstr(line->line, pattern)) {
-                        syme->source = line;
+        pthread_mutex_lock(&syme->src->lock);
+        for (line = syme->src->lines; line; line = line->next) {
+                if (memcmp(line->line, pattern, PATTERN_LEN) == 0) {
+                        syme->src->source = line;
                         break;
                 }
         }
-        pthread_mutex_unlock(&syme->source_lock);
+        pthread_mutex_unlock(&syme->src->lock);
 }
 
 static void show_lines(struct source_line *queue, int count, int total)
@@ -292,24 +336,24 @@ static void show_details(struct sym_entry *syme)
         if (!syme)
                 return;
 
-        if (!syme->source)
+        if (!syme->src->source)
                 lookup_sym_source(syme);
 
-        if (!syme->source)
+        if (!syme->src->source)
                 return;
 
-        symbol = (struct symbol *)(syme + 1);
+        symbol = sym_entry__symbol(syme);
         printf("Showing %s for %s\n", event_name(sym_counter), symbol->name);
         printf("  Events  Pcnt (>=%d%%)\n", sym_pcnt_filter);
 
-        pthread_mutex_lock(&syme->source_lock);
-        line = syme->source;
+        pthread_mutex_lock(&syme->src->lock);
+        line = syme->src->source;
         while (line) {
                 total += line->count[sym_counter];
                 line = line->next;
         }
 
-        line = syme->source;
+        line = syme->src->source;
         while (line) {
                 float pcnt = 0.0;
 
@@ -334,13 +378,13 @@ static void show_details(struct sym_entry *syme)
                 line->count[sym_counter] = zero ? 0 : line->count[sym_counter] * 7 / 8;
                 line = line->next;
         }
-        pthread_mutex_unlock(&syme->source_lock);
+        pthread_mutex_unlock(&syme->src->lock);
         if (more)
                 printf("%d lines not displayed, maybe increase display entries [e]\n", more);
 }
 
 /*
- * Symbols will be added here in record_ip and will get out
+ * Symbols will be added here in event__process_sample and will get out
  * after decayed.
  */
 static LIST_HEAD(active_symbols);
@@ -411,6 +455,8 @@ static void print_sym_table(void)
         struct sym_entry *syme, *n;
         struct rb_root tmp = RB_ROOT;
         struct rb_node *nd;
+        int sym_width = 0, dso_width = 0, dso_short_width = 0;
+        const int win_width = winsize.ws_col - 1;
 
         samples = userspace_samples = 0;
 
@@ -422,6 +468,14 @@ static void print_sym_table(void)
         list_for_each_entry_safe_from(syme, n, &active_symbols, node) {
                 syme->snap_count = syme->count[snap];
                 if (syme->snap_count != 0) {
+
+                        if ((hide_user_symbols &&
+                             syme->origin == PERF_RECORD_MISC_USER) ||
+                            (hide_kernel_symbols &&
+                             syme->origin == PERF_RECORD_MISC_KERNEL)) {
+                                list_remove_active_sym(syme);
+                                continue;
+                        }
                         syme->weight = sym_weight(syme);
                         rb_insert_active_sym(&tmp, syme);
                         sum_ksamples += syme->snap_count;
@@ -434,8 +488,7 @@ static void print_sym_table(void)
 
         puts(CONSOLE_CLEAR);
 
-        printf(
-"------------------------------------------------------------------------------\n");
+        printf("%-*.*s\n", win_width, win_width, graph_dotted_line);
         printf( "   PerfTop:%8.0f irqs/sec  kernel:%4.1f%% [",
                 samples_per_sec,
                 100.0 - (100.0*((samples_per_sec-ksamples_per_sec)/samples_per_sec)));
@@ -473,33 +526,62 @@ static void print_sym_table(void)
                         printf(", %d CPUs)\n", nr_cpus);
         }
 
-        printf("------------------------------------------------------------------------------\n\n");
+        printf("%-*.*s\n", win_width, win_width, graph_dotted_line);
 
         if (sym_filter_entry) {
                 show_details(sym_filter_entry);
                 return;
         }
 
+        /*
+         * Find the longest symbol name that will be displayed
+         */
+        for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) {
+                syme = rb_entry(nd, struct sym_entry, rb_node);
+                if (++printed > print_entries ||
+                    (int)syme->snap_count < count_filter)
+                        continue;
+
+                if (syme->map->dso->long_name_len > dso_width)
+                        dso_width = syme->map->dso->long_name_len;
+
+                if (syme->map->dso->short_name_len > dso_short_width)
+                        dso_short_width = syme->map->dso->short_name_len;
+
+                if (syme->name_len > sym_width)
+                        sym_width = syme->name_len;
+        }
+
+        printed = 0;
+
+        if (sym_width + dso_width > winsize.ws_col - 29) {
+                dso_width = dso_short_width;
+                if (sym_width + dso_width > winsize.ws_col - 29)
+                        sym_width = winsize.ws_col - dso_width - 29;
+        }
+        putchar('\n');
         if (nr_counters == 1)
-                printf("             samples    pcnt");
+                printf("             samples  pcnt");
         else
-                printf("   weight    samples    pcnt");
+                printf("   weight    samples  pcnt");
 
         if (verbose)
                 printf("         RIP       ");
-        printf("   kernel function\n");
-        printf("   %s    _______   _____",
+        printf(" %-*.*s DSO\n", sym_width, sym_width, "function");
+        printf("   %s    _______ _____",
                nr_counters == 1 ? "      " : "______");
         if (verbose)
-                printf("   ________________");
-        printf("   _______________\n\n");
+                printf(" ________________");
+        printf(" %-*.*s", sym_width, sym_width, graph_line);
+        printf(" %-*.*s", dso_width, dso_width, graph_line);
+        puts("\n");
 
         for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) {
                 struct symbol *sym;
                 double pcnt;
 
                 syme = rb_entry(nd, struct sym_entry, rb_node);
-                sym = (struct symbol *)(syme + 1);
+                sym = sym_entry__symbol(syme);
 
                 if (++printed > print_entries || (int)syme->snap_count < count_filter)
                         continue;
@@ -508,17 +590,18 @@ static void print_sym_table(void)
                                          sum_ksamples));
 
                 if (nr_counters == 1 || !display_weighted)
-                        printf("%20.2f - ", syme->weight);
+                        printf("%20.2f ", syme->weight);
                 else
-                        printf("%9.1f %10ld - ", syme->weight, syme->snap_count);
+                        printf("%9.1f %10ld ", syme->weight, syme->snap_count);
 
                 percent_color_fprintf(stdout, "%4.1f%%", pcnt);
                 if (verbose)
-                        printf(" - %016llx", sym->start);
-                printf(" : %s", sym->name);
-                if (sym->module)
-                        printf("\t[%s]", sym->module->name);
-                printf("\n");
+                        printf(" %016llx", sym->start);
+                printf(" %-*.*s", sym_width, sym_width, sym->name);
+                printf(" %-*.*s\n", dso_width, dso_width,
+                       dso_width >= syme->map->dso->long_name_len ?
+                                        syme->map->dso->long_name :
+                                        syme->map->dso->short_name);
         }
 }
 
@@ -565,10 +648,10 @@ static void prompt_symbol(struct sym_entry **target, const char *msg)
 
         /* zero counters of active symbol */
         if (syme) {
-                pthread_mutex_lock(&syme->source_lock);
+                pthread_mutex_lock(&syme->src->lock);
                 __zero_source_counters(syme);
                 *target = NULL;
-                pthread_mutex_unlock(&syme->source_lock);
+                pthread_mutex_unlock(&syme->src->lock);
         }
 
         fprintf(stdout, "\n%s: ", msg);
@@ -584,7 +667,7 @@ static void prompt_symbol(struct sym_entry **target, const char *msg)
         pthread_mutex_unlock(&active_symbols_lock);
 
         list_for_each_entry_safe_from(syme, n, &active_symbols, node) {
-                struct symbol *sym = (struct symbol *)(syme + 1);
+                struct symbol *sym = sym_entry__symbol(syme);
 
                 if (!strcmp(buf, sym->name)) {
                         found = syme;
@@ -593,7 +676,7 @@ static void prompt_symbol(struct sym_entry **target, const char *msg)
         }
 
         if (!found) {
-                fprintf(stderr, "Sorry, %s is not active.\n", sym_filter);
+                fprintf(stderr, "Sorry, %s is not active.\n", buf);
                 sleep(1);
                 return;
         } else
@@ -608,7 +691,7 @@ static void print_mapped_keys(void)
         char *name = NULL;
 
         if (sym_filter_entry) {
-                struct symbol *sym = (struct symbol *)(sym_filter_entry+1);
+                struct symbol *sym = sym_entry__symbol(sym_filter_entry);
                 name = sym->name;
         }
 
@@ -621,15 +704,19 @@ static void print_mapped_keys(void)
 
         fprintf(stdout, "\t[f]     profile display filter (count).    \t(%d)\n", count_filter);
 
-        if (vmlinux_name) {
-                fprintf(stdout, "\t[F]     annotate display filter (percent). \t(%d%%)\n", sym_pcnt_filter);
-                fprintf(stdout, "\t[s]     annotate symbol.                   \t(%s)\n", name?: "NULL");
-                fprintf(stdout, "\t[S]     stop annotation.\n");
-        }
+        fprintf(stdout, "\t[F]     annotate display filter (percent). \t(%d%%)\n", sym_pcnt_filter);
+        fprintf(stdout, "\t[s]     annotate symbol.                   \t(%s)\n", name?: "NULL");
+        fprintf(stdout, "\t[S]     stop annotation.\n");
 
         if (nr_counters > 1)
                 fprintf(stdout, "\t[w]     toggle display weighted/count[E]r. \t(%d)\n", display_weighted ? 1 : 0);
 
+        fprintf(stdout,
+                "\t[K]     hide kernel_symbols symbols.     \t(%s)\n",
+                hide_kernel_symbols ? "yes" : "no");
+        fprintf(stdout,
+                "\t[U]     hide user symbols.               \t(%s)\n",
+                hide_user_symbols ? "yes" : "no");
         fprintf(stdout, "\t[z]     toggle sample zeroing.             \t(%d)\n", zero ? 1 : 0);
         fprintf(stdout, "\t[qQ]    quit.\n");
 }
@@ -643,14 +730,15 @@ static int key_mapped(int c)
                 case 'z':
                 case 'q':
                 case 'Q':
+                case 'K':
+                case 'U':
+                case 'F':
+                case 's':
+                case 'S':
                         return 1;
                 case 'E':
                 case 'w':
                         return nr_counters > 1 ? 1 : 0;
-                case 'F':
-                case 's':
-                case 'S':
-                        return vmlinux_name ? 1 : 0;
                 default:
                         break;
         }
@@ -691,6 +779,11 @@ static void handle_keypress(int c)
                         break;
                 case 'e':
                         prompt_integer(&print_entries, "Enter display entries (lines)");
+                        if (print_entries == 0) {
+                                sig_winch_handler(SIGWINCH);
+                                signal(SIGWINCH, sig_winch_handler);
+                        } else
+                                signal(SIGWINCH, SIG_DFL);
                         break;
                 case 'E':
                         if (nr_counters > 1) {
@@ -715,9 +808,14 @@ static void handle_keypress(int c)
                 case 'F':
                         prompt_percent(&sym_pcnt_filter, "Enter details display event filter (percent)");
                         break;
+                case 'K':
+                        hide_kernel_symbols = !hide_kernel_symbols;
+                        break;
                 case 'q':
                 case 'Q':
                         printf("exiting.\n");
+                        if (dump_symtab)
+                                dsos__fprintf(stderr);
                         exit(0);
                 case 's':
                         prompt_symbol(&sym_filter_entry, "Enter details symbol");
@@ -728,12 +826,15 @@ static void handle_keypress(int c)
                         else {
                                 struct sym_entry *syme = sym_filter_entry;
 
-                                pthread_mutex_lock(&syme->source_lock);
+                                pthread_mutex_lock(&syme->src->lock);
                                 sym_filter_entry = NULL;
                                 __zero_source_counters(syme);
-                                pthread_mutex_unlock(&syme->source_lock);
+                                pthread_mutex_unlock(&syme->src->lock);
                         }
                         break;
+                case 'U':
+                        hide_user_symbols = !hide_user_symbols;
+                        break;
                 case 'w':
                         display_weighted = ~display_weighted;
                         break;
@@ -790,7 +891,7 @@ static const char *skip_symbols[] = {
         NULL
 };
 
-static int symbol_filter(struct dso *self, struct symbol *sym)
+static int symbol_filter(struct map *map, struct symbol *sym)
 {
         struct sym_entry *syme;
         const char *name = sym->name;
@@ -812,10 +913,15 @@ static int symbol_filter(struct dso *self, struct symbol *sym)
             strstr(name, "_text_end"))
                 return 1;
 
-        syme = dso__sym_priv(self, sym);
-        pthread_mutex_init(&syme->source_lock, NULL);
-        if (!sym_filter_entry && sym_filter && !strcmp(name, sym_filter))
-                sym_filter_entry = syme;
+        syme = symbol__priv(sym);
+        syme->map = map;
+        syme->src = NULL;
+
+        if (!sym_filter_entry && sym_filter && !strcmp(name, sym_filter)) {
+                /* schedule initial sym_filter_entry setup */
+                sym_filter_entry_sched = syme;
+                sym_filter = NULL;
+        }
 
         for (i = 0; skip_symbols[i]; i++) {
                 if (!strcmp(skip_symbols[i], name)) {
@@ -824,75 +930,99 @@ static int symbol_filter(struct dso *self, struct symbol *sym)
                 }
         }
 
+        if (!syme->skip)
+                syme->name_len = strlen(sym->name);
+
         return 0;
 }
 
-static int parse_symbols(void)
+static void event__process_sample(const event_t *self,
+                                 struct perf_session *session, int counter)
 {
-        struct rb_node *node;
-        struct symbol  *sym;
-        int use_modules = vmlinux_name ? 1 : 0;
-
-        kernel_dso = dso__new("[kernel]", sizeof(struct sym_entry));
-        if (kernel_dso == NULL)
-                return -1;
-
-        if (dso__load_kernel(kernel_dso, vmlinux_name, symbol_filter, verbose, use_modules) <= 0)
-                goto out_delete_dso;
+        u64 ip = self->ip.ip;
+        struct sym_entry *syme;
+        struct addr_location al;
+        u8 origin = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
-        node = rb_first(&kernel_dso->syms);
-        sym = rb_entry(node, struct symbol, rb_node);
-        min_ip = sym->start;
+        ++samples;
 
-        node = rb_last(&kernel_dso->syms);
-        sym = rb_entry(node, struct symbol, rb_node);
-        max_ip = sym->end;
+        switch (origin) {
+        case PERF_RECORD_MISC_USER:
+                ++userspace_samples;
+                if (hide_user_symbols)
+                        return;
+                break;
+        case PERF_RECORD_MISC_KERNEL:
+                if (hide_kernel_symbols)
+                        return;
+                break;
+        default:
+                return;
+        }
 
-        if (dump_symtab)
-                dso__fprintf(kernel_dso, stderr);
+        if (event__preprocess_sample(self, session, &al, symbol_filter) < 0 ||
+            al.filtered)
+                return;
 
-        return 0;
+        if (al.sym == NULL) {
+                /*
+                 * As we do lazy loading of symtabs we only will know if the
+                 * specified vmlinux file is invalid when we actually have a
+                 * hit in kernel space and then try to load it. So if we get
+                 * here and there are _no_ symbols in the DSO backing the
+                 * kernel map, bail out.
+                 *
+                 * We may never get here, for instance, if we use -K/
+                 * --hide-kernel-symbols, even if the user specifies an
+                 * invalid --vmlinux ;-)
+                 */
+                if (al.map == session->vmlinux_maps[MAP__FUNCTION] &&
+                    RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) {
+                        pr_err("The %s file can't be used\n",
+                               symbol_conf.vmlinux_name);
+                        exit(1);
+                }
 
-out_delete_dso:
-        dso__delete(kernel_dso);
-        kernel_dso = NULL;
-        return -1;
-}
+                return;
+        }
 
-/*
- * Binary search in the histogram table and record the hit:
- */
-static void record_ip(u64 ip, int counter)
-{
-        struct symbol *sym = dso__find_symbol(kernel_dso, ip);
-
-        if (sym != NULL) {
-                struct sym_entry *syme = dso__sym_priv(kernel_dso, sym);
-
-                if (!syme->skip) {
-                        syme->count[counter]++;
-                        record_precise_ip(syme, counter, ip);
-                        pthread_mutex_lock(&active_symbols_lock);
-                        if (list_empty(&syme->node) || !syme->node.next)
-                                __list_insert_active_sym(syme);
-                        pthread_mutex_unlock(&active_symbols_lock);
-                        return;
-                }
+        /* let's see, whether we need to install initial sym_filter_entry */
+        if (sym_filter_entry_sched) {
+                sym_filter_entry = sym_filter_entry_sched;
+                sym_filter_entry_sched = NULL;
+                parse_source(sym_filter_entry);
         }
 
-        samples--;
+        syme = symbol__priv(al.sym);
+        if (!syme->skip) {
+                syme->count[counter]++;
+                syme->origin = origin;
+                record_precise_ip(syme, counter, ip);
+                pthread_mutex_lock(&active_symbols_lock);
+                if (list_empty(&syme->node) || !syme->node.next)
+                        __list_insert_active_sym(syme);
+                pthread_mutex_unlock(&active_symbols_lock);
+        }
 }
 
-static void process_event(u64 ip, int counter, int user)
+static int event__process(event_t *event, struct perf_session *session)
 {
-        samples++;
-
-        if (user) {
-                userspace_samples++;
-                return;
+        switch (event->header.type) {
+        case PERF_RECORD_COMM:
+                event__process_comm(event, session);
+                break;
+        case PERF_RECORD_MMAP:
+                event__process_mmap(event, session);
+                break;
+        case PERF_RECORD_FORK:
+        case PERF_RECORD_EXIT:
+                event__process_task(event, session);
+                break;
+        default:
+                break;
         }
 
-        record_ip(ip, counter);
+        return 0;
 }
 
 struct mmap_data {
@@ -913,17 +1043,14 @@ static unsigned int mmap_read_head(struct mmap_data *md)
         return head;
 }
 
-struct timeval last_read, this_read;
-
-static void mmap_read_counter(struct mmap_data *md)
+static void perf_session__mmap_read_counter(struct perf_session *self,
+                                            struct mmap_data *md)
 {
         unsigned int head = mmap_read_head(md);
         unsigned int old = md->prev;
         unsigned char *data = md->base + page_size;
         int diff;
 
-        gettimeofday(&this_read, NULL);
-
         /*
          * If we're further behind than half the buffer, there's a chance
          * the writer will bite our tail and mess up the samples under us.
@@ -934,14 +1061,7 @@ static void mmap_read_counter(struct mmap_data *md)
          */
         diff = head - old;
         if (diff > md->mask / 2 || diff < 0) {
-                struct timeval iv;
-                unsigned long msecs;
-
-                timersub(&this_read, &last_read, &iv);
-                msecs = iv.tv_sec*1000 + iv.tv_usec/1000;
-
-                fprintf(stderr, "WARNING: failed to keep up with mmap data."
-                                "  Last read %lu msecs ago.\n", msecs);
+                fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");
 
                 /*
                  * head points to a known good entry, start there.
@@ -949,8 +1069,6 @@ static void mmap_read_counter(struct mmap_data *md)
                 old = head;
         }
 
-        last_read = this_read;
-
         for (; old != head;) {
                 event_t *event = (event_t *)&data[old & md->mask];
 
@@ -978,13 +1096,11 @@ static void mmap_read_counter(struct mmap_data *md)
                         event = &event_copy;
                 }
 
+                if (event->header.type == PERF_RECORD_SAMPLE)
+                        event__process_sample(event, self, md->counter);
+                else
+                        event__process(event, self);
                 old += size;
-
-                if (event->header.type == PERF_RECORD_SAMPLE) {
-                        int user =
-        (event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK) == PERF_RECORD_MISC_USER;
-                        process_event(event->ip.ip, md->counter, user);
-                }
         }
 
         md->prev = old;
@@ -993,13 +1109,13 @@ static void mmap_read_counter(struct mmap_data *md)
 static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
 static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
 
-static void mmap_read(void)
+static void perf_session__mmap_read(struct perf_session *self)
 {
         int i, counter;
 
         for (i = 0; i < nr_cpus; i++) {
                 for (counter = 0; counter < nr_counters; counter++)
-                        mmap_read_counter(&mmap_array[i][counter]);
+                        perf_session__mmap_read_counter(self, &mmap_array[i][counter]);
         }
 }
 
@@ -1013,13 +1129,20 @@ static void start_counter(int i, int counter)
 
         cpu = profile_cpu;
         if (target_pid == -1 && profile_cpu == -1)
-                cpu = i;
+                cpu = cpumap[i];
 
         attr = attrs + counter;
 
         attr->sample_type       = PERF_SAMPLE_IP | PERF_SAMPLE_TID;
-        attr->freq              = freq;
+
+        if (freq) {
+                attr->sample_type       |= PERF_SAMPLE_PERIOD;
+                attr->freq              = 1;
+                attr->sample_freq       = freq;
+        }
+
         attr->inherit           = (cpu < 0) && inherit;
+        attr->mmap              = 1;
 
 try_again:
         fd[i][counter] = sys_perf_event_open(attr, target_pid, cpu, group_fd, 0);
@@ -1077,6 +1200,18 @@ static int __cmd_top(void)
         pthread_t thread;
         int i, counter;
         int ret;
+        /*
+         * FIXME: perf_session__new should allow passing a O_MMAP, so that all this
+         * mmap reading, etc is encapsulated in it. Use O_WRONLY for now.
+         */
+        struct perf_session *session = perf_session__new(NULL, O_WRONLY, false);
+        if (session == NULL)
+                return -ENOMEM;
+
+        if (target_pid != -1)
+                event__synthesize_thread(target_pid, event__process, session);
+        else
+                event__synthesize_threads(event__process, session);
 
         for (i = 0; i < nr_cpus; i++) {
                 group_fd = -1;
@@ -1087,7 +1222,7 @@ static int __cmd_top(void)
         /* Wait for a minimal set of events before starting the snapshot */
         poll(event_array, nr_poll, 100);
 
-        mmap_read();
+        perf_session__mmap_read(session);
 
         if (pthread_create(&thread, NULL, display_thread, NULL)) {
                 printf("Could not create display thread.\n");
@@ -1107,7 +1242,7 @@ static int __cmd_top(void)
         while (1) {
                 int hits = samples;
 
-                mmap_read();
+                perf_session__mmap_read(session);
 
                 if (hits == samples)
                         ret = poll(event_array, nr_poll, 100);
@@ -1133,7 +1268,10 @@ static const struct option options[] = {
                             "system-wide collection from all CPUs"),
         OPT_INTEGER('C', "CPU", &profile_cpu,
                     "CPU to profile on"),
-        OPT_STRING('k', "vmlinux", &vmlinux_name, "file", "vmlinux pathname"),
+        OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
+                   "file", "vmlinux pathname"),
+        OPT_BOOLEAN('K', "hide_kernel_symbols", &hide_kernel_symbols,
+                    "hide kernel symbols"),
         OPT_INTEGER('m', "mmap-pages", &mmap_pages,
                     "number of mmap data pages"),
         OPT_INTEGER('r', "realtime", &realtime_prio,
@@ -1149,13 +1287,15 @@ static const struct option options[] = {
         OPT_BOOLEAN('i', "inherit", &inherit,
                     "child tasks inherit counters"),
         OPT_STRING('s', "sym-annotate", &sym_filter, "symbol name",
-                    "symbol to annotate - requires -k option"),
+                    "symbol to annotate"),
         OPT_BOOLEAN('z', "zero", &zero,
                     "zero history across updates"),
         OPT_INTEGER('F', "freq", &freq,
                     "profile at this frequency"),
         OPT_INTEGER('E', "entries", &print_entries,
                     "display this many functions"),
+        OPT_BOOLEAN('U', "hide_user_symbols", &hide_user_symbols,
+                    "hide user symbols"),
         OPT_BOOLEAN('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
         OPT_END()
@@ -1165,19 +1305,12 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
 {
         int counter;
 
-        symbol__init();
-
         page_size = sysconf(_SC_PAGE_SIZE);
 
         argc = parse_options(argc, argv, options, top_usage, 0);
         if (argc)
                 usage_with_options(top_usage, options);
 
-        if (freq) {
-                default_interval = freq;
-                freq = 1;
-        }
-
         /* CPU and PID are mutually exclusive */
         if (target_pid != -1 && profile_cpu != -1) {
                 printf("WARNING: PID switch overriding CPU\n");
@@ -1188,11 +1321,27 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
         if (!nr_counters)
                 nr_counters = 1;
 
+        symbol_conf.priv_size = (sizeof(struct sym_entry) +
+                                 (nr_counters + 1) * sizeof(unsigned long));
+
+        symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
+        if (symbol__init() < 0)
+                return -1;
+
         if (delay_secs < 1)
                 delay_secs = 1;
 
-        parse_symbols();
-        parse_source(sym_filter_entry);
+        /*
+         * User specified count overrides default frequency.
+         */
+        if (default_interval)
+                freq = 0;
+        else if (freq) {
+                default_interval = freq;
+        } else {
+                fprintf(stderr, "frequency and count are zero, aborting\n");
+                exit(EXIT_FAILURE);
+        }
 
         /*
          * Fill in the ones not specifically initialized via -c:
@@ -1204,12 +1353,16 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                 attrs[counter].sample_period = default_interval;
         }
 
-        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
-        assert(nr_cpus <= MAX_NR_CPUS);
-        assert(nr_cpus >= 0);
-
         if (target_pid != -1 || profile_cpu != -1)
                 nr_cpus = 1;
+        else
+                nr_cpus = read_cpu_map();
+
+        get_term_dimensions(&winsize);
+        if (print_entries == 0) {
+                update_print_entries(&winsize);
+                signal(SIGWINCH, sig_winch_handler);
+        }
 
         return __cmd_top();
 }
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 0c5e4f72f2ba..407041d20de0 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -5,259 +5,499 @@
 #include "util/symbol.h"
 #include "util/thread.h"
 #include "util/header.h"
+#include "util/exec_cmd.h"
+#include "util/trace-event.h"
+#include "util/session.h"
 
-#include "util/parse-options.h"
+static char const               *script_name;
+static char const               *generate_script_lang;
 
-#include "perf.h"
-#include "util/debug.h"
+static int default_start_script(const char *script __unused,
+                                int argc __unused,
+                                const char **argv __unused)
+{
+        return 0;
+}
 
-#include "util/trace-event.h"
+static int default_stop_script(void)
+{
+        return 0;
+}
+
+static int default_generate_script(const char *outfile __unused)
+{
+        return 0;
+}
+
+static struct scripting_ops default_scripting_ops = {
+        .start_script           = default_start_script,
+        .stop_script            = default_stop_script,
+        .process_event          = print_event,
+        .generate_script        = default_generate_script,
+};
+
+static struct scripting_ops     *scripting_ops;
+
+static void setup_scripting(void)
+{
+        /* make sure PERF_EXEC_PATH is set for scripts */
+        perf_set_argv_exec_path(perf_exec_path());
+
+        setup_perl_scripting();
+        setup_python_scripting();
 
-static char             const *input_name = "perf.data";
-static int              input;
-static unsigned long    page_size;
-static unsigned long    mmap_window = 32;
+        scripting_ops = &default_scripting_ops;
+}
+
+static int cleanup_scripting(void)
+{
+        return scripting_ops->stop_script();
+}
 
-static unsigned long    total = 0;
-static unsigned long    total_comm = 0;
+#include "util/parse-options.h"
 
-static struct rb_root   threads;
-static struct thread    *last_match;
+#include "perf.h"
+#include "util/debug.h"
 
-static struct perf_header *header;
-static u64              sample_type;
+#include "util/trace-event.h"
+#include "util/exec_cmd.h"
 
+static char const               *input_name = "perf.data";
 
-static int
-process_comm_event(event_t *event, unsigned long offset, unsigned long head)
+static int process_sample_event(event_t *event, struct perf_session *session)
 {
+        struct sample_data data;
         struct thread *thread;
 
-        thread = threads__findnew(event->comm.pid, &threads, &last_match);
+        memset(&data, 0, sizeof(data));
+        data.time = -1;
+        data.cpu = -1;
+        data.period = 1;
 
-        dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->comm.comm, event->comm.pid);
+        event__parse_sample(event, session->sample_type, &data);
 
-        if (thread == NULL ||
-            thread__set_comm(thread, event->comm.comm)) {
-                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
+        dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
+                    data.pid, data.tid, data.ip, data.period);
+
+        thread = perf_session__findnew(session, event->ip.pid);
+        if (thread == NULL) {
+                pr_debug("problem processing %d event, skipping it.\n",
+                         event->header.type);
                 return -1;
         }
-        total_comm++;
 
+        if (session->sample_type & PERF_SAMPLE_RAW) {
+                /*
+                 * FIXME: better resolve from pid from the struct trace_entry
+                 * field, although it should be the same than this perf
+                 * event pid
+                 */
+                scripting_ops->process_event(data.cpu, data.raw_data,
+                                             data.raw_size,
+                                             data.time, thread->comm);
+        }
+
+        session->events_stats.total += data.period;
         return 0;
 }
 
-static int
-process_sample_event(event_t *event, unsigned long offset, unsigned long head)
+static struct perf_event_ops event_ops = {
+        .sample = process_sample_event,
+        .comm   = event__process_comm,
+};
+
+static int __cmd_trace(struct perf_session *session)
 {
-        char level;
-        int show = 0;
-        struct dso *dso = NULL;
-        struct thread *thread;
-        u64 ip = event->ip.ip;
-        u64 timestamp = -1;
-        u32 cpu = -1;
-        u64 period = 1;
-        void *more_data = event->ip.__more_data;
-        int cpumode;
-
-        thread = threads__findnew(event->ip.pid, &threads, &last_match);
-
-        if (sample_type & PERF_SAMPLE_TIME) {
-                timestamp = *(u64 *)more_data;
-                more_data += sizeof(u64);
-        }
+        return perf_session__process_events(session, &event_ops);
+}
 
-        if (sample_type & PERF_SAMPLE_CPU) {
-                cpu = *(u32 *)more_data;
-                more_data += sizeof(u32);
-                more_data += sizeof(u32); /* reserved */
-        }
+struct script_spec {
+        struct list_head        node;
+        struct scripting_ops    *ops;
+        char                    spec[0];
+};
+
+LIST_HEAD(script_specs);
+
+static struct script_spec *script_spec__new(const char *spec,
+                                            struct scripting_ops *ops)
+{
+        struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);
 
-        if (sample_type & PERF_SAMPLE_PERIOD) {
-                period = *(u64 *)more_data;
-                more_data += sizeof(u64);
+        if (s != NULL) {
+                strcpy(s->spec, spec);
+                s->ops = ops;
         }
 
-        dump_printf("%p [%p]: PERF_RECORD_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->header.misc,
-                event->ip.pid, event->ip.tid,
-                (void *)(long)ip,
-                (long long)period);
+        return s;
+}
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+static void script_spec__delete(struct script_spec *s)
+{
+        free(s->spec);
+        free(s);
+}
 
-        if (thread == NULL) {
-                eprintf("problem processing %d event, skipping it.\n",
-                        event->header.type);
-                return -1;
-        }
+static void script_spec__add(struct script_spec *s)
+{
+        list_add_tail(&s->node, &script_specs);
+}
+
+static struct script_spec *script_spec__find(const char *spec)
+{
+        struct script_spec *s;
 
-        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        list_for_each_entry(s, &script_specs, node)
+                if (strcasecmp(s->spec, spec) == 0)
+                        return s;
+        return NULL;
+}
 
-        if (cpumode == PERF_RECORD_MISC_KERNEL) {
-                show = SHOW_KERNEL;
-                level = 'k';
+static struct script_spec *script_spec__findnew(const char *spec,
+                                                struct scripting_ops *ops)
+{
+        struct script_spec *s = script_spec__find(spec);
 
-                dso = kernel_dso;
+        if (s)
+                return s;
 
-                dump_printf(" ...... dso: %s\n", dso->name);
+        s = script_spec__new(spec, ops);
+        if (!s)
+                goto out_delete_spec;
 
-        } else if (cpumode == PERF_RECORD_MISC_USER) {
+        script_spec__add(s);
 
-                show = SHOW_USER;
-                level = '.';
+        return s;
 
-        } else {
-                show = SHOW_HV;
-                level = 'H';
+out_delete_spec:
+        script_spec__delete(s);
 
-                dso = hypervisor_dso;
+        return NULL;
+}
 
-                dump_printf(" ...... dso: [hypervisor]\n");
-        }
+int script_spec_register(const char *spec, struct scripting_ops *ops)
+{
+        struct script_spec *s;
 
-        if (sample_type & PERF_SAMPLE_RAW) {
-                struct {
-                        u32 size;
-                        char data[0];
-                } *raw = more_data;
+        s = script_spec__find(spec);
+        if (s)
+                return -1;
 
-                /*
-                 * FIXME: better resolve from pid from the struct trace_entry
-                 * field, although it should be the same than this perf
-                 * event pid
-                 */
-                print_event(cpu, raw->data, raw->size, timestamp, thread->comm);
-        }
-        total += period;
+        s = script_spec__findnew(spec, ops);
+        if (!s)
+                return -1;
 
         return 0;
 }
 
-static int
-process_event(event_t *event, unsigned long offset, unsigned long head)
+static struct scripting_ops *script_spec__lookup(const char *spec)
 {
-        trace_event(event);
+        struct script_spec *s = script_spec__find(spec);
+        if (!s)
+                return NULL;
 
-        switch (event->header.type) {
-        case PERF_RECORD_MMAP ... PERF_RECORD_LOST:
-                return 0;
+        return s->ops;
+}
 
-        case PERF_RECORD_COMM:
-                return process_comm_event(event, offset, head);
+static void list_available_languages(void)
+{
+        struct script_spec *s;
 
-        case PERF_RECORD_EXIT ... PERF_RECORD_READ:
-                return 0;
+        fprintf(stderr, "\n");
+        fprintf(stderr, "Scripting language extensions (used in "
+                "perf trace -s [spec:]script.[spec]):\n\n");
 
-        case PERF_RECORD_SAMPLE:
-                return process_sample_event(event, offset, head);
+        list_for_each_entry(s, &script_specs, node)
+                fprintf(stderr, "  %-42s [%s]\n", s->spec, s->ops->name);
 
-        case PERF_RECORD_MAX:
-        default:
-                return -1;
+        fprintf(stderr, "\n");
+}
+
+static int parse_scriptname(const struct option *opt __used,
+                            const char *str, int unset __used)
+{
+        char spec[PATH_MAX];
+        const char *script, *ext;
+        int len;
+
+        if (strcmp(str, "lang") == 0) {
+                list_available_languages();
+                exit(0);
+        }
+
+        script = strchr(str, ':');
+        if (script) {
+                len = script - str;
+                if (len >= PATH_MAX) {
+                        fprintf(stderr, "invalid language specifier");
+                        return -1;
+                }
+                strncpy(spec, str, len);
+                spec[len] = '\0';
+                scripting_ops = script_spec__lookup(spec);
+                if (!scripting_ops) {
+                        fprintf(stderr, "invalid language specifier");
+                        return -1;
+                }
+                script++;
+        } else {
+                script = str;
+                ext = strchr(script, '.');
+                if (!ext) {
+                        fprintf(stderr, "invalid script extension");
+                        return -1;
+                }
+                scripting_ops = script_spec__lookup(++ext);
+                if (!scripting_ops) {
+                        fprintf(stderr, "invalid script extension");
+                        return -1;
+                }
         }
 
+        script_name = strdup(script);
+
         return 0;
 }
 
-static int __cmd_trace(void)
+#define for_each_lang(scripts_dir, lang_dirent, lang_next)              \
+        while (!readdir_r(scripts_dir, &lang_dirent, &lang_next) &&     \
+               lang_next)                                               \
+                if (lang_dirent.d_type == DT_DIR &&                     \
+                    (strcmp(lang_dirent.d_name, ".")) &&                \
+                    (strcmp(lang_dirent.d_name, "..")))
+
+#define for_each_script(lang_dir, script_dirent, script_next)           \
+        while (!readdir_r(lang_dir, &script_dirent, &script_next) &&    \
+               script_next)                                             \
+                if (script_dirent.d_type != DT_DIR)
+
+
+#define RECORD_SUFFIX                   "-record"
+#define REPORT_SUFFIX                   "-report"
+
+struct script_desc {
+        struct list_head        node;
+        char                    *name;
+        char                    *half_liner;
+        char                    *args;
+};
+
+LIST_HEAD(script_descs);
+
+static struct script_desc *script_desc__new(const char *name)
 {
-        int ret, rc = EXIT_FAILURE;
-        unsigned long offset = 0;
-        unsigned long head = 0;
-        struct stat perf_stat;
-        event_t *event;
-        uint32_t size;
-        char *buf;
-
-        trace_report();
-        register_idle_thread(&threads, &last_match);
-
-        input = open(input_name, O_RDONLY);
-        if (input < 0) {
-                perror("failed to open file");
-                exit(-1);
-        }
+        struct script_desc *s = zalloc(sizeof(*s));
 
-        ret = fstat(input, &perf_stat);
-        if (ret < 0) {
-                perror("failed to stat file");
-                exit(-1);
-        }
+        if (s != NULL)
+                s->name = strdup(name);
 
-        if (!perf_stat.st_size) {
-                fprintf(stderr, "zero-sized file, nothing to do!\n");
-                exit(0);
-        }
-        header = perf_header__read(input);
-        head = header->data_offset;
-        sample_type = perf_header__sample_type(header);
+        return s;
+}
+
+static void script_desc__delete(struct script_desc *s)
+{
+        free(s->name);
+        free(s);
+}
+
+static void script_desc__add(struct script_desc *s)
+{
+        list_add_tail(&s->node, &script_descs);
+}
+
+static struct script_desc *script_desc__find(const char *name)
+{
+        struct script_desc *s;
+
+        list_for_each_entry(s, &script_descs, node)
+                if (strcasecmp(s->name, name) == 0)
+                        return s;
+        return NULL;
+}
+
+static struct script_desc *script_desc__findnew(const char *name)
+{
+        struct script_desc *s = script_desc__find(name);
+
+        if (s)
+                return s;
+
+        s = script_desc__new(name);
+        if (!s)
+                goto out_delete_desc;
+
+        script_desc__add(s);
+
+        return s;
 
-        if (!(sample_type & PERF_SAMPLE_RAW))
-                die("No trace sample to read. Did you call perf record "
-                    "without -R?");
+out_delete_desc:
+        script_desc__delete(s);
 
-        if (load_kernel() < 0) {
-                perror("failed to load kernel symbols");
-                return EXIT_FAILURE;
+        return NULL;
+}
+
+static char *ends_with(char *str, const char *suffix)
+{
+        size_t suffix_len = strlen(suffix);
+        char *p = str;
+
+        if (strlen(str) > suffix_len) {
+                p = str + strlen(str) - suffix_len;
+                if (!strncmp(p, suffix, suffix_len))
+                        return p;
         }
 
-remap:
-        buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
-                           MAP_SHARED, input, offset);
-        if (buf == MAP_FAILED) {
-                perror("failed to mmap file");
-                exit(-1);
+        return NULL;
+}
+
+static char *ltrim(char *str)
+{
+        int len = strlen(str);
+
+        while (len && isspace(*str)) {
+                len--;
+                str++;
         }
 
-more:
-        event = (event_t *)(buf + head);
+        return str;
+}
 
-        if (head + event->header.size >= page_size * mmap_window) {
-                unsigned long shift = page_size * (head / page_size);
-                int res;
+static int read_script_info(struct script_desc *desc, const char *filename)
+{
+        char line[BUFSIZ], *p;
+        FILE *fp;
 
-                res = munmap(buf, page_size * mmap_window);
-                assert(res == 0);
+        fp = fopen(filename, "r");
+        if (!fp)
+                return -1;
 
-                offset += shift;
-                head -= shift;
-                goto remap;
+        while (fgets(line, sizeof(line), fp)) {
+                p = ltrim(line);
+                if (strlen(p) == 0)
+                        continue;
+                if (*p != '#')
+                        continue;
+                p++;
+                if (strlen(p) && *p == '!')
+                        continue;
+
+                p = ltrim(p);
+                if (strlen(p) && p[strlen(p) - 1] == '\n')
+                        p[strlen(p) - 1] = '\0';
+
+                if (!strncmp(p, "description:", strlen("description:"))) {
+                        p += strlen("description:");
+                        desc->half_liner = strdup(ltrim(p));
+                        continue;
+                }
+
+                if (!strncmp(p, "args:", strlen("args:"))) {
+                        p += strlen("args:");
+                        desc->args = strdup(ltrim(p));
+                        continue;
+                }
         }
 
-        size = event->header.size;
-
-        if (!size || process_event(event, offset, head) < 0) {
+        fclose(fp);
 
-                /*
-                 * assume we lost track of the stream, check alignment, and
-                 * increment a single u64 in the hope to catch on again 'soon'.
-                 */
+        return 0;
+}
 
-                if (unlikely(head & 7))
-                        head &= ~7ULL;
+static int list_available_scripts(const struct option *opt __used,
+                                  const char *s __used, int unset __used)
+{
+        struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
+        char scripts_path[MAXPATHLEN];
+        DIR *scripts_dir, *lang_dir;
+        char script_path[MAXPATHLEN];
+        char lang_path[MAXPATHLEN];
+        struct script_desc *desc;
+        char first_half[BUFSIZ];
+        char *script_root;
+        char *str;
+
+        snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());
+
+        scripts_dir = opendir(scripts_path);
+        if (!scripts_dir)
+                return -1;
 
-                size = 8;
+        for_each_lang(scripts_dir, lang_dirent, lang_next) {
+                snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
+                         lang_dirent.d_name);
+                lang_dir = opendir(lang_path);
+                if (!lang_dir)
+                        continue;
+
+                for_each_script(lang_dir, script_dirent, script_next) {
+                        script_root = strdup(script_dirent.d_name);
+                        str = ends_with(script_root, REPORT_SUFFIX);
+                        if (str) {
+                                *str = '\0';
+                                desc = script_desc__findnew(script_root);
+                                snprintf(script_path, MAXPATHLEN, "%s/%s",
+                                         lang_path, script_dirent.d_name);
+                                read_script_info(desc, script_path);
+                        }
+                        free(script_root);
+                }
         }
 
-        head += size;
+        fprintf(stdout, "List of available trace scripts:\n");
+        list_for_each_entry(desc, &script_descs, node) {
+                sprintf(first_half, "%s %s", desc->name,
+                        desc->args ? desc->args : "");
+                fprintf(stdout, "  %-36s %s\n", first_half,
+                        desc->half_liner ? desc->half_liner : "");
+        }
 
-        if (offset + head < (unsigned long)perf_stat.st_size)
-                goto more;
+        exit(0);
+}
 
-        rc = EXIT_SUCCESS;
-        close(input);
+static char *get_script_path(const char *script_root, const char *suffix)
+{
+        struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
+        char scripts_path[MAXPATHLEN];
+        char script_path[MAXPATHLEN];
+        DIR *scripts_dir, *lang_dir;
+        char lang_path[MAXPATHLEN];
+        char *str, *__script_root;
+        char *path = NULL;
+
+        snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());
+
+        scripts_dir = opendir(scripts_path);
+        if (!scripts_dir)
+                return NULL;
+
+        for_each_lang(scripts_dir, lang_dirent, lang_next) {
+                snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
+                         lang_dirent.d_name);
+                lang_dir = opendir(lang_path);
+                if (!lang_dir)
+                        continue;
+
+                for_each_script(lang_dir, script_dirent, script_next) {
+                        __script_root = strdup(script_dirent.d_name);
+                        str = ends_with(__script_root, suffix);
+                        if (str) {
+                                *str = '\0';
+                                if (strcmp(__script_root, script_root))
+                                        continue;
+                                snprintf(script_path, MAXPATHLEN, "%s/%s",
+                                         lang_path, script_dirent.d_name);
+                                path = strdup(script_path);
+                                free(__script_root);
+                                break;
+                        }
+                        free(__script_root);
+                }
+        }
 
-        return rc;
+        return path;
 }
 
-static const char * const annotate_usage[] = {
+static const char * const trace_usage[] = {
         "perf trace [<options>] <command>",
         NULL
 };
@@ -267,25 +507,122 @@ static const struct option options[] = {
                     "dump raw trace in ASCII"),
         OPT_BOOLEAN('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
+        OPT_BOOLEAN('L', "Latency", &latency_format,
+                    "show latency attributes (irqs/preemption disabled, etc)"),
+        OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
+                           list_available_scripts),
+        OPT_CALLBACK('s', "script", NULL, "name",
+                     "script file name (lang:script name, script name, or *)",
+                     parse_scriptname),
+        OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
+                   "generate perf-trace.xx script in specified language"),
+        OPT_STRING('i', "input", &input_name, "file",
+                    "input file name"),
+
         OPT_END()
 };
 
 int cmd_trace(int argc, const char **argv, const char *prefix __used)
 {
-        symbol__init();
-        page_size = getpagesize();
+        struct perf_session *session;
+        const char *suffix = NULL;
+        const char **__argv;
+        char *script_path;
+        int i, err;
+
+        if (argc >= 2 && strncmp(argv[1], "rec", strlen("rec")) == 0) {
+                if (argc < 3) {
+                        fprintf(stderr,
+                                "Please specify a record script\n");
+                        return -1;
+                }
+                suffix = RECORD_SUFFIX;
+        }
 
-        argc = parse_options(argc, argv, options, annotate_usage, 0);
-        if (argc) {
-                /*
-                 * Special case: if there's an argument left then assume tha
-                 * it's a symbol filter:
-                 */
-                if (argc > 1)
-                        usage_with_options(annotate_usage, options);
+        if (argc >= 2 && strncmp(argv[1], "rep", strlen("rep")) == 0) {
+                if (argc < 3) {
+                        fprintf(stderr,
+                                "Please specify a report script\n");
+                        return -1;
+                }
+                suffix = REPORT_SUFFIX;
+        }
+
+        if (suffix) {
+                script_path = get_script_path(argv[2], suffix);
+                if (!script_path) {
+                        fprintf(stderr, "script not found\n");
+                        return -1;
+                }
+
+                __argv = malloc((argc + 1) * sizeof(const char *));
+                __argv[0] = "/bin/sh";
+                __argv[1] = script_path;
+                for (i = 3; i < argc; i++)
+                        __argv[i - 1] = argv[i];
+                __argv[argc - 1] = NULL;
+
+                execvp("/bin/sh", (char **)__argv);
+                exit(-1);
+        }
+
+        setup_scripting();
+
+        argc = parse_options(argc, argv, options, trace_usage,
+                             PARSE_OPT_STOP_AT_NON_OPTION);
+
+        if (symbol__init() < 0)
+                return -1;
+        if (!script_name)
+                setup_pager();
+
+        session = perf_session__new(input_name, O_RDONLY, 0);
+        if (session == NULL)
+                return -ENOMEM;
+
+        if (!perf_session__has_traces(session, "record -R"))
+                return -EINVAL;
+
+        if (generate_script_lang) {
+                struct stat perf_stat;
+
+                int input = open(input_name, O_RDONLY);
+                if (input < 0) {
+                        perror("failed to open file");
+                        exit(-1);
+                }
+
+                err = fstat(input, &perf_stat);
+                if (err < 0) {
+                        perror("failed to stat file");
+                        exit(-1);
+                }
+
+                if (!perf_stat.st_size) {
+                        fprintf(stderr, "zero-sized file, nothing to do!\n");
+                        exit(0);
+                }
+
+                scripting_ops = script_spec__lookup(generate_script_lang);
+                if (!scripting_ops) {
+                        fprintf(stderr, "invalid language specifier");
+                        return -1;
+                }
+
+                err = scripting_ops->generate_script("perf-trace");
+                goto out;
+        }
+
+        if (script_name) {
+                err = scripting_ops->start_script(script_name, argc, argv);
+                if (err)
+                        goto out;
         }
 
-        setup_pager();
+        err = __cmd_trace(session);
 
-        return __cmd_trace();
+        perf_session__delete(session);
+        cleanup_scripting();
+out:
+        return err;
 }
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index e11d8d231c3b..10fe49e7048a 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -15,6 +15,10 @@ extern int read_line_with_nul(char *buf, int size, FILE *file);
 extern int check_pager_config(const char *cmd);
 
 extern int cmd_annotate(int argc, const char **argv, const char *prefix);
+extern int cmd_bench(int argc, const char **argv, const char *prefix);
+extern int cmd_buildid_cache(int argc, const char **argv, const char *prefix);
+extern int cmd_buildid_list(int argc, const char **argv, const char *prefix);
+extern int cmd_diff(int argc, const char **argv, const char *prefix);
 extern int cmd_help(int argc, const char **argv, const char *prefix);
 extern int cmd_sched(int argc, const char **argv, const char *prefix);
 extern int cmd_list(int argc, const char **argv, const char *prefix);
@@ -25,5 +29,8 @@ extern int cmd_timechart(int argc, const char **argv, const char *prefix);
 extern int cmd_top(int argc, const char **argv, const char *prefix);
 extern int cmd_trace(int argc, const char **argv, const char *prefix);
 extern int cmd_version(int argc, const char **argv, const char *prefix);
+extern int cmd_probe(int argc, const char **argv, const char *prefix);
+extern int cmd_kmem(int argc, const char **argv, const char *prefix);
+extern int cmd_lock(int argc, const char **argv, const char *prefix);
 
 #endif
diff --git a/tools/perf/command-list.txt b/tools/perf/command-list.txt
index 00326e230d87..db6ee94d4a8e 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -3,6 +3,11 @@
 # command name                  category [deprecated] [common]
 #
 perf-annotate                   mainporcelain common
+perf-archive                    mainporcelain common
+perf-bench                      mainporcelain common
+perf-buildid-cache              mainporcelain common
+perf-buildid-list               mainporcelain common
+perf-diff                       mainporcelain common
 perf-list                       mainporcelain common
 perf-sched                      mainporcelain common
 perf-record                     mainporcelain common
@@ -11,3 +16,6 @@ perf-stat			mainporcelain common
 perf-timechart                  mainporcelain common
 perf-top                        mainporcelain common
 perf-trace                      mainporcelain common
+perf-probe                      mainporcelain common
+perf-kmem                       mainporcelain common
+perf-lock                       mainporcelain common
diff --git a/tools/perf/design.txt b/tools/perf/design.txt
index fdd42a824c98..bd0bb1b1279b 100644
--- a/tools/perf/design.txt
+++ b/tools/perf/design.txt
@@ -21,7 +21,7 @@ There's one file descriptor per virtual counter used.
 The special file descriptor is opened via the perf_event_open()
 system call:
 
-   int sys_perf_event_open(struct perf_event_hw_event *hw_event_uptr,
+   int sys_perf_event_open(struct perf_event_attr *hw_event_uptr,
                              pid_t pid, int cpu, int group_fd,
                              unsigned long flags);
 
@@ -32,9 +32,9 @@ can be used to set the blocking mode, etc.
 Multiple counters can be kept open at a time, and the counters
 can be poll()ed.
 
-When creating a new counter fd, 'perf_event_hw_event' is:
+When creating a new counter fd, 'perf_event_attr' is:
 
-struct perf_event_hw_event {
+struct perf_event_attr {
         /*
          * The MSB of the config word signifies if the rest contains cpu
          * specific (raw) counter configuration data, if unset, the next
@@ -101,10 +101,10 @@ enum hw_event_ids {
          */
         PERF_COUNT_HW_CPU_CYCLES                = 0,
         PERF_COUNT_HW_INSTRUCTIONS              = 1,
-        PERF_COUNT_HW_CACHE_REFERENCES  = 2,
+        PERF_COUNT_HW_CACHE_REFERENCES          = 2,
         PERF_COUNT_HW_CACHE_MISSES              = 3,
         PERF_COUNT_HW_BRANCH_INSTRUCTIONS       = 4,
-        PERF_COUNT_HW_BRANCH_MISSES     = 5,
+        PERF_COUNT_HW_BRANCH_MISSES             = 5,
         PERF_COUNT_HW_BUS_CYCLES                = 6,
 };
 
@@ -131,12 +131,14 @@ software events, selected by 'event_id':
  */
 enum sw_event_ids {
         PERF_COUNT_SW_CPU_CLOCK         = 0,
-        PERF_COUNT_SW_TASK_CLOCK                = 1,
-        PERF_COUNT_SW_PAGE_FAULTS               = 2,
+        PERF_COUNT_SW_TASK_CLOCK        = 1,
+        PERF_COUNT_SW_PAGE_FAULTS       = 2,
         PERF_COUNT_SW_CONTEXT_SWITCHES  = 3,
         PERF_COUNT_SW_CPU_MIGRATIONS    = 4,
         PERF_COUNT_SW_PAGE_FAULTS_MIN   = 5,
         PERF_COUNT_SW_PAGE_FAULTS_MAJ   = 6,
+        PERF_COUNT_SW_ALIGNMENT_FAULTS  = 7,
+        PERF_COUNT_SW_EMULATION_FAULTS  = 8,
 };
 
 Counters of the type PERF_TYPE_TRACEPOINT are available when the ftrace event
@@ -397,7 +399,7 @@ Notification of new events is possible through poll()/select()/epoll() and
 fcntl() managing signals.
 
 Normally a notification is generated for every page filled, however one can
-additionally set perf_event_hw_event.wakeup_events to generate one every
+additionally set perf_event_attr.wakeup_events to generate one every
 so many counter overflow events.
 
 Future work will include a splice() interface to the ring-buffer.
diff --git a/tools/perf/perf-archive.sh b/tools/perf/perf-archive.sh
new file mode 100644
index 000000000000..910468e6e01c
--- /dev/null
+++ b/tools/perf/perf-archive.sh
@@ -0,0 +1,33 @@
+#!/bin/bash
+# perf archive
+# Arnaldo Carvalho de Melo <acme@redhat.com>
+
+PERF_DATA=perf.data
+if [ $# -ne 0 ] ; then
+        PERF_DATA=$1
+fi
+
+DEBUGDIR=~/.debug/
+BUILDIDS=$(mktemp /tmp/perf-archive-buildids.XXXXXX)
+NOBUILDID=0000000000000000000000000000000000000000
+
+perf buildid-list -i $PERF_DATA --with-hits | grep -v "^$NOBUILDID " > $BUILDIDS
+if [ ! -s $BUILDIDS ] ; then
+        echo "perf archive: no build-ids found"
+        rm -f $BUILDIDS
+        exit 1
+fi
+
+MANIFEST=$(mktemp /tmp/perf-archive-manifest.XXXXXX)
+
+cut -d ' ' -f 1 $BUILDIDS | \
+while read build_id ; do
+        linkname=$DEBUGDIR.build-id/${build_id:0:2}/${build_id:2}
+        filename=$(readlink -f $linkname)
+        echo ${linkname#$DEBUGDIR} >> $MANIFEST
+        echo ${filename#$DEBUGDIR} >> $MANIFEST
+done
+
+tar cfj $PERF_DATA.tar.bz2 -C $DEBUGDIR -T $MANIFEST
+rm -f $MANIFEST $BUILDIDS
+exit 0
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 19fc7feb9d59..cd32c200cdb3 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -14,6 +14,7 @@
 #include "util/run-command.h"
 #include "util/parse-events.h"
 #include "util/string.h"
+#include "util/debugfs.h"
 
 const char perf_usage_string[] =
         "perf [--version] [--help] COMMAND [ARGS]";
@@ -47,7 +48,8 @@ int check_pager_config(const char *cmd)
         return c.val;
 }
 
-static void commit_pager_choice(void) {
+static void commit_pager_choice(void)
+{
         switch (use_pager) {
         case 0:
                 setenv("PERF_PAGER", "cat", 1);
@@ -69,7 +71,7 @@ static void set_debugfs_path(void)
                  "tracing/events");
 }
 
-static int handle_options(const char*** argv, int* argc, int* envchanged)
+static int handle_options(const char ***argv, int *argc, int *envchanged)
 {
         int handled = 0;
 
@@ -89,8 +91,8 @@ static int handle_options(const char*** argv, int* argc, int* envchanged)
                 /*
                  * Check remaining flags.
                  */
-                if (!prefixcmp(cmd, "--exec-path")) {
-                        cmd += 11;
+                if (!prefixcmp(cmd, CMD_EXEC_PATH)) {
+                        cmd += strlen(CMD_EXEC_PATH);
                         if (*cmd == '=')
                                 perf_set_argv_exec_path(cmd + 1);
                         else {
@@ -108,7 +110,7 @@ static int handle_options(const char*** argv, int* argc, int* envchanged)
                                 *envchanged = 1;
                 } else if (!strcmp(cmd, "--perf-dir")) {
                         if (*argc < 2) {
-                                fprintf(stderr, "No directory given for --perf-dir.\n" );
+                                fprintf(stderr, "No directory given for --perf-dir.\n");
                                 usage(perf_usage_string);
                         }
                         setenv(PERF_DIR_ENVIRONMENT, (*argv)[1], 1);
@@ -117,13 +119,13 @@ static int handle_options(const char*** argv, int* argc, int* envchanged)
                         (*argv)++;
                         (*argc)--;
                         handled++;
-                } else if (!prefixcmp(cmd, "--perf-dir=")) {
-                        setenv(PERF_DIR_ENVIRONMENT, cmd + 10, 1);
+                } else if (!prefixcmp(cmd, CMD_PERF_DIR)) {
+                        setenv(PERF_DIR_ENVIRONMENT, cmd + strlen(CMD_PERF_DIR), 1);
                         if (envchanged)
                                 *envchanged = 1;
                 } else if (!strcmp(cmd, "--work-tree")) {
                         if (*argc < 2) {
-                                fprintf(stderr, "No directory given for --work-tree.\n" );
+                                fprintf(stderr, "No directory given for --work-tree.\n");
                                 usage(perf_usage_string);
                         }
                         setenv(PERF_WORK_TREE_ENVIRONMENT, (*argv)[1], 1);
@@ -131,8 +133,8 @@ static int handle_options(const char*** argv, int* argc, int* envchanged)
                                 *envchanged = 1;
                         (*argv)++;
                         (*argc)--;
-                } else if (!prefixcmp(cmd, "--work-tree=")) {
-                        setenv(PERF_WORK_TREE_ENVIRONMENT, cmd + 12, 1);
+                } else if (!prefixcmp(cmd, CMD_WORK_TREE)) {
+                        setenv(PERF_WORK_TREE_ENVIRONMENT, cmd + strlen(CMD_WORK_TREE), 1);
                         if (envchanged)
                                 *envchanged = 1;
                 } else if (!strcmp(cmd, "--debugfs-dir")) {
@@ -146,8 +148,8 @@ static int handle_options(const char*** argv, int* argc, int* envchanged)
                                 *envchanged = 1;
                         (*argv)++;
                         (*argc)--;
-                } else if (!prefixcmp(cmd, "--debugfs-dir=")) {
-                        strncpy(debugfs_mntpt, cmd + 14, MAXPATHLEN);
+                } else if (!prefixcmp(cmd, CMD_DEBUGFS_DIR)) {
+                        strncpy(debugfs_mntpt, cmd + strlen(CMD_DEBUGFS_DIR), MAXPATHLEN);
                         debugfs_mntpt[MAXPATHLEN - 1] = '\0';
                         if (envchanged)
                                 *envchanged = 1;
@@ -167,7 +169,7 @@ static int handle_alias(int *argcp, const char ***argv)
 {
         int envchanged = 0, ret = 0, saved_errno = errno;
         int count, option_count;
-        const char** new_argv;
+        const char **new_argv;
         const char *alias_command;
         char *alias_string;
 
@@ -209,11 +211,11 @@ static int handle_alias(int *argcp, const char ***argv)
                 if (!strcmp(alias_command, new_argv[0]))
                         die("recursive alias: %s", alias_command);
 
-                new_argv = realloc(new_argv, sizeof(char*) *
+                new_argv = realloc(new_argv, sizeof(char *) *
                                     (count + *argcp + 1));
                 /* insert after command name */
-                memcpy(new_argv + count, *argv + 1, sizeof(char*) * *argcp);
-                new_argv[count+*argcp] = NULL;
+                memcpy(new_argv + count, *argv + 1, sizeof(char *) * *argcp);
+                new_argv[count + *argcp] = NULL;
 
                 *argv = new_argv;
                 *argcp += count - 1;
@@ -284,17 +286,24 @@ static void handle_internal_command(int argc, const char **argv)
 {
         const char *cmd = argv[0];
         static struct cmd_struct commands[] = {
-                { "help", cmd_help, 0 },
-                { "list", cmd_list, 0 },
-                { "record", cmd_record, 0 },
-                { "report", cmd_report, 0 },
-                { "stat", cmd_stat, 0 },
-                { "timechart", cmd_timechart, 0 },
-                { "top", cmd_top, 0 },
-                { "annotate", cmd_annotate, 0 },
-                { "version", cmd_version, 0 },
-                { "trace", cmd_trace, 0 },
-                { "sched", cmd_sched, 0 },
+                { "buildid-cache", cmd_buildid_cache, 0 },
+                { "buildid-list", cmd_buildid_list, 0 },
+                { "diff",       cmd_diff,       0 },
+                { "help",       cmd_help,       0 },
+                { "list",       cmd_list,       0 },
+                { "record",     cmd_record,     0 },
+                { "report",     cmd_report,     0 },
+                { "bench",      cmd_bench,      0 },
+                { "stat",       cmd_stat,       0 },
+                { "timechart",  cmd_timechart,  0 },
+                { "top",        cmd_top,        0 },
+                { "annotate",   cmd_annotate,   0 },
+                { "version",    cmd_version,    0 },
+                { "trace",      cmd_trace,      0 },
+                { "sched",      cmd_sched,      0 },
+                { "probe",      cmd_probe,      0 },
+                { "kmem",       cmd_kmem,       0 },
+                { "lock",       cmd_lock,       0 },
         };
         unsigned int i;
         static const char ext[] = STRIP_EXTENSION;
@@ -382,45 +391,12 @@ static int run_argv(int *argcp, const char ***argv)
 /* mini /proc/mounts parser: searching for "^blah /mount/point debugfs" */
 static void get_debugfs_mntpt(void)
 {
-        FILE *file;
-        char fs_type[100];
-        char debugfs[MAXPATHLEN];
-
-        /*
-         * try the standard location
-         */
-        if (valid_debugfs_mount("/sys/kernel/debug/") == 0) {
-                strcpy(debugfs_mntpt, "/sys/kernel/debug/");
-                return;
-        }
-
-        /*
-         * try the sane location
-         */
-        if (valid_debugfs_mount("/debug/") == 0) {
-                strcpy(debugfs_mntpt, "/debug/");
-                return;
-        }
+        const char *path = debugfs_mount(NULL);
 
-        /*
-         * give up and parse /proc/mounts
-         */
-        file = fopen("/proc/mounts", "r");
-        if (file == NULL)
-                return;
-
-        while (fscanf(file, "%*s %"
-                      STR(MAXPATHLEN)
-                      "s %99s %*s %*d %*d\n",
-                      debugfs, fs_type) == 2) {
-                if (strcmp(fs_type, "debugfs") == 0)
-                        break;
-        }
-        fclose(file);
-        if (strcmp(fs_type, "debugfs") == 0) {
-                strncpy(debugfs_mntpt, debugfs, MAXPATHLEN);
-                debugfs_mntpt[MAXPATHLEN - 1] = '\0';
-        }
+        if (path)
+                strncpy(debugfs_mntpt, path, sizeof(debugfs_mntpt));
+        else
+                debugfs_mntpt[0] = '\0';
 }
 
 int main(int argc, const char **argv)
@@ -469,15 +445,15 @@ int main(int argc, const char **argv)
 
         /*
          * We use PATH to find perf commands, but we prepend some higher
-         * precidence paths: the "--exec-path" option, the PERF_EXEC_PATH
+         * precedence paths: the "--exec-path" option, the PERF_EXEC_PATH
          * environment, and the $(perfexecdir) from the Makefile at build
          * time.
          */
         setup_path();
 
         while (1) {
-                static int done_help = 0;
-                static int was_alias = 0;
+                static int done_help;
+                static int was_alias;
 
                 was_alias = run_argv(&argc, &argv);
                 if (errno != ENOENT)
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 8cc4623afd6f..6fb379bc1d1f 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -47,6 +47,28 @@
 #define cpu_relax()     asm volatile("":::"memory")
 #endif
 
+#ifdef __alpha__
+#include "../../arch/alpha/include/asm/unistd.h"
+#define rmb()           asm volatile("mb" ::: "memory")
+#define cpu_relax()     asm volatile("" ::: "memory")
+#endif
+
+#ifdef __ia64__
+#include "../../arch/ia64/include/asm/unistd.h"
+#define rmb()           asm volatile ("mf" ::: "memory")
+#define cpu_relax()     asm volatile ("hint @pause" ::: "memory")
+#endif
+
+#ifdef __arm__
+#include "../../arch/arm/include/asm/unistd.h"
+/*
+ * Use the __kuser_memory_barrier helper in the CPU helper page. See
+ * arch/arm/kernel/entry-armv.S in the kernel source for details.
+ */
+#define rmb()           ((void(*)(void))0xffff0fa0)()
+#define cpu_relax()     asm volatile("":::"memory")
+#endif
+
 #include <time.h>
 #include <unistd.h>
 #include <sys/types.h>
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Context.c b/tools/perf/scripts/perl/Perf-Trace-Util/Context.c
new file mode 100644
index 000000000000..01a64ad693f2
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Context.c
@@ -0,0 +1,135 @@
+/*
+ * This file was generated automatically by ExtUtils::ParseXS version 2.18_02 from the
+ * contents of Context.xs. Do not edit this file, edit Context.xs instead.
+ *
+ *      ANY CHANGES MADE HERE WILL BE LOST! 
+ *
+ */
+
+#line 1 "Context.xs"
+/*
+ * Context.xs.  XS interfaces for perf trace.
+ *
+ * Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+#include "../../../perf.h"
+#include "../../../util/trace-event.h"
+
+#ifndef PERL_UNUSED_VAR
+#  define PERL_UNUSED_VAR(var) if (0) var = var
+#endif
+
+#line 42 "Context.c"
+
+XS(XS_Perf__Trace__Context_common_pc); /* prototype to pass -Wmissing-prototypes */
+XS(XS_Perf__Trace__Context_common_pc)
+{
+#ifdef dVAR
+    dVAR; dXSARGS;
+#else
+    dXSARGS;
+#endif
+    if (items != 1)
+       Perl_croak(aTHX_ "Usage: %s(%s)", "Perf::Trace::Context::common_pc", "context");
+    PERL_UNUSED_VAR(cv); /* -W */
+    {
+        struct scripting_context *      context = INT2PTR(struct scripting_context *,SvIV(ST(0)));
+        int     RETVAL;
+        dXSTARG;
+
+        RETVAL = common_pc(context);
+        XSprePUSH; PUSHi((IV)RETVAL);
+    }
+    XSRETURN(1);
+}
+
+
+XS(XS_Perf__Trace__Context_common_flags); /* prototype to pass -Wmissing-prototypes */
+XS(XS_Perf__Trace__Context_common_flags)
+{
+#ifdef dVAR
+    dVAR; dXSARGS;
+#else
+    dXSARGS;
+#endif
+    if (items != 1)
+       Perl_croak(aTHX_ "Usage: %s(%s)", "Perf::Trace::Context::common_flags", "context");
+    PERL_UNUSED_VAR(cv); /* -W */
+    {
+        struct scripting_context *      context = INT2PTR(struct scripting_context *,SvIV(ST(0)));
+        int     RETVAL;
+        dXSTARG;
+
+        RETVAL = common_flags(context);
+        XSprePUSH; PUSHi((IV)RETVAL);
+    }
+    XSRETURN(1);
+}
+
+
+XS(XS_Perf__Trace__Context_common_lock_depth); /* prototype to pass -Wmissing-prototypes */
+XS(XS_Perf__Trace__Context_common_lock_depth)
+{
+#ifdef dVAR
+    dVAR; dXSARGS;
+#else
+    dXSARGS;
+#endif
+    if (items != 1)
+       Perl_croak(aTHX_ "Usage: %s(%s)", "Perf::Trace::Context::common_lock_depth", "context");
+    PERL_UNUSED_VAR(cv); /* -W */
+    {
+        struct scripting_context *      context = INT2PTR(struct scripting_context *,SvIV(ST(0)));
+        int     RETVAL;
+        dXSTARG;
+
+        RETVAL = common_lock_depth(context);
+        XSprePUSH; PUSHi((IV)RETVAL);
+    }
+    XSRETURN(1);
+}
+
+#ifdef __cplusplus
+extern "C"
+#endif
+XS(boot_Perf__Trace__Context); /* prototype to pass -Wmissing-prototypes */
+XS(boot_Perf__Trace__Context)
+{
+#ifdef dVAR
+    dVAR; dXSARGS;
+#else
+    dXSARGS;
+#endif
+    const char* file = __FILE__;
+
+    PERL_UNUSED_VAR(cv); /* -W */
+    PERL_UNUSED_VAR(items); /* -W */
+    XS_VERSION_BOOTCHECK ;
+
+        newXSproto("Perf::Trace::Context::common_pc", XS_Perf__Trace__Context_common_pc, file, "$");
+        newXSproto("Perf::Trace::Context::common_flags", XS_Perf__Trace__Context_common_flags, file, "$");
+        newXSproto("Perf::Trace::Context::common_lock_depth", XS_Perf__Trace__Context_common_lock_depth, file, "$");
+    if (PL_unitcheckav)
+         call_list(PL_scopestack_ix, PL_unitcheckav);
+    XSRETURN_YES;
+}
+
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs b/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs
new file mode 100644
index 000000000000..549cf0467d30
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs
@@ -0,0 +1,42 @@
+/*
+ * Context.xs.  XS interfaces for perf trace.
+ *
+ * Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+#include "../../../perf.h"
+#include "../../../util/trace-event.h"
+
+MODULE = Perf::Trace::Context           PACKAGE = Perf::Trace::Context
+PROTOTYPES: ENABLE
+
+int
+common_pc(context)
+        struct scripting_context * context
+
+int
+common_flags(context)
+        struct scripting_context * context
+
+int
+common_lock_depth(context)
+        struct scripting_context * context
+
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Makefile.PL b/tools/perf/scripts/perl/Perf-Trace-Util/Makefile.PL
new file mode 100644
index 000000000000..decdeb0f6789
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Makefile.PL
@@ -0,0 +1,17 @@
+use 5.010000;
+use ExtUtils::MakeMaker;
+# See lib/ExtUtils/MakeMaker.pm for details of how to influence
+# the contents of the Makefile that is written.
+WriteMakefile(
+    NAME              => 'Perf::Trace::Context',
+    VERSION_FROM      => 'lib/Perf/Trace/Context.pm', # finds $VERSION
+    PREREQ_PM         => {}, # e.g., Module::Name => 1.1
+    ($] >= 5.005 ?     ## Add these new keywords supported since 5.005
+      (ABSTRACT_FROM  => 'lib/Perf/Trace/Context.pm', # retrieve abstract from module
+       AUTHOR         => 'Tom Zanussi <tzanussi@gmail.com>') : ()),
+    LIBS              => [''], # e.g., '-lm'
+    DEFINE            => '-I ../..', # e.g., '-DHAVE_SOMETHING'
+    INC               => '-I.', # e.g., '-I. -I/usr/include/other'
+        # Un-comment this if you add C files to link with later:
+    OBJECT            => 'Context.o', # link all the C files too
+);
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/README b/tools/perf/scripts/perl/Perf-Trace-Util/README
new file mode 100644
index 000000000000..9a9707630791
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/README
@@ -0,0 +1,59 @@
+Perf-Trace-Util version 0.01
+============================
+
+This module contains utility functions for use with perf trace.
+
+Core.pm and Util.pm are pure Perl modules; Core.pm contains routines
+that the core perf support for Perl calls on and should always be
+'used', while Util.pm contains useful but optional utility functions
+that scripts may want to use.  Context.pm contains the Perl->C
+interface that allows scripts to access data in the embedding perf
+executable; scripts wishing to do that should 'use Context.pm'.
+
+The Perl->C perf interface is completely driven by Context.xs.  If you
+want to add new Perl functions that end up accessing C data in the
+perf executable, you add desciptions of the new functions here.
+scripting_context is a pointer to the perf data in the perf executable
+that you want to access - it's passed as the second parameter,
+$context, to all handler functions.
+
+After you do that:
+
+  perl Makefile.PL   # to create a Makefile for the next step
+  make               # to create Context.c
+
+  edit Context.c to add const to the char* file = __FILE__ line in
+  XS(boot_Perf__Trace__Context) to silence a warning/error.
+
+  You can delete the Makefile, object files and anything else that was
+  generated e.g. blib and shared library, etc, except for of course
+  Context.c
+
+  You should then be able to run the normal perf make as usual.
+
+INSTALLATION
+
+Building perf with perf trace Perl scripting should install this
+module in the right place.
+
+You should make sure libperl and ExtUtils/Embed.pm are installed first
+e.g. apt-get install libperl-dev or yum install perl-ExtUtils-Embed.
+
+DEPENDENCIES
+
+This module requires these other modules and libraries:
+
+  None
+
+COPYRIGHT AND LICENCE
+
+Copyright (C) 2009 by Tom Zanussi <tzanussi@gmail.com>
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself, either Perl version 5.10.0 or,
+at your option, any later version of Perl 5 you may have available.
+
+Alternatively, this software may be distributed under the terms of the
+GNU General Public License ("GPL") version 2 as published by the Free
+Software Foundation.
+
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Context.pm b/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Context.pm
new file mode 100644
index 000000000000..6c7f3659cb17
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Context.pm
@@ -0,0 +1,55 @@
+package Perf::Trace::Context;
+
+use 5.010000;
+use strict;
+use warnings;
+
+require Exporter;
+
+our @ISA = qw(Exporter);
+
+our %EXPORT_TAGS = ( 'all' => [ qw(
+) ] );
+
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+
+our @EXPORT = qw(
+        common_pc common_flags common_lock_depth
+);
+
+our $VERSION = '0.01';
+
+require XSLoader;
+XSLoader::load('Perf::Trace::Context', $VERSION);
+
+1;
+__END__
+=head1 NAME
+
+Perf::Trace::Context - Perl extension for accessing functions in perf.
+
+=head1 SYNOPSIS
+
+  use Perf::Trace::Context;
+
+=head1 SEE ALSO
+
+Perf (trace) documentation
+
+=head1 AUTHOR
+
+Tom Zanussi, E<lt>tzanussi@gmail.com<gt>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (C) 2009 by Tom Zanussi
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself, either Perl version 5.10.0 or,
+at your option, any later version of Perl 5 you may have available.
+
+Alternatively, this software may be distributed under the terms of the
+GNU General Public License ("GPL") version 2 as published by the Free
+Software Foundation.
+
+=cut
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Core.pm b/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Core.pm
new file mode 100644
index 000000000000..9df376a9f629
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Core.pm
@@ -0,0 +1,192 @@
+package Perf::Trace::Core;
+
+use 5.010000;
+use strict;
+use warnings;
+
+require Exporter;
+
+our @ISA = qw(Exporter);
+
+our %EXPORT_TAGS = ( 'all' => [ qw(
+) ] );
+
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+
+our @EXPORT = qw(
+define_flag_field define_flag_value flag_str dump_flag_fields
+define_symbolic_field define_symbolic_value symbol_str dump_symbolic_fields
+trace_flag_str
+);
+
+our $VERSION = '0.01';
+
+my %trace_flags = (0x00 => "NONE",
+                   0x01 => "IRQS_OFF",
+                   0x02 => "IRQS_NOSUPPORT",
+                   0x04 => "NEED_RESCHED",
+                   0x08 => "HARDIRQ",
+                   0x10 => "SOFTIRQ");
+
+sub trace_flag_str
+{
+    my ($value) = @_;
+
+    my $string;
+
+    my $print_delim = 0;
+
+    foreach my $idx (sort {$a <=> $b} keys %trace_flags) {
+        if (!$value && !$idx) {
+            $string .= "NONE";
+            last;
+        }
+
+        if ($idx && ($value & $idx) == $idx) {
+            if ($print_delim) {
+                $string .= " | ";
+            }
+            $string .= "$trace_flags{$idx}";
+            $print_delim = 1;
+            $value &= ~$idx;
+        }
+    }
+
+    return $string;
+}
+
+my %flag_fields;
+my %symbolic_fields;
+
+sub flag_str
+{
+    my ($event_name, $field_name, $value) = @_;
+
+    my $string;
+
+    if ($flag_fields{$event_name}{$field_name}) {
+        my $print_delim = 0;
+        foreach my $idx (sort {$a <=> $b} keys %{$flag_fields{$event_name}{$field_name}{"values"}}) {
+            if (!$value && !$idx) {
+                $string .= "$flag_fields{$event_name}{$field_name}{'values'}{$idx}";
+                last;
+            }
+            if ($idx && ($value & $idx) == $idx) {
+                if ($print_delim && $flag_fields{$event_name}{$field_name}{'delim'}) {
+                    $string .= " $flag_fields{$event_name}{$field_name}{'delim'} ";
+                }
+                $string .= "$flag_fields{$event_name}{$field_name}{'values'}{$idx}";
+                $print_delim = 1;
+                $value &= ~$idx;
+            }
+        }
+    }
+
+    return $string;
+}
+
+sub define_flag_field
+{
+    my ($event_name, $field_name, $delim) = @_;
+
+    $flag_fields{$event_name}{$field_name}{"delim"} = $delim;
+}
+
+sub define_flag_value
+{
+    my ($event_name, $field_name, $value, $field_str) = @_;
+
+    $flag_fields{$event_name}{$field_name}{"values"}{$value} = $field_str;
+}
+
+sub dump_flag_fields
+{
+    for my $event (keys %flag_fields) {
+        print "event $event:\n";
+        for my $field (keys %{$flag_fields{$event}}) {
+            print "    field: $field:\n";
+            print "        delim: $flag_fields{$event}{$field}{'delim'}\n";
+            foreach my $idx (sort {$a <=> $b} keys %{$flag_fields{$event}{$field}{"values"}}) {
+                print "        value $idx: $flag_fields{$event}{$field}{'values'}{$idx}\n";
+            }
+        }
+    }
+}
+
+sub symbol_str
+{
+    my ($event_name, $field_name, $value) = @_;
+
+    if ($symbolic_fields{$event_name}{$field_name}) {
+        foreach my $idx (sort {$a <=> $b} keys %{$symbolic_fields{$event_name}{$field_name}{"values"}}) {
+            if (!$value && !$idx) {
+                return "$symbolic_fields{$event_name}{$field_name}{'values'}{$idx}";
+                last;
+            }
+            if ($value == $idx) {
+                return "$symbolic_fields{$event_name}{$field_name}{'values'}{$idx}";
+            }
+        }
+    }
+
+    return undef;
+}
+
+sub define_symbolic_field
+{
+    my ($event_name, $field_name) = @_;
+
+    # nothing to do, really
+}
+
+sub define_symbolic_value
+{
+    my ($event_name, $field_name, $value, $field_str) = @_;
+
+    $symbolic_fields{$event_name}{$field_name}{"values"}{$value} = $field_str;
+}
+
+sub dump_symbolic_fields
+{
+    for my $event (keys %symbolic_fields) {
+        print "event $event:\n";
+        for my $field (keys %{$symbolic_fields{$event}}) {
+            print "    field: $field:\n";
+            foreach my $idx (sort {$a <=> $b} keys %{$symbolic_fields{$event}{$field}{"values"}}) {
+                print "        value $idx: $symbolic_fields{$event}{$field}{'values'}{$idx}\n";
+            }
+        }
+    }
+}
+
+1;
+__END__
+=head1 NAME
+
+Perf::Trace::Core - Perl extension for perf trace
+
+=head1 SYNOPSIS
+
+  use Perf::Trace::Core
+
+=head1 SEE ALSO
+
+Perf (trace) documentation
+
+=head1 AUTHOR
+
+Tom Zanussi, E<lt>tzanussi@gmail.com<gt>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (C) 2009 by Tom Zanussi
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself, either Perl version 5.10.0 or,
+at your option, any later version of Perl 5 you may have available.
+
+Alternatively, this software may be distributed under the terms of the
+GNU General Public License ("GPL") version 2 as published by the Free
+Software Foundation.
+
+=cut
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Util.pm b/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Util.pm
new file mode 100644
index 000000000000..f869c48dc9b0
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Util.pm
@@ -0,0 +1,88 @@
+package Perf::Trace::Util;
+
+use 5.010000;
+use strict;
+use warnings;
+
+require Exporter;
+
+our @ISA = qw(Exporter);
+
+our %EXPORT_TAGS = ( 'all' => [ qw(
+) ] );
+
+our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
+
+our @EXPORT = qw(
+avg nsecs nsecs_secs nsecs_nsecs nsecs_usecs print_nsecs
+);
+
+our $VERSION = '0.01';
+
+sub avg
+{
+    my ($total, $n) = @_;
+
+    return $total / $n;
+}
+
+my $NSECS_PER_SEC    = 1000000000;
+
+sub nsecs
+{
+    my ($secs, $nsecs) = @_;
+
+    return $secs * $NSECS_PER_SEC + $nsecs;
+}
+
+sub nsecs_secs {
+    my ($nsecs) = @_;
+
+    return $nsecs / $NSECS_PER_SEC;
+}
+
+sub nsecs_nsecs {
+    my ($nsecs) = @_;
+
+    return $nsecs % $NSECS_PER_SEC;
+}
+
+sub nsecs_str {
+    my ($nsecs) = @_;
+
+    my $str = sprintf("%5u.%09u", nsecs_secs($nsecs), nsecs_nsecs($nsecs));
+
+    return $str;
+}
+
+1;
+__END__
+=head1 NAME
+
+Perf::Trace::Util - Perl extension for perf trace
+
+=head1 SYNOPSIS
+
+  use Perf::Trace::Util;
+
+=head1 SEE ALSO
+
+Perf (trace) documentation
+
+=head1 AUTHOR
+
+Tom Zanussi, E<lt>tzanussi@gmail.com<gt>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (C) 2009 by Tom Zanussi
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself, either Perl version 5.10.0 or,
+at your option, any later version of Perl 5 you may have available.
+
+Alternatively, this software may be distributed under the terms of the
+GNU General Public License ("GPL") version 2 as published by the Free
+Software Foundation.
+
+=cut
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/typemap b/tools/perf/scripts/perl/Perf-Trace-Util/typemap
new file mode 100644
index 000000000000..840836804aa7
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/typemap
@@ -0,0 +1 @@
+struct scripting_context * T_PTR
diff --git a/tools/perf/scripts/perl/bin/check-perf-trace-record b/tools/perf/scripts/perl/bin/check-perf-trace-record
new file mode 100644
index 000000000000..e6cb1474f8e8
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/check-perf-trace-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e kmem:kmalloc -e irq:softirq_entry -e kmem:kfree
diff --git a/tools/perf/scripts/perl/bin/failed-syscalls-record b/tools/perf/scripts/perl/bin/failed-syscalls-record
new file mode 100644
index 000000000000..f8885d389e6f
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/failed-syscalls-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e raw_syscalls:sys_exit
diff --git a/tools/perf/scripts/perl/bin/failed-syscalls-report b/tools/perf/scripts/perl/bin/failed-syscalls-report
new file mode 100644
index 000000000000..8bfc660e5056
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/failed-syscalls-report
@@ -0,0 +1,4 @@
+#!/bin/bash
+# description: system-wide failed syscalls
+# args: [comm]
+perf trace -s ~/libexec/perf-core/scripts/perl/failed-syscalls.pl $1
diff --git a/tools/perf/scripts/perl/bin/rw-by-file-record b/tools/perf/scripts/perl/bin/rw-by-file-record
new file mode 100644
index 000000000000..b25056ebf963
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/rw-by-file-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e syscalls:sys_enter_read -e syscalls:sys_enter_write
diff --git a/tools/perf/scripts/perl/bin/rw-by-file-report b/tools/perf/scripts/perl/bin/rw-by-file-report
new file mode 100644
index 000000000000..eddb9ccce6a5
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/rw-by-file-report
@@ -0,0 +1,7 @@
+#!/bin/bash
+# description: r/w activity for a program, by file
+# args: <comm>
+perf trace -s ~/libexec/perf-core/scripts/perl/rw-by-file.pl $1
+
+
+
diff --git a/tools/perf/scripts/perl/bin/rw-by-pid-record b/tools/perf/scripts/perl/bin/rw-by-pid-record
new file mode 100644
index 000000000000..8903979c5b6c
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/rw-by-pid-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e syscalls:sys_enter_read -e syscalls:sys_exit_read -e syscalls:sys_enter_write -e syscalls:sys_exit_write
diff --git a/tools/perf/scripts/perl/bin/rw-by-pid-report b/tools/perf/scripts/perl/bin/rw-by-pid-report
new file mode 100644
index 000000000000..7f44c25cc857
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/rw-by-pid-report
@@ -0,0 +1,6 @@
+#!/bin/bash
+# description: system-wide r/w activity
+perf trace -s ~/libexec/perf-core/scripts/perl/rw-by-pid.pl
+
+
+
diff --git a/tools/perf/scripts/perl/bin/wakeup-latency-record b/tools/perf/scripts/perl/bin/wakeup-latency-record
new file mode 100644
index 000000000000..6abedda911a4
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/wakeup-latency-record
@@ -0,0 +1,6 @@
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e sched:sched_switch -e sched:sched_wakeup
+
+
+
+
diff --git a/tools/perf/scripts/perl/bin/wakeup-latency-report b/tools/perf/scripts/perl/bin/wakeup-latency-report
new file mode 100644
index 000000000000..fce3adcb3249
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/wakeup-latency-report
@@ -0,0 +1,6 @@
+#!/bin/bash
+# description: system-wide min/max/avg wakeup latency
+perf trace -s ~/libexec/perf-core/scripts/perl/wakeup-latency.pl
+
+
+
diff --git a/tools/perf/scripts/perl/bin/workqueue-stats-record b/tools/perf/scripts/perl/bin/workqueue-stats-record
new file mode 100644
index 000000000000..fce6637b19ba
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/workqueue-stats-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e workqueue:workqueue_creation -e workqueue:workqueue_destruction -e workqueue:workqueue_execution -e workqueue:workqueue_insertion
diff --git a/tools/perf/scripts/perl/bin/workqueue-stats-report b/tools/perf/scripts/perl/bin/workqueue-stats-report
new file mode 100644
index 000000000000..71cfbd182fb9
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/workqueue-stats-report
@@ -0,0 +1,7 @@
+#!/bin/bash
+# description: workqueue stats (ins/exe/create/destroy)
+perf trace -s ~/libexec/perf-core/scripts/perl/workqueue-stats.pl
+
+
+
+
diff --git a/tools/perf/scripts/perl/check-perf-trace.pl b/tools/perf/scripts/perl/check-perf-trace.pl
new file mode 100644
index 000000000000..4e7dc0a407a5
--- /dev/null
+++ b/tools/perf/scripts/perl/check-perf-trace.pl
@@ -0,0 +1,106 @@
+# perf trace event handlers, generated by perf trace -g perl
+# (c) 2009, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+
+# This script tests basic functionality such as flag and symbol
+# strings, common_xxx() calls back into perf, begin, end, unhandled
+# events, etc.  Basically, if this script runs successfully and
+# displays expected results, perl scripting support should be ok.
+
+use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
+use lib "./Perf-Trace-Util/lib";
+use Perf::Trace::Core;
+use Perf::Trace::Context;
+use Perf::Trace::Util;
+
+sub trace_begin
+{
+    print "trace_begin\n";
+}
+
+sub trace_end
+{
+    print "trace_end\n";
+
+    print_unhandled();
+}
+
+sub irq::softirq_entry
+{
+        my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+            $common_pid, $common_comm,
+            $vec) = @_;
+
+        print_header($event_name, $common_cpu, $common_secs, $common_nsecs,
+                     $common_pid, $common_comm);
+
+        print_uncommon($context);
+
+        printf("vec=%s\n",
+               symbol_str("irq::softirq_entry", "vec", $vec));
+}
+
+sub kmem::kmalloc
+{
+        my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+            $common_pid, $common_comm,
+            $call_site, $ptr, $bytes_req, $bytes_alloc,
+            $gfp_flags) = @_;
+
+        print_header($event_name, $common_cpu, $common_secs, $common_nsecs,
+                     $common_pid, $common_comm);
+
+        print_uncommon($context);
+
+        printf("call_site=%p, ptr=%p, bytes_req=%u, bytes_alloc=%u, ".
+               "gfp_flags=%s\n",
+               $call_site, $ptr, $bytes_req, $bytes_alloc,
+
+               flag_str("kmem::kmalloc", "gfp_flags", $gfp_flags));
+}
+
+# print trace fields not included in handler args
+sub print_uncommon
+{
+    my ($context) = @_;
+
+    printf("common_preempt_count=%d, common_flags=%s, common_lock_depth=%d, ",
+           common_pc($context), trace_flag_str(common_flags($context)),
+           common_lock_depth($context));
+
+}
+
+my %unhandled;
+
+sub print_unhandled
+{
+    if ((scalar keys %unhandled) == 0) {
+        return;
+    }
+
+    print "\nunhandled events:\n\n";
+
+    printf("%-40s  %10s\n", "event", "count");
+    printf("%-40s  %10s\n", "----------------------------------------",
+           "-----------");
+
+    foreach my $event_name (keys %unhandled) {
+        printf("%-40s  %10d\n", $event_name, $unhandled{$event_name});
+    }
+}
+
+sub trace_unhandled
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm) = @_;
+
+    $unhandled{$event_name}++;
+}
+
+sub print_header
+{
+        my ($event_name, $cpu, $secs, $nsecs, $pid, $comm) = @_;
+
+        printf("%-20s %5u %05u.%09u %8u %-20s ",
+               $event_name, $cpu, $secs, $nsecs, $pid, $comm);
+}
diff --git a/tools/perf/scripts/perl/failed-syscalls.pl b/tools/perf/scripts/perl/failed-syscalls.pl
new file mode 100644
index 000000000000..c18e7e27a84b
--- /dev/null
+++ b/tools/perf/scripts/perl/failed-syscalls.pl
@@ -0,0 +1,38 @@
+# failed system call counts
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# Displays system-wide failed system call totals
+# If a [comm] arg is specified, only syscalls called by [comm] are displayed.
+
+use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
+use lib "./Perf-Trace-Util/lib";
+use Perf::Trace::Core;
+use Perf::Trace::Context;
+use Perf::Trace::Util;
+
+my %failed_syscalls;
+
+sub raw_syscalls::sys_exit
+{
+        my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+            $common_pid, $common_comm,
+            $id, $ret) = @_;
+
+        if ($ret < 0) {
+            $failed_syscalls{$common_comm}++;
+        }
+}
+
+sub trace_end
+{
+    printf("\nfailed syscalls by comm:\n\n");
+
+    printf("%-20s  %10s\n", "comm", "# errors");
+    printf("%-20s  %6s  %10s\n", "--------------------", "----------");
+
+    foreach my $comm (sort {$failed_syscalls{$b} <=> $failed_syscalls{$a}}
+                      keys %failed_syscalls) {
+            printf("%-20s  %10s\n", $comm, $failed_syscalls{$comm});
+    }
+}
diff --git a/tools/perf/scripts/perl/rw-by-file.pl b/tools/perf/scripts/perl/rw-by-file.pl
new file mode 100644
index 000000000000..2a39097687b9
--- /dev/null
+++ b/tools/perf/scripts/perl/rw-by-file.pl
@@ -0,0 +1,106 @@
+#!/usr/bin/perl -w
+# (c) 2009, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+
+# Display r/w activity for files read/written to for a given program
+
+# The common_* event handler fields are the most useful fields common to
+# all events.  They don't necessarily correspond to the 'common_*' fields
+# in the status files.  Those fields not available as handler params can
+# be retrieved via script functions of the form get_common_*().
+
+use 5.010000;
+use strict;
+use warnings;
+
+use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
+use lib "./Perf-Trace-Util/lib";
+use Perf::Trace::Core;
+use Perf::Trace::Util;
+
+my $usage = "perf trace -s rw-by-file.pl <comm>\n";
+
+my $for_comm = shift or die $usage;
+
+my %reads;
+my %writes;
+
+sub syscalls::sys_enter_read
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm, $nr, $fd, $buf, $count) = @_;
+
+    if ($common_comm eq $for_comm) {
+        $reads{$fd}{bytes_requested} += $count;
+        $reads{$fd}{total_reads}++;
+    }
+}
+
+sub syscalls::sys_enter_write
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm, $nr, $fd, $buf, $count) = @_;
+
+    if ($common_comm eq $for_comm) {
+        $writes{$fd}{bytes_written} += $count;
+        $writes{$fd}{total_writes}++;
+    }
+}
+
+sub trace_end
+{
+    printf("file read counts for $for_comm:\n\n");
+
+    printf("%6s  %10s  %10s\n", "fd", "# reads", "bytes_requested");
+    printf("%6s  %10s  %10s\n", "------", "----------", "-----------");
+
+    foreach my $fd (sort {$reads{$b}{bytes_requested} <=>
+                              $reads{$a}{bytes_requested}} keys %reads) {
+        my $total_reads = $reads{$fd}{total_reads};
+        my $bytes_requested = $reads{$fd}{bytes_requested};
+        printf("%6u  %10u  %10u\n", $fd, $total_reads, $bytes_requested);
+    }
+
+    printf("\nfile write counts for $for_comm:\n\n");
+
+    printf("%6s  %10s  %10s\n", "fd", "# writes", "bytes_written");
+    printf("%6s  %10s  %10s\n", "------", "----------", "-----------");
+
+    foreach my $fd (sort {$writes{$b}{bytes_written} <=>
+                              $writes{$a}{bytes_written}} keys %writes) {
+        my $total_writes = $writes{$fd}{total_writes};
+        my $bytes_written = $writes{$fd}{bytes_written};
+        printf("%6u  %10u  %10u\n", $fd, $total_writes, $bytes_written);
+    }
+
+    print_unhandled();
+}
+
+my %unhandled;
+
+sub print_unhandled
+{
+    if ((scalar keys %unhandled) == 0) {
+        return;
+    }
+
+    print "\nunhandled events:\n\n";
+
+    printf("%-40s  %10s\n", "event", "count");
+    printf("%-40s  %10s\n", "----------------------------------------",
+           "-----------");
+
+    foreach my $event_name (keys %unhandled) {
+        printf("%-40s  %10d\n", $event_name, $unhandled{$event_name});
+    }
+}
+
+sub trace_unhandled
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm) = @_;
+
+    $unhandled{$event_name}++;
+}
+
+
diff --git a/tools/perf/scripts/perl/rw-by-pid.pl b/tools/perf/scripts/perl/rw-by-pid.pl
new file mode 100644
index 000000000000..da601fae1a00
--- /dev/null
+++ b/tools/perf/scripts/perl/rw-by-pid.pl
@@ -0,0 +1,170 @@
+#!/usr/bin/perl -w
+# (c) 2009, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+
+# Display r/w activity for all processes
+
+# The common_* event handler fields are the most useful fields common to
+# all events.  They don't necessarily correspond to the 'common_*' fields
+# in the status files.  Those fields not available as handler params can
+# be retrieved via script functions of the form get_common_*().
+
+use 5.010000;
+use strict;
+use warnings;
+
+use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
+use lib "./Perf-Trace-Util/lib";
+use Perf::Trace::Core;
+use Perf::Trace::Util;
+
+my %reads;
+my %writes;
+
+sub syscalls::sys_exit_read
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $nr, $ret) = @_;
+
+    if ($ret > 0) {
+        $reads{$common_pid}{bytes_read} += $ret;
+    } else {
+        if (!defined ($reads{$common_pid}{bytes_read})) {
+            $reads{$common_pid}{bytes_read} = 0;
+        }
+        $reads{$common_pid}{errors}{$ret}++;
+    }
+}
+
+sub syscalls::sys_enter_read
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $nr, $fd, $buf, $count) = @_;
+
+    $reads{$common_pid}{bytes_requested} += $count;
+    $reads{$common_pid}{total_reads}++;
+    $reads{$common_pid}{comm} = $common_comm;
+}
+
+sub syscalls::sys_exit_write
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $nr, $ret) = @_;
+
+    if ($ret <= 0) {
+        $writes{$common_pid}{errors}{$ret}++;
+    }
+}
+
+sub syscalls::sys_enter_write
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $nr, $fd, $buf, $count) = @_;
+
+    $writes{$common_pid}{bytes_written} += $count;
+    $writes{$common_pid}{total_writes}++;
+    $writes{$common_pid}{comm} = $common_comm;
+}
+
+sub trace_end
+{
+    printf("read counts by pid:\n\n");
+
+    printf("%6s  %20s  %10s  %10s  %10s\n", "pid", "comm",
+           "# reads", "bytes_requested", "bytes_read");
+    printf("%6s  %-20s  %10s  %10s  %10s\n", "------", "--------------------",
+           "-----------", "----------", "----------");
+
+    foreach my $pid (sort {$reads{$b}{bytes_read} <=>
+                               $reads{$a}{bytes_read}} keys %reads) {
+        my $comm = $reads{$pid}{comm};
+        my $total_reads = $reads{$pid}{total_reads};
+        my $bytes_requested = $reads{$pid}{bytes_requested};
+        my $bytes_read = $reads{$pid}{bytes_read};
+
+        printf("%6s  %-20s  %10s  %10s  %10s\n", $pid, $comm,
+               $total_reads, $bytes_requested, $bytes_read);
+    }
+
+    printf("\nfailed reads by pid:\n\n");
+
+    printf("%6s  %20s  %6s  %10s\n", "pid", "comm", "error #", "# errors");
+    printf("%6s  %20s  %6s  %10s\n", "------", "--------------------",
+           "------", "----------");
+
+    foreach my $pid (keys %reads) {
+        my $comm = $reads{$pid}{comm};
+        foreach my $err (sort {$reads{$b}{comm} cmp $reads{$a}{comm}}
+                         keys %{$reads{$pid}{errors}}) {
+            my $errors = $reads{$pid}{errors}{$err};
+
+            printf("%6d  %-20s  %6d  %10s\n", $pid, $comm, $err, $errors);
+        }
+    }
+
+    printf("\nwrite counts by pid:\n\n");
+
+    printf("%6s  %20s  %10s  %10s\n", "pid", "comm",
+           "# writes", "bytes_written");
+    printf("%6s  %-20s  %10s  %10s\n", "------", "--------------------",
+           "-----------", "----------");
+
+    foreach my $pid (sort {$writes{$b}{bytes_written} <=>
+                               $writes{$a}{bytes_written}} keys %writes) {
+        my $comm = $writes{$pid}{comm};
+        my $total_writes = $writes{$pid}{total_writes};
+        my $bytes_written = $writes{$pid}{bytes_written};
+
+        printf("%6s  %-20s  %10s  %10s\n", $pid, $comm,
+               $total_writes, $bytes_written);
+    }
+
+    printf("\nfailed writes by pid:\n\n");
+
+    printf("%6s  %20s  %6s  %10s\n", "pid", "comm", "error #", "# errors");
+    printf("%6s  %20s  %6s  %10s\n", "------", "--------------------",
+           "------", "----------");
+
+    foreach my $pid (keys %writes) {
+        my $comm = $writes{$pid}{comm};
+        foreach my $err (sort {$writes{$b}{comm} cmp $writes{$a}{comm}}
+                         keys %{$writes{$pid}{errors}}) {
+            my $errors = $writes{$pid}{errors}{$err};
+
+            printf("%6d  %-20s  %6d  %10s\n", $pid, $comm, $err, $errors);
+        }
+    }
+
+    print_unhandled();
+}
+
+my %unhandled;
+
+sub print_unhandled
+{
+    if ((scalar keys %unhandled) == 0) {
+        return;
+    }
+
+    print "\nunhandled events:\n\n";
+
+    printf("%-40s  %10s\n", "event", "count");
+    printf("%-40s  %10s\n", "----------------------------------------",
+           "-----------");
+
+    foreach my $event_name (keys %unhandled) {
+        printf("%-40s  %10d\n", $event_name, $unhandled{$event_name});
+    }
+}
+
+sub trace_unhandled
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm) = @_;
+
+    $unhandled{$event_name}++;
+}
diff --git a/tools/perf/scripts/perl/wakeup-latency.pl b/tools/perf/scripts/perl/wakeup-latency.pl
new file mode 100644
index 000000000000..ed58ef284e23
--- /dev/null
+++ b/tools/perf/scripts/perl/wakeup-latency.pl
@@ -0,0 +1,103 @@
+#!/usr/bin/perl -w
+# (c) 2009, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+
+# Display avg/min/max wakeup latency
+
+# The common_* event handler fields are the most useful fields common to
+# all events.  They don't necessarily correspond to the 'common_*' fields
+# in the status files.  Those fields not available as handler params can
+# be retrieved via script functions of the form get_common_*().
+
+use 5.010000;
+use strict;
+use warnings;
+
+use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
+use lib "./Perf-Trace-Util/lib";
+use Perf::Trace::Core;
+use Perf::Trace::Util;
+
+my %last_wakeup;
+
+my $max_wakeup_latency;
+my $min_wakeup_latency;
+my $total_wakeup_latency;
+my $total_wakeups;
+
+sub sched::sched_switch
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $prev_comm, $prev_pid, $prev_prio, $prev_state, $next_comm, $next_pid,
+        $next_prio) = @_;
+
+    my $wakeup_ts = $last_wakeup{$common_cpu}{ts};
+    if ($wakeup_ts) {
+        my $switch_ts = nsecs($common_secs, $common_nsecs);
+        my $wakeup_latency = $switch_ts - $wakeup_ts;
+        if ($wakeup_latency > $max_wakeup_latency) {
+            $max_wakeup_latency = $wakeup_latency;
+        }
+        if ($wakeup_latency < $min_wakeup_latency) {
+            $min_wakeup_latency = $wakeup_latency;
+        }
+        $total_wakeup_latency += $wakeup_latency;
+        $total_wakeups++;
+    }
+    $last_wakeup{$common_cpu}{ts} = 0;
+}
+
+sub sched::sched_wakeup
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $comm, $pid, $prio, $success, $target_cpu) = @_;
+
+    $last_wakeup{$target_cpu}{ts} = nsecs($common_secs, $common_nsecs);
+}
+
+sub trace_begin
+{
+    $min_wakeup_latency = 1000000000;
+    $max_wakeup_latency = 0;
+}
+
+sub trace_end
+{
+    printf("wakeup_latency stats:\n\n");
+    print "total_wakeups: $total_wakeups\n";
+    printf("avg_wakeup_latency (ns): %u\n",
+           avg($total_wakeup_latency, $total_wakeups));
+    printf("min_wakeup_latency (ns): %u\n", $min_wakeup_latency);
+    printf("max_wakeup_latency (ns): %u\n", $max_wakeup_latency);
+
+    print_unhandled();
+}
+
+my %unhandled;
+
+sub print_unhandled
+{
+    if ((scalar keys %unhandled) == 0) {
+        return;
+    }
+
+    print "\nunhandled events:\n\n";
+
+    printf("%-40s  %10s\n", "event", "count");
+    printf("%-40s  %10s\n", "----------------------------------------",
+           "-----------");
+
+    foreach my $event_name (keys %unhandled) {
+        printf("%-40s  %10d\n", $event_name, $unhandled{$event_name});
+    }
+}
+
+sub trace_unhandled
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm) = @_;
+
+    $unhandled{$event_name}++;
+}
diff --git a/tools/perf/scripts/perl/workqueue-stats.pl b/tools/perf/scripts/perl/workqueue-stats.pl
new file mode 100644
index 000000000000..511302c8a494
--- /dev/null
+++ b/tools/perf/scripts/perl/workqueue-stats.pl
@@ -0,0 +1,129 @@
+#!/usr/bin/perl -w
+# (c) 2009, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+
+# Displays workqueue stats
+#
+# Usage:
+#
+#   perf record -c 1 -f -a -R -e workqueue:workqueue_creation -e
+#     workqueue:workqueue_destruction -e workqueue:workqueue_execution
+#     -e workqueue:workqueue_insertion
+#
+#   perf trace -p -s tools/perf/scripts/perl/workqueue-stats.pl
+
+use 5.010000;
+use strict;
+use warnings;
+
+use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
+use lib "./Perf-Trace-Util/lib";
+use Perf::Trace::Core;
+use Perf::Trace::Util;
+
+my @cpus;
+
+sub workqueue::workqueue_destruction
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $thread_comm, $thread_pid) = @_;
+
+    $cpus[$common_cpu]{$thread_pid}{destroyed}++;
+    $cpus[$common_cpu]{$thread_pid}{comm} = $thread_comm;
+}
+
+sub workqueue::workqueue_creation
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $thread_comm, $thread_pid, $cpu) = @_;
+
+    $cpus[$common_cpu]{$thread_pid}{created}++;
+    $cpus[$common_cpu]{$thread_pid}{comm} = $thread_comm;
+}
+
+sub workqueue::workqueue_execution
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $thread_comm, $thread_pid, $func) = @_;
+
+    $cpus[$common_cpu]{$thread_pid}{executed}++;
+    $cpus[$common_cpu]{$thread_pid}{comm} = $thread_comm;
+}
+
+sub workqueue::workqueue_insertion
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $thread_comm, $thread_pid, $func) = @_;
+
+    $cpus[$common_cpu]{$thread_pid}{inserted}++;
+    $cpus[$common_cpu]{$thread_pid}{comm} = $thread_comm;
+}
+
+sub trace_end
+{
+    print "workqueue work stats:\n\n";
+    my $cpu = 0;
+    printf("%3s %6s %6s\t%-20s\n", "cpu", "ins", "exec", "name");
+    printf("%3s %6s %6s\t%-20s\n", "---", "---", "----", "----");
+    foreach my $pidhash (@cpus) {
+        while ((my $pid, my $wqhash) = each %$pidhash) {
+            my $ins = $$wqhash{'inserted'};
+            my $exe = $$wqhash{'executed'};
+            my $comm = $$wqhash{'comm'};
+            if ($ins || $exe) {
+                printf("%3u %6u %6u\t%-20s\n", $cpu, $ins, $exe, $comm);
+            }
+        }
+        $cpu++;
+    }
+
+    $cpu = 0;
+    print "\nworkqueue lifecycle stats:\n\n";
+    printf("%3s %6s %6s\t%-20s\n", "cpu", "created", "destroyed", "name");
+    printf("%3s %6s %6s\t%-20s\n", "---", "-------", "---------", "----");
+    foreach my $pidhash (@cpus) {
+        while ((my $pid, my $wqhash) = each %$pidhash) {
+            my $created = $$wqhash{'created'};
+            my $destroyed = $$wqhash{'destroyed'};
+            my $comm = $$wqhash{'comm'};
+            if ($created || $destroyed) {
+                printf("%3u %6u %6u\t%-20s\n", $cpu, $created, $destroyed,
+                       $comm);
+            }
+        }
+        $cpu++;
+    }
+
+    print_unhandled();
+}
+
+my %unhandled;
+
+sub print_unhandled
+{
+    if ((scalar keys %unhandled) == 0) {
+        return;
+    }
+
+    print "\nunhandled events:\n\n";
+
+    printf("%-40s  %10s\n", "event", "count");
+    printf("%-40s  %10s\n", "----------------------------------------",
+           "-----------");
+
+    foreach my $event_name (keys %unhandled) {
+        printf("%-40s  %10d\n", $event_name, $unhandled{$event_name});
+    }
+}
+
+sub trace_unhandled
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm) = @_;
+
+    $unhandled{$event_name}++;
+}
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/Context.c b/tools/perf/scripts/python/Perf-Trace-Util/Context.c
new file mode 100644
index 000000000000..957085dd5d8d
--- /dev/null
+++ b/tools/perf/scripts/python/Perf-Trace-Util/Context.c
@@ -0,0 +1,88 @@
+/*
+ * Context.c.  Python interfaces for perf trace.
+ *
+ * Copyright (C) 2010 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <Python.h>
+#include "../../../perf.h"
+#include "../../../util/trace-event.h"
+
+PyMODINIT_FUNC initperf_trace_context(void);
+
+static PyObject *perf_trace_context_common_pc(PyObject *self, PyObject *args)
+{
+        static struct scripting_context *scripting_context;
+        PyObject *context;
+        int retval;
+
+        if (!PyArg_ParseTuple(args, "O", &context))
+                return NULL;
+
+        scripting_context = PyCObject_AsVoidPtr(context);
+        retval = common_pc(scripting_context);
+
+        return Py_BuildValue("i", retval);
+}
+
+static PyObject *perf_trace_context_common_flags(PyObject *self,
+                                                 PyObject *args)
+{
+        static struct scripting_context *scripting_context;
+        PyObject *context;
+        int retval;
+
+        if (!PyArg_ParseTuple(args, "O", &context))
+                return NULL;
+
+        scripting_context = PyCObject_AsVoidPtr(context);
+        retval = common_flags(scripting_context);
+
+        return Py_BuildValue("i", retval);
+}
+
+static PyObject *perf_trace_context_common_lock_depth(PyObject *self,
+                                                      PyObject *args)
+{
+        static struct scripting_context *scripting_context;
+        PyObject *context;
+        int retval;
+
+        if (!PyArg_ParseTuple(args, "O", &context))
+                return NULL;
+
+        scripting_context = PyCObject_AsVoidPtr(context);
+        retval = common_lock_depth(scripting_context);
+
+        return Py_BuildValue("i", retval);
+}
+
+static PyMethodDef ContextMethods[] = {
+        { "common_pc", perf_trace_context_common_pc, METH_VARARGS,
+          "Get the common preempt count event field value."},
+        { "common_flags", perf_trace_context_common_flags, METH_VARARGS,
+          "Get the common flags event field value."},
+        { "common_lock_depth", perf_trace_context_common_lock_depth,
+          METH_VARARGS, "Get the common lock depth event field value."},
+        { NULL, NULL, 0, NULL}
+};
+
+PyMODINIT_FUNC initperf_trace_context(void)
+{
+        (void) Py_InitModule("perf_trace_context", ContextMethods);
+}
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py
new file mode 100644
index 000000000000..1dc464ee2ca8
--- /dev/null
+++ b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py
@@ -0,0 +1,91 @@
+# Core.py - Python extension for perf trace, core functions
+#
+# Copyright (C) 2010 by Tom Zanussi <tzanussi@gmail.com>
+#
+# This software may be distributed under the terms of the GNU General
+# Public License ("GPL") version 2 as published by the Free Software
+# Foundation.
+
+from collections import defaultdict
+
+def autodict():
+    return defaultdict(autodict)
+
+flag_fields = autodict()
+symbolic_fields = autodict()
+
+def define_flag_field(event_name, field_name, delim):
+    flag_fields[event_name][field_name]['delim'] = delim
+
+def define_flag_value(event_name, field_name, value, field_str):
+    flag_fields[event_name][field_name]['values'][value] = field_str
+
+def define_symbolic_field(event_name, field_name):
+    # nothing to do, really
+    pass
+
+def define_symbolic_value(event_name, field_name, value, field_str):
+    symbolic_fields[event_name][field_name]['values'][value] = field_str
+
+def flag_str(event_name, field_name, value):
+    string = ""
+
+    if flag_fields[event_name][field_name]:
+        print_delim = 0
+        keys = flag_fields[event_name][field_name]['values'].keys()
+        keys.sort()
+        for idx in keys:
+            if not value and not idx:
+                string += flag_fields[event_name][field_name]['values'][idx]
+                break
+            if idx and (value & idx) == idx:
+                if print_delim and flag_fields[event_name][field_name]['delim']:
+                    string += " " + flag_fields[event_name][field_name]['delim'] + " "
+                string += flag_fields[event_name][field_name]['values'][idx]
+                print_delim = 1
+                value &= ~idx
+
+    return string
+
+def symbol_str(event_name, field_name, value):
+    string = ""
+
+    if symbolic_fields[event_name][field_name]:
+        keys = symbolic_fields[event_name][field_name]['values'].keys()
+        keys.sort()
+        for idx in keys:
+            if not value and not idx:
+                string = symbolic_fields[event_name][field_name]['values'][idx]
+                break
+            if (value == idx):
+                string = symbolic_fields[event_name][field_name]['values'][idx]
+                break
+
+    return string
+
+trace_flags = { 0x00: "NONE", \
+                    0x01: "IRQS_OFF", \
+                    0x02: "IRQS_NOSUPPORT", \
+                    0x04: "NEED_RESCHED", \
+                    0x08: "HARDIRQ", \
+                    0x10: "SOFTIRQ" }
+
+def trace_flag_str(value):
+    string = ""
+    print_delim = 0
+
+    keys = trace_flags.keys()
+
+    for idx in keys:
+        if not value and not idx:
+            string += "NONE"
+            break
+
+        if idx and (value & idx) == idx:
+            if print_delim:
+                string += " | ";
+            string += trace_flags[idx]
+            print_delim = 1
+            value &= ~idx
+
+    return string
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Util.py b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Util.py
new file mode 100644
index 000000000000..83e91435ed09
--- /dev/null
+++ b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Util.py
@@ -0,0 +1,25 @@
+# Util.py - Python extension for perf trace, miscellaneous utility code
+#
+# Copyright (C) 2010 by Tom Zanussi <tzanussi@gmail.com>
+#
+# This software may be distributed under the terms of the GNU General
+# Public License ("GPL") version 2 as published by the Free Software
+# Foundation.
+
+NSECS_PER_SEC    = 1000000000
+
+def avg(total, n):
+    return total / n
+
+def nsecs(secs, nsecs):
+    return secs * NSECS_PER_SEC + nsecs
+
+def nsecs_secs(nsecs):
+    return nsecs / NSECS_PER_SEC
+
+def nsecs_nsecs(nsecs):
+    return nsecs % NSECS_PER_SEC
+
+def nsecs_str(nsecs):
+    str = "%5u.%09u" % (nsecs_secs(nsecs), nsecs_nsecs(nsecs)),
+    return str
diff --git a/tools/perf/scripts/python/bin/failed-syscalls-by-pid-record b/tools/perf/scripts/python/bin/failed-syscalls-by-pid-record
new file mode 100644
index 000000000000..f8885d389e6f
--- /dev/null
+++ b/tools/perf/scripts/python/bin/failed-syscalls-by-pid-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e raw_syscalls:sys_exit
diff --git a/tools/perf/scripts/python/bin/failed-syscalls-by-pid-report b/tools/perf/scripts/python/bin/failed-syscalls-by-pid-report
new file mode 100644
index 000000000000..1e0c0a860c87
--- /dev/null
+++ b/tools/perf/scripts/python/bin/failed-syscalls-by-pid-report
@@ -0,0 +1,4 @@
+#!/bin/bash
+# description: system-wide failed syscalls, by pid
+# args: [comm]
+perf trace -s ~/libexec/perf-core/scripts/python/failed-syscalls-by-pid.py $1
diff --git a/tools/perf/scripts/python/bin/syscall-counts-by-pid-record b/tools/perf/scripts/python/bin/syscall-counts-by-pid-record
new file mode 100644
index 000000000000..45a8c50359da
--- /dev/null
+++ b/tools/perf/scripts/python/bin/syscall-counts-by-pid-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e raw_syscalls:sys_enter
diff --git a/tools/perf/scripts/python/bin/syscall-counts-by-pid-report b/tools/perf/scripts/python/bin/syscall-counts-by-pid-report
new file mode 100644
index 000000000000..f8044d192271
--- /dev/null
+++ b/tools/perf/scripts/python/bin/syscall-counts-by-pid-report
@@ -0,0 +1,4 @@
+#!/bin/bash
+# description: system-wide syscall counts, by pid
+# args: [comm]
+perf trace -s ~/libexec/perf-core/scripts/python/syscall-counts-by-pid.py $1
diff --git a/tools/perf/scripts/python/bin/syscall-counts-record b/tools/perf/scripts/python/bin/syscall-counts-record
new file mode 100644
index 000000000000..45a8c50359da
--- /dev/null
+++ b/tools/perf/scripts/python/bin/syscall-counts-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e raw_syscalls:sys_enter
diff --git a/tools/perf/scripts/python/bin/syscall-counts-report b/tools/perf/scripts/python/bin/syscall-counts-report
new file mode 100644
index 000000000000..a366aa61612f
--- /dev/null
+++ b/tools/perf/scripts/python/bin/syscall-counts-report
@@ -0,0 +1,4 @@
+#!/bin/bash
+# description: system-wide syscall counts
+# args: [comm]
+perf trace -s ~/libexec/perf-core/scripts/python/syscall-counts.py $1
diff --git a/tools/perf/scripts/python/check-perf-trace.py b/tools/perf/scripts/python/check-perf-trace.py
new file mode 100644
index 000000000000..964d934395ff
--- /dev/null
+++ b/tools/perf/scripts/python/check-perf-trace.py
@@ -0,0 +1,83 @@
+# perf trace event handlers, generated by perf trace -g python
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# This script tests basic functionality such as flag and symbol
+# strings, common_xxx() calls back into perf, begin, end, unhandled
+# events, etc.  Basically, if this script runs successfully and
+# displays expected results, Python scripting support should be ok.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from Core import *
+from perf_trace_context import *
+
+unhandled = autodict()
+
+def trace_begin():
+        print "trace_begin"
+        pass
+
+def trace_end():
+        print_unhandled()
+
+def irq__softirq_entry(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        vec):
+                print_header(event_name, common_cpu, common_secs, common_nsecs,
+                        common_pid, common_comm)
+
+                print_uncommon(context)
+
+                print "vec=%s\n" % \
+                (symbol_str("irq__softirq_entry", "vec", vec)),
+
+def kmem__kmalloc(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        call_site, ptr, bytes_req, bytes_alloc,
+        gfp_flags):
+                print_header(event_name, common_cpu, common_secs, common_nsecs,
+                        common_pid, common_comm)
+
+                print_uncommon(context)
+
+                print "call_site=%u, ptr=%u, bytes_req=%u, " \
+                "bytes_alloc=%u, gfp_flags=%s\n" % \
+                (call_site, ptr, bytes_req, bytes_alloc,
+
+                flag_str("kmem__kmalloc", "gfp_flags", gfp_flags)),
+
+def trace_unhandled(event_name, context, common_cpu, common_secs, common_nsecs,
+                common_pid, common_comm):
+    try:
+        unhandled[event_name] += 1
+    except TypeError:
+        unhandled[event_name] = 1
+
+def print_header(event_name, cpu, secs, nsecs, pid, comm):
+        print "%-20s %5u %05u.%09u %8u %-20s " % \
+        (event_name, cpu, secs, nsecs, pid, comm),
+
+# print trace fields not included in handler args
+def print_uncommon(context):
+    print "common_preempt_count=%d, common_flags=%s, common_lock_depth=%d, " \
+        % (common_pc(context), trace_flag_str(common_flags(context)), \
+               common_lock_depth(context))
+
+def print_unhandled():
+    keys = unhandled.keys()
+    if not keys:
+        return
+
+    print "\nunhandled events:\n\n",
+
+    print "%-40s  %10s\n" % ("event", "count"),
+    print "%-40s  %10s\n" % ("----------------------------------------", \
+                                 "-----------"),
+
+    for event_name in keys:
+        print "%-40s  %10d\n" % (event_name, unhandled[event_name])
diff --git a/tools/perf/scripts/python/failed-syscalls-by-pid.py b/tools/perf/scripts/python/failed-syscalls-by-pid.py
new file mode 100644
index 000000000000..0ca02278fe69
--- /dev/null
+++ b/tools/perf/scripts/python/failed-syscalls-by-pid.py
@@ -0,0 +1,68 @@
+# failed system call counts, by pid
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# Displays system-wide failed system call totals, broken down by pid.
+# If a [comm] arg is specified, only syscalls called by [comm] are displayed.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+
+usage = "perf trace -s syscall-counts-by-pid.py [comm]\n";
+
+for_comm = None
+
+if len(sys.argv) > 2:
+        sys.exit(usage)
+
+if len(sys.argv) > 1:
+        for_comm = sys.argv[1]
+
+syscalls = autodict()
+
+def trace_begin():
+        pass
+
+def trace_end():
+        print_error_totals()
+
+def raw_syscalls__sys_exit(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, ret):
+        if for_comm is not None:
+                if common_comm != for_comm:
+                        return
+
+        if ret < 0:
+                try:
+                        syscalls[common_comm][common_pid][id][ret] += 1
+                except TypeError:
+                        syscalls[common_comm][common_pid][id][ret] = 1
+
+def print_error_totals():
+    if for_comm is not None:
+            print "\nsyscall errors for %s:\n\n" % (for_comm),
+    else:
+            print "\nsyscall errors:\n\n",
+
+    print "%-30s  %10s\n" % ("comm [pid]", "count"),
+    print "%-30s  %10s\n" % ("------------------------------", \
+                                 "----------"),
+
+    comm_keys = syscalls.keys()
+    for comm in comm_keys:
+            pid_keys = syscalls[comm].keys()
+            for pid in pid_keys:
+                    print "\n%s [%d]\n" % (comm, pid),
+                    id_keys = syscalls[comm][pid].keys()
+                    for id in id_keys:
+                            print "  syscall: %-16d\n" % (id),
+                            ret_keys = syscalls[comm][pid][id].keys()
+                            for ret, val in sorted(syscalls[comm][pid][id].iteritems(), key = lambda(k, v): (v, k),  reverse = True):
+                                    print "    err = %-20d  %10d\n" % (ret, val),
diff --git a/tools/perf/scripts/python/syscall-counts-by-pid.py b/tools/perf/scripts/python/syscall-counts-by-pid.py
new file mode 100644
index 000000000000..af722d6a4b3f
--- /dev/null
+++ b/tools/perf/scripts/python/syscall-counts-by-pid.py
@@ -0,0 +1,64 @@
+# system call counts, by pid
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# Displays system-wide system call totals, broken down by syscall.
+# If a [comm] arg is specified, only syscalls called by [comm] are displayed.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+
+usage = "perf trace -s syscall-counts-by-pid.py [comm]\n";
+
+for_comm = None
+
+if len(sys.argv) > 2:
+        sys.exit(usage)
+
+if len(sys.argv) > 1:
+        for_comm = sys.argv[1]
+
+syscalls = autodict()
+
+def trace_begin():
+        pass
+
+def trace_end():
+        print_syscall_totals()
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+        if for_comm is not None:
+                if common_comm != for_comm:
+                        return
+        try:
+                syscalls[common_comm][common_pid][id] += 1
+        except TypeError:
+                syscalls[common_comm][common_pid][id] = 1
+
+def print_syscall_totals():
+    if for_comm is not None:
+            print "\nsyscall events for %s:\n\n" % (for_comm),
+    else:
+            print "\nsyscall events by comm/pid:\n\n",
+
+    print "%-40s  %10s\n" % ("comm [pid]/syscalls", "count"),
+    print "%-40s  %10s\n" % ("----------------------------------------", \
+                                 "----------"),
+
+    comm_keys = syscalls.keys()
+    for comm in comm_keys:
+            pid_keys = syscalls[comm].keys()
+            for pid in pid_keys:
+                    print "\n%s [%d]\n" % (comm, pid),
+                    id_keys = syscalls[comm][pid].keys()
+                    for id, val in sorted(syscalls[comm][pid].iteritems(), \
+                                  key = lambda(k, v): (v, k),  reverse = True):
+                            print "  %-38d  %10d\n" % (id, val),
diff --git a/tools/perf/scripts/python/syscall-counts.py b/tools/perf/scripts/python/syscall-counts.py
new file mode 100644
index 000000000000..f977e85ff049
--- /dev/null
+++ b/tools/perf/scripts/python/syscall-counts.py
@@ -0,0 +1,58 @@
+# system call counts
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# Displays system-wide system call totals, broken down by syscall.
+# If a [comm] arg is specified, only syscalls called by [comm] are displayed.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+
+usage = "perf trace -s syscall-counts.py [comm]\n";
+
+for_comm = None
+
+if len(sys.argv) > 2:
+        sys.exit(usage)
+
+if len(sys.argv) > 1:
+        for_comm = sys.argv[1]
+
+syscalls = autodict()
+
+def trace_begin():
+        pass
+
+def trace_end():
+        print_syscall_totals()
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+        if for_comm is not None:
+                if common_comm != for_comm:
+                        return
+        try:
+                syscalls[id] += 1
+        except TypeError:
+                syscalls[id] = 1
+
+def print_syscall_totals():
+    if for_comm is not None:
+            print "\nsyscall events for %s:\n\n" % (for_comm),
+    else:
+            print "\nsyscall events:\n\n",
+
+    print "%-40s  %10s\n" % ("event", "count"),
+    print "%-40s  %10s\n" % ("----------------------------------------", \
+                                 "-----------"),
+
+    for id, val in sorted(syscalls.iteritems(), key = lambda(k, v): (v, k), \
+                                  reverse = True):
+            print "%-40d  %10d\n" % (id, val),
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
new file mode 100644
index 000000000000..04904b35ba81
--- /dev/null
+++ b/tools/perf/util/build-id.c
@@ -0,0 +1,39 @@
+/*
+ * build-id.c
+ *
+ * build-id support
+ *
+ * Copyright (C) 2009, 2010 Red Hat Inc.
+ * Copyright (C) 2009, 2010 Arnaldo Carvalho de Melo <acme@redhat.com>
+ */
+#include "build-id.h"
+#include "event.h"
+#include "symbol.h"
+#include <linux/kernel.h>
+
+static int build_id__mark_dso_hit(event_t *event, struct perf_session *session)
+{
+        struct addr_location al;
+        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        struct thread *thread = perf_session__findnew(session, event->ip.pid);
+
+        if (thread == NULL) {
+                pr_err("problem processing %d event, skipping it.\n",
+                        event->header.type);
+                return -1;
+        }
+
+        thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
+                              event->ip.ip, &al);
+
+        if (al.map != NULL)
+                al.map->dso->hit = 1;
+
+        return 0;
+}
+
+struct perf_event_ops build_id__mark_dso_hit_ops = {
+        .sample = build_id__mark_dso_hit,
+        .mmap   = event__process_mmap,
+        .fork   = event__process_task,
+};
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
new file mode 100644
index 000000000000..1d981d63cf9a
--- /dev/null
+++ b/tools/perf/util/build-id.h
@@ -0,0 +1,8 @@
+#ifndef PERF_BUILD_ID_H_
+#define PERF_BUILD_ID_H_ 1
+
+#include "session.h"
+
+extern struct perf_event_ops build_id__mark_dso_hit_ops;
+
+#endif
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 6f8ea9d210b6..918eb376abe3 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -1,10 +1,15 @@
-#ifndef CACHE_H
-#define CACHE_H
+#ifndef __PERF_CACHE_H
+#define __PERF_CACHE_H
 
 #include "util.h"
 #include "strbuf.h"
 #include "../perf.h"
 
+#define CMD_EXEC_PATH "--exec-path"
+#define CMD_PERF_DIR "--perf-dir="
+#define CMD_WORK_TREE "--work-tree="
+#define CMD_DEBUGFS_DIR "--debugfs-dir="
+
 #define PERF_DIR_ENVIRONMENT "PERF_DIR"
 #define PERF_WORK_TREE_ENVIRONMENT "PERF_WORK_TREE"
 #define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
@@ -117,4 +122,4 @@ extern char *perf_pathdup(const char *fmt, ...)
 
 extern size_t strlcpy(char *dest, const char *src, size_t size);
 
-#endif /* CACHE_H */
+#endif /* __PERF_CACHE_H */
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 3b8380f1b478..b3b71258272a 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -206,7 +206,7 @@ fill_node(struct callchain_node *node, struct ip_callchain *chain,
         }
         node->val_nr = chain->nr - start;
         if (!node->val_nr)
-                printf("Warning: empty node in callchain tree\n");
+                pr_warning("Warning: empty node in callchain tree\n");
 }
 
 static void
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index 43cf3ea9e088..ad4626de4c2b 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -58,4 +58,4 @@ static inline u64 cumul_hits(struct callchain_node *node)
 int register_callchain_param(struct callchain_param *param);
 void append_chain(struct callchain_node *root, struct ip_callchain *chain,
                   struct symbol **syms);
-#endif
+#endif  /* __PERF_CALLCHAIN_H */
diff --git a/tools/perf/util/color.h b/tools/perf/util/color.h
index 58d597564b99..24e8809210bb 100644
--- a/tools/perf/util/color.h
+++ b/tools/perf/util/color.h
@@ -1,5 +1,5 @@
-#ifndef COLOR_H
-#define COLOR_H
+#ifndef __PERF_COLOR_H
+#define __PERF_COLOR_H
 
 /* "\033[1;38;5;2xx;48;5;2xxm\0" is 23 bytes */
 #define COLOR_MAXLEN 24
@@ -39,4 +39,4 @@ int color_fwrite_lines(FILE *fp, const char *color, size_t count, const char *bu
 int percent_color_fprintf(FILE *fp, const char *fmt, double percent);
 const char *get_percent_color(double percent);
 
-#endif /* COLOR_H */
+#endif /* __PERF_COLOR_H */
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
new file mode 100644
index 000000000000..4e01490e51e5
--- /dev/null
+++ b/tools/perf/util/cpumap.c
@@ -0,0 +1,59 @@
+#include "util.h"
+#include "../perf.h"
+#include "cpumap.h"
+#include <assert.h>
+#include <stdio.h>
+
+int cpumap[MAX_NR_CPUS];
+
+static int default_cpu_map(void)
+{
+        int nr_cpus, i;
+
+        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+        assert(nr_cpus <= MAX_NR_CPUS);
+        assert((int)nr_cpus >= 0);
+
+        for (i = 0; i < nr_cpus; ++i)
+                cpumap[i] = i;
+
+        return nr_cpus;
+}
+
+int read_cpu_map(void)
+{
+        FILE *onlnf;
+        int nr_cpus = 0;
+        int n, cpu, prev;
+        char sep;
+
+        onlnf = fopen("/sys/devices/system/cpu/online", "r");
+        if (!onlnf)
+                return default_cpu_map();
+
+        sep = 0;
+        prev = -1;
+        for (;;) {
+                n = fscanf(onlnf, "%u%c", &cpu, &sep);
+                if (n <= 0)
+                        break;
+                if (prev >= 0) {
+                        assert(nr_cpus + cpu - prev - 1 < MAX_NR_CPUS);
+                        while (++prev < cpu)
+                                cpumap[nr_cpus++] = prev;
+                }
+                assert (nr_cpus < MAX_NR_CPUS);
+                cpumap[nr_cpus++] = cpu;
+                if (n == 2 && sep == '-')
+                        prev = cpu;
+                else
+                        prev = -1;
+                if (n == 1 || sep == '\n')
+                        break;
+        }
+        fclose(onlnf);
+        if (nr_cpus > 0)
+                return nr_cpus;
+
+        return default_cpu_map();
+}
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
new file mode 100644
index 000000000000..86c78bb33098
--- /dev/null
+++ b/tools/perf/util/cpumap.h
@@ -0,0 +1,7 @@
+#ifndef __PERF_CPUMAP_H
+#define __PERF_CPUMAP_H
+
+extern int read_cpu_map(void);
+extern int cpumap[];
+
+#endif /* __PERF_CPUMAP_H */
diff --git a/tools/perf/util/ctype.c b/tools/perf/util/ctype.c
index 0b791bd346bc..35073621e5de 100644
--- a/tools/perf/util/ctype.c
+++ b/tools/perf/util/ctype.c
@@ -29,3 +29,11 @@ unsigned char sane_ctype[256] = {
         A, A, A, A, A, A, A, A, A, A, A, R, R, P, P, 0,         /* 112..127 */
         /* Nothing in the 128.. range */
 };
+
+const char *graph_line =
+        "_____________________________________________________________________"
+        "_____________________________________________________________________";
+const char *graph_dotted_line =
+        "---------------------------------------------------------------------"
+        "---------------------------------------------------------------------"
+        "---------------------------------------------------------------------";
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index e8ca98fe0bd4..0905600c3851 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -9,16 +9,17 @@
 #include "color.h"
 #include "event.h"
 #include "debug.h"
+#include "util.h"
 
 int verbose = 0;
 int dump_trace = 0;
 
-int eprintf(const char *fmt, ...)
+int eprintf(int level, const char *fmt, ...)
 {
         va_list args;
         int ret = 0;
 
-        if (verbose) {
+        if (verbose >= level) {
                 va_start(args, fmt);
                 ret = vfprintf(stderr, fmt, args);
                 va_end(args);
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 437eea58ce40..c6c24c522dea 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -1,8 +1,15 @@
 /* For debugging general purposes */
+#ifndef __PERF_DEBUG_H
+#define __PERF_DEBUG_H
+
+#include "event.h"
 
 extern int verbose;
 extern int dump_trace;
 
-int eprintf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
+int eprintf(int level,
+            const char *fmt, ...) __attribute__((format(printf, 2, 3)));
 int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
 void trace_event(event_t *event);
+
+#endif  /* __PERF_DEBUG_H */
diff --git a/tools/perf/util/debugfs.c b/tools/perf/util/debugfs.c
new file mode 100644
index 000000000000..a88fefc0cc0a
--- /dev/null
+++ b/tools/perf/util/debugfs.c
@@ -0,0 +1,240 @@
+#include "util.h"
+#include "debugfs.h"
+#include "cache.h"
+
+static int debugfs_premounted;
+static char debugfs_mountpoint[MAX_PATH+1];
+
+static const char *debugfs_known_mountpoints[] = {
+        "/sys/kernel/debug/",
+        "/debug/",
+        0,
+};
+
+/* use this to force a umount */
+void debugfs_force_cleanup(void)
+{
+        debugfs_find_mountpoint();
+        debugfs_premounted = 0;
+        debugfs_umount();
+}
+
+/* construct a full path to a debugfs element */
+int debugfs_make_path(const char *element, char *buffer, int size)
+{
+        int len;
+
+        if (strlen(debugfs_mountpoint) == 0) {
+                buffer[0] = '\0';
+                return -1;
+        }
+
+        len = strlen(debugfs_mountpoint) + strlen(element) + 1;
+        if (len >= size)
+                return len+1;
+
+        snprintf(buffer, size-1, "%s/%s", debugfs_mountpoint, element);
+        return 0;
+}
+
+static int debugfs_found;
+
+/* find the path to the mounted debugfs */
+const char *debugfs_find_mountpoint(void)
+{
+        const char **ptr;
+        char type[100];
+        FILE *fp;
+
+        if (debugfs_found)
+                return (const char *) debugfs_mountpoint;
+
+        ptr = debugfs_known_mountpoints;
+        while (*ptr) {
+                if (debugfs_valid_mountpoint(*ptr) == 0) {
+                        debugfs_found = 1;
+                        strcpy(debugfs_mountpoint, *ptr);
+                        return debugfs_mountpoint;
+                }
+                ptr++;
+        }
+
+        /* give up and parse /proc/mounts */
+        fp = fopen("/proc/mounts", "r");
+        if (fp == NULL)
+                die("Can't open /proc/mounts for read");
+
+        while (fscanf(fp, "%*s %"
+                      STR(MAX_PATH)
+                      "s %99s %*s %*d %*d\n",
+                      debugfs_mountpoint, type) == 2) {
+                if (strcmp(type, "debugfs") == 0)
+                        break;
+        }
+        fclose(fp);
+
+        if (strcmp(type, "debugfs") != 0)
+                return NULL;
+
+        debugfs_found = 1;
+
+        return debugfs_mountpoint;
+}
+
+/* verify that a mountpoint is actually a debugfs instance */
+
+int debugfs_valid_mountpoint(const char *debugfs)
+{
+        struct statfs st_fs;
+
+        if (statfs(debugfs, &st_fs) < 0)
+                return -ENOENT;
+        else if (st_fs.f_type != (long) DEBUGFS_MAGIC)
+                return -ENOENT;
+
+        return 0;
+}
+
+
+int debugfs_valid_entry(const char *path)
+{
+        struct stat st;
+
+        if (stat(path, &st))
+                return -errno;
+
+        return 0;
+}
+
+/* mount the debugfs somewhere if it's not mounted */
+
+char *debugfs_mount(const char *mountpoint)
+{
+        /* see if it's already mounted */
+        if (debugfs_find_mountpoint()) {
+                debugfs_premounted = 1;
+                return debugfs_mountpoint;
+        }
+
+        /* if not mounted and no argument */
+        if (mountpoint == NULL) {
+                /* see if environment variable set */
+                mountpoint = getenv(PERF_DEBUGFS_ENVIRONMENT);
+                /* if no environment variable, use default */
+                if (mountpoint == NULL)
+                        mountpoint = "/sys/kernel/debug";
+        }
+
+        if (mount(NULL, mountpoint, "debugfs", 0, NULL) < 0)
+                return NULL;
+
+        /* save the mountpoint */
+        strncpy(debugfs_mountpoint, mountpoint, sizeof(debugfs_mountpoint));
+        debugfs_found = 1;
+
+        return debugfs_mountpoint;
+}
+
+/* umount the debugfs */
+
+int debugfs_umount(void)
+{
+        char umountcmd[128];
+        int ret;
+
+        /* if it was already mounted, leave it */
+        if (debugfs_premounted)
+                return 0;
+
+        /* make sure it's a valid mount point */
+        ret = debugfs_valid_mountpoint(debugfs_mountpoint);
+        if (ret)
+                return ret;
+
+        snprintf(umountcmd, sizeof(umountcmd),
+                 "/bin/umount %s", debugfs_mountpoint);
+        return system(umountcmd);
+}
+
+int debugfs_write(const char *entry, const char *value)
+{
+        char path[MAX_PATH+1];
+        int ret, count;
+        int fd;
+
+        /* construct the path */
+        snprintf(path, sizeof(path), "%s/%s", debugfs_mountpoint, entry);
+
+        /* verify that it exists */
+        ret = debugfs_valid_entry(path);
+        if (ret)
+                return ret;
+
+        /* get how many chars we're going to write */
+        count = strlen(value);
+
+        /* open the debugfs entry */
+        fd = open(path, O_RDWR);
+        if (fd < 0)
+                return -errno;
+
+        while (count > 0) {
+                /* write it */
+                ret = write(fd, value, count);
+                if (ret <= 0) {
+                        if (ret == EAGAIN)
+                                continue;
+                        close(fd);
+                        return -errno;
+                }
+                count -= ret;
+        }
+
+        /* close it */
+        close(fd);
+
+        /* return success */
+        return 0;
+}
+
+/*
+ * read a debugfs entry
+ * returns the number of chars read or a negative errno
+ */
+int debugfs_read(const char *entry, char *buffer, size_t size)
+{
+        char path[MAX_PATH+1];
+        int ret;
+        int fd;
+
+        /* construct the path */
+        snprintf(path, sizeof(path), "%s/%s", debugfs_mountpoint, entry);
+
+        /* verify that it exists */
+        ret = debugfs_valid_entry(path);
+        if (ret)
+                return ret;
+
+        /* open the debugfs entry */
+        fd = open(path, O_RDONLY);
+        if (fd < 0)
+                return -errno;
+
+        do {
+                /* read it */
+                ret = read(fd, buffer, size);
+                if (ret == 0) {
+                        close(fd);
+                        return EOF;
+                }
+        } while (ret < 0 && errno == EAGAIN);
+
+        /* close it */
+        close(fd);
+
+        /* make *sure* there's a null character at the end */
+        buffer[ret] = '\0';
+
+        /* return the number of chars read */
+        return ret;
+}
diff --git a/tools/perf/util/debugfs.h b/tools/perf/util/debugfs.h
new file mode 100644
index 000000000000..83a02879745f
--- /dev/null
+++ b/tools/perf/util/debugfs.h
@@ -0,0 +1,25 @@
+#ifndef __DEBUGFS_H__
+#define __DEBUGFS_H__
+
+#include <sys/mount.h>
+
+#ifndef MAX_PATH
+# define MAX_PATH 256
+#endif
+
+#ifndef STR
+# define _STR(x) #x
+# define STR(x) _STR(x)
+#endif
+
+extern const char *debugfs_find_mountpoint(void);
+extern int debugfs_valid_mountpoint(const char *debugfs);
+extern int debugfs_valid_entry(const char *path);
+extern char *debugfs_mount(const char *mountpoint);
+extern int debugfs_umount(void);
+extern int debugfs_write(const char *entry, const char *value);
+extern int debugfs_read(const char *entry, char *buffer, size_t size);
+extern void debugfs_force_cleanup(void);
+extern int debugfs_make_path(const char *element, char *buffer, int size);
+
+#endif /* __DEBUGFS_H__ */
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
new file mode 100644
index 000000000000..705ec63548b4
--- /dev/null
+++ b/tools/perf/util/event.c
@@ -0,0 +1,612 @@
+#include <linux/types.h>
+#include "event.h"
+#include "debug.h"
+#include "session.h"
+#include "sort.h"
+#include "string.h"
+#include "strlist.h"
+#include "thread.h"
+
+static pid_t event__synthesize_comm(pid_t pid, int full,
+                                    event__handler_t process,
+                                    struct perf_session *session)
+{
+        event_t ev;
+        char filename[PATH_MAX];
+        char bf[BUFSIZ];
+        FILE *fp;
+        size_t size = 0;
+        DIR *tasks;
+        struct dirent dirent, *next;
+        pid_t tgid = 0;
+
+        snprintf(filename, sizeof(filename), "/proc/%d/status", pid);
+
+        fp = fopen(filename, "r");
+        if (fp == NULL) {
+out_race:
+                /*
+                 * We raced with a task exiting - just return:
+                 */
+                pr_debug("couldn't open %s\n", filename);
+                return 0;
+        }
+
+        memset(&ev.comm, 0, sizeof(ev.comm));
+        while (!ev.comm.comm[0] || !ev.comm.pid) {
+                if (fgets(bf, sizeof(bf), fp) == NULL)
+                        goto out_failure;
+
+                if (memcmp(bf, "Name:", 5) == 0) {
+                        char *name = bf + 5;
+                        while (*name && isspace(*name))
+                                ++name;
+                        size = strlen(name) - 1;
+                        memcpy(ev.comm.comm, name, size++);
+                } else if (memcmp(bf, "Tgid:", 5) == 0) {
+                        char *tgids = bf + 5;
+                        while (*tgids && isspace(*tgids))
+                                ++tgids;
+                        tgid = ev.comm.pid = atoi(tgids);
+                }
+        }
+
+        ev.comm.header.type = PERF_RECORD_COMM;
+        size = ALIGN(size, sizeof(u64));
+        ev.comm.header.size = sizeof(ev.comm) - (sizeof(ev.comm.comm) - size);
+
+        if (!full) {
+                ev.comm.tid = pid;
+
+                process(&ev, session);
+                goto out_fclose;
+        }
+
+        snprintf(filename, sizeof(filename), "/proc/%d/task", pid);
+
+        tasks = opendir(filename);
+        if (tasks == NULL)
+                goto out_race;
+
+        while (!readdir_r(tasks, &dirent, &next) && next) {
+                char *end;
+                pid = strtol(dirent.d_name, &end, 10);
+                if (*end)
+                        continue;
+
+                ev.comm.tid = pid;
+
+                process(&ev, session);
+        }
+        closedir(tasks);
+
+out_fclose:
+        fclose(fp);
+        return tgid;
+
+out_failure:
+        pr_warning("couldn't get COMM and pgid, malformed %s\n", filename);
+        return -1;
+}
+
+static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
+                                         event__handler_t process,
+                                         struct perf_session *session)
+{
+        char filename[PATH_MAX];
+        FILE *fp;
+
+        snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
+
+        fp = fopen(filename, "r");
+        if (fp == NULL) {
+                /*
+                 * We raced with a task exiting - just return:
+                 */
+                pr_debug("couldn't open %s\n", filename);
+                return -1;
+        }
+
+        while (1) {
+                char bf[BUFSIZ], *pbf = bf;
+                event_t ev = {
+                        .header = {
+                                .type = PERF_RECORD_MMAP,
+                                .misc = 0, /* Just like the kernel, see kernel/perf_event.c __perf_event_mmap */
+                         },
+                };
+                int n;
+                size_t size;
+                if (fgets(bf, sizeof(bf), fp) == NULL)
+                        break;
+
+                /* 00400000-0040c000 r-xp 00000000 fd:01 41038  /bin/cat */
+                n = hex2u64(pbf, &ev.mmap.start);
+                if (n < 0)
+                        continue;
+                pbf += n + 1;
+                n = hex2u64(pbf, &ev.mmap.len);
+                if (n < 0)
+                        continue;
+                pbf += n + 3;
+                if (*pbf == 'x') { /* vm_exec */
+                        char *execname = strchr(bf, '/');
+
+                        /* Catch VDSO */
+                        if (execname == NULL)
+                                execname = strstr(bf, "[vdso]");
+
+                        if (execname == NULL)
+                                continue;
+
+                        size = strlen(execname);
+                        execname[size - 1] = '\0'; /* Remove \n */
+                        memcpy(ev.mmap.filename, execname, size);
+                        size = ALIGN(size, sizeof(u64));
+                        ev.mmap.len -= ev.mmap.start;
+                        ev.mmap.header.size = (sizeof(ev.mmap) -
+                                               (sizeof(ev.mmap.filename) - size));
+                        ev.mmap.pid = tgid;
+                        ev.mmap.tid = pid;
+
+                        process(&ev, session);
+                }
+        }
+
+        fclose(fp);
+        return 0;
+}
+
+int event__synthesize_modules(event__handler_t process,
+                              struct perf_session *session)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(&session->kmaps.maps[MAP__FUNCTION]);
+             nd; nd = rb_next(nd)) {
+                event_t ev;
+                size_t size;
+                struct map *pos = rb_entry(nd, struct map, rb_node);
+
+                if (pos->dso->kernel)
+                        continue;
+
+                size = ALIGN(pos->dso->long_name_len + 1, sizeof(u64));
+                memset(&ev, 0, sizeof(ev));
+                ev.mmap.header.misc = 1; /* kernel uses 0 for user space maps, see kernel/perf_event.c __perf_event_mmap */
+                ev.mmap.header.type = PERF_RECORD_MMAP;
+                ev.mmap.header.size = (sizeof(ev.mmap) -
+                                        (sizeof(ev.mmap.filename) - size));
+                ev.mmap.start = pos->start;
+                ev.mmap.len   = pos->end - pos->start;
+
+                memcpy(ev.mmap.filename, pos->dso->long_name,
+                       pos->dso->long_name_len + 1);
+                process(&ev, session);
+        }
+
+        return 0;
+}
+
+int event__synthesize_thread(pid_t pid, event__handler_t process,
+                             struct perf_session *session)
+{
+        pid_t tgid = event__synthesize_comm(pid, 1, process, session);
+        if (tgid == -1)
+                return -1;
+        return event__synthesize_mmap_events(pid, tgid, process, session);
+}
+
+void event__synthesize_threads(event__handler_t process,
+                               struct perf_session *session)
+{
+        DIR *proc;
+        struct dirent dirent, *next;
+
+        proc = opendir("/proc");
+
+        while (!readdir_r(proc, &dirent, &next) && next) {
+                char *end;
+                pid_t pid = strtol(dirent.d_name, &end, 10);
+
+                if (*end) /* only interested in proper numerical dirents */
+                        continue;
+
+                event__synthesize_thread(pid, process, session);
+        }
+
+        closedir(proc);
+}
+
+struct process_symbol_args {
+        const char *name;
+        u64        start;
+};
+
+static int find_symbol_cb(void *arg, const char *name, char type, u64 start)
+{
+        struct process_symbol_args *args = arg;
+
+        /*
+         * Must be a function or at least an alias, as in PARISC64, where "_text" is
+         * an 'A' to the same address as "_stext".
+         */
+        if (!(symbol_type__is_a(type, MAP__FUNCTION) ||
+              type == 'A') || strcmp(name, args->name))
+                return 0;
+
+        args->start = start;
+        return 1;
+}
+
+int event__synthesize_kernel_mmap(event__handler_t process,
+                                  struct perf_session *session,
+                                  const char *symbol_name)
+{
+        size_t size;
+        event_t ev = {
+                .header = {
+                        .type = PERF_RECORD_MMAP,
+                        .misc = 1, /* kernel uses 0 for user space maps, see kernel/perf_event.c __perf_event_mmap */
+                },
+        };
+        /*
+         * We should get this from /sys/kernel/sections/.text, but till that is
+         * available use this, and after it is use this as a fallback for older
+         * kernels.
+         */
+        struct process_symbol_args args = { .name = symbol_name, };
+
+        if (kallsyms__parse("/proc/kallsyms", &args, find_symbol_cb) <= 0)
+                return -ENOENT;
+
+        size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename),
+                        "[kernel.kallsyms.%s]", symbol_name) + 1;
+        size = ALIGN(size, sizeof(u64));
+        ev.mmap.header.size = (sizeof(ev.mmap) - (sizeof(ev.mmap.filename) - size));
+        ev.mmap.pgoff = args.start;
+        ev.mmap.start = session->vmlinux_maps[MAP__FUNCTION]->start;
+        ev.mmap.len   = session->vmlinux_maps[MAP__FUNCTION]->end - ev.mmap.start ;
+
+        return process(&ev, session);
+}
+
+static void thread__comm_adjust(struct thread *self)
+{
+        char *comm = self->comm;
+
+        if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
+            (!symbol_conf.comm_list ||
+             strlist__has_entry(symbol_conf.comm_list, comm))) {
+                unsigned int slen = strlen(comm);
+
+                if (slen > comms__col_width) {
+                        comms__col_width = slen;
+                        threads__col_width = slen + 6;
+                }
+        }
+}
+
+static int thread__set_comm_adjust(struct thread *self, const char *comm)
+{
+        int ret = thread__set_comm(self, comm);
+
+        if (ret)
+                return ret;
+
+        thread__comm_adjust(self);
+
+        return 0;
+}
+
+int event__process_comm(event_t *self, struct perf_session *session)
+{
+        struct thread *thread = perf_session__findnew(session, self->comm.pid);
+
+        dump_printf(": %s:%d\n", self->comm.comm, self->comm.pid);
+
+        if (thread == NULL || thread__set_comm_adjust(thread, self->comm.comm)) {
+                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+int event__process_lost(event_t *self, struct perf_session *session)
+{
+        dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost);
+        session->events_stats.lost += self->lost.lost;
+        return 0;
+}
+
+int event__process_mmap(event_t *self, struct perf_session *session)
+{
+        struct thread *thread;
+        struct map *map;
+
+        dump_printf(" %d/%d: [%#Lx(%#Lx) @ %#Lx]: %s\n",
+                    self->mmap.pid, self->mmap.tid, self->mmap.start,
+                    self->mmap.len, self->mmap.pgoff, self->mmap.filename);
+
+        if (self->mmap.pid == 0) {
+                static const char kmmap_prefix[] = "[kernel.kallsyms.";
+
+                if (self->mmap.filename[0] == '/') {
+                        char short_module_name[1024];
+                        char *name = strrchr(self->mmap.filename, '/'), *dot;
+
+                        if (name == NULL)
+                                goto out_problem;
+
+                        ++name; /* skip / */
+                        dot = strrchr(name, '.');
+                        if (dot == NULL)
+                                goto out_problem;
+
+                        snprintf(short_module_name, sizeof(short_module_name),
+                                 "[%.*s]", (int)(dot - name), name);
+                        strxfrchar(short_module_name, '-', '_');
+
+                        map = perf_session__new_module_map(session,
+                                                           self->mmap.start,
+                                                           self->mmap.filename);
+                        if (map == NULL)
+                                goto out_problem;
+
+                        name = strdup(short_module_name);
+                        if (name == NULL)
+                                goto out_problem;
+
+                        map->dso->short_name = name;
+                        map->end = map->start + self->mmap.len;
+                } else if (memcmp(self->mmap.filename, kmmap_prefix,
+                                sizeof(kmmap_prefix) - 1) == 0) {
+                        const char *symbol_name = (self->mmap.filename +
+                                                   sizeof(kmmap_prefix) - 1);
+                        /*
+                         * Should be there already, from the build-id table in
+                         * the header.
+                         */
+                        struct dso *kernel = __dsos__findnew(&dsos__kernel,
+                                                             "[kernel.kallsyms]");
+                        if (kernel == NULL)
+                                goto out_problem;
+
+                        kernel->kernel = 1;
+                        if (__perf_session__create_kernel_maps(session, kernel) < 0)
+                                goto out_problem;
+
+                        session->vmlinux_maps[MAP__FUNCTION]->start = self->mmap.start;
+                        session->vmlinux_maps[MAP__FUNCTION]->end   = self->mmap.start + self->mmap.len;
+                        /*
+                         * Be a bit paranoid here, some perf.data file came with
+                         * a zero sized synthesized MMAP event for the kernel.
+                         */
+                        if (session->vmlinux_maps[MAP__FUNCTION]->end == 0)
+                                session->vmlinux_maps[MAP__FUNCTION]->end = ~0UL;
+
+                        perf_session__set_kallsyms_ref_reloc_sym(session, symbol_name,
+                                                                 self->mmap.pgoff);
+                }
+                return 0;
+        }
+
+        thread = perf_session__findnew(session, self->mmap.pid);
+        map = map__new(&self->mmap, MAP__FUNCTION,
+                       session->cwd, session->cwdlen);
+
+        if (thread == NULL || map == NULL)
+                goto out_problem;
+
+        thread__insert_map(thread, map);
+        return 0;
+
+out_problem:
+        dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
+        return 0;
+}
+
+int event__process_task(event_t *self, struct perf_session *session)
+{
+        struct thread *thread = perf_session__findnew(session, self->fork.pid);
+        struct thread *parent = perf_session__findnew(session, self->fork.ppid);
+
+        dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
+                    self->fork.ppid, self->fork.ptid);
+        /*
+         * A thread clone will have the same PID for both parent and child.
+         */
+        if (thread == parent)
+                return 0;
+
+        if (self->header.type == PERF_RECORD_EXIT)
+                return 0;
+
+        if (thread == NULL || parent == NULL ||
+            thread__fork(thread, parent) < 0) {
+                dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+void thread__find_addr_map(struct thread *self,
+                           struct perf_session *session, u8 cpumode,
+                           enum map_type type, u64 addr,
+                           struct addr_location *al)
+{
+        struct map_groups *mg = &self->mg;
+
+        al->thread = self;
+        al->addr = addr;
+
+        if (cpumode == PERF_RECORD_MISC_KERNEL) {
+                al->level = 'k';
+                mg = &session->kmaps;
+        } else if (cpumode == PERF_RECORD_MISC_USER)
+                al->level = '.';
+        else {
+                al->level = 'H';
+                al->map = NULL;
+                return;
+        }
+try_again:
+        al->map = map_groups__find(mg, type, al->addr);
+        if (al->map == NULL) {
+                /*
+                 * If this is outside of all known maps, and is a negative
+                 * address, try to look it up in the kernel dso, as it might be
+                 * a vsyscall or vdso (which executes in user-mode).
+                 *
+                 * XXX This is nasty, we should have a symbol list in the
+                 * "[vdso]" dso, but for now lets use the old trick of looking
+                 * in the whole kernel symbol list.
+                 */
+                if ((long long)al->addr < 0 && mg != &session->kmaps) {
+                        mg = &session->kmaps;
+                        goto try_again;
+                }
+        } else
+                al->addr = al->map->map_ip(al->map, al->addr);
+}
+
+void thread__find_addr_location(struct thread *self,
+                                struct perf_session *session, u8 cpumode,
+                                enum map_type type, u64 addr,
+                                struct addr_location *al,
+                                symbol_filter_t filter)
+{
+        thread__find_addr_map(self, session, cpumode, type, addr, al);
+        if (al->map != NULL)
+                al->sym = map__find_symbol(al->map, al->addr, filter);
+        else
+                al->sym = NULL;
+}
+
+static void dso__calc_col_width(struct dso *self)
+{
+        if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
+            (!symbol_conf.dso_list ||
+             strlist__has_entry(symbol_conf.dso_list, self->name))) {
+                unsigned int slen = strlen(self->name);
+                if (slen > dsos__col_width)
+                        dsos__col_width = slen;
+        }
+
+        self->slen_calculated = 1;
+}
+
+int event__preprocess_sample(const event_t *self, struct perf_session *session,
+                             struct addr_location *al, symbol_filter_t filter)
+{
+        u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        struct thread *thread = perf_session__findnew(session, self->ip.pid);
+
+        if (thread == NULL)
+                return -1;
+
+        if (symbol_conf.comm_list &&
+            !strlist__has_entry(symbol_conf.comm_list, thread->comm))
+                goto out_filtered;
+
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
+        thread__find_addr_location(thread, session, cpumode, MAP__FUNCTION,
+                                   self->ip.ip, al, filter);
+        dump_printf(" ...... dso: %s\n",
+                    al->map ? al->map->dso->long_name :
+                        al->level == 'H' ? "[hypervisor]" : "<not found>");
+        /*
+         * We have to do this here as we may have a dso with no symbol hit that
+         * has a name longer than the ones with symbols sampled.
+         */
+        if (al->map && !sort_dso.elide && !al->map->dso->slen_calculated)
+                dso__calc_col_width(al->map->dso);
+
+        if (symbol_conf.dso_list &&
+            (!al->map || !al->map->dso ||
+             !(strlist__has_entry(symbol_conf.dso_list, al->map->dso->short_name) ||
+               (al->map->dso->short_name != al->map->dso->long_name &&
+                strlist__has_entry(symbol_conf.dso_list, al->map->dso->long_name)))))
+                goto out_filtered;
+
+        if (symbol_conf.sym_list && al->sym &&
+            !strlist__has_entry(symbol_conf.sym_list, al->sym->name))
+                goto out_filtered;
+
+        al->filtered = false;
+        return 0;
+
+out_filtered:
+        al->filtered = true;
+        return 0;
+}
+
+int event__parse_sample(event_t *event, u64 type, struct sample_data *data)
+{
+        u64 *array = event->sample.array;
+
+        if (type & PERF_SAMPLE_IP) {
+                data->ip = event->ip.ip;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_TID) {
+                u32 *p = (u32 *)array;
+                data->pid = p[0];
+                data->tid = p[1];
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_TIME) {
+                data->time = *array;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_ADDR) {
+                data->addr = *array;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_ID) {
+                data->id = *array;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_STREAM_ID) {
+                data->stream_id = *array;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_CPU) {
+                u32 *p = (u32 *)array;
+                data->cpu = *p;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_PERIOD) {
+                data->period = *array;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_READ) {
+                pr_debug("PERF_SAMPLE_READ is unsuported for now\n");
+                return -1;
+        }
+
+        if (type & PERF_SAMPLE_CALLCHAIN) {
+                data->callchain = (struct ip_callchain *)array;
+                array += 1 + data->callchain->nr;
+        }
+
+        if (type & PERF_SAMPLE_RAW) {
+                u32 *p = (u32 *)array;
+                data->raw_size = *p;
+                p++;
+                data->raw_data = p;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 2c9c26d6ded0..a33b94952e34 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -1,14 +1,10 @@
 #ifndef __PERF_RECORD_H
 #define __PERF_RECORD_H
-#include "../perf.h"
-#include "util.h"
-#include <linux/list.h>
 
-enum {
-        SHOW_KERNEL     = 1,
-        SHOW_USER       = 2,
-        SHOW_HV         = 4,
-};
+#include <limits.h>
+
+#include "../perf.h"
+#include "map.h"
 
 /*
  * PERF_SAMPLE_IP | PERF_SAMPLE_TID | *
@@ -60,11 +56,32 @@ struct read_event {
         u64 id;
 };
 
-struct sample_event{
+struct sample_event {
         struct perf_event_header        header;
         u64 array[];
 };
 
+struct sample_data {
+        u64 ip;
+        u32 pid, tid;
+        u64 time;
+        u64 addr;
+        u64 id;
+        u64 stream_id;
+        u32 cpu;
+        u64 period;
+        struct ip_callchain *callchain;
+        u32 raw_size;
+        void *raw_data;
+};
+
+#define BUILD_ID_SIZE 20
+
+struct build_id_event {
+        struct perf_event_header header;
+        u8                       build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
+        char                     filename[];
+};
 
 typedef union event_union {
         struct perf_event_header        header;
@@ -77,28 +94,44 @@ typedef union event_union {
         struct sample_event             sample;
 } event_t;
 
-struct map {
-        struct list_head        node;
-        u64                     start;
-        u64                     end;
-        u64                     pgoff;
-        u64                     (*map_ip)(struct map *, u64);
-        struct dso              *dso;
+struct events_stats {
+        u64 total;
+        u64 lost;
 };
 
-static inline u64 map__map_ip(struct map *map, u64 ip)
-{
-        return ip - map->start + map->pgoff;
-}
+struct event_stat_id {
+        struct rb_node          rb_node;
+        struct rb_root          hists;
+        struct events_stats     stats;
+        u64                     config;
+        u64                     event_stream;
+        u32                     type;
+};
+
+void event__print_totals(void);
+
+struct perf_session;
+
+typedef int (*event__handler_t)(event_t *event, struct perf_session *session);
+
+int event__synthesize_thread(pid_t pid, event__handler_t process,
+                             struct perf_session *session);
+void event__synthesize_threads(event__handler_t process,
+                               struct perf_session *session);
+int event__synthesize_kernel_mmap(event__handler_t process,
+                                  struct perf_session *session,
+                                  const char *symbol_name);
+int event__synthesize_modules(event__handler_t process,
+                              struct perf_session *session);
 
-static inline u64 vdso__map_ip(struct map *map __used, u64 ip)
-{
-        return ip;
-}
+int event__process_comm(event_t *self, struct perf_session *session);
+int event__process_lost(event_t *self, struct perf_session *session);
+int event__process_mmap(event_t *self, struct perf_session *session);
+int event__process_task(event_t *self, struct perf_session *session);
 
-struct map *map__new(struct mmap_event *event, char *cwd, int cwdlen);
-struct map *map__clone(struct map *self);
-int map__overlap(struct map *l, struct map *r);
-size_t map__fprintf(struct map *self, FILE *fp);
+struct addr_location;
+int event__preprocess_sample(const event_t *self, struct perf_session *session,
+                             struct addr_location *al, symbol_filter_t filter);
+int event__parse_sample(event_t *event, u64 type, struct sample_data *data);
 
-#endif
+#endif /* __PERF_RECORD_H */
diff --git a/tools/perf/util/exec_cmd.h b/tools/perf/util/exec_cmd.h
index effe25eb1545..31647ac92ed1 100644
--- a/tools/perf/util/exec_cmd.h
+++ b/tools/perf/util/exec_cmd.h
@@ -1,5 +1,5 @@
-#ifndef PERF_EXEC_CMD_H
-#define PERF_EXEC_CMD_H
+#ifndef __PERF_EXEC_CMD_H
+#define __PERF_EXEC_CMD_H
 
 extern void perf_set_argv_exec_path(const char *exec_path);
 extern const char *perf_extract_argv0_path(const char *path);
@@ -10,4 +10,4 @@ extern int execv_perf_cmd(const char **argv); /* NULL terminated */
 extern int execl_perf_cmd(const char *cmd, ...);
 extern const char *system_path(const char *path);
 
-#endif /* PERF_EXEC_CMD_H */
+#endif /* __PERF_EXEC_CMD_H */
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index e306857b2c2b..6c9aa16ee51f 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -1,10 +1,20 @@
+#define _FILE_OFFSET_BITS 64
+
 #include <sys/types.h>
+#include <byteswap.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <linux/list.h>
+#include <linux/kernel.h>
 
 #include "util.h"
 #include "header.h"
+#include "../perf.h"
+#include "trace-event.h"
+#include "session.h"
+#include "symbol.h"
+#include "debug.h"
 
 /*
  * Create new perf.data header attribute:
@@ -13,75 +23,80 @@ struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr)
 {
         struct perf_header_attr *self = malloc(sizeof(*self));
 
-        if (!self)
-                die("nomem");
-
-        self->attr = *attr;
-        self->ids = 0;
-        self->size = 1;
-        self->id = malloc(sizeof(u64));
-
-        if (!self->id)
-                die("nomem");
+        if (self != NULL) {
+                self->attr = *attr;
+                self->ids  = 0;
+                self->size = 1;
+                self->id   = malloc(sizeof(u64));
+                if (self->id == NULL) {
+                        free(self);
+                        self = NULL;
+                }
+        }
 
         return self;
 }
 
-void perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
+void perf_header_attr__delete(struct perf_header_attr *self)
+{
+        free(self->id);
+        free(self);
+}
+
+int perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
 {
         int pos = self->ids;
 
         self->ids++;
         if (self->ids > self->size) {
-                self->size *= 2;
-                self->id = realloc(self->id, self->size * sizeof(u64));
-                if (!self->id)
-                        die("nomem");
+                int nsize = self->size * 2;
+                u64 *nid = realloc(self->id, nsize * sizeof(u64));
+
+                if (nid == NULL)
+                        return -1;
+
+                self->size = nsize;
+                self->id = nid;
         }
         self->id[pos] = id;
+        return 0;
 }
 
-/*
- * Create new perf.data header:
- */
-struct perf_header *perf_header__new(void)
+int perf_header__init(struct perf_header *self)
 {
-        struct perf_header *self = malloc(sizeof(*self));
-
-        if (!self)
-                die("nomem");
-
-        self->frozen = 0;
-
-        self->attrs = 0;
         self->size = 1;
         self->attr = malloc(sizeof(void *));
-
-        if (!self->attr)
-                die("nomem");
-
-        self->data_offset = 0;
-        self->data_size = 0;
-
-        return self;
+        return self->attr == NULL ? -ENOMEM : 0;
 }
 
-void perf_header__add_attr(struct perf_header *self,
-                           struct perf_header_attr *attr)
+void perf_header__exit(struct perf_header *self)
 {
-        int pos = self->attrs;
+        int i;
+        for (i = 0; i < self->attrs; ++i)
+                perf_header_attr__delete(self->attr[i]);
+        free(self->attr);
+}
 
+int perf_header__add_attr(struct perf_header *self,
+                          struct perf_header_attr *attr)
+{
         if (self->frozen)
-                die("frozen");
-
-        self->attrs++;
-        if (self->attrs > self->size) {
-                self->size *= 2;
-                self->attr = realloc(self->attr, self->size * sizeof(void *));
-                if (!self->attr)
-                        die("nomem");
+                return -1;
+
+        if (self->attrs == self->size) {
+                int nsize = self->size * 2;
+                struct perf_header_attr **nattr;
+
+                nattr = realloc(self->attr, nsize * sizeof(void *));
+                if (nattr == NULL)
+                        return -1;
+
+                self->size = nsize;
+                self->attr = nattr;
         }
-        self->attr[pos] = attr;
+
+        self->attr[self->attrs++] = attr;
+        return 0;
 }
 
 #define MAX_EVENT_NAME 64
@@ -94,24 +109,28 @@ struct perf_trace_event_type {
 static int event_count;
 static struct perf_trace_event_type *events;
 
-void perf_header__push_event(u64 id, const char *name)
+int perf_header__push_event(u64 id, const char *name)
 {
         if (strlen(name) > MAX_EVENT_NAME)
-                printf("Event %s will be truncated\n", name);
+                pr_warning("Event %s will be truncated\n", name);
 
         if (!events) {
                 events = malloc(sizeof(struct perf_trace_event_type));
-                if (!events)
-                        die("nomem");
+                if (events == NULL)
+                        return -ENOMEM;
         } else {
-                events = realloc(events, (event_count + 1) * sizeof(struct perf_trace_event_type));
-                if (!events)
-                        die("nomem");
+                struct perf_trace_event_type *nevents;
+
+                nevents = realloc(events, (event_count + 1) * sizeof(*events));
+                if (nevents == NULL)
+                        return -ENOMEM;
+                events = nevents;
         }
         memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
         events[event_count].event_id = id;
         strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
         event_count++;
+        return 0;
 }
 
 char *perf_header__find_event(u64 id)
@@ -128,44 +147,292 @@ static const char *__perf_magic = "PERFFILE";
 
 #define PERF_MAGIC      (*(u64 *)__perf_magic)
 
-struct perf_file_section {
-        u64 offset;
-        u64 size;
-};
-
 struct perf_file_attr {
         struct perf_event_attr  attr;
         struct perf_file_section        ids;
 };
 
-struct perf_file_header {
-        u64                             magic;
-        u64                             size;
-        u64                             attr_size;
-        struct perf_file_section        attrs;
-        struct perf_file_section        data;
-        struct perf_file_section        event_types;
-};
+void perf_header__set_feat(struct perf_header *self, int feat)
+{
+        set_bit(feat, self->adds_features);
+}
 
-static void do_write(int fd, void *buf, size_t size)
+bool perf_header__has_feat(const struct perf_header *self, int feat)
+{
+        return test_bit(feat, self->adds_features);
+}
+
+static int do_write(int fd, const void *buf, size_t size)
 {
         while (size) {
                 int ret = write(fd, buf, size);
 
                 if (ret < 0)
-                        die("failed to write");
+                        return -errno;
 
                 size -= ret;
                 buf += ret;
         }
+
+        return 0;
+}
+
+#define NAME_ALIGN 64
+
+static int write_padded(int fd, const void *bf, size_t count,
+                        size_t count_aligned)
+{
+        static const char zero_buf[NAME_ALIGN];
+        int err = do_write(fd, bf, count);
+
+        if (!err)
+                err = do_write(fd, zero_buf, count_aligned - count);
+
+        return err;
+}
+
+#define dsos__for_each_with_build_id(pos, head) \
+        list_for_each_entry(pos, head, node)    \
+                if (!pos->has_build_id)         \
+                        continue;               \
+                else
+
+static int __dsos__write_buildid_table(struct list_head *head, u16 misc, int fd)
+{
+        struct dso *pos;
+
+        dsos__for_each_with_build_id(pos, head) {
+                int err;
+                struct build_id_event b;
+                size_t len;
+
+                if (!pos->hit)
+                        continue;
+                len = pos->long_name_len + 1;
+                len = ALIGN(len, NAME_ALIGN);
+                memset(&b, 0, sizeof(b));
+                memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
+                b.header.misc = misc;
+                b.header.size = sizeof(b) + len;
+                err = do_write(fd, &b, sizeof(b));
+                if (err < 0)
+                        return err;
+                err = write_padded(fd, pos->long_name,
+                                   pos->long_name_len + 1, len);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+static int dsos__write_buildid_table(int fd)
+{
+        int err = __dsos__write_buildid_table(&dsos__kernel,
+                                              PERF_RECORD_MISC_KERNEL, fd);
+        if (err == 0)
+                err = __dsos__write_buildid_table(&dsos__user,
+                                                  PERF_RECORD_MISC_USER, fd);
+        return err;
+}
+
+int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
+                          const char *name, bool is_kallsyms)
+{
+        const size_t size = PATH_MAX;
+        char *filename = malloc(size),
+             *linkname = malloc(size), *targetname;
+        int len, err = -1;
+
+        if (filename == NULL || linkname == NULL)
+                goto out_free;
+
+        len = snprintf(filename, size, "%s%s%s",
+                       debugdir, is_kallsyms ? "/" : "", name);
+        if (mkdir_p(filename, 0755))
+                goto out_free;
+
+        snprintf(filename + len, sizeof(filename) - len, "/%s", sbuild_id);
+
+        if (access(filename, F_OK)) {
+                if (is_kallsyms) {
+                         if (copyfile("/proc/kallsyms", filename))
+                                goto out_free;
+                } else if (link(name, filename) && copyfile(name, filename))
+                        goto out_free;
+        }
+
+        len = snprintf(linkname, size, "%s/.build-id/%.2s",
+                       debugdir, sbuild_id);
+
+        if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
+                goto out_free;
+
+        snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
+        targetname = filename + strlen(debugdir) - 5;
+        memcpy(targetname, "../..", 5);
+
+        if (symlink(targetname, linkname) == 0)
+                err = 0;
+out_free:
+        free(filename);
+        free(linkname);
+        return err;
+}
+
+static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
+                                 const char *name, const char *debugdir,
+                                 bool is_kallsyms)
+{
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        build_id__sprintf(build_id, build_id_size, sbuild_id);
+
+        return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);
+}
+
+int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
+{
+        const size_t size = PATH_MAX;
+        char *filename = malloc(size),
+             *linkname = malloc(size);
+        int err = -1;
+
+        if (filename == NULL || linkname == NULL)
+                goto out_free;
+
+        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
+                 debugdir, sbuild_id, sbuild_id + 2);
+
+        if (access(linkname, F_OK))
+                goto out_free;
+
+        if (readlink(linkname, filename, size) < 0)
+                goto out_free;
+
+        if (unlink(linkname))
+                goto out_free;
+
+        /*
+         * Since the link is relative, we must make it absolute:
+         */
+        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
+                 debugdir, sbuild_id, filename);
+
+        if (unlink(linkname))
+                goto out_free;
+
+        err = 0;
+out_free:
+        free(filename);
+        free(linkname);
+        return err;
+}
+
+static int dso__cache_build_id(struct dso *self, const char *debugdir)
+{
+        bool is_kallsyms = self->kernel && self->long_name[0] != '/';
+
+        return build_id_cache__add_b(self->build_id, sizeof(self->build_id),
+                                     self->long_name, debugdir, is_kallsyms);
+}
+
+static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
+{
+        struct dso *pos;
+        int err = 0;
+
+        dsos__for_each_with_build_id(pos, head)
+                if (dso__cache_build_id(pos, debugdir))
+                        err = -1;
+
+        return err;
+}
+
+static int dsos__cache_build_ids(void)
+{
+        int err_kernel, err_user;
+        char debugdir[PATH_MAX];
+
+        snprintf(debugdir, sizeof(debugdir), "%s/%s", getenv("HOME"),
+                 DEBUG_CACHE_DIR);
+
+        if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
+                return -1;
+
+        err_kernel = __dsos__cache_build_ids(&dsos__kernel, debugdir);
+        err_user   = __dsos__cache_build_ids(&dsos__user, debugdir);
+        return err_kernel || err_user ? -1 : 0;
+}
+
+static int perf_header__adds_write(struct perf_header *self, int fd)
+{
+        int nr_sections;
+        struct perf_file_section *feat_sec;
+        int sec_size;
+        u64 sec_start;
+        int idx = 0, err;
+
+        if (dsos__read_build_ids(true))
+                perf_header__set_feat(self, HEADER_BUILD_ID);
+
+        nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
+        if (!nr_sections)
+                return 0;
+
+        feat_sec = calloc(sizeof(*feat_sec), nr_sections);
+        if (feat_sec == NULL)
+                return -ENOMEM;
+
+        sec_size = sizeof(*feat_sec) * nr_sections;
+
+        sec_start = self->data_offset + self->data_size;
+        lseek(fd, sec_start + sec_size, SEEK_SET);
+
+        if (perf_header__has_feat(self, HEADER_TRACE_INFO)) {
+                struct perf_file_section *trace_sec;
+
+                trace_sec = &feat_sec[idx++];
+
+                /* Write trace info */
+                trace_sec->offset = lseek(fd, 0, SEEK_CUR);
+                read_tracing_data(fd, attrs, nr_counters);
+                trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
+        }
+
+
+        if (perf_header__has_feat(self, HEADER_BUILD_ID)) {
+                struct perf_file_section *buildid_sec;
+
+                buildid_sec = &feat_sec[idx++];
+
+                /* Write build-ids */
+                buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
+                err = dsos__write_buildid_table(fd);
+                if (err < 0) {
+                        pr_debug("failed to write buildid table\n");
+                        goto out_free;
+                }
+                buildid_sec->size = lseek(fd, 0, SEEK_CUR) -
+                                          buildid_sec->offset;
+                dsos__cache_build_ids();
+        }
+
+        lseek(fd, sec_start, SEEK_SET);
+        err = do_write(fd, feat_sec, sec_size);
+        if (err < 0)
+                pr_debug("failed to write feature section\n");
+out_free:
+        free(feat_sec);
+        return err;
 }
 
-void perf_header__write(struct perf_header *self, int fd)
+int perf_header__write(struct perf_header *self, int fd, bool at_exit)
 {
         struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
         struct perf_header_attr *attr;
-        int i;
+        int i, err;
 
         lseek(fd, sizeof(f_header), SEEK_SET);
 
@@ -174,7 +441,11 @@ void perf_header__write(struct perf_header *self, int fd)
                 attr = self->attr[i];
 
                 attr->id_offset = lseek(fd, 0, SEEK_CUR);
-                do_write(fd, attr->id, attr->ids * sizeof(u64));
+                err = do_write(fd, attr->id, attr->ids * sizeof(u64));
+                if (err < 0) {
+                        pr_debug("failed to write perf header\n");
+                        return err;
+                }
         }
 
 
@@ -190,17 +461,31 @@ void perf_header__write(struct perf_header *self, int fd)
                                 .size   = attr->ids * sizeof(u64),
                         }
                 };
-                do_write(fd, &f_attr, sizeof(f_attr));
+                err = do_write(fd, &f_attr, sizeof(f_attr));
+                if (err < 0) {
+                        pr_debug("failed to write perf header attribute\n");
+                        return err;
+                }
         }
 
         self->event_offset = lseek(fd, 0, SEEK_CUR);
         self->event_size = event_count * sizeof(struct perf_trace_event_type);
-        if (events)
-                do_write(fd, events, self->event_size);
-
+        if (events) {
+                err = do_write(fd, events, self->event_size);
+                if (err < 0) {
+                        pr_debug("failed to write perf header events\n");
+                        return err;
+                }
+        }
 
         self->data_offset = lseek(fd, 0, SEEK_CUR);
 
+        if (at_exit) {
+                err = perf_header__adds_write(self, fd);
+                if (err < 0)
+                        return err;
+        }
+
         f_header = (struct perf_file_header){
                 .magic     = PERF_MAGIC,
                 .size      = sizeof(f_header),
@@ -219,44 +504,175 @@ void perf_header__write(struct perf_header *self, int fd)
                 },
         };
 
+        memcpy(&f_header.adds_features, &self->adds_features, sizeof(self->adds_features));
+
         lseek(fd, 0, SEEK_SET);
-        do_write(fd, &f_header, sizeof(f_header));
+        err = do_write(fd, &f_header, sizeof(f_header));
+        if (err < 0) {
+                pr_debug("failed to write perf header\n");
+                return err;
+        }
         lseek(fd, self->data_offset + self->data_size, SEEK_SET);
 
         self->frozen = 1;
+        return 0;
 }
 
-static void do_read(int fd, void *buf, size_t size)
+static int do_read(int fd, void *buf, size_t size)
 {
         while (size) {
                 int ret = read(fd, buf, size);
 
-                if (ret < 0)
-                        die("failed to read");
-                if (ret == 0)
-                        die("failed to read: missing data");
+                if (ret <= 0)
+                        return -1;
 
                 size -= ret;
                 buf += ret;
         }
+
+        return 0;
 }
 
-struct perf_header *perf_header__read(int fd)
+static int perf_header__getbuffer64(struct perf_header *self,
+                                    int fd, void *buf, size_t size)
 {
-        struct perf_header      *self = perf_header__new();
-        struct perf_file_header f_header;
-        struct perf_file_attr   f_attr;
-        u64                     f_id;
+        if (do_read(fd, buf, size))
+                return -1;
 
-        int nr_attrs, nr_ids, i, j;
+        if (self->needs_swap)
+                mem_bswap_64(buf, size);
+
+        return 0;
+}
+
+int perf_header__process_sections(struct perf_header *self, int fd,
+                                  int (*process)(struct perf_file_section *self,
+                                                 struct perf_header *ph,
+                                                 int feat, int fd))
+{
+        struct perf_file_section *feat_sec;
+        int nr_sections;
+        int sec_size;
+        int idx = 0;
+        int err = -1, feat = 1;
+
+        nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
+        if (!nr_sections)
+                return 0;
+
+        feat_sec = calloc(sizeof(*feat_sec), nr_sections);
+        if (!feat_sec)
+                return -1;
+
+        sec_size = sizeof(*feat_sec) * nr_sections;
+
+        lseek(fd, self->data_offset + self->data_size, SEEK_SET);
+
+        if (perf_header__getbuffer64(self, fd, feat_sec, sec_size))
+                goto out_free;
+
+        err = 0;
+        while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
+                if (perf_header__has_feat(self, feat)) {
+                        struct perf_file_section *sec = &feat_sec[idx++];
+
+                        err = process(sec, self, feat, fd);
+                        if (err < 0)
+                                break;
+                }
+                ++feat;
+        }
+out_free:
+        free(feat_sec);
+        return err;
+}
 
+int perf_file_header__read(struct perf_file_header *self,
+                           struct perf_header *ph, int fd)
+{
         lseek(fd, 0, SEEK_SET);
-        do_read(fd, &f_header, sizeof(f_header));
 
-        if (f_header.magic      != PERF_MAGIC           ||
-            f_header.size       != sizeof(f_header)     ||
-            f_header.attr_size  != sizeof(f_attr))
-                die("incompatible file format");
+        if (do_read(fd, self, sizeof(*self)) ||
+            memcmp(&self->magic, __perf_magic, sizeof(self->magic)))
+                return -1;
+
+        if (self->attr_size != sizeof(struct perf_file_attr)) {
+                u64 attr_size = bswap_64(self->attr_size);
+
+                if (attr_size != sizeof(struct perf_file_attr))
+                        return -1;
+
+                mem_bswap_64(self, offsetof(struct perf_file_header,
+                                            adds_features));
+                ph->needs_swap = true;
+        }
+
+        if (self->size != sizeof(*self)) {
+                /* Support the previous format */
+                if (self->size == offsetof(typeof(*self), adds_features))
+                        bitmap_zero(self->adds_features, HEADER_FEAT_BITS);
+                else
+                        return -1;
+        }
+
+        memcpy(&ph->adds_features, &self->adds_features,
+               sizeof(ph->adds_features));
+        /*
+         * FIXME: hack that assumes that if we need swap the perf.data file
+         * may be coming from an arch with a different word-size, ergo different
+         * DEFINE_BITMAP format, investigate more later, but for now its mostly
+         * safe to assume that we have a build-id section. Trace files probably
+         * have several other issues in this realm anyway...
+         */
+        if (ph->needs_swap) {
+                memset(&ph->adds_features, 0, sizeof(ph->adds_features));
+                perf_header__set_feat(ph, HEADER_BUILD_ID);
+        }
+
+        ph->event_offset = self->event_types.offset;
+        ph->event_size   = self->event_types.size;
+        ph->data_offset  = self->data.offset;
+        ph->data_size    = self->data.size;
+        return 0;
+}
+
+static int perf_file_section__process(struct perf_file_section *self,
+                                      struct perf_header *ph,
+                                      int feat, int fd)
+{
+        if (lseek(fd, self->offset, SEEK_SET) == (off_t)-1) {
+                pr_debug("Failed to lseek to %Ld offset for feature %d, "
+                         "continuing...\n", self->offset, feat);
+                return 0;
+        }
+
+        switch (feat) {
+        case HEADER_TRACE_INFO:
+                trace_report(fd);
+                break;
+
+        case HEADER_BUILD_ID:
+                if (perf_header__read_build_ids(ph, fd, self->offset, self->size))
+                        pr_debug("Failed to read buildids, continuing...\n");
+                break;
+        default:
+                pr_debug("unknown feature %d, continuing...\n", feat);
+        }
+
+        return 0;
+}
+
+int perf_header__read(struct perf_header *self, int fd)
+{
+        struct perf_file_header f_header;
+        struct perf_file_attr   f_attr;
+        u64                     f_id;
+        int nr_attrs, nr_ids, i, j;
+
+        if (perf_file_header__read(&f_header, self, fd) < 0) {
+                pr_debug("incompatible file format\n");
+                return -EINVAL;
+        }
 
         nr_attrs = f_header.attrs.size / sizeof(f_attr);
         lseek(fd, f_header.attrs.offset, SEEK_SET);
@@ -265,42 +681,54 @@ struct perf_header *perf_header__read(int fd)
                 struct perf_header_attr *attr;
                 off_t tmp;
 
-                do_read(fd, &f_attr, sizeof(f_attr));
+                if (perf_header__getbuffer64(self, fd, &f_attr, sizeof(f_attr)))
+                        goto out_errno;
+
                 tmp = lseek(fd, 0, SEEK_CUR);
 
                 attr = perf_header_attr__new(&f_attr.attr);
+                if (attr == NULL)
+                         return -ENOMEM;
 
                 nr_ids = f_attr.ids.size / sizeof(u64);
                 lseek(fd, f_attr.ids.offset, SEEK_SET);
 
                 for (j = 0; j < nr_ids; j++) {
-                        do_read(fd, &f_id, sizeof(f_id));
+                        if (perf_header__getbuffer64(self, fd, &f_id, sizeof(f_id)))
+                                goto out_errno;
 
-                        perf_header_attr__add_id(attr, f_id);
+                        if (perf_header_attr__add_id(attr, f_id) < 0) {
+                                perf_header_attr__delete(attr);
+                                return -ENOMEM;
+                        }
+                }
+                if (perf_header__add_attr(self, attr) < 0) {
+                        perf_header_attr__delete(attr);
+                        return -ENOMEM;
                 }
-                perf_header__add_attr(self, attr);
+
                 lseek(fd, tmp, SEEK_SET);
         }
 
         if (f_header.event_types.size) {
                 lseek(fd, f_header.event_types.offset, SEEK_SET);
                 events = malloc(f_header.event_types.size);
-                if (!events)
-                        die("nomem");
-                do_read(fd, events, f_header.event_types.size);
+                if (events == NULL)
+                        return -ENOMEM;
+                if (perf_header__getbuffer64(self, fd, events,
+                                             f_header.event_types.size))
+                        goto out_errno;
                 event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
         }
-        self->event_offset = f_header.event_types.offset;
-        self->event_size   = f_header.event_types.size;
 
-        self->data_offset = f_header.data.offset;
-        self->data_size   = f_header.data.size;
+        perf_header__process_sections(self, fd, perf_file_section__process);
 
         lseek(fd, self->data_offset, SEEK_SET);
 
         self->frozen = 1;
-
-        return self;
+        return 0;
+out_errno:
+        return -errno;
 }
 
 u64 perf_header__sample_type(struct perf_header *header)
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index a0761bc7863c..82a6af72d4cc 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -1,9 +1,13 @@
-#ifndef _PERF_HEADER_H
-#define _PERF_HEADER_H
+#ifndef __PERF_HEADER_H
+#define __PERF_HEADER_H
 
 #include "../../../include/linux/perf_event.h"
 #include <sys/types.h>
+#include <stdbool.h>
 #include "types.h"
+#include "event.h"
+
+#include <linux/bitmap.h>
 
 struct perf_header_attr {
         struct perf_event_attr attr;
@@ -12,36 +16,77 @@ struct perf_header_attr {
         off_t id_offset;
 };
 
+enum {
+        HEADER_TRACE_INFO = 1,
+        HEADER_BUILD_ID,
+        HEADER_LAST_FEATURE,
+};
+
+#define HEADER_FEAT_BITS                        256
+
+struct perf_file_section {
+        u64 offset;
+        u64 size;
+};
+
+struct perf_file_header {
+        u64                             magic;
+        u64                             size;
+        u64                             attr_size;
+        struct perf_file_section        attrs;
+        struct perf_file_section        data;
+        struct perf_file_section        event_types;
+        DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
+};
+
+struct perf_header;
+
+int perf_file_header__read(struct perf_file_header *self,
+                           struct perf_header *ph, int fd);
+
 struct perf_header {
-        int frozen;
-        int attrs, size;
+        int                     frozen;
+        int                     attrs, size;
         struct perf_header_attr **attr;
-        s64 attr_offset;
-        u64 data_offset;
-        u64 data_size;
-        u64 event_offset;
-        u64 event_size;
+        s64                     attr_offset;
+        u64                     data_offset;
+        u64                     data_size;
+        u64                     event_offset;
+        u64                     event_size;
+        bool                    needs_swap;
+        DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
 };
 
-struct perf_header *perf_header__read(int fd);
-void perf_header__write(struct perf_header *self, int fd);
+int perf_header__init(struct perf_header *self);
+void perf_header__exit(struct perf_header *self);
+
+int perf_header__read(struct perf_header *self, int fd);
+int perf_header__write(struct perf_header *self, int fd, bool at_exit);
 
-void perf_header__add_attr(struct perf_header *self,
-                           struct perf_header_attr *attr);
+int perf_header__add_attr(struct perf_header *self,
+                          struct perf_header_attr *attr);
 
-void perf_header__push_event(u64 id, const char *name);
+int perf_header__push_event(u64 id, const char *name);
 char *perf_header__find_event(u64 id);
 
+struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr);
+void perf_header_attr__delete(struct perf_header_attr *self);
 
-struct perf_header_attr *
-perf_header_attr__new(struct perf_event_attr *attr);
-void perf_header_attr__add_id(struct perf_header_attr *self, u64 id);
+int perf_header_attr__add_id(struct perf_header_attr *self, u64 id);
 
 u64 perf_header__sample_type(struct perf_header *header);
 struct perf_event_attr *
 perf_header__find_attr(u64 id, struct perf_header *header);
+void perf_header__set_feat(struct perf_header *self, int feat);
+bool perf_header__has_feat(const struct perf_header *self, int feat);
 
+int perf_header__process_sections(struct perf_header *self, int fd,
+                                  int (*process)(struct perf_file_section *self,
+                                                 struct perf_header *ph,
+                                                 int feat, int fd));
 
-struct perf_header *perf_header__new(void);
+int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
+                          const char *name, bool is_kallsyms);
+int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir);
 
-#endif /* _PERF_HEADER_H */
+#endif /* __PERF_HEADER_H */
diff --git a/tools/perf/util/help.h b/tools/perf/util/help.h
index 7128783637b4..7f5c6dedd714 100644
--- a/tools/perf/util/help.h
+++ b/tools/perf/util/help.h
@@ -1,5 +1,5 @@
-#ifndef HELP_H
-#define HELP_H
+#ifndef __PERF_HELP_H
+#define __PERF_HELP_H
 
 struct cmdnames {
         size_t alloc;
@@ -26,4 +26,4 @@ int is_in_cmdlist(struct cmdnames *c, const char *s);
 void list_commands(const char *title, struct cmdnames *main_cmds,
                    struct cmdnames *other_cmds);
 
-#endif /* HELP_H */
+#endif /* __PERF_HELP_H */
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
new file mode 100644
index 000000000000..2be33c7dbf03
--- /dev/null
+++ b/tools/perf/util/hist.c
@@ -0,0 +1,668 @@
+#include "hist.h"
+#include "session.h"
+#include "sort.h"
+#include <math.h>
+
+struct callchain_param  callchain_param = {
+        .mode   = CHAIN_GRAPH_REL,
+        .min_percent = 0.5
+};
+
+/*
+ * histogram, sorted on item, collects counts
+ */
+
+struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists,
+                                                  struct addr_location *al,
+                                                  struct symbol *sym_parent,
+                                                  u64 count, bool *hit)
+{
+        struct rb_node **p = &hists->rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *he;
+        struct hist_entry entry = {
+                .thread = al->thread,
+                .map    = al->map,
+                .sym    = al->sym,
+                .ip     = al->addr,
+                .level  = al->level,
+                .count  = count,
+                .parent = sym_parent,
+        };
+        int cmp;
+
+        while (*p != NULL) {
+                parent = *p;
+                he = rb_entry(parent, struct hist_entry, rb_node);
+
+                cmp = hist_entry__cmp(&entry, he);
+
+                if (!cmp) {
+                        *hit = true;
+                        return he;
+                }
+
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        he = malloc(sizeof(*he));
+        if (!he)
+                return NULL;
+        *he = entry;
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, hists);
+        *hit = false;
+        return he;
+}
+
+int64_t
+hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct sort_entry *se;
+        int64_t cmp = 0;
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                cmp = se->cmp(left, right);
+                if (cmp)
+                        break;
+        }
+
+        return cmp;
+}
+
+int64_t
+hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
+{
+        struct sort_entry *se;
+        int64_t cmp = 0;
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                int64_t (*f)(struct hist_entry *, struct hist_entry *);
+
+                f = se->collapse ?: se->cmp;
+
+                cmp = f(left, right);
+                if (cmp)
+                        break;
+        }
+
+        return cmp;
+}
+
+void hist_entry__free(struct hist_entry *he)
+{
+        free(he);
+}
+
+/*
+ * collapse the histogram
+ */
+
+static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *iter;
+        int64_t cmp;
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct hist_entry, rb_node);
+
+                cmp = hist_entry__collapse(iter, he);
+
+                if (!cmp) {
+                        iter->count += he->count;
+                        hist_entry__free(he);
+                        return;
+                }
+
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, root);
+}
+
+void perf_session__collapse_resort(struct rb_root *hists)
+{
+        struct rb_root tmp;
+        struct rb_node *next;
+        struct hist_entry *n;
+
+        if (!sort__need_collapse)
+                return;
+
+        tmp = RB_ROOT;
+        next = rb_first(hists);
+
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                next = rb_next(&n->rb_node);
+
+                rb_erase(&n->rb_node, hists);
+                collapse__insert_entry(&tmp, n);
+        }
+
+        *hists = tmp;
+}
+
+/*
+ * reverse the map, sort on count.
+ */
+
+static void perf_session__insert_output_hist_entry(struct rb_root *root,
+                                                   struct hist_entry *he,
+                                                   u64 min_callchain_hits)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *iter;
+
+        if (symbol_conf.use_callchain)
+                callchain_param.sort(&he->sorted_chain, &he->callchain,
+                                      min_callchain_hits, &callchain_param);
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct hist_entry, rb_node);
+
+                if (he->count > iter->count)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, root);
+}
+
+void perf_session__output_resort(struct rb_root *hists, u64 total_samples)
+{
+        struct rb_root tmp;
+        struct rb_node *next;
+        struct hist_entry *n;
+        u64 min_callchain_hits;
+
+        min_callchain_hits =
+                total_samples * (callchain_param.min_percent / 100);
+
+        tmp = RB_ROOT;
+        next = rb_first(hists);
+
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                next = rb_next(&n->rb_node);
+
+                rb_erase(&n->rb_node, hists);
+                perf_session__insert_output_hist_entry(&tmp, n,
+                                                       min_callchain_hits);
+        }
+
+        *hists = tmp;
+}
+
+static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
+{
+        int i;
+        int ret = fprintf(fp, "            ");
+
+        for (i = 0; i < left_margin; i++)
+                ret += fprintf(fp, " ");
+
+        return ret;
+}
+
+static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
+                                          int left_margin)
+{
+        int i;
+        size_t ret = callchain__fprintf_left_margin(fp, left_margin);
+
+        for (i = 0; i < depth; i++)
+                if (depth_mask & (1 << i))
+                        ret += fprintf(fp, "|          ");
+                else
+                        ret += fprintf(fp, "           ");
+
+        ret += fprintf(fp, "\n");
+
+        return ret;
+}
+
+static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
+                                     int depth, int depth_mask, int count,
+                                     u64 total_samples, int hits,
+                                     int left_margin)
+{
+        int i;
+        size_t ret = 0;
+
+        ret += callchain__fprintf_left_margin(fp, left_margin);
+        for (i = 0; i < depth; i++) {
+                if (depth_mask & (1 << i))
+                        ret += fprintf(fp, "|");
+                else
+                        ret += fprintf(fp, " ");
+                if (!count && i == depth - 1) {
+                        double percent;
+
+                        percent = hits * 100.0 / total_samples;
+                        ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
+                } else
+                        ret += fprintf(fp, "%s", "          ");
+        }
+        if (chain->sym)
+                ret += fprintf(fp, "%s\n", chain->sym->name);
+        else
+                ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
+
+        return ret;
+}
+
+static struct symbol *rem_sq_bracket;
+static struct callchain_list rem_hits;
+
+static void init_rem_hits(void)
+{
+        rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
+        if (!rem_sq_bracket) {
+                fprintf(stderr, "Not enough memory to display remaining hits\n");
+                return;
+        }
+
+        strcpy(rem_sq_bracket->name, "[...]");
+        rem_hits.sym = rem_sq_bracket;
+}
+
+static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
+                                         u64 total_samples, int depth,
+                                         int depth_mask, int left_margin)
+{
+        struct rb_node *node, *next;
+        struct callchain_node *child;
+        struct callchain_list *chain;
+        int new_depth_mask = depth_mask;
+        u64 new_total;
+        u64 remaining;
+        size_t ret = 0;
+        int i;
+
+        if (callchain_param.mode == CHAIN_GRAPH_REL)
+                new_total = self->children_hit;
+        else
+                new_total = total_samples;
+
+        remaining = new_total;
+
+        node = rb_first(&self->rb_root);
+        while (node) {
+                u64 cumul;
+
+                child = rb_entry(node, struct callchain_node, rb_node);
+                cumul = cumul_hits(child);
+                remaining -= cumul;
+
+                /*
+                 * The depth mask manages the output of pipes that show
+                 * the depth. We don't want to keep the pipes of the current
+                 * level for the last child of this depth.
+                 * Except if we have remaining filtered hits. They will
+                 * supersede the last child
+                 */
+                next = rb_next(node);
+                if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
+                        new_depth_mask &= ~(1 << (depth - 1));
+
+                /*
+                 * But we keep the older depth mask for the line separator
+                 * to keep the level link until we reach the last child
+                 */
+                ret += ipchain__fprintf_graph_line(fp, depth, depth_mask,
+                                                   left_margin);
+                i = 0;
+                list_for_each_entry(chain, &child->val, list) {
+                        if (chain->ip >= PERF_CONTEXT_MAX)
+                                continue;
+                        ret += ipchain__fprintf_graph(fp, chain, depth,
+                                                      new_depth_mask, i++,
+                                                      new_total,
+                                                      cumul,
+                                                      left_margin);
+                }
+                ret += __callchain__fprintf_graph(fp, child, new_total,
+                                                  depth + 1,
+                                                  new_depth_mask | (1 << depth),
+                                                  left_margin);
+                node = next;
+        }
+
+        if (callchain_param.mode == CHAIN_GRAPH_REL &&
+                remaining && remaining != new_total) {
+
+                if (!rem_sq_bracket)
+                        return ret;
+
+                new_depth_mask &= ~(1 << (depth - 1));
+
+                ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
+                                              new_depth_mask, 0, new_total,
+                                              remaining, left_margin);
+        }
+
+        return ret;
+}
+
+static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
+                                       u64 total_samples, int left_margin)
+{
+        struct callchain_list *chain;
+        bool printed = false;
+        int i = 0;
+        int ret = 0;
+
+        list_for_each_entry(chain, &self->val, list) {
+                if (chain->ip >= PERF_CONTEXT_MAX)
+                        continue;
+
+                if (!i++ && sort__first_dimension == SORT_SYM)
+                        continue;
+
+                if (!printed) {
+                        ret += callchain__fprintf_left_margin(fp, left_margin);
+                        ret += fprintf(fp, "|\n");
+                        ret += callchain__fprintf_left_margin(fp, left_margin);
+                        ret += fprintf(fp, "---");
+
+                        left_margin += 3;
+                        printed = true;
+                } else
+                        ret += callchain__fprintf_left_margin(fp, left_margin);
+
+                if (chain->sym)
+                        ret += fprintf(fp, " %s\n", chain->sym->name);
+                else
+                        ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
+        }
+
+        ret += __callchain__fprintf_graph(fp, self, total_samples, 1, 1, left_margin);
+
+        return ret;
+}
+
+static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
+                                      u64 total_samples)
+{
+        struct callchain_list *chain;
+        size_t ret = 0;
+
+        if (!self)
+                return 0;
+
+        ret += callchain__fprintf_flat(fp, self->parent, total_samples);
+
+
+        list_for_each_entry(chain, &self->val, list) {
+                if (chain->ip >= PERF_CONTEXT_MAX)
+                        continue;
+                if (chain->sym)
+                        ret += fprintf(fp, "                %s\n", chain->sym->name);
+                else
+                        ret += fprintf(fp, "                %p\n",
+                                        (void *)(long)chain->ip);
+        }
+
+        return ret;
+}
+
+static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
+                                            u64 total_samples, int left_margin)
+{
+        struct rb_node *rb_node;
+        struct callchain_node *chain;
+        size_t ret = 0;
+
+        rb_node = rb_first(&self->sorted_chain);
+        while (rb_node) {
+                double percent;
+
+                chain = rb_entry(rb_node, struct callchain_node, rb_node);
+                percent = chain->hit * 100.0 / total_samples;
+                switch (callchain_param.mode) {
+                case CHAIN_FLAT:
+                        ret += percent_color_fprintf(fp, "           %6.2f%%\n",
+                                                     percent);
+                        ret += callchain__fprintf_flat(fp, chain, total_samples);
+                        break;
+                case CHAIN_GRAPH_ABS: /* Falldown */
+                case CHAIN_GRAPH_REL:
+                        ret += callchain__fprintf_graph(fp, chain, total_samples,
+                                                        left_margin);
+                case CHAIN_NONE:
+                default:
+                        break;
+                }
+                ret += fprintf(fp, "\n");
+                rb_node = rb_next(rb_node);
+        }
+
+        return ret;
+}
+
+static size_t hist_entry__fprintf(struct hist_entry *self,
+                                  struct perf_session *pair_session,
+                                  bool show_displacement,
+                                  long displacement, FILE *fp,
+                                  u64 session_total)
+{
+        struct sort_entry *se;
+        u64 count, total;
+        const char *sep = symbol_conf.field_sep;
+        size_t ret;
+
+        if (symbol_conf.exclude_other && !self->parent)
+                return 0;
+
+        if (pair_session) {
+                count = self->pair ? self->pair->count : 0;
+                total = pair_session->events_stats.total;
+        } else {
+                count = self->count;
+                total = session_total;
+        }
+
+        if (total)
+                ret = percent_color_fprintf(fp, sep ? "%.2f" : "   %6.2f%%",
+                                            (count * 100.0) / total);
+        else
+                ret = fprintf(fp, sep ? "%lld" : "%12lld ", count);
+
+        if (symbol_conf.show_nr_samples) {
+                if (sep)
+                        fprintf(fp, "%c%lld", *sep, count);
+                else
+                        fprintf(fp, "%11lld", count);
+        }
+
+        if (pair_session) {
+                char bf[32];
+                double old_percent = 0, new_percent = 0, diff;
+
+                if (total > 0)
+                        old_percent = (count * 100.0) / total;
+                if (session_total > 0)
+                        new_percent = (self->count * 100.0) / session_total;
+
+                diff = new_percent - old_percent;
+
+                if (fabs(diff) >= 0.01)
+                        snprintf(bf, sizeof(bf), "%+4.2F%%", diff);
+                else
+                        snprintf(bf, sizeof(bf), " ");
+
+                if (sep)
+                        ret += fprintf(fp, "%c%s", *sep, bf);
+                else
+                        ret += fprintf(fp, "%11.11s", bf);
+
+                if (show_displacement) {
+                        if (displacement)
+                                snprintf(bf, sizeof(bf), "%+4ld", displacement);
+                        else
+                                snprintf(bf, sizeof(bf), " ");
+
+                        if (sep)
+                                fprintf(fp, "%c%s", *sep, bf);
+                        else
+                                fprintf(fp, "%6.6s", bf);
+                }
+        }
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                if (se->elide)
+                        continue;
+
+                fprintf(fp, "%s", sep ?: "  ");
+                ret += se->print(fp, self, se->width ? *se->width : 0);
+        }
+
+        ret += fprintf(fp, "\n");
+
+        if (symbol_conf.use_callchain) {
+                int left_margin = 0;
+
+                if (sort__first_dimension == SORT_COMM) {
+                        se = list_first_entry(&hist_entry__sort_list, typeof(*se),
+                                                list);
+                        left_margin = se->width ? *se->width : 0;
+                        left_margin -= thread__comm_len(self->thread);
+                }
+
+                hist_entry_callchain__fprintf(fp, self, session_total,
+                                              left_margin);
+        }
+
+        return ret;
+}
+
+size_t perf_session__fprintf_hists(struct rb_root *hists,
+                                   struct perf_session *pair,
+                                   bool show_displacement, FILE *fp,
+                                   u64 session_total)
+{
+        struct sort_entry *se;
+        struct rb_node *nd;
+        size_t ret = 0;
+        unsigned long position = 1;
+        long displacement = 0;
+        unsigned int width;
+        const char *sep = symbol_conf.field_sep;
+        char *col_width = symbol_conf.col_width_list_str;
+
+        init_rem_hits();
+
+        fprintf(fp, "# %s", pair ? "Baseline" : "Overhead");
+
+        if (symbol_conf.show_nr_samples) {
+                if (sep)
+                        fprintf(fp, "%cSamples", *sep);
+                else
+                        fputs("  Samples  ", fp);
+        }
+
+        if (pair) {
+                if (sep)
+                        ret += fprintf(fp, "%cDelta", *sep);
+                else
+                        ret += fprintf(fp, "  Delta    ");
+
+                if (show_displacement) {
+                        if (sep)
+                                ret += fprintf(fp, "%cDisplacement", *sep);
+                        else
+                                ret += fprintf(fp, " Displ");
+                }
+        }
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                if (se->elide)
+                        continue;
+                if (sep) {
+                        fprintf(fp, "%c%s", *sep, se->header);
+                        continue;
+                }
+                width = strlen(se->header);
+                if (se->width) {
+                        if (symbol_conf.col_width_list_str) {
+                                if (col_width) {
+                                        *se->width = atoi(col_width);
+                                        col_width = strchr(col_width, ',');
+                                        if (col_width)
+                                                ++col_width;
+                                }
+                        }
+                        width = *se->width = max(*se->width, width);
+                }
+                fprintf(fp, "  %*s", width, se->header);
+        }
+        fprintf(fp, "\n");
+
+        if (sep)
+                goto print_entries;
+
+        fprintf(fp, "# ........");
+        if (symbol_conf.show_nr_samples)
+                fprintf(fp, " ..........");
+        if (pair) {
+                fprintf(fp, " ..........");
+                if (show_displacement)
+                        fprintf(fp, " .....");
+        }
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                unsigned int i;
+
+                if (se->elide)
+                        continue;
+
+                fprintf(fp, "  ");
+                if (se->width)
+                        width = *se->width;
+                else
+                        width = strlen(se->header);
+                for (i = 0; i < width; i++)
+                        fprintf(fp, ".");
+        }
+
+        fprintf(fp, "\n#\n");
+
+print_entries:
+        for (nd = rb_first(hists); nd; nd = rb_next(nd)) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+
+                if (show_displacement) {
+                        if (h->pair != NULL)
+                                displacement = ((long)h->pair->position -
+                                                (long)position);
+                        else
+                                displacement = 0;
+                        ++position;
+                }
+                ret += hist_entry__fprintf(h, pair, show_displacement,
+                                           displacement, fp, session_total);
+                if (h->map == NULL && verbose > 1) {
+                        __map_groups__fprintf_maps(&h->thread->mg,
+                                                   MAP__FUNCTION, fp);
+                        fprintf(fp, "%.10s end\n", graph_dotted_line);
+                }
+        }
+
+        free(rem_sq_bracket);
+
+        return ret;
+}
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
new file mode 100644
index 000000000000..16f360cce5bf
--- /dev/null
+++ b/tools/perf/util/hist.h
@@ -0,0 +1,29 @@
+#ifndef __PERF_HIST_H
+#define __PERF_HIST_H
+
+#include <linux/types.h>
+#include "callchain.h"
+
+extern struct callchain_param callchain_param;
+
+struct perf_session;
+struct hist_entry;
+struct addr_location;
+struct symbol;
+struct rb_root;
+
+struct hist_entry *__perf_session__add_hist_entry(struct rb_root *hists,
+                                                  struct addr_location *al,
+                                                  struct symbol *parent,
+                                                  u64 count, bool *hit);
+extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *);
+extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *);
+void hist_entry__free(struct hist_entry *);
+
+void perf_session__output_resort(struct rb_root *hists, u64 total_samples);
+void perf_session__collapse_resort(struct rb_root *hists);
+size_t perf_session__fprintf_hists(struct rb_root *hists,
+                                   struct perf_session *pair,
+                                   bool show_displacement, FILE *fp,
+                                   u64 session_total);
+#endif  /* __PERF_HIST_H */
diff --git a/tools/perf/util/include/asm/asm-offsets.h b/tools/perf/util/include/asm/asm-offsets.h
new file mode 100644
index 000000000000..ed538942523d
--- /dev/null
+++ b/tools/perf/util/include/asm/asm-offsets.h
@@ -0,0 +1 @@
+/* stub */
diff --git a/tools/perf/util/include/asm/bitops.h b/tools/perf/util/include/asm/bitops.h
new file mode 100644
index 000000000000..58e9817ffae0
--- /dev/null
+++ b/tools/perf/util/include/asm/bitops.h
@@ -0,0 +1,18 @@
+#ifndef _PERF_ASM_BITOPS_H_
+#define _PERF_ASM_BITOPS_H_
+
+#include <sys/types.h>
+#include "../../types.h"
+#include <linux/compiler.h>
+
+/* CHECKME: Not sure both always match */
+#define BITS_PER_LONG   __WORDSIZE
+
+#include "../../../../include/asm-generic/bitops/__fls.h"
+#include "../../../../include/asm-generic/bitops/fls.h"
+#include "../../../../include/asm-generic/bitops/fls64.h"
+#include "../../../../include/asm-generic/bitops/__ffs.h"
+#include "../../../../include/asm-generic/bitops/ffz.h"
+#include "../../../../include/asm-generic/bitops/hweight.h"
+
+#endif
diff --git a/tools/perf/util/include/asm/bug.h b/tools/perf/util/include/asm/bug.h
new file mode 100644
index 000000000000..7fcc6810adc2
--- /dev/null
+++ b/tools/perf/util/include/asm/bug.h
@@ -0,0 +1,22 @@
+#ifndef _PERF_ASM_GENERIC_BUG_H
+#define _PERF_ASM_GENERIC_BUG_H
+
+#define __WARN_printf(arg...)   do { fprintf(stderr, arg); } while (0)
+
+#define WARN(condition, format...) ({           \
+        int __ret_warn_on = !!(condition);      \
+        if (unlikely(__ret_warn_on))            \
+                __WARN_printf(format);          \
+        unlikely(__ret_warn_on);                \
+})
+
+#define WARN_ONCE(condition, format...) ({      \
+        static int __warned;                    \
+        int __ret_warn_once = !!(condition);    \
+                                                \
+        if (unlikely(__ret_warn_once))          \
+                if (WARN(!__warned, format))    \
+                        __warned = 1;           \
+        unlikely(__ret_warn_once);              \
+})
+#endif
diff --git a/tools/perf/util/include/asm/byteorder.h b/tools/perf/util/include/asm/byteorder.h
new file mode 100644
index 000000000000..b722abe3a626
--- /dev/null
+++ b/tools/perf/util/include/asm/byteorder.h
@@ -0,0 +1,2 @@
+#include <asm/types.h>
+#include "../../../../include/linux/swab.h"
diff --git a/tools/perf/util/include/asm/swab.h b/tools/perf/util/include/asm/swab.h
new file mode 100644
index 000000000000..ed538942523d
--- /dev/null
+++ b/tools/perf/util/include/asm/swab.h
@@ -0,0 +1 @@
+/* stub */
diff --git a/tools/perf/util/include/asm/uaccess.h b/tools/perf/util/include/asm/uaccess.h
new file mode 100644
index 000000000000..d0f72b8fcc35
--- /dev/null
+++ b/tools/perf/util/include/asm/uaccess.h
@@ -0,0 +1,14 @@
+#ifndef _PERF_ASM_UACCESS_H_
+#define _PERF_ASM_UACCESS_H_
+
+#define __get_user(src, dest)                                           \
+({                                                                      \
+        (src) = *dest;                                                  \
+        0;                                                              \
+})
+
+#define get_user        __get_user
+
+#define access_ok(type, addr, size)     1
+
+#endif
diff --git a/tools/perf/util/include/linux/bitmap.h b/tools/perf/util/include/linux/bitmap.h
new file mode 100644
index 000000000000..94507639a8c4
--- /dev/null
+++ b/tools/perf/util/include/linux/bitmap.h
@@ -0,0 +1,3 @@
+#include "../../../../include/linux/bitmap.h"
+#include "../../../../include/asm-generic/bitops/find.h"
+#include <linux/errno.h>
diff --git a/tools/perf/util/include/linux/bitops.h b/tools/perf/util/include/linux/bitops.h
new file mode 100644
index 000000000000..8d63116e9435
--- /dev/null
+++ b/tools/perf/util/include/linux/bitops.h
@@ -0,0 +1,29 @@
+#ifndef _PERF_LINUX_BITOPS_H_
+#define _PERF_LINUX_BITOPS_H_
+
+#define __KERNEL__
+
+#define CONFIG_GENERIC_FIND_NEXT_BIT
+#define CONFIG_GENERIC_FIND_FIRST_BIT
+#include "../../../../include/linux/bitops.h"
+
+#undef __KERNEL__
+
+static inline void set_bit(int nr, unsigned long *addr)
+{
+        addr[nr / BITS_PER_LONG] |= 1UL << (nr % BITS_PER_LONG);
+}
+
+static __always_inline int test_bit(unsigned int nr, const unsigned long *addr)
+{
+        return ((1UL << (nr % BITS_PER_LONG)) &
+                (((unsigned long *)addr)[nr / BITS_PER_LONG])) != 0;
+}
+
+unsigned long generic_find_next_zero_le_bit(const unsigned long *addr, unsigned
+                long size, unsigned long offset);
+
+unsigned long generic_find_next_le_bit(const unsigned long *addr, unsigned
+                long size, unsigned long offset);
+
+#endif
diff --git a/tools/perf/util/include/linux/compiler.h b/tools/perf/util/include/linux/compiler.h
new file mode 100644
index 000000000000..dfb0713ed47f
--- /dev/null
+++ b/tools/perf/util/include/linux/compiler.h
@@ -0,0 +1,10 @@
+#ifndef _PERF_LINUX_COMPILER_H_
+#define _PERF_LINUX_COMPILER_H_
+
+#ifndef __always_inline
+#define __always_inline inline
+#endif
+#define __user
+#define __attribute_const__
+
+#endif
diff --git a/tools/perf/util/include/linux/ctype.h b/tools/perf/util/include/linux/ctype.h
new file mode 100644
index 000000000000..a53d4ee1e0b7
--- /dev/null
+++ b/tools/perf/util/include/linux/ctype.h
@@ -0,0 +1 @@
+#include "../util.h"
diff --git a/tools/perf/util/include/linux/hash.h b/tools/perf/util/include/linux/hash.h
new file mode 100644
index 000000000000..201f57397997
--- /dev/null
+++ b/tools/perf/util/include/linux/hash.h
@@ -0,0 +1,5 @@
+#include "../../../../include/linux/hash.h"
+
+#ifndef PERF_HASH_H
+#define PERF_HASH_H
+#endif
diff --git a/tools/perf/util/include/linux/kernel.h b/tools/perf/util/include/linux/kernel.h
index a6b87390cb52..f2611655ab51 100644
--- a/tools/perf/util/include/linux/kernel.h
+++ b/tools/perf/util/include/linux/kernel.h
@@ -1,6 +1,16 @@
 #ifndef PERF_LINUX_KERNEL_H_
 #define PERF_LINUX_KERNEL_H_
 
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
+
+#define ALIGN(x,a)              __ALIGN_MASK(x,(typeof(x))(a)-1)
+#define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))
+
 #ifndef offsetof
 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 #endif
@@ -26,4 +36,71 @@
         _max1 > _max2 ? _max1 : _max2; })
 #endif
 
+#ifndef min
+#define min(x, y) ({                            \
+        typeof(x) _min1 = (x);                  \
+        typeof(y) _min2 = (y);                  \
+        (void) (&_min1 == &_min2);              \
+        _min1 < _min2 ? _min1 : _min2; })
+#endif
+
+#ifndef BUG_ON
+#define BUG_ON(cond) assert(!(cond))
+#endif
+
+/*
+ * Both need more care to handle endianness
+ * (Don't use bitmap_copy_le() for now)
+ */
+#define cpu_to_le64(x)  (x)
+#define cpu_to_le32(x)  (x)
+
+static inline int
+vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
+{
+        int i;
+        ssize_t ssize = size;
+
+        i = vsnprintf(buf, size, fmt, args);
+
+        return (i >= ssize) ? (ssize - 1) : i;
+}
+
+static inline int scnprintf(char * buf, size_t size, const char * fmt, ...)
+{
+        va_list args;
+        ssize_t ssize = size;
+        int i;
+
+        va_start(args, fmt);
+        i = vsnprintf(buf, size, fmt, args);
+        va_end(args);
+
+        return (i >= ssize) ? (ssize - 1) : i;
+}
+
+static inline unsigned long
+simple_strtoul(const char *nptr, char **endptr, int base)
+{
+        return strtoul(nptr, endptr, base);
+}
+
+#ifndef pr_fmt
+#define pr_fmt(fmt) fmt
+#endif
+
+#define pr_err(fmt, ...) \
+        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+#define pr_warning(fmt, ...) \
+        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+#define pr_info(fmt, ...) \
+        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+#define pr_debug(fmt, ...) \
+        eprintf(1, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debugN(n, fmt, ...) \
+        eprintf(n, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug2(fmt, ...) pr_debugN(2, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug3(fmt, ...) pr_debugN(3, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug4(fmt, ...) pr_debugN(4, pr_fmt(fmt), ##__VA_ARGS__)
+
 #endif
diff --git a/tools/perf/util/include/linux/string.h b/tools/perf/util/include/linux/string.h
new file mode 100644
index 000000000000..3b2f5900276f
--- /dev/null
+++ b/tools/perf/util/include/linux/string.h
@@ -0,0 +1 @@
+#include <string.h>
diff --git a/tools/perf/util/include/linux/types.h b/tools/perf/util/include/linux/types.h
new file mode 100644
index 000000000000..196862a81a21
--- /dev/null
+++ b/tools/perf/util/include/linux/types.h
@@ -0,0 +1,9 @@
+#ifndef _PERF_LINUX_TYPES_H_
+#define _PERF_LINUX_TYPES_H_
+
+#include <asm/types.h>
+
+#define DECLARE_BITMAP(name,bits) \
+        unsigned long name[BITS_TO_LONGS(bits)]
+
+#endif
diff --git a/tools/perf/util/levenshtein.h b/tools/perf/util/levenshtein.h
index 0173abeef52c..b0fcb6d8a881 100644
--- a/tools/perf/util/levenshtein.h
+++ b/tools/perf/util/levenshtein.h
@@ -1,8 +1,8 @@
-#ifndef LEVENSHTEIN_H
-#define LEVENSHTEIN_H
+#ifndef __PERF_LEVENSHTEIN_H
+#define __PERF_LEVENSHTEIN_H
 
 int levenshtein(const char *string1, const char *string2,
         int swap_penalty, int substition_penalty,
         int insertion_penalty, int deletion_penalty);
 
-#endif
+#endif /* __PERF_LEVENSHTEIN_H */
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 804e02382739..e509cd59c67d 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -3,6 +3,12 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include "debug.h"
+
+const char *map_type__name[MAP__NR_TYPES] = {
+        [MAP__FUNCTION] = "Functions",
+        [MAP__VARIABLE] = "Variables",
+};
 
 static inline int is_anon_memory(const char *filename)
 {
@@ -19,13 +25,28 @@ static int strcommon(const char *pathname, char *cwd, int cwdlen)
         return n;
 }
 
- struct map *map__new(struct mmap_event *event, char *cwd, int cwdlen)
+void map__init(struct map *self, enum map_type type,
+               u64 start, u64 end, u64 pgoff, struct dso *dso)
+{
+        self->type     = type;
+        self->start    = start;
+        self->end      = end;
+        self->pgoff    = pgoff;
+        self->dso      = dso;
+        self->map_ip   = map__map_ip;
+        self->unmap_ip = map__unmap_ip;
+        RB_CLEAR_NODE(&self->rb_node);
+}
+
+struct map *map__new(struct mmap_event *event, enum map_type type,
+                     char *cwd, int cwdlen)
 {
         struct map *self = malloc(sizeof(*self));
 
         if (self != NULL) {
                 const char *filename = event->filename;
                 char newfilename[PATH_MAX];
+                struct dso *dso;
                 int anon;
 
                 if (cwd) {
@@ -45,18 +66,20 @@ static int strcommon(const char *pathname, char *cwd, int cwdlen)
                         filename = newfilename;
                 }
 
-                self->start = event->start;
-                self->end   = event->start + event->len;
-                self->pgoff = event->pgoff;
-
-                self->dso = dsos__findnew(filename);
-                if (self->dso == NULL)
+                dso = dsos__findnew(filename);
+                if (dso == NULL)
                         goto out_delete;
 
-                if (self->dso == vdso || anon)
-                        self->map_ip = vdso__map_ip;
-                else
-                        self->map_ip = map__map_ip;
+                map__init(self, type, event->start, event->start + event->len,
+                          event->pgoff, dso);
+
+                if (anon) {
+set_identity:
+                        self->map_ip = self->unmap_ip = identity__map_ip;
+                } else if (strcmp(filename, "[vdso]") == 0) {
+                        dso__set_loaded(dso, self->type);
+                        goto set_identity;
+                }
         }
         return self;
 out_delete:
@@ -64,6 +87,103 @@ out_delete:
         return NULL;
 }
 
+void map__delete(struct map *self)
+{
+        free(self);
+}
+
+void map__fixup_start(struct map *self)
+{
+        struct rb_root *symbols = &self->dso->symbols[self->type];
+        struct rb_node *nd = rb_first(symbols);
+        if (nd != NULL) {
+                struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
+                self->start = sym->start;
+        }
+}
+
+void map__fixup_end(struct map *self)
+{
+        struct rb_root *symbols = &self->dso->symbols[self->type];
+        struct rb_node *nd = rb_last(symbols);
+        if (nd != NULL) {
+                struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
+                self->end = sym->end;
+        }
+}
+
+#define DSO__DELETED "(deleted)"
+
+int map__load(struct map *self, symbol_filter_t filter)
+{
+        const char *name = self->dso->long_name;
+        int nr;
+
+        if (dso__loaded(self->dso, self->type))
+                return 0;
+
+        nr = dso__load(self->dso, self, filter);
+        if (nr < 0) {
+                if (self->dso->has_build_id) {
+                        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+                        build_id__sprintf(self->dso->build_id,
+                                          sizeof(self->dso->build_id),
+                                          sbuild_id);
+                        pr_warning("%s with build id %s not found",
+                                   name, sbuild_id);
+                } else
+                        pr_warning("Failed to open %s", name);
+
+                pr_warning(", continuing without symbols\n");
+                return -1;
+        } else if (nr == 0) {
+                const size_t len = strlen(name);
+                const size_t real_len = len - sizeof(DSO__DELETED);
+
+                if (len > sizeof(DSO__DELETED) &&
+                    strcmp(name + real_len + 1, DSO__DELETED) == 0) {
+                        pr_warning("%.*s was updated, restart the long "
+                                   "running apps that use it!\n",
+                                   (int)real_len, name);
+                } else {
+                        pr_warning("no symbols found in %s, maybe install "
+                                   "a debug package?\n", name);
+                }
+
+                return -1;
+        }
+        /*
+         * Only applies to the kernel, as its symtabs aren't relative like the
+         * module ones.
+         */
+        if (self->dso->kernel)
+                map__reloc_vmlinux(self);
+
+        return 0;
+}
+
+struct symbol *map__find_symbol(struct map *self, u64 addr,
+                                symbol_filter_t filter)
+{
+        if (map__load(self, filter) < 0)
+                return NULL;
+
+        return dso__find_symbol(self->dso, self->type, addr);
+}
+
+struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
+                                        symbol_filter_t filter)
+{
+        if (map__load(self, filter) < 0)
+                return NULL;
+
+        if (!dso__sorted_by_name(self->dso, self->type))
+                dso__sort_by_name(self->dso, self->type);
+
+        return dso__find_symbol_by_name(self->dso, self->type, name);
+}
+
 struct map *map__clone(struct map *self)
 {
         struct map *map = malloc(sizeof(*self));
@@ -95,3 +215,23 @@ size_t map__fprintf(struct map *self, FILE *fp)
         return fprintf(fp, " %Lx-%Lx %Lx %s\n",
                        self->start, self->end, self->pgoff, self->dso->name);
 }
+
+/*
+ * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
+ * map->dso->adjust_symbols==1 for ET_EXEC-like cases.
+ */
+u64 map__rip_2objdump(struct map *map, u64 rip)
+{
+        u64 addr = map->dso->adjust_symbols ?
+                        map->unmap_ip(map, rip) :       /* RIP -> IP */
+                        rip;
+        return addr;
+}
+
+u64 map__objdump_2ip(struct map *map, u64 addr)
+{
+        u64 ip = map->dso->adjust_symbols ?
+                        addr :
+                        map->unmap_ip(map, addr);       /* RIP -> IP */
+        return ip;
+}
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
new file mode 100644
index 000000000000..b756368076c6
--- /dev/null
+++ b/tools/perf/util/map.h
@@ -0,0 +1,94 @@
+#ifndef __PERF_MAP_H
+#define __PERF_MAP_H
+
+#include <linux/compiler.h>
+#include <linux/list.h>
+#include <linux/rbtree.h>
+#include <linux/types.h>
+
+enum map_type {
+        MAP__FUNCTION = 0,
+        MAP__VARIABLE,
+};
+
+#define MAP__NR_TYPES (MAP__VARIABLE + 1)
+
+extern const char *map_type__name[MAP__NR_TYPES];
+
+struct dso;
+struct ref_reloc_sym;
+struct map_groups;
+
+struct map {
+        union {
+                struct rb_node  rb_node;
+                struct list_head node;
+        };
+        u64                     start;
+        u64                     end;
+        enum map_type           type;
+        u64                     pgoff;
+
+        /* ip -> dso rip */
+        u64                     (*map_ip)(struct map *, u64);
+        /* dso rip -> ip */
+        u64                     (*unmap_ip)(struct map *, u64);
+
+        struct dso              *dso;
+};
+
+struct kmap {
+        struct ref_reloc_sym    *ref_reloc_sym;
+        struct map_groups       *kmaps;
+};
+
+static inline struct kmap *map__kmap(struct map *self)
+{
+        return (struct kmap *)(self + 1);
+}
+
+static inline u64 map__map_ip(struct map *map, u64 ip)
+{
+        return ip - map->start + map->pgoff;
+}
+
+static inline u64 map__unmap_ip(struct map *map, u64 ip)
+{
+        return ip + map->start - map->pgoff;
+}
+
+static inline u64 identity__map_ip(struct map *map __used, u64 ip)
+{
+        return ip;
+}
+
+
+/* rip/ip <-> addr suitable for passing to `objdump --start-address=` */
+u64 map__rip_2objdump(struct map *map, u64 rip);
+u64 map__objdump_2ip(struct map *map, u64 addr);
+
+struct symbol;
+struct mmap_event;
+
+typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
+
+void map__init(struct map *self, enum map_type type,
+               u64 start, u64 end, u64 pgoff, struct dso *dso);
+struct map *map__new(struct mmap_event *event, enum map_type,
+                     char *cwd, int cwdlen);
+void map__delete(struct map *self);
+struct map *map__clone(struct map *self);
+int map__overlap(struct map *l, struct map *r);
+size_t map__fprintf(struct map *self, FILE *fp);
+
+int map__load(struct map *self, symbol_filter_t filter);
+struct symbol *map__find_symbol(struct map *self,
+                                u64 addr, symbol_filter_t filter);
+struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
+                                        symbol_filter_t filter);
+void map__fixup_start(struct map *self);
+void map__fixup_end(struct map *self);
+
+void map__reloc_vmlinux(struct map *self);
+
+#endif /* __PERF_MAP_H */
diff --git a/tools/perf/util/module.c b/tools/perf/util/module.c
deleted file mode 100644
index 0d8c85defcd2..000000000000
--- a/tools/perf/util/module.c
+++ /dev/null
@@ -1,545 +0,0 @@
-#include "util.h"
-#include "../perf.h"
-#include "string.h"
-#include "module.h"
-
-#include <libelf.h>
-#include <libgen.h>
-#include <gelf.h>
-#include <elf.h>
-#include <dirent.h>
-#include <sys/utsname.h>
-
-static unsigned int crc32(const char *p, unsigned int len)
-{
-        int i;
-        unsigned int crc = 0;
-
-        while (len--) {
-                crc ^= *p++;
-                for (i = 0; i < 8; i++)
-                        crc = (crc >> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
-        }
-        return crc;
-}
-
-/* module section methods */
-
-struct sec_dso *sec_dso__new_dso(const char *name)
-{
-        struct sec_dso *self = malloc(sizeof(*self) + strlen(name) + 1);
-
-        if (self != NULL) {
-                strcpy(self->name, name);
-                self->secs = RB_ROOT;
-                self->find_section = sec_dso__find_section;
-        }
-
-        return self;
-}
-
-static void sec_dso__delete_section(struct section *self)
-{
-        free(((void *)self));
-}
-
-void sec_dso__delete_sections(struct sec_dso *self)
-{
-        struct section *pos;
-        struct rb_node *next = rb_first(&self->secs);
-
-        while (next) {
-                pos = rb_entry(next, struct section, rb_node);
-                next = rb_next(&pos->rb_node);
-                rb_erase(&pos->rb_node, &self->secs);
-                sec_dso__delete_section(pos);
-        }
-}
-
-void sec_dso__delete_self(struct sec_dso *self)
-{
-        sec_dso__delete_sections(self);
-        free(self);
-}
-
-static void sec_dso__insert_section(struct sec_dso *self, struct section *sec)
-{
-        struct rb_node **p = &self->secs.rb_node;
-        struct rb_node *parent = NULL;
-        const u64 hash = sec->hash;
-        struct section *s;
-
-        while (*p != NULL) {
-                parent = *p;
-                s = rb_entry(parent, struct section, rb_node);
-                if (hash < s->hash)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-        rb_link_node(&sec->rb_node, parent, p);
-        rb_insert_color(&sec->rb_node, &self->secs);
-}
-
-struct section *sec_dso__find_section(struct sec_dso *self, const char *name)
-{
-        struct rb_node *n;
-        u64 hash;
-        int len;
-
-        if (self == NULL)
-                return NULL;
-
-        len = strlen(name);
-        hash = crc32(name, len);
-
-        n = self->secs.rb_node;
-
-        while (n) {
-                struct section *s = rb_entry(n, struct section, rb_node);
-
-                if (hash < s->hash)
-                        n = n->rb_left;
-                else if (hash > s->hash)
-                        n = n->rb_right;
-                else {
-                        if (!strcmp(name, s->name))
-                                return s;
-                        else
-                                n = rb_next(&s->rb_node);
-                }
-        }
-
-        return NULL;
-}
-
-static size_t sec_dso__fprintf_section(struct section *self, FILE *fp)
-{
-        return fprintf(fp, "name:%s vma:%llx path:%s\n",
-                       self->name, self->vma, self->path);
-}
-
-size_t sec_dso__fprintf(struct sec_dso *self, FILE *fp)
-{
-        size_t ret = fprintf(fp, "dso: %s\n", self->name);
-
-        struct rb_node *nd;
-        for (nd = rb_first(&self->secs); nd; nd = rb_next(nd)) {
-                struct section *pos = rb_entry(nd, struct section, rb_node);
-                ret += sec_dso__fprintf_section(pos, fp);
-        }
-
-        return ret;
-}
-
-static struct section *section__new(const char *name, const char *path)
-{
-        struct section *self = calloc(1, sizeof(*self));
-
-        if (!self)
-                goto out_failure;
-
-        self->name = calloc(1, strlen(name) + 1);
-        if (!self->name)
-                goto out_failure;
-
-        self->path = calloc(1, strlen(path) + 1);
-        if (!self->path)
-                goto out_failure;
-
-        strcpy(self->name, name);
-        strcpy(self->path, path);
-        self->hash = crc32(self->name, strlen(name));
-
-        return self;
-
-out_failure:
-        if (self) {
-                if (self->name)
-                        free(self->name);
-                if (self->path)
-                        free(self->path);
-                free(self);
-        }
-
-        return NULL;
-}
-
-/* module methods */
-
-struct mod_dso *mod_dso__new_dso(const char *name)
-{
-        struct mod_dso *self = malloc(sizeof(*self) + strlen(name) + 1);
-
-        if (self != NULL) {
-                strcpy(self->name, name);
-                self->mods = RB_ROOT;
-                self->find_module = mod_dso__find_module;
-        }
-
-        return self;
-}
-
-static void mod_dso__delete_module(struct module *self)
-{
-        free(((void *)self));
-}
-
-void mod_dso__delete_modules(struct mod_dso *self)
-{
-        struct module *pos;
-        struct rb_node *next = rb_first(&self->mods);
-
-        while (next) {
-                pos = rb_entry(next, struct module, rb_node);
-                next = rb_next(&pos->rb_node);
-                rb_erase(&pos->rb_node, &self->mods);
-                mod_dso__delete_module(pos);
-        }
-}
-
-void mod_dso__delete_self(struct mod_dso *self)
-{
-        mod_dso__delete_modules(self);
-        free(self);
-}
-
-static void mod_dso__insert_module(struct mod_dso *self, struct module *mod)
-{
-        struct rb_node **p = &self->mods.rb_node;
-        struct rb_node *parent = NULL;
-        const u64 hash = mod->hash;
-        struct module *m;
-
-        while (*p != NULL) {
-                parent = *p;
-                m = rb_entry(parent, struct module, rb_node);
-                if (hash < m->hash)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-        rb_link_node(&mod->rb_node, parent, p);
-        rb_insert_color(&mod->rb_node, &self->mods);
-}
-
-struct module *mod_dso__find_module(struct mod_dso *self, const char *name)
-{
-        struct rb_node *n;
-        u64 hash;
-        int len;
-
-        if (self == NULL)
-                return NULL;
-
-        len = strlen(name);
-        hash = crc32(name, len);
-
-        n = self->mods.rb_node;
-
-        while (n) {
-                struct module *m = rb_entry(n, struct module, rb_node);
-
-                if (hash < m->hash)
-                        n = n->rb_left;
-                else if (hash > m->hash)
-                        n = n->rb_right;
-                else {
-                        if (!strcmp(name, m->name))
-                                return m;
-                        else
-                                n = rb_next(&m->rb_node);
-                }
-        }
-
-        return NULL;
-}
-
-static size_t mod_dso__fprintf_module(struct module *self, FILE *fp)
-{
-        return fprintf(fp, "name:%s path:%s\n", self->name, self->path);
-}
-
-size_t mod_dso__fprintf(struct mod_dso *self, FILE *fp)
-{
-        struct rb_node *nd;
-        size_t ret;
-
-        ret = fprintf(fp, "dso: %s\n", self->name);
-
-        for (nd = rb_first(&self->mods); nd; nd = rb_next(nd)) {
-                struct module *pos = rb_entry(nd, struct module, rb_node);
-
-                ret += mod_dso__fprintf_module(pos, fp);
-        }
-
-        return ret;
-}
-
-static struct module *module__new(const char *name, const char *path)
-{
-        struct module *self = calloc(1, sizeof(*self));
-
-        if (!self)
-                goto out_failure;
-
-        self->name = calloc(1, strlen(name) + 1);
-        if (!self->name)
-                goto out_failure;
-
-        self->path = calloc(1, strlen(path) + 1);
-        if (!self->path)
-                goto out_failure;
-
-        strcpy(self->name, name);
-        strcpy(self->path, path);
-        self->hash = crc32(self->name, strlen(name));
-
-        return self;
-
-out_failure:
-        if (self) {
-                if (self->name)
-                        free(self->name);
-                if (self->path)
-                        free(self->path);
-                free(self);
-        }
-
-        return NULL;
-}
-
-static int mod_dso__load_sections(struct module *mod)
-{
-        int count = 0, path_len;
-        struct dirent *entry;
-        char *line = NULL;
-        char *dir_path;
-        DIR *dir;
-        size_t n;
-
-        path_len = strlen("/sys/module/");
-        path_len += strlen(mod->name);
-        path_len += strlen("/sections/");
-
-        dir_path = calloc(1, path_len + 1);
-        if (dir_path == NULL)
-                goto out_failure;
-
-        strcat(dir_path, "/sys/module/");
-        strcat(dir_path, mod->name);
-        strcat(dir_path, "/sections/");
-
-        dir = opendir(dir_path);
-        if (dir == NULL)
-                goto out_free;
-
-        while ((entry = readdir(dir))) {
-                struct section *section;
-                char *path, *vma;
-                int line_len;
-                FILE *file;
-
-                if (!strcmp(".", entry->d_name) || !strcmp("..", entry->d_name))
-                        continue;
-
-                path = calloc(1, path_len + strlen(entry->d_name) + 1);
-                if (path == NULL)
-                        break;
-                strcat(path, dir_path);
-                strcat(path, entry->d_name);
-
-                file = fopen(path, "r");
-                if (file == NULL) {
-                        free(path);
-                        break;
-                }
-
-                line_len = getline(&line, &n, file);
-                if (line_len < 0) {
-                        free(path);
-                        fclose(file);
-                        break;
-                }
-
-                if (!line) {
-                        free(path);
-                        fclose(file);
-                        break;
-                }
-
-                line[--line_len] = '\0'; /* \n */
-
-                vma = strstr(line, "0x");
-                if (!vma) {
-                        free(path);
-                        fclose(file);
-                        break;
-                }
-                vma += 2;
-
-                section = section__new(entry->d_name, path);
-                if (!section) {
-                        fprintf(stderr, "load_sections: allocation error\n");
-                        free(path);
-                        fclose(file);
-                        break;
-                }
-
-                hex2u64(vma, &section->vma);
-                sec_dso__insert_section(mod->sections, section);
-
-                free(path);
-                fclose(file);
-                count++;
-        }
-
-        closedir(dir);
-        free(line);
-        free(dir_path);
-
-        return count;
-
-out_free:
-        free(dir_path);
-
-out_failure:
-        return count;
-}
-
-static int mod_dso__load_module_paths(struct mod_dso *self)
-{
-        struct utsname uts;
-        int count = 0, len, err = -1;
-        char *line = NULL;
-        FILE *file;
-        char *dpath, *dir;
-        size_t n;
-
-        if (uname(&uts) < 0)
-                return err;
-
-        len = strlen("/lib/modules/");
-        len += strlen(uts.release);
-        len += strlen("/modules.dep");
-
-        dpath = calloc(1, len + 1);
-        if (dpath == NULL)
-                return err;
-
-        strcat(dpath, "/lib/modules/");
-        strcat(dpath, uts.release);
-        strcat(dpath, "/modules.dep");
-
-        file = fopen(dpath, "r");
-        if (file == NULL)
-                goto out_failure;
-
-        dir = dirname(dpath);
-        if (!dir)
-                goto out_failure;
-        strcat(dir, "/");
-
-        while (!feof(file)) {
-                struct module *module;
-                char *name, *path, *tmp;
-                FILE *modfile;
-                int line_len;
-
-                line_len = getline(&line, &n, file);
-                if (line_len < 0)
-                        break;
-
-                if (!line)
-                        break;
-
-                line[--line_len] = '\0'; /* \n */
-
-                path = strchr(line, ':');
-                if (!path)
-                        break;
-                *path = '\0';
-
-                path = strdup(line);
-                if (!path)
-                        break;
-
-                if (!strstr(path, dir)) {
-                        if (strncmp(path, "kernel/", 7))
-                                break;
-
-                        free(path);
-                        path = calloc(1, strlen(dir) + strlen(line) + 1);
-                        if (!path)
-                                break;
-                        strcat(path, dir);
-                        strcat(path, line);
-                }
-
-                modfile = fopen(path, "r");
-                if (modfile == NULL)
-                        break;
-                fclose(modfile);
-
-                name = strdup(path);
-                if (!name)
-                        break;
-
-                name = strtok(name, "/");
-                tmp = name;
-
-                while (tmp) {
-                        tmp = strtok(NULL, "/");
-                        if (tmp)
-                                name = tmp;
-                }
-
-                name = strsep(&name, ".");
-                if (!name)
-                        break;
-
-                /* Quirk: replace '-' with '_' in all modules */
-                for (len = strlen(name); len; len--) {
-                        if (*(name+len) == '-')
-                                *(name+len) = '_';
-                }
-
-                module = module__new(name, path);
-                if (!module)
-                        break;
-                mod_dso__insert_module(self, module);
-
-                module->sections = sec_dso__new_dso("sections");
-                if (!module->sections)
-                        break;
-
-                module->active = mod_dso__load_sections(module);
-
-                if (module->active > 0)
-                        count++;
-        }
-
-        if (feof(file))
-                err = count;
-        else
-                fprintf(stderr, "load_module_paths: modules.dep parsing failure!\n");
-
-out_failure:
-        if (dpath)
-                free(dpath);
-        if (file)
-                fclose(file);
-        if (line)
-                free(line);
-
-        return err;
-}
-
-int mod_dso__load_modules(struct mod_dso *dso)
-{
-        int err;
-
-        err = mod_dso__load_module_paths(dso);
-
-        return err;
-}
diff --git a/tools/perf/util/module.h b/tools/perf/util/module.h
deleted file mode 100644
index 8a592ef641ca..000000000000
--- a/tools/perf/util/module.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#ifndef _PERF_MODULE_
-#define _PERF_MODULE_ 1
-
-#include <linux/types.h>
-#include "../types.h"
-#include <linux/list.h>
-#include <linux/rbtree.h>
-
-struct section {
-        struct rb_node  rb_node;
-        u64             hash;
-        u64             vma;
-        char            *name;
-        char            *path;
-};
-
-struct sec_dso {
-        struct list_head node;
-        struct rb_root   secs;
-        struct section    *(*find_section)(struct sec_dso *, const char *name);
-        char             name[0];
-};
-
-struct module {
-        struct rb_node  rb_node;
-        u64             hash;
-        char            *name;
-        char            *path;
-        struct sec_dso  *sections;
-        int             active;
-};
-
-struct mod_dso {
-        struct list_head node;
-        struct rb_root   mods;
-        struct module    *(*find_module)(struct mod_dso *, const char *name);
-        char             name[0];
-};
-
-struct sec_dso *sec_dso__new_dso(const char *name);
-void sec_dso__delete_sections(struct sec_dso *self);
-void sec_dso__delete_self(struct sec_dso *self);
-size_t sec_dso__fprintf(struct sec_dso *self, FILE *fp);
-struct section *sec_dso__find_section(struct sec_dso *self, const char *name);
-
-struct mod_dso *mod_dso__new_dso(const char *name);
-void mod_dso__delete_modules(struct mod_dso *self);
-void mod_dso__delete_self(struct mod_dso *self);
-size_t mod_dso__fprintf(struct mod_dso *self, FILE *fp);
-struct module *mod_dso__find_module(struct mod_dso *self, const char *name);
-int mod_dso__load_modules(struct mod_dso *dso);
-
-#endif /* _PERF_MODULE_ */
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 8cfb48cbbea0..05d0c5c2030c 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -1,4 +1,4 @@
-
+#include "../../../include/linux/hw_breakpoint.h"
 #include "util.h"
 #include "../perf.h"
 #include "parse-options.h"
@@ -7,10 +7,12 @@
 #include "string.h"
 #include "cache.h"
 #include "header.h"
+#include "debugfs.h"
 
-int                                     nr_counters;
+int                             nr_counters;
 
 struct perf_event_attr          attrs[MAX_COUNTERS];
+char                            *filters[MAX_COUNTERS];
 
 struct event_symbol {
         u8              type;
@@ -46,6 +48,8 @@ static struct event_symbol event_symbols[] = {
   { CSW(PAGE_FAULTS_MAJ),       "major-faults",         ""              },
   { CSW(CONTEXT_SWITCHES),      "context-switches",     "cs"            },
   { CSW(CPU_MIGRATIONS),        "cpu-migrations",       "migrations"    },
+  { CSW(ALIGNMENT_FAULTS),      "alignment-faults",     ""              },
+  { CSW(EMULATION_FAULTS),      "emulation-faults",     ""              },
 };
 
 #define __PERF_EVENT_FIELD(config, name) \
@@ -74,6 +78,8 @@ static const char *sw_event_names[] = {
         "CPU-migrations",
         "minor-faults",
         "major-faults",
+        "alignment-faults",
+        "emulation-faults",
 };
 
 #define MAX_ALIASES 8
@@ -148,16 +154,6 @@ static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
 
 #define MAX_EVENT_LENGTH 512
 
-int valid_debugfs_mount(const char *debugfs)
-{
-        struct statfs st_fs;
-
-        if (statfs(debugfs, &st_fs) < 0)
-                return -ENOENT;
-        else if (st_fs.f_type != (long) DEBUGFS_MAGIC)
-                return -ENOENT;
-        return 0;
-}
 
 struct tracepoint_path *tracepoint_id_to_path(u64 config)
 {
@@ -170,7 +166,7 @@ struct tracepoint_path *tracepoint_id_to_path(u64 config)
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
 
-        if (valid_debugfs_mount(debugfs_path))
+        if (debugfs_valid_mountpoint(debugfs_path))
                 return NULL;
 
         sys_dir = opendir(debugfs_path);
@@ -201,7 +197,7 @@ struct tracepoint_path *tracepoint_id_to_path(u64 config)
                         if (id == config) {
                                 closedir(evt_dir);
                                 closedir(sys_dir);
-                                path = calloc(1, sizeof(path));
+                                path = zalloc(sizeof(*path));
                                 path->system = malloc(MAX_EVENT_LENGTH);
                                 if (!path->system) {
                                         free(path);
@@ -454,7 +450,8 @@ parse_single_tracepoint_event(char *sys_name,
 /* sys + ':' + event + ':' + flags*/
 #define MAX_EVOPT_LEN   (MAX_EVENT_LENGTH * 2 + 2 + 128)
 static enum event_result
-parse_subsystem_tracepoint_event(char *sys_name, char *flags)
+parse_multiple_tracepoint_event(char *sys_name, const char *evt_exp,
+                                char *flags)
 {
         char evt_path[MAXPATHLEN];
         struct dirent *evt_ent;
@@ -471,7 +468,6 @@ parse_subsystem_tracepoint_event(char *sys_name, char *flags)
         while ((evt_ent = readdir(evt_dir))) {
                 char event_opt[MAX_EVOPT_LEN + 1];
                 int len;
-                unsigned int rem = MAX_EVOPT_LEN;
 
                 if (!strcmp(evt_ent->d_name, ".")
                     || !strcmp(evt_ent->d_name, "..")
@@ -479,20 +475,15 @@ parse_subsystem_tracepoint_event(char *sys_name, char *flags)
                     || !strcmp(evt_ent->d_name, "filter"))
                         continue;
 
-                len = snprintf(event_opt, MAX_EVOPT_LEN, "%s:%s", sys_name,
-                               evt_ent->d_name);
+                if (!strglobmatch(evt_ent->d_name, evt_exp))
+                        continue;
+
+                len = snprintf(event_opt, MAX_EVOPT_LEN, "%s:%s%s%s", sys_name,
+                               evt_ent->d_name, flags ? ":" : "",
+                               flags ?: "");
                 if (len < 0)
                         return EVT_FAILED;
 
-                rem -= len;
-                if (flags) {
-                        if (rem < strlen(flags) + 1)
-                                return EVT_FAILED;
-
-                        strcat(event_opt, ":");
-                        strcat(event_opt, flags);
-                }
-
                 if (parse_events(NULL, event_opt, 0))
                         return EVT_FAILED;
         }
@@ -509,7 +500,7 @@ static enum event_result parse_tracepoint_event(const char **strp,
         char sys_name[MAX_EVENT_LENGTH];
         unsigned int sys_length, evt_length;
 
-        if (valid_debugfs_mount(debugfs_path))
+        if (debugfs_valid_mountpoint(debugfs_path))
                 return 0;
 
         evt_name = strchr(*strp, ':');
@@ -535,15 +526,91 @@ static enum event_result parse_tracepoint_event(const char **strp,
         if (evt_length >= MAX_EVENT_LENGTH)
                 return EVT_FAILED;
 
-        if (!strcmp(evt_name, "*")) {
+        if (strpbrk(evt_name, "*?")) {
                 *strp = evt_name + evt_length;
-                return parse_subsystem_tracepoint_event(sys_name, flags);
+                return parse_multiple_tracepoint_event(sys_name, evt_name,
+                                                       flags);
         } else
                 return parse_single_tracepoint_event(sys_name, evt_name,
                                                      evt_length, flags,
                                                      attr, strp);
 }
 
+static enum event_result
+parse_breakpoint_type(const char *type, const char **strp,
+                      struct perf_event_attr *attr)
+{
+        int i;
+
+        for (i = 0; i < 3; i++) {
+                if (!type[i])
+                        break;
+
+                switch (type[i]) {
+                case 'r':
+                        attr->bp_type |= HW_BREAKPOINT_R;
+                        break;
+                case 'w':
+                        attr->bp_type |= HW_BREAKPOINT_W;
+                        break;
+                case 'x':
+                        attr->bp_type |= HW_BREAKPOINT_X;
+                        break;
+                default:
+                        return EVT_FAILED;
+                }
+        }
+        if (!attr->bp_type) /* Default */
+                attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
+
+        *strp = type + i;
+
+        return EVT_HANDLED;
+}
+
+static enum event_result
+parse_breakpoint_event(const char **strp, struct perf_event_attr *attr)
+{
+        const char *target;
+        const char *type;
+        char *endaddr;
+        u64 addr;
+        enum event_result err;
+
+        target = strchr(*strp, ':');
+        if (!target)
+                return EVT_FAILED;
+
+        if (strncmp(*strp, "mem", target - *strp) != 0)
+                return EVT_FAILED;
+
+        target++;
+
+        addr = strtoull(target, &endaddr, 0);
+        if (target == endaddr)
+                return EVT_FAILED;
+
+        attr->bp_addr = addr;
+        *strp = endaddr;
+
+        type = strchr(target, ':');
+
+        /* If no type is defined, just rw as default */
+        if (!type) {
+                attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
+        } else {
+                err = parse_breakpoint_type(++type, strp, attr);
+                if (err == EVT_FAILED)
+                        return EVT_FAILED;
+        }
+
+        /* We should find a nice way to override the access type */
+        attr->bp_len = HW_BREAKPOINT_LEN_4;
+        attr->type = PERF_TYPE_BREAKPOINT;
+
+        return EVT_HANDLED;
+}
+
 static int check_events(const char *str, unsigned int i)
 {
         int n;
@@ -677,6 +744,12 @@ parse_event_symbols(const char **str, struct perf_event_attr *attr)
         if (ret != EVT_FAILED)
                 goto modifier;
 
+        ret = parse_breakpoint_event(str, attr);
+        if (ret != EVT_FAILED)
+                goto modifier;
+
+        fprintf(stderr, "invalid or unsupported event: '%s'\n", *str);
+        fprintf(stderr, "Run 'perf list' for a list of valid events\n");
         return EVT_FAILED;
 
 modifier:
@@ -685,11 +758,11 @@ modifier:
         return ret;
 }
 
-static void store_event_type(const char *orgname)
+static int store_event_type(const char *orgname)
 {
         char filename[PATH_MAX], *c;
         FILE *file;
-        int id;
+        int id, n;
 
         sprintf(filename, "%s/", debugfs_path);
         strncat(filename, orgname, strlen(orgname));
@@ -701,21 +774,24 @@ static void store_event_type(const char *orgname)
 
         file = fopen(filename, "r");
         if (!file)
-                return;
-        if (fscanf(file, "%i", &id) < 1)
-                die("cannot store event ID");
+                return 0;
+        n = fscanf(file, "%i", &id);
         fclose(file);
-        perf_header__push_event(id, orgname);
+        if (n < 1) {
+                pr_err("cannot store event ID\n");
+                return -EINVAL;
+        }
+        return perf_header__push_event(id, orgname);
 }
 
-
 int parse_events(const struct option *opt __used, const char *str, int unset __used)
 {
         struct perf_event_attr attr;
         enum event_result ret;
 
         if (strchr(str, ':'))
-                store_event_type(str);
+                if (store_event_type(str) < 0)
+                        return -1;
 
         for (;;) {
                 if (nr_counters == MAX_COUNTERS)
@@ -745,12 +821,35 @@ int parse_events(const struct option *opt __used, const char *str, int unset __u
         return 0;
 }
 
+int parse_filter(const struct option *opt __used, const char *str,
+                 int unset __used)
+{
+        int i = nr_counters - 1;
+        int len = strlen(str);
+
+        if (i < 0 || attrs[i].type != PERF_TYPE_TRACEPOINT) {
+                fprintf(stderr,
+                        "-F option should follow a -e tracepoint option\n");
+                return -1;
+        }
+
+        filters[i] = malloc(len + 1);
+        if (!filters[i]) {
+                fprintf(stderr, "not enough memory to hold filter string\n");
+                return -1;
+        }
+        strcpy(filters[i], str);
+
+        return 0;
+}
+
 static const char * const event_type_descriptors[] = {
-        "",
         "Hardware event",
         "Software event",
         "Tracepoint event",
         "Hardware cache event",
+        "Raw hardware event descriptor",
+        "Hardware breakpoint",
 };
 
 /*
@@ -764,7 +863,7 @@ static void print_tracepoint_events(void)
         char evt_path[MAXPATHLEN];
         char dir_path[MAXPATHLEN];
 
-        if (valid_debugfs_mount(debugfs_path))
+        if (debugfs_valid_mountpoint(debugfs_path))
                 return;
 
         sys_dir = opendir(debugfs_path);
@@ -782,8 +881,8 @@ static void print_tracepoint_events(void)
                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
                                  sys_dirent.d_name, evt_dirent.d_name);
-                        fprintf(stderr, "  %-42s [%s]\n", evt_path,
-                                event_type_descriptors[PERF_TYPE_TRACEPOINT+1]);
+                        printf("  %-42s [%s]\n", evt_path,
+                                event_type_descriptors[PERF_TYPE_TRACEPOINT]);
                 }
                 closedir(evt_dir);
         }
@@ -799,28 +898,26 @@ void print_events(void)
         unsigned int i, type, op, prev_type = -1;
         char name[40];
 
-        fprintf(stderr, "\n");
-        fprintf(stderr, "List of pre-defined events (to be used in -e):\n");
+        printf("\n");
+        printf("List of pre-defined events (to be used in -e):\n");
 
         for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
-                type = syms->type + 1;
-                if (type >= ARRAY_SIZE(event_type_descriptors))
-                        type = 0;
+                type = syms->type;
 
                 if (type != prev_type)
-                        fprintf(stderr, "\n");
+                        printf("\n");
 
                 if (strlen(syms->alias))
                         sprintf(name, "%s OR %s", syms->symbol, syms->alias);
                 else
                         strcpy(name, syms->symbol);
-                fprintf(stderr, "  %-42s [%s]\n", name,
+                printf("  %-42s [%s]\n", name,
                         event_type_descriptors[type]);
 
                 prev_type = type;
         }
 
-        fprintf(stderr, "\n");
+        printf("\n");
         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
                         /* skip invalid cache type */
@@ -828,17 +925,22 @@ void print_events(void)
                                 continue;
 
                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
-                                fprintf(stderr, "  %-42s [%s]\n",
+                                printf("  %-42s [%s]\n",
                                         event_cache_name(type, op, i),
-                                        event_type_descriptors[4]);
+                                        event_type_descriptors[PERF_TYPE_HW_CACHE]);
                         }
                 }
         }
 
-        fprintf(stderr, "\n");
-        fprintf(stderr, "  %-42s [raw hardware event descriptor]\n",
-                "rNNN");
-        fprintf(stderr, "\n");
+        printf("\n");
+        printf("  %-42s [%s]\n",
+                "rNNN", event_type_descriptors[PERF_TYPE_RAW]);
+        printf("\n");
+
+        printf("  %-42s [%s]\n",
+                        "mem:<addr>[:access]",
+                        event_type_descriptors[PERF_TYPE_BREAKPOINT]);
+        printf("\n");
 
         print_tracepoint_events();
 
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 30c608112845..b8c1f64bc935 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -1,5 +1,5 @@
-#ifndef _PARSE_EVENTS_H
-#define _PARSE_EVENTS_H
+#ifndef __PERF_PARSE_EVENTS_H
+#define __PERF_PARSE_EVENTS_H
 /*
  * Parse symbolic events/counts passed in as options:
  */
@@ -17,11 +17,13 @@ extern struct tracepoint_path *tracepoint_id_to_path(u64 config);
 extern int                      nr_counters;
 
 extern struct perf_event_attr attrs[MAX_COUNTERS];
+extern char *filters[MAX_COUNTERS];
 
 extern const char *event_name(int ctr);
 extern const char *__event_name(int type, u64 config);
 
 extern int parse_events(const struct option *opt, const char *str, int unset);
+extern int parse_filter(const struct option *opt, const char *str, int unset);
 
 #define EVENTS_HELP_MAX (128*1024)
 
@@ -31,4 +33,4 @@ extern char debugfs_path[];
 extern int valid_debugfs_mount(const char *debugfs);
 
 
-#endif /* _PARSE_EVENTS_H */
+#endif /* __PERF_PARSE_EVENTS_H */
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
index 6d8af48c925e..efebd5b476b3 100644
--- a/tools/perf/util/parse-options.c
+++ b/tools/perf/util/parse-options.c
@@ -430,6 +430,9 @@ int usage_with_options_internal(const char * const *usagestr,
                 pos = fprintf(stderr, "    ");
                 if (opts->short_name)
                         pos += fprintf(stderr, "-%c", opts->short_name);
+                else
+                        pos += fprintf(stderr, "    ");
+
                 if (opts->long_name && opts->short_name)
                         pos += fprintf(stderr, ", ");
                 if (opts->long_name)
diff --git a/tools/perf/util/parse-options.h b/tools/perf/util/parse-options.h
index 2ee248ff27e5..948805af43c2 100644
--- a/tools/perf/util/parse-options.h
+++ b/tools/perf/util/parse-options.h
@@ -1,5 +1,5 @@
-#ifndef PARSE_OPTIONS_H
-#define PARSE_OPTIONS_H
+#ifndef __PERF_PARSE_OPTIONS_H
+#define __PERF_PARSE_OPTIONS_H
 
 enum parse_opt_type {
         /* special types */
@@ -174,4 +174,4 @@ extern int parse_opt_verbosity_cb(const struct option *, const char *, int);
 
 extern const char *parse_options_fix_filename(const char *prefix, const char *file);
 
-#endif
+#endif /* __PERF_PARSE_OPTIONS_H */
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
new file mode 100644
index 000000000000..7c004b6ef24f
--- /dev/null
+++ b/tools/perf/util/probe-event.c
@@ -0,0 +1,802 @@
+/*
+ * probe-event.c : perf-probe definition to kprobe_events format converter
+ *
+ * Written by Masami Hiramatsu <mhiramat@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#define _GNU_SOURCE
+#include <sys/utsname.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <limits.h>
+
+#undef _GNU_SOURCE
+#include "event.h"
+#include "string.h"
+#include "strlist.h"
+#include "debug.h"
+#include "cache.h"
+#include "color.h"
+#include "parse-events.h"  /* For debugfs_path */
+#include "probe-event.h"
+
+#define MAX_CMDLEN 256
+#define MAX_PROBE_ARGS 128
+#define PERFPROBE_GROUP "probe"
+
+#define semantic_error(msg ...) die("Semantic error :" msg)
+
+/* If there is no space to write, returns -E2BIG. */
+static int e_snprintf(char *str, size_t size, const char *format, ...)
+        __attribute__((format(printf, 3, 4)));
+
+static int e_snprintf(char *str, size_t size, const char *format, ...)
+{
+        int ret;
+        va_list ap;
+        va_start(ap, format);
+        ret = vsnprintf(str, size, format, ap);
+        va_end(ap);
+        if (ret >= (int)size)
+                ret = -E2BIG;
+        return ret;
+}
+
+void parse_line_range_desc(const char *arg, struct line_range *lr)
+{
+        const char *ptr;
+        char *tmp;
+        /*
+         * <Syntax>
+         * SRC:SLN[+NUM|-ELN]
+         * FUNC[:SLN[+NUM|-ELN]]
+         */
+        ptr = strchr(arg, ':');
+        if (ptr) {
+                lr->start = (unsigned int)strtoul(ptr + 1, &tmp, 0);
+                if (*tmp == '+')
+                        lr->end = lr->start + (unsigned int)strtoul(tmp + 1,
+                                                                    &tmp, 0);
+                else if (*tmp == '-')
+                        lr->end = (unsigned int)strtoul(tmp + 1, &tmp, 0);
+                else
+                        lr->end = 0;
+                pr_debug("Line range is %u to %u\n", lr->start, lr->end);
+                if (lr->end && lr->start > lr->end)
+                        semantic_error("Start line must be smaller"
+                                       " than end line.");
+                if (*tmp != '\0')
+                        semantic_error("Tailing with invalid character '%d'.",
+                                       *tmp);
+                tmp = strndup(arg, (ptr - arg));
+        } else
+                tmp = strdup(arg);
+
+        if (strchr(tmp, '.'))
+                lr->file = tmp;
+        else
+                lr->function = tmp;
+}
+
+/* Check the name is good for event/group */
+static bool check_event_name(const char *name)
+{
+        if (!isalpha(*name) && *name != '_')
+                return false;
+        while (*++name != '\0') {
+                if (!isalpha(*name) && !isdigit(*name) && *name != '_')
+                        return false;
+        }
+        return true;
+}
+
+/* Parse probepoint definition. */
+static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
+{
+        char *ptr, *tmp;
+        char c, nc = 0;
+        /*
+         * <Syntax>
+         * perf probe [EVENT=]SRC[:LN|;PTN]
+         * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
+         *
+         * TODO:Group name support
+         */
+
+        ptr = strpbrk(arg, ";=@+%");
+        if (ptr && *ptr == '=') {       /* Event name */
+                *ptr = '\0';
+                tmp = ptr + 1;
+                ptr = strchr(arg, ':');
+                if (ptr)        /* Group name is not supported yet. */
+                        semantic_error("Group name is not supported yet.");
+                if (!check_event_name(arg))
+                        semantic_error("%s is bad for event name -it must "
+                                       "follow C symbol-naming rule.", arg);
+                pp->event = strdup(arg);
+                arg = tmp;
+        }
+
+        ptr = strpbrk(arg, ";:+@%");
+        if (ptr) {
+                nc = *ptr;
+                *ptr++ = '\0';
+        }
+
+        /* Check arg is function or file and copy it */
+        if (strchr(arg, '.'))   /* File */
+                pp->file = strdup(arg);
+        else                    /* Function */
+                pp->function = strdup(arg);
+        DIE_IF(pp->file == NULL && pp->function == NULL);
+
+        /* Parse other options */
+        while (ptr) {
+                arg = ptr;
+                c = nc;
+                if (c == ';') { /* Lazy pattern must be the last part */
+                        pp->lazy_line = strdup(arg);
+                        break;
+                }
+                ptr = strpbrk(arg, ";:+@%");
+                if (ptr) {
+                        nc = *ptr;
+                        *ptr++ = '\0';
+                }
+                switch (c) {
+                case ':':       /* Line number */
+                        pp->line = strtoul(arg, &tmp, 0);
+                        if (*tmp != '\0')
+                                semantic_error("There is non-digit char"
+                                               " in line number.");
+                        break;
+                case '+':       /* Byte offset from a symbol */
+                        pp->offset = strtoul(arg, &tmp, 0);
+                        if (*tmp != '\0')
+                                semantic_error("There is non-digit character"
+                                                " in offset.");
+                        break;
+                case '@':       /* File name */
+                        if (pp->file)
+                                semantic_error("SRC@SRC is not allowed.");
+                        pp->file = strdup(arg);
+                        DIE_IF(pp->file == NULL);
+                        break;
+                case '%':       /* Probe places */
+                        if (strcmp(arg, "return") == 0) {
+                                pp->retprobe = 1;
+                        } else  /* Others not supported yet */
+                                semantic_error("%%%s is not supported.", arg);
+                        break;
+                default:
+                        DIE_IF("Program has a bug.");
+                        break;
+                }
+        }
+
+        /* Exclusion check */
+        if (pp->lazy_line && pp->line)
+                semantic_error("Lazy pattern can't be used with line number.");
+
+        if (pp->lazy_line && pp->offset)
+                semantic_error("Lazy pattern can't be used with offset.");
+
+        if (pp->line && pp->offset)
+                semantic_error("Offset can't be used with line number.");
+
+        if (!pp->line && !pp->lazy_line && pp->file && !pp->function)
+                semantic_error("File always requires line number or "
+                               "lazy pattern.");
+
+        if (pp->offset && !pp->function)
+                semantic_error("Offset requires an entry function.");
+
+        if (pp->retprobe && !pp->function)
+                semantic_error("Return probe requires an entry function.");
+
+        if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe)
+                semantic_error("Offset/Line/Lazy pattern can't be used with "
+                               "return probe.");
+
+        pr_debug("symbol:%s file:%s line:%d offset:%d return:%d lazy:%s\n",
+                 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
+                 pp->lazy_line);
+}
+
+/* Parse perf-probe event definition */
+void parse_perf_probe_event(const char *str, struct probe_point *pp,
+                            bool *need_dwarf)
+{
+        char **argv;
+        int argc, i;
+
+        *need_dwarf = false;
+
+        argv = argv_split(str, &argc);
+        if (!argv)
+                die("argv_split failed.");
+        if (argc > MAX_PROBE_ARGS + 1)
+                semantic_error("Too many arguments");
+
+        /* Parse probe point */
+        parse_perf_probe_probepoint(argv[0], pp);
+        if (pp->file || pp->line || pp->lazy_line)
+                *need_dwarf = true;
+
+        /* Copy arguments and ensure return probe has no C argument */
+        pp->nr_args = argc - 1;
+        pp->args = zalloc(sizeof(char *) * pp->nr_args);
+        for (i = 0; i < pp->nr_args; i++) {
+                pp->args[i] = strdup(argv[i + 1]);
+                if (!pp->args[i])
+                        die("Failed to copy argument.");
+                if (is_c_varname(pp->args[i])) {
+                        if (pp->retprobe)
+                                semantic_error("You can't specify local"
+                                                " variable for kretprobe");
+                        *need_dwarf = true;
+                }
+        }
+
+        argv_free(argv);
+}
+
+/* Parse kprobe_events event into struct probe_point */
+void parse_trace_kprobe_event(const char *str, struct probe_point *pp)
+{
+        char pr;
+        char *p;
+        int ret, i, argc;
+        char **argv;
+
+        pr_debug("Parsing kprobe_events: %s\n", str);
+        argv = argv_split(str, &argc);
+        if (!argv)
+                die("argv_split failed.");
+        if (argc < 2)
+                semantic_error("Too less arguments.");
+
+        /* Scan event and group name. */
+        ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]",
+                     &pr, (float *)(void *)&pp->group,
+                     (float *)(void *)&pp->event);
+        if (ret != 3)
+                semantic_error("Failed to parse event name: %s", argv[0]);
+        pr_debug("Group:%s Event:%s probe:%c\n", pp->group, pp->event, pr);
+
+        pp->retprobe = (pr == 'r');
+
+        /* Scan function name and offset */
+        ret = sscanf(argv[1], "%a[^+]+%d", (float *)(void *)&pp->function,
+                     &pp->offset);
+        if (ret == 1)
+                pp->offset = 0;
+
+        /* kprobe_events doesn't have this information */
+        pp->line = 0;
+        pp->file = NULL;
+
+        pp->nr_args = argc - 2;
+        pp->args = zalloc(sizeof(char *) * pp->nr_args);
+        for (i = 0; i < pp->nr_args; i++) {
+                p = strchr(argv[i + 2], '=');
+                if (p)  /* We don't need which register is assigned. */
+                        *p = '\0';
+                pp->args[i] = strdup(argv[i + 2]);
+                if (!pp->args[i])
+                        die("Failed to copy argument.");
+        }
+
+        argv_free(argv);
+}
+
+/* Synthesize only probe point (not argument) */
+int synthesize_perf_probe_point(struct probe_point *pp)
+{
+        char *buf;
+        char offs[64] = "", line[64] = "";
+        int ret;
+
+        pp->probes[0] = buf = zalloc(MAX_CMDLEN);
+        pp->found = 1;
+        if (!buf)
+                die("Failed to allocate memory by zalloc.");
+        if (pp->offset) {
+                ret = e_snprintf(offs, 64, "+%d", pp->offset);
+                if (ret <= 0)
+                        goto error;
+        }
+        if (pp->line) {
+                ret = e_snprintf(line, 64, ":%d", pp->line);
+                if (ret <= 0)
+                        goto error;
+        }
+
+        if (pp->function)
+                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s", pp->function,
+                                 offs, pp->retprobe ? "%return" : "", line);
+        else
+                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", pp->file, line);
+        if (ret <= 0) {
+error:
+                free(pp->probes[0]);
+                pp->probes[0] = NULL;
+                pp->found = 0;
+        }
+        return ret;
+}
+
+int synthesize_perf_probe_event(struct probe_point *pp)
+{
+        char *buf;
+        int i, len, ret;
+
+        len = synthesize_perf_probe_point(pp);
+        if (len < 0)
+                return 0;
+
+        buf = pp->probes[0];
+        for (i = 0; i < pp->nr_args; i++) {
+                ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
+                                 pp->args[i]);
+                if (ret <= 0)
+                        goto error;
+                len += ret;
+        }
+        pp->found = 1;
+
+        return pp->found;
+error:
+        free(pp->probes[0]);
+        pp->probes[0] = NULL;
+
+        return ret;
+}
+
+int synthesize_trace_kprobe_event(struct probe_point *pp)
+{
+        char *buf;
+        int i, len, ret;
+
+        pp->probes[0] = buf = zalloc(MAX_CMDLEN);
+        if (!buf)
+                die("Failed to allocate memory by zalloc.");
+        ret = e_snprintf(buf, MAX_CMDLEN, "%s+%d", pp->function, pp->offset);
+        if (ret <= 0)
+                goto error;
+        len = ret;
+
+        for (i = 0; i < pp->nr_args; i++) {
+                ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
+                                 pp->args[i]);
+                if (ret <= 0)
+                        goto error;
+                len += ret;
+        }
+        pp->found = 1;
+
+        return pp->found;
+error:
+        free(pp->probes[0]);
+        pp->probes[0] = NULL;
+
+        return ret;
+}
+
+static int open_kprobe_events(int flags, int mode)
+{
+        char buf[PATH_MAX];
+        int ret;
+
+        ret = e_snprintf(buf, PATH_MAX, "%s/../kprobe_events", debugfs_path);
+        if (ret < 0)
+                die("Failed to make kprobe_events path.");
+
+        ret = open(buf, flags, mode);
+        if (ret < 0) {
+                if (errno == ENOENT)
+                        die("kprobe_events file does not exist -"
+                            " please rebuild with CONFIG_KPROBE_EVENT.");
+                else
+                        die("Could not open kprobe_events file: %s",
+                            strerror(errno));
+        }
+        return ret;
+}
+
+/* Get raw string list of current kprobe_events */
+static struct strlist *get_trace_kprobe_event_rawlist(int fd)
+{
+        int ret, idx;
+        FILE *fp;
+        char buf[MAX_CMDLEN];
+        char *p;
+        struct strlist *sl;
+
+        sl = strlist__new(true, NULL);
+
+        fp = fdopen(dup(fd), "r");
+        while (!feof(fp)) {
+                p = fgets(buf, MAX_CMDLEN, fp);
+                if (!p)
+                        break;
+
+                idx = strlen(p) - 1;
+                if (p[idx] == '\n')
+                        p[idx] = '\0';
+                ret = strlist__add(sl, buf);
+                if (ret < 0)
+                        die("strlist__add failed: %s", strerror(-ret));
+        }
+        fclose(fp);
+
+        return sl;
+}
+
+/* Free and zero clear probe_point */
+static void clear_probe_point(struct probe_point *pp)
+{
+        int i;
+
+        if (pp->event)
+                free(pp->event);
+        if (pp->group)
+                free(pp->group);
+        if (pp->function)
+                free(pp->function);
+        if (pp->file)
+                free(pp->file);
+        if (pp->lazy_line)
+                free(pp->lazy_line);
+        for (i = 0; i < pp->nr_args; i++)
+                free(pp->args[i]);
+        if (pp->args)
+                free(pp->args);
+        for (i = 0; i < pp->found; i++)
+                free(pp->probes[i]);
+        memset(pp, 0, sizeof(*pp));
+}
+
+/* Show an event */
+static void show_perf_probe_event(const char *event, const char *place,
+                                  struct probe_point *pp)
+{
+        int i, ret;
+        char buf[128];
+
+        ret = e_snprintf(buf, 128, "%s:%s", pp->group, event);
+        if (ret < 0)
+                die("Failed to copy event: %s", strerror(-ret));
+        printf("  %-40s (on %s", buf, place);
+
+        if (pp->nr_args > 0) {
+                printf(" with");
+                for (i = 0; i < pp->nr_args; i++)
+                        printf(" %s", pp->args[i]);
+        }
+        printf(")\n");
+}
+
+/* List up current perf-probe events */
+void show_perf_probe_events(void)
+{
+        int fd;
+        struct probe_point pp;
+        struct strlist *rawlist;
+        struct str_node *ent;
+
+        setup_pager();
+        memset(&pp, 0, sizeof(pp));
+
+        fd = open_kprobe_events(O_RDONLY, 0);
+        rawlist = get_trace_kprobe_event_rawlist(fd);
+        close(fd);
+
+        strlist__for_each(ent, rawlist) {
+                parse_trace_kprobe_event(ent->s, &pp);
+                /* Synthesize only event probe point */
+                synthesize_perf_probe_point(&pp);
+                /* Show an event */
+                show_perf_probe_event(pp.event, pp.probes[0], &pp);
+                clear_probe_point(&pp);
+        }
+
+        strlist__delete(rawlist);
+}
+
+/* Get current perf-probe event names */
+static struct strlist *get_perf_event_names(int fd, bool include_group)
+{
+        char buf[128];
+        struct strlist *sl, *rawlist;
+        struct str_node *ent;
+        struct probe_point pp;
+
+        memset(&pp, 0, sizeof(pp));
+        rawlist = get_trace_kprobe_event_rawlist(fd);
+
+        sl = strlist__new(true, NULL);
+        strlist__for_each(ent, rawlist) {
+                parse_trace_kprobe_event(ent->s, &pp);
+                if (include_group) {
+                        if (e_snprintf(buf, 128, "%s:%s", pp.group,
+                                       pp.event) < 0)
+                                die("Failed to copy group:event name.");
+                        strlist__add(sl, buf);
+                } else
+                        strlist__add(sl, pp.event);
+                clear_probe_point(&pp);
+        }
+
+        strlist__delete(rawlist);
+
+        return sl;
+}
+
+static void write_trace_kprobe_event(int fd, const char *buf)
+{
+        int ret;
+
+        pr_debug("Writing event: %s\n", buf);
+        ret = write(fd, buf, strlen(buf));
+        if (ret <= 0)
+                die("Failed to write event: %s", strerror(errno));
+}
+
+static void get_new_event_name(char *buf, size_t len, const char *base,
+                               struct strlist *namelist, bool allow_suffix)
+{
+        int i, ret;
+
+        /* Try no suffix */
+        ret = e_snprintf(buf, len, "%s", base);
+        if (ret < 0)
+                die("snprintf() failed: %s", strerror(-ret));
+        if (!strlist__has_entry(namelist, buf))
+                return;
+
+        if (!allow_suffix) {
+                pr_warning("Error: event \"%s\" already exists. "
+                           "(Use -f to force duplicates.)\n", base);
+                die("Can't add new event.");
+        }
+
+        /* Try to add suffix */
+        for (i = 1; i < MAX_EVENT_INDEX; i++) {
+                ret = e_snprintf(buf, len, "%s_%d", base, i);
+                if (ret < 0)
+                        die("snprintf() failed: %s", strerror(-ret));
+                if (!strlist__has_entry(namelist, buf))
+                        break;
+        }
+        if (i == MAX_EVENT_INDEX)
+                die("Too many events are on the same function.");
+}
+
+void add_trace_kprobe_events(struct probe_point *probes, int nr_probes,
+                             bool force_add)
+{
+        int i, j, fd;
+        struct probe_point *pp;
+        char buf[MAX_CMDLEN];
+        char event[64];
+        struct strlist *namelist;
+        bool allow_suffix;
+
+        fd = open_kprobe_events(O_RDWR, O_APPEND);
+        /* Get current event names */
+        namelist = get_perf_event_names(fd, false);
+
+        for (j = 0; j < nr_probes; j++) {
+                pp = probes + j;
+                if (!pp->event)
+                        pp->event = strdup(pp->function);
+                if (!pp->group)
+                        pp->group = strdup(PERFPROBE_GROUP);
+                DIE_IF(!pp->event || !pp->group);
+                /* If force_add is true, suffix search is allowed */
+                allow_suffix = force_add;
+                for (i = 0; i < pp->found; i++) {
+                        /* Get an unused new event name */
+                        get_new_event_name(event, 64, pp->event, namelist,
+                                           allow_suffix);
+                        snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s\n",
+                                 pp->retprobe ? 'r' : 'p',
+                                 pp->group, event,
+                                 pp->probes[i]);
+                        write_trace_kprobe_event(fd, buf);
+                        printf("Added new event:\n");
+                        /* Get the first parameter (probe-point) */
+                        sscanf(pp->probes[i], "%s", buf);
+                        show_perf_probe_event(event, buf, pp);
+                        /* Add added event name to namelist */
+                        strlist__add(namelist, event);
+                        /*
+                         * Probes after the first probe which comes from same
+                         * user input are always allowed to add suffix, because
+                         * there might be several addresses corresponding to
+                         * one code line.
+                         */
+                        allow_suffix = true;
+                }
+        }
+        /* Show how to use the event. */
+        printf("\nYou can now use it on all perf tools, such as:\n\n");
+        printf("\tperf record -e %s:%s -a sleep 1\n\n", PERFPROBE_GROUP, event);
+
+        strlist__delete(namelist);
+        close(fd);
+}
+
+static void __del_trace_kprobe_event(int fd, struct str_node *ent)
+{
+        char *p;
+        char buf[128];
+
+        /* Convert from perf-probe event to trace-kprobe event */
+        if (e_snprintf(buf, 128, "-:%s", ent->s) < 0)
+                die("Failed to copy event.");
+        p = strchr(buf + 2, ':');
+        if (!p)
+                die("Internal error: %s should have ':' but not.", ent->s);
+        *p = '/';
+
+        write_trace_kprobe_event(fd, buf);
+        printf("Remove event: %s\n", ent->s);
+}
+
+static void del_trace_kprobe_event(int fd, const char *group,
+                                   const char *event, struct strlist *namelist)
+{
+        char buf[128];
+        struct str_node *ent, *n;
+        int found = 0;
+
+        if (e_snprintf(buf, 128, "%s:%s", group, event) < 0)
+                die("Failed to copy event.");
+
+        if (strpbrk(buf, "*?")) { /* Glob-exp */
+                strlist__for_each_safe(ent, n, namelist)
+                        if (strglobmatch(ent->s, buf)) {
+                                found++;
+                                __del_trace_kprobe_event(fd, ent);
+                                strlist__remove(namelist, ent);
+                        }
+        } else {
+                ent = strlist__find(namelist, buf);
+                if (ent) {
+                        found++;
+                        __del_trace_kprobe_event(fd, ent);
+                        strlist__remove(namelist, ent);
+                }
+        }
+        if (found == 0)
+                pr_info("Info: event \"%s\" does not exist, could not remove it.\n", buf);
+}
+
+void del_trace_kprobe_events(struct strlist *dellist)
+{
+        int fd;
+        const char *group, *event;
+        char *p, *str;
+        struct str_node *ent;
+        struct strlist *namelist;
+
+        fd = open_kprobe_events(O_RDWR, O_APPEND);
+        /* Get current event names */
+        namelist = get_perf_event_names(fd, true);
+
+        strlist__for_each(ent, dellist) {
+                str = strdup(ent->s);
+                if (!str)
+                        die("Failed to copy event.");
+                pr_debug("Parsing: %s\n", str);
+                p = strchr(str, ':');
+                if (p) {
+                        group = str;
+                        *p = '\0';
+                        event = p + 1;
+                } else {
+                        group = "*";
+                        event = str;
+                }
+                pr_debug("Group: %s, Event: %s\n", group, event);
+                del_trace_kprobe_event(fd, group, event, namelist);
+                free(str);
+        }
+        strlist__delete(namelist);
+        close(fd);
+}
+
+#define LINEBUF_SIZE 256
+#define NR_ADDITIONAL_LINES 2
+
+static void show_one_line(FILE *fp, unsigned int l, bool skip, bool show_num)
+{
+        char buf[LINEBUF_SIZE];
+        const char *color = PERF_COLOR_BLUE;
+
+        if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
+                goto error;
+        if (!skip) {
+                if (show_num)
+                        fprintf(stdout, "%7u  %s", l, buf);
+                else
+                        color_fprintf(stdout, color, "         %s", buf);
+        }
+
+        while (strlen(buf) == LINEBUF_SIZE - 1 &&
+               buf[LINEBUF_SIZE - 2] != '\n') {
+                if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
+                        goto error;
+                if (!skip) {
+                        if (show_num)
+                                fprintf(stdout, "%s", buf);
+                        else
+                                color_fprintf(stdout, color, "%s", buf);
+                }
+        }
+        return;
+error:
+        if (feof(fp))
+                die("Source file is shorter than expected.");
+        else
+                die("File read error: %s", strerror(errno));
+}
+
+void show_line_range(struct line_range *lr)
+{
+        unsigned int l = 1;
+        struct line_node *ln;
+        FILE *fp;
+
+        setup_pager();
+
+        if (lr->function)
+                fprintf(stdout, "<%s:%d>\n", lr->function,
+                        lr->start - lr->offset);
+        else
+                fprintf(stdout, "<%s:%d>\n", lr->file, lr->start);
+
+        fp = fopen(lr->path, "r");
+        if (fp == NULL)
+                die("Failed to open %s: %s", lr->path, strerror(errno));
+        /* Skip to starting line number */
+        while (l < lr->start)
+                show_one_line(fp, l++, true, false);
+
+        list_for_each_entry(ln, &lr->line_list, list) {
+                while (ln->line > l)
+                        show_one_line(fp, (l++) - lr->offset, false, false);
+                show_one_line(fp, (l++) - lr->offset, false, true);
+        }
+
+        if (lr->end == INT_MAX)
+                lr->end = l + NR_ADDITIONAL_LINES;
+        while (l < lr->end && !feof(fp))
+                show_one_line(fp, (l++) - lr->offset, false, false);
+
+        fclose(fp);
+}
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
new file mode 100644
index 000000000000..711287d4baea
--- /dev/null
+++ b/tools/perf/util/probe-event.h
@@ -0,0 +1,24 @@
+#ifndef _PROBE_EVENT_H
+#define _PROBE_EVENT_H
+
+#include <stdbool.h>
+#include "probe-finder.h"
+#include "strlist.h"
+
+extern void parse_line_range_desc(const char *arg, struct line_range *lr);
+extern void parse_perf_probe_event(const char *str, struct probe_point *pp,
+                                   bool *need_dwarf);
+extern int synthesize_perf_probe_point(struct probe_point *pp);
+extern int synthesize_perf_probe_event(struct probe_point *pp);
+extern void parse_trace_kprobe_event(const char *str, struct probe_point *pp);
+extern int synthesize_trace_kprobe_event(struct probe_point *pp);
+extern void add_trace_kprobe_events(struct probe_point *probes, int nr_probes,
+                                    bool force_add);
+extern void del_trace_kprobe_events(struct strlist *dellist);
+extern void show_perf_probe_events(void);
+extern void show_line_range(struct line_range *lr);
+
+/* Maximum index number of event-name postfix */
+#define MAX_EVENT_INDEX 1024
+
+#endif /*_PROBE_EVENT_H */
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
new file mode 100644
index 000000000000..c171a243d05b
--- /dev/null
+++ b/tools/perf/util/probe-finder.c
@@ -0,0 +1,829 @@
+/*
+ * probe-finder.c : C expression to kprobe event converter
+ *
+ * Written by Masami Hiramatsu <mhiramat@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include <sys/utsname.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+#include "string.h"
+#include "event.h"
+#include "debug.h"
+#include "util.h"
+#include "probe-finder.h"
+
+
+/*
+ * Generic dwarf analysis helpers
+ */
+
+#define X86_32_MAX_REGS 8
+const char *x86_32_regs_table[X86_32_MAX_REGS] = {
+        "%ax",
+        "%cx",
+        "%dx",
+        "%bx",
+        "$stack",       /* Stack address instead of %sp */
+        "%bp",
+        "%si",
+        "%di",
+};
+
+#define X86_64_MAX_REGS 16
+const char *x86_64_regs_table[X86_64_MAX_REGS] = {
+        "%ax",
+        "%dx",
+        "%cx",
+        "%bx",
+        "%si",
+        "%di",
+        "%bp",
+        "%sp",
+        "%r8",
+        "%r9",
+        "%r10",
+        "%r11",
+        "%r12",
+        "%r13",
+        "%r14",
+        "%r15",
+};
+
+/* TODO: switching by dwarf address size */
+#ifdef __x86_64__
+#define ARCH_MAX_REGS X86_64_MAX_REGS
+#define arch_regs_table x86_64_regs_table
+#else
+#define ARCH_MAX_REGS X86_32_MAX_REGS
+#define arch_regs_table x86_32_regs_table
+#endif
+
+/* Return architecture dependent register string (for kprobe-tracer) */
+static const char *get_arch_regstr(unsigned int n)
+{
+        return (n <= ARCH_MAX_REGS) ? arch_regs_table[n] : NULL;
+}
+
+/*
+ * Compare the tail of two strings.
+ * Return 0 if whole of either string is same as another's tail part.
+ */
+static int strtailcmp(const char *s1, const char *s2)
+{
+        int i1 = strlen(s1);
+        int i2 = strlen(s2);
+        while (--i1 >= 0 && --i2 >= 0) {
+                if (s1[i1] != s2[i2])
+                        return s1[i1] - s2[i2];
+        }
+        return 0;
+}
+
+/* Line number list operations */
+
+/* Add a line to line number list */
+static void line_list__add_line(struct list_head *head, unsigned int line)
+{
+        struct line_node *ln;
+        struct list_head *p;
+
+        /* Reverse search, because new line will be the last one */
+        list_for_each_entry_reverse(ln, head, list) {
+                if (ln->line < line) {
+                        p = &ln->list;
+                        goto found;
+                } else if (ln->line == line)    /* Already exist */
+                        return ;
+        }
+        /* List is empty, or the smallest entry */
+        p = head;
+found:
+        pr_debug("line list: add a line %u\n", line);
+        ln = zalloc(sizeof(struct line_node));
+        DIE_IF(ln == NULL);
+        ln->line = line;
+        INIT_LIST_HEAD(&ln->list);
+        list_add(&ln->list, p);
+}
+
+/* Check if the line in line number list */
+static int line_list__has_line(struct list_head *head, unsigned int line)
+{
+        struct line_node *ln;
+
+        /* Reverse search, because new line will be the last one */
+        list_for_each_entry(ln, head, list)
+                if (ln->line == line)
+                        return 1;
+
+        return 0;
+}
+
+/* Init line number list */
+static void line_list__init(struct list_head *head)
+{
+        INIT_LIST_HEAD(head);
+}
+
+/* Free line number list */
+static void line_list__free(struct list_head *head)
+{
+        struct line_node *ln;
+        while (!list_empty(head)) {
+                ln = list_first_entry(head, struct line_node, list);
+                list_del(&ln->list);
+                free(ln);
+        }
+}
+
+/* Dwarf wrappers */
+
+/* Find the realpath of the target file. */
+static const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
+{
+        Dwarf_Files *files;
+        size_t nfiles, i;
+        const char *src = NULL;
+        int ret;
+
+        if (!fname)
+                return NULL;
+
+        ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
+        if (ret != 0)
+                return NULL;
+
+        for (i = 0; i < nfiles; i++) {
+                src = dwarf_filesrc(files, i, NULL, NULL);
+                if (strtailcmp(src, fname) == 0)
+                        break;
+        }
+        return src;
+}
+
+struct __addr_die_search_param {
+        Dwarf_Addr      addr;
+        Dwarf_Die       *die_mem;
+};
+
+static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
+{
+        struct __addr_die_search_param *ad = data;
+
+        if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
+            dwarf_haspc(fn_die, ad->addr)) {
+                memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
+                return DWARF_CB_ABORT;
+        }
+        return DWARF_CB_OK;
+}
+
+/* Search a real subprogram including this line, */
+static Dwarf_Die *die_get_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
+                                          Dwarf_Die *die_mem)
+{
+        struct __addr_die_search_param ad;
+        ad.addr = addr;
+        ad.die_mem = die_mem;
+        /* dwarf_getscopes can't find subprogram. */
+        if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
+                return NULL;
+        else
+                return die_mem;
+}
+
+/* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */
+static Dwarf_Die *die_get_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
+                                     Dwarf_Die *die_mem)
+{
+        Dwarf_Die child_die;
+        int ret;
+
+        ret = dwarf_child(sp_die, die_mem);
+        if (ret != 0)
+                return NULL;
+
+        do {
+                if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
+                    dwarf_haspc(die_mem, addr))
+                        return die_mem;
+
+                if (die_get_inlinefunc(die_mem, addr, &child_die)) {
+                        memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
+                        return die_mem;
+                }
+        } while (dwarf_siblingof(die_mem, die_mem) == 0);
+
+        return NULL;
+}
+
+/* Compare diename and tname */
+static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
+{
+        const char *name;
+        name = dwarf_diename(dw_die);
+        DIE_IF(name == NULL);
+        return strcmp(tname, name);
+}
+
+/* Get entry pc(or low pc, 1st entry of ranges)  of the die */
+static Dwarf_Addr die_get_entrypc(Dwarf_Die *dw_die)
+{
+        Dwarf_Addr epc;
+        int ret;
+
+        ret = dwarf_entrypc(dw_die, &epc);
+        DIE_IF(ret == -1);
+        return epc;
+}
+
+/* Get a variable die */
+static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name,
+                                    Dwarf_Die *die_mem)
+{
+        Dwarf_Die child_die;
+        int tag;
+        int ret;
+
+        ret = dwarf_child(sp_die, die_mem);
+        if (ret != 0)
+                return NULL;
+
+        do {
+                tag = dwarf_tag(die_mem);
+                if ((tag == DW_TAG_formal_parameter ||
+                     tag == DW_TAG_variable) &&
+                    (die_compare_name(die_mem, name) == 0))
+                        return die_mem;
+
+                if (die_find_variable(die_mem, name, &child_die)) {
+                        memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
+                        return die_mem;
+                }
+        } while (dwarf_siblingof(die_mem, die_mem) == 0);
+
+        return NULL;
+}
+
+/*
+ * Probe finder related functions
+ */
+
+/* Show a location */
+static void show_location(Dwarf_Op *op, struct probe_finder *pf)
+{
+        unsigned int regn;
+        Dwarf_Word offs = 0;
+        int deref = 0, ret;
+        const char *regs;
+
+        /* TODO: support CFA */
+        /* If this is based on frame buffer, set the offset */
+        if (op->atom == DW_OP_fbreg) {
+                if (pf->fb_ops == NULL)
+                        die("The attribute of frame base is not supported.\n");
+                deref = 1;
+                offs = op->number;
+                op = &pf->fb_ops[0];
+        }
+
+        if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
+                regn = op->atom - DW_OP_breg0;
+                offs += op->number;
+                deref = 1;
+        } else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
+                regn = op->atom - DW_OP_reg0;
+        } else if (op->atom == DW_OP_bregx) {
+                regn = op->number;
+                offs += op->number2;
+                deref = 1;
+        } else if (op->atom == DW_OP_regx) {
+                regn = op->number;
+        } else
+                die("DW_OP %d is not supported.", op->atom);
+
+        regs = get_arch_regstr(regn);
+        if (!regs)
+                die("%u exceeds max register number.", regn);
+
+        if (deref)
+                ret = snprintf(pf->buf, pf->len, " %s=%+jd(%s)",
+                               pf->var, (intmax_t)offs, regs);
+        else
+                ret = snprintf(pf->buf, pf->len, " %s=%s", pf->var, regs);
+        DIE_IF(ret < 0);
+        DIE_IF(ret >= pf->len);
+}
+
+/* Show a variables in kprobe event format */
+static void show_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
+{
+        Dwarf_Attribute attr;
+        Dwarf_Op *expr;
+        size_t nexpr;
+        int ret;
+
+        if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
+                goto error;
+        /* TODO: handle more than 1 exprs */
+        ret = dwarf_getlocation_addr(&attr, pf->addr, &expr, &nexpr, 1);
+        if (ret <= 0 || nexpr == 0)
+                goto error;
+
+        show_location(expr, pf);
+        /* *expr will be cached in libdw. Don't free it. */
+        return ;
+error:
+        /* TODO: Support const_value */
+        die("Failed to find the location of %s at this address.\n"
+            " Perhaps, it has been optimized out.", pf->var);
+}
+
+/* Find a variable in a subprogram die */
+static void find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
+{
+        int ret;
+        Dwarf_Die vr_die;
+
+        /* TODO: Support struct members and arrays */
+        if (!is_c_varname(pf->var)) {
+                /* Output raw parameters */
+                ret = snprintf(pf->buf, pf->len, " %s", pf->var);
+                DIE_IF(ret < 0);
+                DIE_IF(ret >= pf->len);
+                return ;
+        }
+
+        pr_debug("Searching '%s' variable in context.\n", pf->var);
+        /* Search child die for local variables and parameters. */
+        if (!die_find_variable(sp_die, pf->var, &vr_die))
+                die("Failed to find '%s' in this function.", pf->var);
+
+        show_variable(&vr_die, pf);
+}
+
+/* Show a probe point to output buffer */
+static void show_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
+{
+        struct probe_point *pp = pf->pp;
+        Dwarf_Addr eaddr;
+        Dwarf_Die die_mem;
+        const char *name;
+        char tmp[MAX_PROBE_BUFFER];
+        int ret, i, len;
+        Dwarf_Attribute fb_attr;
+        size_t nops;
+
+        /* If no real subprogram, find a real one */
+        if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
+                sp_die = die_get_real_subprogram(&pf->cu_die,
+                                                 pf->addr, &die_mem);
+                if (!sp_die)
+                        die("Probe point is not found in subprograms.");
+        }
+
+        /* Output name of probe point */
+        name = dwarf_diename(sp_die);
+        if (name) {
+                dwarf_entrypc(sp_die, &eaddr);
+                ret = snprintf(tmp, MAX_PROBE_BUFFER, "%s+%lu", name,
+                                (unsigned long)(pf->addr - eaddr));
+                /* Copy the function name if possible */
+                if (!pp->function) {
+                        pp->function = strdup(name);
+                        pp->offset = (size_t)(pf->addr - eaddr);
+                }
+        } else {
+                /* This function has no name. */
+                ret = snprintf(tmp, MAX_PROBE_BUFFER, "0x%jx",
+                               (uintmax_t)pf->addr);
+                if (!pp->function) {
+                        /* TODO: Use _stext */
+                        pp->function = strdup("");
+                        pp->offset = (size_t)pf->addr;
+                }
+        }
+        DIE_IF(ret < 0);
+        DIE_IF(ret >= MAX_PROBE_BUFFER);
+        len = ret;
+        pr_debug("Probe point found: %s\n", tmp);
+
+        /* Get the frame base attribute/ops */
+        dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
+        ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
+        if (ret <= 0 || nops == 0)
+                pf->fb_ops = NULL;
+
+        /* Find each argument */
+        /* TODO: use dwarf_cfi_addrframe */
+        for (i = 0; i < pp->nr_args; i++) {
+                pf->var = pp->args[i];
+                pf->buf = &tmp[len];
+                pf->len = MAX_PROBE_BUFFER - len;
+                find_variable(sp_die, pf);
+                len += strlen(pf->buf);
+        }
+
+        /* *pf->fb_ops will be cached in libdw. Don't free it. */
+        pf->fb_ops = NULL;
+
+        if (pp->found == MAX_PROBES)
+                die("Too many( > %d) probe point found.\n", MAX_PROBES);
+
+        pp->probes[pp->found] = strdup(tmp);
+        pp->found++;
+}
+
+/* Find probe point from its line number */
+static void find_probe_point_by_line(struct probe_finder *pf)
+{
+        Dwarf_Lines *lines;
+        Dwarf_Line *line;
+        size_t nlines, i;
+        Dwarf_Addr addr;
+        int lineno;
+        int ret;
+
+        ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
+        DIE_IF(ret != 0);
+
+        for (i = 0; i < nlines; i++) {
+                line = dwarf_onesrcline(lines, i);
+                dwarf_lineno(line, &lineno);
+                if (lineno != pf->lno)
+                        continue;
+
+                /* TODO: Get fileno from line, but how? */
+                if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
+                        continue;
+
+                ret = dwarf_lineaddr(line, &addr);
+                DIE_IF(ret != 0);
+                pr_debug("Probe line found: line[%d]:%d addr:0x%jx\n",
+                         (int)i, lineno, (uintmax_t)addr);
+                pf->addr = addr;
+
+                show_probe_point(NULL, pf);
+                /* Continuing, because target line might be inlined. */
+        }
+}
+
+/* Find lines which match lazy pattern */
+static int find_lazy_match_lines(struct list_head *head,
+                                 const char *fname, const char *pat)
+{
+        char *fbuf, *p1, *p2;
+        int fd, line, nlines = 0;
+        struct stat st;
+
+        fd = open(fname, O_RDONLY);
+        if (fd < 0)
+                die("failed to open %s", fname);
+        DIE_IF(fstat(fd, &st) < 0);
+        fbuf = malloc(st.st_size + 2);
+        DIE_IF(fbuf == NULL);
+        DIE_IF(read(fd, fbuf, st.st_size) < 0);
+        close(fd);
+        fbuf[st.st_size] = '\n';        /* Dummy line */
+        fbuf[st.st_size + 1] = '\0';
+        p1 = fbuf;
+        line = 1;
+        while ((p2 = strchr(p1, '\n')) != NULL) {
+                *p2 = '\0';
+                if (strlazymatch(p1, pat)) {
+                        line_list__add_line(head, line);
+                        nlines++;
+                }
+                line++;
+                p1 = p2 + 1;
+        }
+        free(fbuf);
+        return nlines;
+}
+
+/* Find probe points from lazy pattern  */
+static void find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
+{
+        Dwarf_Lines *lines;
+        Dwarf_Line *line;
+        size_t nlines, i;
+        Dwarf_Addr addr;
+        Dwarf_Die die_mem;
+        int lineno;
+        int ret;
+
+        if (list_empty(&pf->lcache)) {
+                /* Matching lazy line pattern */
+                ret = find_lazy_match_lines(&pf->lcache, pf->fname,
+                                            pf->pp->lazy_line);
+                if (ret <= 0)
+                        die("No matched lines found in %s.", pf->fname);
+        }
+
+        ret = dwarf_getsrclines(&pf->cu_die, &lines, &nlines);
+        DIE_IF(ret != 0);
+        for (i = 0; i < nlines; i++) {
+                line = dwarf_onesrcline(lines, i);
+
+                dwarf_lineno(line, &lineno);
+                if (!line_list__has_line(&pf->lcache, lineno))
+                        continue;
+
+                /* TODO: Get fileno from line, but how? */
+                if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
+                        continue;
+
+                ret = dwarf_lineaddr(line, &addr);
+                DIE_IF(ret != 0);
+                if (sp_die) {
+                        /* Address filtering 1: does sp_die include addr? */
+                        if (!dwarf_haspc(sp_die, addr))
+                                continue;
+                        /* Address filtering 2: No child include addr? */
+                        if (die_get_inlinefunc(sp_die, addr, &die_mem))
+                                continue;
+                }
+
+                pr_debug("Probe line found: line[%d]:%d addr:0x%llx\n",
+                         (int)i, lineno, (unsigned long long)addr);
+                pf->addr = addr;
+
+                show_probe_point(sp_die, pf);
+                /* Continuing, because target line might be inlined. */
+        }
+        /* TODO: deallocate lines, but how? */
+}
+
+static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
+{
+        struct probe_finder *pf = (struct probe_finder *)data;
+        struct probe_point *pp = pf->pp;
+
+        if (pp->lazy_line)
+                find_probe_point_lazy(in_die, pf);
+        else {
+                /* Get probe address */
+                pf->addr = die_get_entrypc(in_die);
+                pf->addr += pp->offset;
+                pr_debug("found inline addr: 0x%jx\n",
+                         (uintmax_t)pf->addr);
+
+                show_probe_point(in_die, pf);
+        }
+
+        return DWARF_CB_OK;
+}
+
+/* Search function from function name */
+static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
+{
+        struct probe_finder *pf = (struct probe_finder *)data;
+        struct probe_point *pp = pf->pp;
+
+        /* Check tag and diename */
+        if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
+            die_compare_name(sp_die, pp->function) != 0)
+                return 0;
+
+        pf->fname = dwarf_decl_file(sp_die);
+        if (pp->line) { /* Function relative line */
+                dwarf_decl_line(sp_die, &pf->lno);
+                pf->lno += pp->line;
+                find_probe_point_by_line(pf);
+        } else if (!dwarf_func_inline(sp_die)) {
+                /* Real function */
+                if (pp->lazy_line)
+                        find_probe_point_lazy(sp_die, pf);
+                else {
+                        pf->addr = die_get_entrypc(sp_die);
+                        pf->addr += pp->offset;
+                        /* TODO: Check the address in this function */
+                        show_probe_point(sp_die, pf);
+                }
+        } else
+                /* Inlined function: search instances */
+                dwarf_func_inline_instances(sp_die, probe_point_inline_cb, pf);
+
+        return 1; /* Exit; no same symbol in this CU. */
+}
+
+static void find_probe_point_by_func(struct probe_finder *pf)
+{
+        dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, pf, 0);
+}
+
+/* Find a probe point */
+int find_probe_point(int fd, struct probe_point *pp)
+{
+        struct probe_finder pf = {.pp = pp};
+        Dwarf_Off off, noff;
+        size_t cuhl;
+        Dwarf_Die *diep;
+        Dwarf *dbg;
+
+        dbg = dwarf_begin(fd, DWARF_C_READ);
+        if (!dbg)
+                return -ENOENT;
+
+        pp->found = 0;
+        off = 0;
+        line_list__init(&pf.lcache);
+        /* Loop on CUs (Compilation Unit) */
+        while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
+                /* Get the DIE(Debugging Information Entry) of this CU */
+                diep = dwarf_offdie(dbg, off + cuhl, &pf.cu_die);
+                if (!diep)
+                        continue;
+
+                /* Check if target file is included. */
+                if (pp->file)
+                        pf.fname = cu_find_realpath(&pf.cu_die, pp->file);
+                else
+                        pf.fname = NULL;
+
+                if (!pp->file || pf.fname) {
+                        if (pp->function)
+                                find_probe_point_by_func(&pf);
+                        else if (pp->lazy_line)
+                                find_probe_point_lazy(NULL, &pf);
+                        else {
+                                pf.lno = pp->line;
+                                find_probe_point_by_line(&pf);
+                        }
+                }
+                off = noff;
+        }
+        line_list__free(&pf.lcache);
+        dwarf_end(dbg);
+
+        return pp->found;
+}
+
+/* Find line range from its line number */
+static void find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
+{
+        Dwarf_Lines *lines;
+        Dwarf_Line *line;
+        size_t nlines, i;
+        Dwarf_Addr addr;
+        int lineno;
+        int ret;
+        const char *src;
+        Dwarf_Die die_mem;
+
+        line_list__init(&lf->lr->line_list);
+        ret = dwarf_getsrclines(&lf->cu_die, &lines, &nlines);
+        DIE_IF(ret != 0);
+
+        for (i = 0; i < nlines; i++) {
+                line = dwarf_onesrcline(lines, i);
+                ret = dwarf_lineno(line, &lineno);
+                DIE_IF(ret != 0);
+                if (lf->lno_s > lineno || lf->lno_e < lineno)
+                        continue;
+
+                if (sp_die) {
+                        /* Address filtering 1: does sp_die include addr? */
+                        ret = dwarf_lineaddr(line, &addr);
+                        DIE_IF(ret != 0);
+                        if (!dwarf_haspc(sp_die, addr))
+                                continue;
+
+                        /* Address filtering 2: No child include addr? */
+                        if (die_get_inlinefunc(sp_die, addr, &die_mem))
+                                continue;
+                }
+
+                /* TODO: Get fileno from line, but how? */
+                src = dwarf_linesrc(line, NULL, NULL);
+                if (strtailcmp(src, lf->fname) != 0)
+                        continue;
+
+                /* Copy real path */
+                if (!lf->lr->path)
+                        lf->lr->path = strdup(src);
+                line_list__add_line(&lf->lr->line_list, (unsigned int)lineno);
+        }
+        /* Update status */
+        if (!list_empty(&lf->lr->line_list))
+                lf->found = 1;
+        else {
+                free(lf->lr->path);
+                lf->lr->path = NULL;
+        }
+}
+
+static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
+{
+        find_line_range_by_line(in_die, (struct line_finder *)data);
+        return DWARF_CB_ABORT;  /* No need to find other instances */
+}
+
+/* Search function from function name */
+static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
+{
+        struct line_finder *lf = (struct line_finder *)data;
+        struct line_range *lr = lf->lr;
+
+        if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
+            die_compare_name(sp_die, lr->function) == 0) {
+                lf->fname = dwarf_decl_file(sp_die);
+                dwarf_decl_line(sp_die, &lr->offset);
+                pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
+                lf->lno_s = lr->offset + lr->start;
+                if (!lr->end)
+                        lf->lno_e = INT_MAX;
+                else
+                        lf->lno_e = lr->offset + lr->end;
+                lr->start = lf->lno_s;
+                lr->end = lf->lno_e;
+                if (dwarf_func_inline(sp_die))
+                        dwarf_func_inline_instances(sp_die,
+                                                    line_range_inline_cb, lf);
+                else
+                        find_line_range_by_line(sp_die, lf);
+                return 1;
+        }
+        return 0;
+}
+
+static void find_line_range_by_func(struct line_finder *lf)
+{
+        dwarf_getfuncs(&lf->cu_die, line_range_search_cb, lf, 0);
+}
+
+int find_line_range(int fd, struct line_range *lr)
+{
+        struct line_finder lf = {.lr = lr, .found = 0};
+        int ret;
+        Dwarf_Off off = 0, noff;
+        size_t cuhl;
+        Dwarf_Die *diep;
+        Dwarf *dbg;
+
+        dbg = dwarf_begin(fd, DWARF_C_READ);
+        if (!dbg)
+                return -ENOENT;
+
+        /* Loop on CUs (Compilation Unit) */
+        while (!lf.found) {
+                ret = dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL);
+                if (ret != 0)
+                        break;
+
+                /* Get the DIE(Debugging Information Entry) of this CU */
+                diep = dwarf_offdie(dbg, off + cuhl, &lf.cu_die);
+                if (!diep)
+                        continue;
+
+                /* Check if target file is included. */
+                if (lr->file)
+                        lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
+                else
+                        lf.fname = 0;
+
+                if (!lr->file || lf.fname) {
+                        if (lr->function)
+                                find_line_range_by_func(&lf);
+                        else {
+                                lf.lno_s = lr->start;
+                                if (!lr->end)
+                                        lf.lno_e = INT_MAX;
+                                else
+                                        lf.lno_e = lr->end;
+                                find_line_range_by_line(NULL, &lf);
+                        }
+                }
+                off = noff;
+        }
+        pr_debug("path: %lx\n", (unsigned long)lr->path);
+        dwarf_end(dbg);
+        return lf.found;
+}
+
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
new file mode 100644
index 000000000000..21f7354397b4
--- /dev/null
+++ b/tools/perf/util/probe-finder.h
@@ -0,0 +1,92 @@
+#ifndef _PROBE_FINDER_H
+#define _PROBE_FINDER_H
+
+#include <stdbool.h>
+#include "util.h"
+
+#define MAX_PATH_LEN             256
+#define MAX_PROBE_BUFFER        1024
+#define MAX_PROBES               128
+
+static inline int is_c_varname(const char *name)
+{
+        /* TODO */
+        return isalpha(name[0]) || name[0] == '_';
+}
+
+struct probe_point {
+        char                    *event;                 /* Event name */
+        char                    *group;                 /* Event group */
+
+        /* Inputs */
+        char                    *file;                  /* File name */
+        int                     line;                   /* Line number */
+        char                    *lazy_line;             /* Lazy line pattern */
+
+        char                    *function;              /* Function name */
+        int                     offset;                 /* Offset bytes */
+
+        int                     nr_args;                /* Number of arguments */
+        char                    **args;                 /* Arguments */
+
+        int                     retprobe;               /* Return probe */
+
+        /* Output */
+        int                     found;                  /* Number of found probe points */
+        char                    *probes[MAX_PROBES];    /* Output buffers (will be allocated)*/
+};
+
+/* Line number container */
+struct line_node {
+        struct list_head        list;
+        unsigned int            line;
+};
+
+/* Line range */
+struct line_range {
+        char                    *file;                  /* File name */
+        char                    *function;              /* Function name */
+        unsigned int            start;                  /* Start line number */
+        unsigned int            end;                    /* End line number */
+        int                     offset;                 /* Start line offset */
+        char                    *path;                  /* Real path name */
+        struct list_head        line_list;              /* Visible lines */
+};
+
+#ifndef NO_DWARF_SUPPORT
+extern int find_probe_point(int fd, struct probe_point *pp);
+extern int find_line_range(int fd, struct line_range *lr);
+
+#include <dwarf.h>
+#include <libdw.h>
+
+struct probe_finder {
+        struct probe_point      *pp;            /* Target probe point */
+
+        /* For function searching */
+        Dwarf_Addr              addr;           /* Address */
+        const char              *fname;         /* File name */
+        int                     lno;            /* Line number */
+        Dwarf_Die               cu_die;         /* Current CU */
+
+        /* For variable searching */
+        Dwarf_Op                *fb_ops;        /* Frame base attribute */
+        const char              *var;           /* Current variable name */
+        char                    *buf;           /* Current output buffer */
+        int                     len;            /* Length of output buffer */
+        struct list_head        lcache;         /* Line cache for lazy match */
+};
+
+struct line_finder {
+        struct line_range       *lr;            /* Target line range */
+
+        const char              *fname;         /* File name */
+        int                     lno_s;          /* Start line number */
+        int                     lno_e;          /* End line number */
+        Dwarf_Die               cu_die;         /* Current CU */
+        int                     found;
+};
+
+#endif /* NO_DWARF_SUPPORT */
+
+#endif /*_PROBE_FINDER_H */
diff --git a/tools/perf/util/quote.h b/tools/perf/util/quote.h
index a5454a1d1c13..b6a019733919 100644
--- a/tools/perf/util/quote.h
+++ b/tools/perf/util/quote.h
@@ -1,5 +1,5 @@
-#ifndef QUOTE_H
-#define QUOTE_H
+#ifndef __PERF_QUOTE_H
+#define __PERF_QUOTE_H
 
 #include <stddef.h>
 #include <stdio.h>
@@ -65,4 +65,4 @@ extern void perl_quote_print(FILE *stream, const char *src);
 extern void python_quote_print(FILE *stream, const char *src);
 extern void tcl_quote_print(FILE *stream, const char *src);
 
-#endif
+#endif /* __PERF_QUOTE_H */
diff --git a/tools/perf/util/run-command.h b/tools/perf/util/run-command.h
index cc1837deba88..d79028727ce2 100644
--- a/tools/perf/util/run-command.h
+++ b/tools/perf/util/run-command.h
@@ -1,5 +1,5 @@
-#ifndef RUN_COMMAND_H
-#define RUN_COMMAND_H
+#ifndef __PERF_RUN_COMMAND_H
+#define __PERF_RUN_COMMAND_H
 
 enum {
         ERR_RUN_COMMAND_FORK = 10000,
@@ -85,4 +85,4 @@ struct async {
 int start_async(struct async *async);
 int finish_async(struct async *async);
 
-#endif
+#endif /* __PERF_RUN_COMMAND_H */
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
new file mode 100644
index 000000000000..5376378e0cfc
--- /dev/null
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -0,0 +1,568 @@
+/*
+ * trace-event-perl.  Feed perf trace events to an embedded Perl interpreter.
+ *
+ * Copyright (C) 2009 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "../../perf.h"
+#include "../util.h"
+#include "../trace-event.h"
+
+#include <EXTERN.h>
+#include <perl.h>
+
+void boot_Perf__Trace__Context(pTHX_ CV *cv);
+void boot_DynaLoader(pTHX_ CV *cv);
+typedef PerlInterpreter * INTERP;
+
+void xs_init(pTHX);
+
+void xs_init(pTHX)
+{
+        const char *file = __FILE__;
+        dXSUB_SYS;
+
+        newXS("Perf::Trace::Context::bootstrap", boot_Perf__Trace__Context,
+              file);
+        newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
+}
+
+INTERP my_perl;
+
+#define FTRACE_MAX_EVENT                                \
+        ((1 << (sizeof(unsigned short) * 8)) - 1)
+
+struct event *events[FTRACE_MAX_EVENT];
+
+extern struct scripting_context *scripting_context;
+
+static char *cur_field_name;
+static int zero_flag_atom;
+
+static void define_symbolic_value(const char *ev_name,
+                                  const char *field_name,
+                                  const char *field_value,
+                                  const char *field_str)
+{
+        unsigned long long value;
+        dSP;
+
+        value = eval_flag(field_value);
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+        XPUSHs(sv_2mortal(newSVuv(value)));
+        XPUSHs(sv_2mortal(newSVpv(field_str, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_symbolic_value", 0))
+                call_pv("main::define_symbolic_value", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_symbolic_values(struct print_flag_sym *field,
+                                   const char *ev_name,
+                                   const char *field_name)
+{
+        define_symbolic_value(ev_name, field_name, field->value, field->str);
+        if (field->next)
+                define_symbolic_values(field->next, ev_name, field_name);
+}
+
+static void define_symbolic_field(const char *ev_name,
+                                  const char *field_name)
+{
+        dSP;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_symbolic_field", 0))
+                call_pv("main::define_symbolic_field", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_flag_value(const char *ev_name,
+                              const char *field_name,
+                              const char *field_value,
+                              const char *field_str)
+{
+        unsigned long long value;
+        dSP;
+
+        value = eval_flag(field_value);
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+        XPUSHs(sv_2mortal(newSVuv(value)));
+        XPUSHs(sv_2mortal(newSVpv(field_str, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_flag_value", 0))
+                call_pv("main::define_flag_value", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_flag_values(struct print_flag_sym *field,
+                               const char *ev_name,
+                               const char *field_name)
+{
+        define_flag_value(ev_name, field_name, field->value, field->str);
+        if (field->next)
+                define_flag_values(field->next, ev_name, field_name);
+}
+
+static void define_flag_field(const char *ev_name,
+                              const char *field_name,
+                              const char *delim)
+{
+        dSP;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(ev_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(field_name, 0)));
+        XPUSHs(sv_2mortal(newSVpv(delim, 0)));
+
+        PUTBACK;
+        if (get_cv("main::define_flag_field", 0))
+                call_pv("main::define_flag_field", G_SCALAR);
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void define_event_symbols(struct event *event,
+                                 const char *ev_name,
+                                 struct print_arg *args)
+{
+        switch (args->type) {
+        case PRINT_NULL:
+                break;
+        case PRINT_ATOM:
+                define_flag_value(ev_name, cur_field_name, "0",
+                                  args->atom.atom);
+                zero_flag_atom = 0;
+                break;
+        case PRINT_FIELD:
+                if (cur_field_name)
+                        free(cur_field_name);
+                cur_field_name = strdup(args->field.name);
+                break;
+        case PRINT_FLAGS:
+                define_event_symbols(event, ev_name, args->flags.field);
+                define_flag_field(ev_name, cur_field_name, args->flags.delim);
+                define_flag_values(args->flags.flags, ev_name, cur_field_name);
+                break;
+        case PRINT_SYMBOL:
+                define_event_symbols(event, ev_name, args->symbol.field);
+                define_symbolic_field(ev_name, cur_field_name);
+                define_symbolic_values(args->symbol.symbols, ev_name,
+                                       cur_field_name);
+                break;
+        case PRINT_STRING:
+                break;
+        case PRINT_TYPE:
+                define_event_symbols(event, ev_name, args->typecast.item);
+                break;
+        case PRINT_OP:
+                if (strcmp(args->op.op, ":") == 0)
+                        zero_flag_atom = 1;
+                define_event_symbols(event, ev_name, args->op.left);
+                define_event_symbols(event, ev_name, args->op.right);
+                break;
+        default:
+                /* we should warn... */
+                return;
+        }
+
+        if (args->next)
+                define_event_symbols(event, ev_name, args->next);
+}
+
+static inline struct event *find_cache_event(int type)
+{
+        static char ev_name[256];
+        struct event *event;
+
+        if (events[type])
+                return events[type];
+
+        events[type] = event = trace_find_event(type);
+        if (!event)
+                return NULL;
+
+        sprintf(ev_name, "%s::%s", event->system, event->name);
+
+        define_event_symbols(event, ev_name, event->print_fmt.args);
+
+        return event;
+}
+
+static void perl_process_event(int cpu, void *data,
+                               int size __unused,
+                               unsigned long long nsecs, char *comm)
+{
+        struct format_field *field;
+        static char handler[256];
+        unsigned long long val;
+        unsigned long s, ns;
+        struct event *event;
+        int type;
+        int pid;
+
+        dSP;
+
+        type = trace_parse_common_type(data);
+
+        event = find_cache_event(type);
+        if (!event)
+                die("ug! no event found for type %d", type);
+
+        pid = trace_parse_common_pid(data);
+
+        sprintf(handler, "%s::%s", event->system, event->name);
+
+        s = nsecs / NSECS_PER_SEC;
+        ns = nsecs - s * NSECS_PER_SEC;
+
+        scripting_context->event_data = data;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+
+        XPUSHs(sv_2mortal(newSVpv(handler, 0)));
+        XPUSHs(sv_2mortal(newSViv(PTR2IV(scripting_context))));
+        XPUSHs(sv_2mortal(newSVuv(cpu)));
+        XPUSHs(sv_2mortal(newSVuv(s)));
+        XPUSHs(sv_2mortal(newSVuv(ns)));
+        XPUSHs(sv_2mortal(newSViv(pid)));
+        XPUSHs(sv_2mortal(newSVpv(comm, 0)));
+
+        /* common fields other than pid can be accessed via xsub fns */
+
+        for (field = event->format.fields; field; field = field->next) {
+                if (field->flags & FIELD_IS_STRING) {
+                        int offset;
+                        if (field->flags & FIELD_IS_DYNAMIC) {
+                                offset = *(int *)(data + field->offset);
+                                offset &= 0xffff;
+                        } else
+                                offset = field->offset;
+                        XPUSHs(sv_2mortal(newSVpv((char *)data + offset, 0)));
+                } else { /* FIELD_IS_NUMERIC */
+                        val = read_size(data + field->offset, field->size);
+                        if (field->flags & FIELD_IS_SIGNED) {
+                                XPUSHs(sv_2mortal(newSViv(val)));
+                        } else {
+                                XPUSHs(sv_2mortal(newSVuv(val)));
+                        }
+                }
+        }
+
+        PUTBACK;
+
+        if (get_cv(handler, 0))
+                call_pv(handler, G_SCALAR);
+        else if (get_cv("main::trace_unhandled", 0)) {
+                XPUSHs(sv_2mortal(newSVpv(handler, 0)));
+                XPUSHs(sv_2mortal(newSViv(PTR2IV(scripting_context))));
+                XPUSHs(sv_2mortal(newSVuv(cpu)));
+                XPUSHs(sv_2mortal(newSVuv(nsecs)));
+                XPUSHs(sv_2mortal(newSViv(pid)));
+                XPUSHs(sv_2mortal(newSVpv(comm, 0)));
+                call_pv("main::trace_unhandled", G_SCALAR);
+        }
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void run_start_sub(void)
+{
+        dSP; /* access to Perl stack */
+        PUSHMARK(SP);
+
+        if (get_cv("main::trace_begin", 0))
+                call_pv("main::trace_begin", G_DISCARD | G_NOARGS);
+}
+
+/*
+ * Start trace script
+ */
+static int perl_start_script(const char *script, int argc, const char **argv)
+{
+        const char **command_line;
+        int i, err = 0;
+
+        command_line = malloc((argc + 2) * sizeof(const char *));
+        command_line[0] = "";
+        command_line[1] = script;
+        for (i = 2; i < argc + 2; i++)
+                command_line[i] = argv[i - 2];
+
+        my_perl = perl_alloc();
+        perl_construct(my_perl);
+
+        if (perl_parse(my_perl, xs_init, argc + 2, (char **)command_line,
+                       (char **)NULL)) {
+                err = -1;
+                goto error;
+        }
+
+        if (perl_run(my_perl)) {
+                err = -1;
+                goto error;
+        }
+
+        if (SvTRUE(ERRSV)) {
+                err = -1;
+                goto error;
+        }
+
+        run_start_sub();
+
+        free(command_line);
+        fprintf(stderr, "perf trace started with Perl script %s\n\n", script);
+        return 0;
+error:
+        perl_free(my_perl);
+        free(command_line);
+
+        return err;
+}
+
+/*
+ * Stop trace script
+ */
+static int perl_stop_script(void)
+{
+        dSP; /* access to Perl stack */
+        PUSHMARK(SP);
+
+        if (get_cv("main::trace_end", 0))
+                call_pv("main::trace_end", G_DISCARD | G_NOARGS);
+
+        perl_destruct(my_perl);
+        perl_free(my_perl);
+
+        fprintf(stderr, "\nperf trace Perl script stopped\n");
+
+        return 0;
+}
+
+static int perl_generate_script(const char *outfile)
+{
+        struct event *event = NULL;
+        struct format_field *f;
+        char fname[PATH_MAX];
+        int not_first, count;
+        FILE *ofp;
+
+        sprintf(fname, "%s.pl", outfile);
+        ofp = fopen(fname, "w");
+        if (ofp == NULL) {
+                fprintf(stderr, "couldn't open %s\n", fname);
+                return -1;
+        }
+
+        fprintf(ofp, "# perf trace event handlers, "
+                "generated by perf trace -g perl\n");
+
+        fprintf(ofp, "# Licensed under the terms of the GNU GPL"
+                " License version 2\n\n");
+
+        fprintf(ofp, "# The common_* event handler fields are the most useful "
+                "fields common to\n");
+
+        fprintf(ofp, "# all events.  They don't necessarily correspond to "
+                "the 'common_*' fields\n");
+
+        fprintf(ofp, "# in the format files.  Those fields not available as "
+                "handler params can\n");
+
+        fprintf(ofp, "# be retrieved using Perl functions of the form "
+                "common_*($context).\n");
+
+        fprintf(ofp, "# See Context.pm for the list of available "
+                "functions.\n\n");
+
+        fprintf(ofp, "use lib \"$ENV{'PERF_EXEC_PATH'}/scripts/perl/"
+                "Perf-Trace-Util/lib\";\n");
+
+        fprintf(ofp, "use lib \"./Perf-Trace-Util/lib\";\n");
+        fprintf(ofp, "use Perf::Trace::Core;\n");
+        fprintf(ofp, "use Perf::Trace::Context;\n");
+        fprintf(ofp, "use Perf::Trace::Util;\n\n");
+
+        fprintf(ofp, "sub trace_begin\n{\n\t# optional\n}\n\n");
+        fprintf(ofp, "sub trace_end\n{\n\t# optional\n}\n\n");
+
+        while ((event = trace_find_next_event(event))) {
+                fprintf(ofp, "sub %s::%s\n{\n", event->system, event->name);
+                fprintf(ofp, "\tmy (");
+
+                fprintf(ofp, "$event_name, ");
+                fprintf(ofp, "$context, ");
+                fprintf(ofp, "$common_cpu, ");
+                fprintf(ofp, "$common_secs, ");
+                fprintf(ofp, "$common_nsecs,\n");
+                fprintf(ofp, "\t    $common_pid, ");
+                fprintf(ofp, "$common_comm,\n\t    ");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t    ");
+
+                        fprintf(ofp, "$%s", f->name);
+                }
+                fprintf(ofp, ") = @_;\n\n");
+
+                fprintf(ofp, "\tprint_header($event_name, $common_cpu, "
+                        "$common_secs, $common_nsecs,\n\t             "
+                        "$common_pid, $common_comm);\n\n");
+
+                fprintf(ofp, "\tprintf(\"");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (count && count % 4 == 0) {
+                                fprintf(ofp, "\".\n\t       \"");
+                        }
+                        count++;
+
+                        fprintf(ofp, "%s=", f->name);
+                        if (f->flags & FIELD_IS_STRING ||
+                            f->flags & FIELD_IS_FLAG ||
+                            f->flags & FIELD_IS_SYMBOLIC)
+                                fprintf(ofp, "%%s");
+                        else if (f->flags & FIELD_IS_SIGNED)
+                                fprintf(ofp, "%%d");
+                        else
+                                fprintf(ofp, "%%u");
+                }
+
+                fprintf(ofp, "\\n\",\n\t       ");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t       ");
+
+                        if (f->flags & FIELD_IS_FLAG) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t       ");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "flag_str(\"");
+                                fprintf(ofp, "%s::%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", $%s)", f->name,
+                                        f->name);
+                        } else if (f->flags & FIELD_IS_SYMBOLIC) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t       ");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "symbol_str(\"");
+                                fprintf(ofp, "%s::%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", $%s)", f->name,
+                                        f->name);
+                        } else
+                                fprintf(ofp, "$%s", f->name);
+                }
+
+                fprintf(ofp, ");\n");
+                fprintf(ofp, "}\n\n");
+        }
+
+        fprintf(ofp, "sub trace_unhandled\n{\n\tmy ($event_name, $context, "
+                "$common_cpu, $common_secs, $common_nsecs,\n\t    "
+                "$common_pid, $common_comm) = @_;\n\n");
+
+        fprintf(ofp, "\tprint_header($event_name, $common_cpu, "
+                "$common_secs, $common_nsecs,\n\t             $common_pid, "
+                "$common_comm);\n}\n\n");
+
+        fprintf(ofp, "sub print_header\n{\n"
+                "\tmy ($event_name, $cpu, $secs, $nsecs, $pid, $comm) = @_;\n\n"
+                "\tprintf(\"%%-20s %%5u %%05u.%%09u %%8u %%-20s \",\n\t       "
+                "$event_name, $cpu, $secs, $nsecs, $pid, $comm);\n}");
+
+        fclose(ofp);
+
+        fprintf(stderr, "generated Perl script: %s\n", fname);
+
+        return 0;
+}
+
+struct scripting_ops perl_scripting_ops = {
+        .name = "Perl",
+        .start_script = perl_start_script,
+        .stop_script = perl_stop_script,
+        .process_event = perl_process_event,
+        .generate_script = perl_generate_script,
+};
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
new file mode 100644
index 000000000000..6a72f14c5986
--- /dev/null
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -0,0 +1,580 @@
+/*
+ * trace-event-python.  Feed trace events to an embedded Python interpreter.
+ *
+ * Copyright (C) 2010 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <Python.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "../../perf.h"
+#include "../util.h"
+#include "../trace-event.h"
+
+PyMODINIT_FUNC initperf_trace_context(void);
+
+#define FTRACE_MAX_EVENT                                \
+        ((1 << (sizeof(unsigned short) * 8)) - 1)
+
+struct event *events[FTRACE_MAX_EVENT];
+
+#define MAX_FIELDS      64
+#define N_COMMON_FIELDS 7
+
+extern struct scripting_context *scripting_context;
+
+static char *cur_field_name;
+static int zero_flag_atom;
+
+static PyObject *main_module, *main_dict;
+
+static void handler_call_die(const char *handler_name)
+{
+        PyErr_Print();
+        Py_FatalError("problem in Python trace event handler");
+}
+
+static void define_value(enum print_arg_type field_type,
+                         const char *ev_name,
+                         const char *field_name,
+                         const char *field_value,
+                         const char *field_str)
+{
+        const char *handler_name = "define_flag_value";
+        PyObject *handler, *t, *retval;
+        unsigned long long value;
+        unsigned n = 0;
+
+        if (field_type == PRINT_SYMBOL)
+                handler_name = "define_symbolic_value";
+
+        t = PyTuple_New(4);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+
+        value = eval_flag(field_value);
+
+        PyTuple_SetItem(t, n++, PyString_FromString(ev_name));
+        PyTuple_SetItem(t, n++, PyString_FromString(field_name));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(value));
+        PyTuple_SetItem(t, n++, PyString_FromString(field_str));
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && PyCallable_Check(handler)) {
+                retval = PyObject_CallObject(handler, t);
+                if (retval == NULL)
+                        handler_call_die(handler_name);
+        }
+
+        Py_DECREF(t);
+}
+
+static void define_values(enum print_arg_type field_type,
+                          struct print_flag_sym *field,
+                          const char *ev_name,
+                          const char *field_name)
+{
+        define_value(field_type, ev_name, field_name, field->value,
+                     field->str);
+
+        if (field->next)
+                define_values(field_type, field->next, ev_name, field_name);
+}
+
+static void define_field(enum print_arg_type field_type,
+                         const char *ev_name,
+                         const char *field_name,
+                         const char *delim)
+{
+        const char *handler_name = "define_flag_field";
+        PyObject *handler, *t, *retval;
+        unsigned n = 0;
+
+        if (field_type == PRINT_SYMBOL)
+                handler_name = "define_symbolic_field";
+
+        if (field_type == PRINT_FLAGS)
+                t = PyTuple_New(3);
+        else
+                t = PyTuple_New(2);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+
+        PyTuple_SetItem(t, n++, PyString_FromString(ev_name));
+        PyTuple_SetItem(t, n++, PyString_FromString(field_name));
+        if (field_type == PRINT_FLAGS)
+                PyTuple_SetItem(t, n++, PyString_FromString(delim));
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && PyCallable_Check(handler)) {
+                retval = PyObject_CallObject(handler, t);
+                if (retval == NULL)
+                        handler_call_die(handler_name);
+        }
+
+        Py_DECREF(t);
+}
+
+static void define_event_symbols(struct event *event,
+                                 const char *ev_name,
+                                 struct print_arg *args)
+{
+        switch (args->type) {
+        case PRINT_NULL:
+                break;
+        case PRINT_ATOM:
+                define_value(PRINT_FLAGS, ev_name, cur_field_name, "0",
+                             args->atom.atom);
+                zero_flag_atom = 0;
+                break;
+        case PRINT_FIELD:
+                if (cur_field_name)
+                        free(cur_field_name);
+                cur_field_name = strdup(args->field.name);
+                break;
+        case PRINT_FLAGS:
+                define_event_symbols(event, ev_name, args->flags.field);
+                define_field(PRINT_FLAGS, ev_name, cur_field_name,
+                             args->flags.delim);
+                define_values(PRINT_FLAGS, args->flags.flags, ev_name,
+                              cur_field_name);
+                break;
+        case PRINT_SYMBOL:
+                define_event_symbols(event, ev_name, args->symbol.field);
+                define_field(PRINT_SYMBOL, ev_name, cur_field_name, NULL);
+                define_values(PRINT_SYMBOL, args->symbol.symbols, ev_name,
+                              cur_field_name);
+                break;
+        case PRINT_STRING:
+                break;
+        case PRINT_TYPE:
+                define_event_symbols(event, ev_name, args->typecast.item);
+                break;
+        case PRINT_OP:
+                if (strcmp(args->op.op, ":") == 0)
+                        zero_flag_atom = 1;
+                define_event_symbols(event, ev_name, args->op.left);
+                define_event_symbols(event, ev_name, args->op.right);
+                break;
+        default:
+                /* we should warn... */
+                return;
+        }
+
+        if (args->next)
+                define_event_symbols(event, ev_name, args->next);
+}
+
+static inline struct event *find_cache_event(int type)
+{
+        static char ev_name[256];
+        struct event *event;
+
+        if (events[type])
+                return events[type];
+
+        events[type] = event = trace_find_event(type);
+        if (!event)
+                return NULL;
+
+        sprintf(ev_name, "%s__%s", event->system, event->name);
+
+        define_event_symbols(event, ev_name, event->print_fmt.args);
+
+        return event;
+}
+
+static void python_process_event(int cpu, void *data,
+                                 int size __unused,
+                                 unsigned long long nsecs, char *comm)
+{
+        PyObject *handler, *retval, *context, *t, *obj;
+        static char handler_name[256];
+        struct format_field *field;
+        unsigned long long val;
+        unsigned long s, ns;
+        struct event *event;
+        unsigned n = 0;
+        int type;
+        int pid;
+
+        t = PyTuple_New(MAX_FIELDS);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+
+        type = trace_parse_common_type(data);
+
+        event = find_cache_event(type);
+        if (!event)
+                die("ug! no event found for type %d", type);
+
+        pid = trace_parse_common_pid(data);
+
+        sprintf(handler_name, "%s__%s", event->system, event->name);
+
+        s = nsecs / NSECS_PER_SEC;
+        ns = nsecs - s * NSECS_PER_SEC;
+
+        scripting_context->event_data = data;
+
+        context = PyCObject_FromVoidPtr(scripting_context, NULL);
+
+        PyTuple_SetItem(t, n++, PyString_FromString(handler_name));
+        PyTuple_SetItem(t, n++,
+                        PyCObject_FromVoidPtr(scripting_context, NULL));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(s));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(ns));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(pid));
+        PyTuple_SetItem(t, n++, PyString_FromString(comm));
+
+        for (field = event->format.fields; field; field = field->next) {
+                if (field->flags & FIELD_IS_STRING) {
+                        int offset;
+                        if (field->flags & FIELD_IS_DYNAMIC) {
+                                offset = *(int *)(data + field->offset);
+                                offset &= 0xffff;
+                        } else
+                                offset = field->offset;
+                        obj = PyString_FromString((char *)data + offset);
+                } else { /* FIELD_IS_NUMERIC */
+                        val = read_size(data + field->offset, field->size);
+                        if (field->flags & FIELD_IS_SIGNED) {
+                                if ((long long)val >= LONG_MIN &&
+                                    (long long)val <= LONG_MAX)
+                                        obj = PyInt_FromLong(val);
+                                else
+                                        obj = PyLong_FromLongLong(val);
+                        } else {
+                                if (val <= LONG_MAX)
+                                        obj = PyInt_FromLong(val);
+                                else
+                                        obj = PyLong_FromUnsignedLongLong(val);
+                        }
+                }
+                PyTuple_SetItem(t, n++, obj);
+        }
+
+        if (_PyTuple_Resize(&t, n) == -1)
+                Py_FatalError("error resizing Python tuple");
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && PyCallable_Check(handler)) {
+                retval = PyObject_CallObject(handler, t);
+                if (retval == NULL)
+                        handler_call_die(handler_name);
+        } else {
+                handler = PyDict_GetItemString(main_dict, "trace_unhandled");
+                if (handler && PyCallable_Check(handler)) {
+                        if (_PyTuple_Resize(&t, N_COMMON_FIELDS) == -1)
+                                Py_FatalError("error resizing Python tuple");
+
+                        retval = PyObject_CallObject(handler, t);
+                        if (retval == NULL)
+                                handler_call_die("trace_unhandled");
+                }
+        }
+
+        Py_DECREF(t);
+}
+
+static int run_start_sub(void)
+{
+        PyObject *handler, *retval;
+        int err = 0;
+
+        main_module = PyImport_AddModule("__main__");
+        if (main_module == NULL)
+                return -1;
+        Py_INCREF(main_module);
+
+        main_dict = PyModule_GetDict(main_module);
+        if (main_dict == NULL) {
+                err = -1;
+                goto error;
+        }
+        Py_INCREF(main_dict);
+
+        handler = PyDict_GetItemString(main_dict, "trace_begin");
+        if (handler == NULL || !PyCallable_Check(handler))
+                goto out;
+
+        retval = PyObject_CallObject(handler, NULL);
+        if (retval == NULL)
+                handler_call_die("trace_begin");
+
+        Py_DECREF(retval);
+        return err;
+error:
+        Py_XDECREF(main_dict);
+        Py_XDECREF(main_module);
+out:
+        return err;
+}
+
+/*
+ * Start trace script
+ */
+static int python_start_script(const char *script, int argc, const char **argv)
+{
+        const char **command_line;
+        char buf[PATH_MAX];
+        int i, err = 0;
+        FILE *fp;
+
+        command_line = malloc((argc + 1) * sizeof(const char *));
+        command_line[0] = script;
+        for (i = 1; i < argc + 1; i++)
+                command_line[i] = argv[i - 1];
+
+        Py_Initialize();
+
+        initperf_trace_context();
+
+        PySys_SetArgv(argc + 1, (char **)command_line);
+
+        fp = fopen(script, "r");
+        if (!fp) {
+                sprintf(buf, "Can't open python script \"%s\"", script);
+                perror(buf);
+                err = -1;
+                goto error;
+        }
+
+        err = PyRun_SimpleFile(fp, script);
+        if (err) {
+                fprintf(stderr, "Error running python script %s\n", script);
+                goto error;
+        }
+
+        err = run_start_sub();
+        if (err) {
+                fprintf(stderr, "Error starting python script %s\n", script);
+                goto error;
+        }
+
+        free(command_line);
+        fprintf(stderr, "perf trace started with Python script %s\n\n",
+                script);
+
+        return err;
+error:
+        Py_Finalize();
+        free(command_line);
+
+        return err;
+}
+
+/*
+ * Stop trace script
+ */
+static int python_stop_script(void)
+{
+        PyObject *handler, *retval;
+        int err = 0;
+
+        handler = PyDict_GetItemString(main_dict, "trace_end");
+        if (handler == NULL || !PyCallable_Check(handler))
+                goto out;
+
+        retval = PyObject_CallObject(handler, NULL);
+        if (retval == NULL)
+                handler_call_die("trace_end");
+        else
+                Py_DECREF(retval);
+out:
+        Py_XDECREF(main_dict);
+        Py_XDECREF(main_module);
+        Py_Finalize();
+
+        fprintf(stderr, "\nperf trace Python script stopped\n");
+
+        return err;
+}
+
+static int python_generate_script(const char *outfile)
+{
+        struct event *event = NULL;
+        struct format_field *f;
+        char fname[PATH_MAX];
+        int not_first, count;
+        FILE *ofp;
+
+        sprintf(fname, "%s.py", outfile);
+        ofp = fopen(fname, "w");
+        if (ofp == NULL) {
+                fprintf(stderr, "couldn't open %s\n", fname);
+                return -1;
+        }
+        fprintf(ofp, "# perf trace event handlers, "
+                "generated by perf trace -g python\n");
+
+        fprintf(ofp, "# Licensed under the terms of the GNU GPL"
+                " License version 2\n\n");
+
+        fprintf(ofp, "# The common_* event handler fields are the most useful "
+                "fields common to\n");
+
+        fprintf(ofp, "# all events.  They don't necessarily correspond to "
+                "the 'common_*' fields\n");
+
+        fprintf(ofp, "# in the format files.  Those fields not available as "
+                "handler params can\n");
+
+        fprintf(ofp, "# be retrieved using Python functions of the form "
+                "common_*(context).\n");
+
+        fprintf(ofp, "# See the perf-trace-python Documentation for the list "
+                "of available functions.\n\n");
+
+        fprintf(ofp, "import os\n");
+        fprintf(ofp, "import sys\n\n");
+
+        fprintf(ofp, "sys.path.append(os.environ['PERF_EXEC_PATH'] + \\\n");
+        fprintf(ofp, "\t'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')\n");
+        fprintf(ofp, "\nfrom perf_trace_context import *\n");
+        fprintf(ofp, "from Core import *\n\n\n");
+
+        fprintf(ofp, "def trace_begin():\n");
+        fprintf(ofp, "\tprint \"in trace_begin\"\n\n");
+
+        fprintf(ofp, "def trace_end():\n");
+        fprintf(ofp, "\tprint \"in trace_end\"\n\n");
+
+        while ((event = trace_find_next_event(event))) {
+                fprintf(ofp, "def %s__%s(", event->system, event->name);
+                fprintf(ofp, "event_name, ");
+                fprintf(ofp, "context, ");
+                fprintf(ofp, "common_cpu,\n");
+                fprintf(ofp, "\tcommon_secs, ");
+                fprintf(ofp, "common_nsecs, ");
+                fprintf(ofp, "common_pid, ");
+                fprintf(ofp, "common_comm,\n\t");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t");
+
+                        fprintf(ofp, "%s", f->name);
+                }
+                fprintf(ofp, "):\n");
+
+                fprintf(ofp, "\t\tprint_header(event_name, common_cpu, "
+                        "common_secs, common_nsecs,\n\t\t\t"
+                        "common_pid, common_comm)\n\n");
+
+                fprintf(ofp, "\t\tprint \"");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (count && count % 3 == 0) {
+                                fprintf(ofp, "\" \\\n\t\t\"");
+                        }
+                        count++;
+
+                        fprintf(ofp, "%s=", f->name);
+                        if (f->flags & FIELD_IS_STRING ||
+                            f->flags & FIELD_IS_FLAG ||
+                            f->flags & FIELD_IS_SYMBOLIC)
+                                fprintf(ofp, "%%s");
+                        else if (f->flags & FIELD_IS_SIGNED)
+                                fprintf(ofp, "%%d");
+                        else
+                                fprintf(ofp, "%%u");
+                }
+
+                fprintf(ofp, "\\n\" %% \\\n\t\t(");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t\t");
+
+                        if (f->flags & FIELD_IS_FLAG) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t\t");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "flag_str(\"");
+                                fprintf(ofp, "%s__%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", %s)", f->name,
+                                        f->name);
+                        } else if (f->flags & FIELD_IS_SYMBOLIC) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t\t");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "symbol_str(\"");
+                                fprintf(ofp, "%s__%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", %s)", f->name,
+                                        f->name);
+                        } else
+                                fprintf(ofp, "%s", f->name);
+                }
+
+                fprintf(ofp, "),\n\n");
+        }
+
+        fprintf(ofp, "def trace_unhandled(event_name, context, "
+                "common_cpu, common_secs, common_nsecs,\n\t\t"
+                "common_pid, common_comm):\n");
+
+        fprintf(ofp, "\t\tprint_header(event_name, common_cpu, "
+                "common_secs, common_nsecs,\n\t\tcommon_pid, "
+                "common_comm)\n\n");
+
+        fprintf(ofp, "def print_header("
+                "event_name, cpu, secs, nsecs, pid, comm):\n"
+                "\tprint \"%%-20s %%5u %%05u.%%09u %%8u %%-20s \" %% \\\n\t"
+                "(event_name, cpu, secs, nsecs, pid, comm),\n");
+
+        fclose(ofp);
+
+        fprintf(stderr, "generated Python script: %s\n", fname);
+
+        return 0;
+}
+
+struct scripting_ops python_scripting_ops = {
+        .name = "Python",
+        .start_script = python_start_script,
+        .stop_script = python_stop_script,
+        .process_event = python_process_event,
+        .generate_script = python_generate_script,
+};
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
new file mode 100644
index 000000000000..eed1cb889008
--- /dev/null
+++ b/tools/perf/util/session.c
@@ -0,0 +1,574 @@
+#define _FILE_OFFSET_BITS 64
+
+#include <linux/kernel.h>
+
+#include <byteswap.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "session.h"
+#include "sort.h"
+#include "util.h"
+
+static int perf_session__open(struct perf_session *self, bool force)
+{
+        struct stat input_stat;
+
+        self->fd = open(self->filename, O_RDONLY);
+        if (self->fd < 0) {
+                pr_err("failed to open file: %s", self->filename);
+                if (!strcmp(self->filename, "perf.data"))
+                        pr_err("  (try 'perf record' first)");
+                pr_err("\n");
+                return -errno;
+        }
+
+        if (fstat(self->fd, &input_stat) < 0)
+                goto out_close;
+
+        if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
+                pr_err("file %s not owned by current user or root\n",
+                       self->filename);
+                goto out_close;
+        }
+
+        if (!input_stat.st_size) {
+                pr_info("zero-sized file (%s), nothing to do!\n",
+                        self->filename);
+                goto out_close;
+        }
+
+        if (perf_header__read(&self->header, self->fd) < 0) {
+                pr_err("incompatible file format");
+                goto out_close;
+        }
+
+        self->size = input_stat.st_size;
+        return 0;
+
+out_close:
+        close(self->fd);
+        self->fd = -1;
+        return -1;
+}
+
+static inline int perf_session__create_kernel_maps(struct perf_session *self)
+{
+        return map_groups__create_kernel_maps(&self->kmaps, self->vmlinux_maps);
+}
+
+struct perf_session *perf_session__new(const char *filename, int mode, bool force)
+{
+        size_t len = filename ? strlen(filename) + 1 : 0;
+        struct perf_session *self = zalloc(sizeof(*self) + len);
+
+        if (self == NULL)
+                goto out;
+
+        if (perf_header__init(&self->header) < 0)
+                goto out_free;
+
+        memcpy(self->filename, filename, len);
+        self->threads = RB_ROOT;
+        self->stats_by_id = RB_ROOT;
+        self->last_match = NULL;
+        self->mmap_window = 32;
+        self->cwd = NULL;
+        self->cwdlen = 0;
+        self->unknown_events = 0;
+        map_groups__init(&self->kmaps);
+
+        if (mode == O_RDONLY) {
+                if (perf_session__open(self, force) < 0)
+                        goto out_delete;
+        } else if (mode == O_WRONLY) {
+                /*
+                 * In O_RDONLY mode this will be performed when reading the
+                 * kernel MMAP event, in event__process_mmap().
+                 */
+                if (perf_session__create_kernel_maps(self) < 0)
+                        goto out_delete;
+        }
+
+        self->sample_type = perf_header__sample_type(&self->header);
+out:
+        return self;
+out_free:
+        free(self);
+        return NULL;
+out_delete:
+        perf_session__delete(self);
+        return NULL;
+}
+
+void perf_session__delete(struct perf_session *self)
+{
+        perf_header__exit(&self->header);
+        close(self->fd);
+        free(self->cwd);
+        free(self);
+}
+
+static bool symbol__match_parent_regex(struct symbol *sym)
+{
+        if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
+                return 1;
+
+        return 0;
+}
+
+struct symbol **perf_session__resolve_callchain(struct perf_session *self,
+                                                struct thread *thread,
+                                                struct ip_callchain *chain,
+                                                struct symbol **parent)
+{
+        u8 cpumode = PERF_RECORD_MISC_USER;
+        struct symbol **syms = NULL;
+        unsigned int i;
+
+        if (symbol_conf.use_callchain) {
+                syms = calloc(chain->nr, sizeof(*syms));
+                if (!syms) {
+                        fprintf(stderr, "Can't allocate memory for symbols\n");
+                        exit(-1);
+                }
+        }
+
+        for (i = 0; i < chain->nr; i++) {
+                u64 ip = chain->ips[i];
+                struct addr_location al;
+
+                if (ip >= PERF_CONTEXT_MAX) {
+                        switch (ip) {
+                        case PERF_CONTEXT_HV:
+                                cpumode = PERF_RECORD_MISC_HYPERVISOR;  break;
+                        case PERF_CONTEXT_KERNEL:
+                                cpumode = PERF_RECORD_MISC_KERNEL;      break;
+                        case PERF_CONTEXT_USER:
+                                cpumode = PERF_RECORD_MISC_USER;        break;
+                        default:
+                                break;
+                        }
+                        continue;
+                }
+
+                thread__find_addr_location(thread, self, cpumode,
+                                           MAP__FUNCTION, ip, &al, NULL);
+                if (al.sym != NULL) {
+                        if (sort__has_parent && !*parent &&
+                            symbol__match_parent_regex(al.sym))
+                                *parent = al.sym;
+                        if (!symbol_conf.use_callchain)
+                                break;
+                        syms[i] = al.sym;
+                }
+        }
+
+        return syms;
+}
+
+static int process_event_stub(event_t *event __used,
+                              struct perf_session *session __used)
+{
+        dump_printf(": unhandled!\n");
+        return 0;
+}
+
+static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
+{
+        if (handler->sample == NULL)
+                handler->sample = process_event_stub;
+        if (handler->mmap == NULL)
+                handler->mmap = process_event_stub;
+        if (handler->comm == NULL)
+                handler->comm = process_event_stub;
+        if (handler->fork == NULL)
+                handler->fork = process_event_stub;
+        if (handler->exit == NULL)
+                handler->exit = process_event_stub;
+        if (handler->lost == NULL)
+                handler->lost = process_event_stub;
+        if (handler->read == NULL)
+                handler->read = process_event_stub;
+        if (handler->throttle == NULL)
+                handler->throttle = process_event_stub;
+        if (handler->unthrottle == NULL)
+                handler->unthrottle = process_event_stub;
+}
+
+static const char *event__name[] = {
+        [0]                      = "TOTAL",
+        [PERF_RECORD_MMAP]       = "MMAP",
+        [PERF_RECORD_LOST]       = "LOST",
+        [PERF_RECORD_COMM]       = "COMM",
+        [PERF_RECORD_EXIT]       = "EXIT",
+        [PERF_RECORD_THROTTLE]   = "THROTTLE",
+        [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE",
+        [PERF_RECORD_FORK]       = "FORK",
+        [PERF_RECORD_READ]       = "READ",
+        [PERF_RECORD_SAMPLE]     = "SAMPLE",
+};
+
+unsigned long event__total[PERF_RECORD_MAX];
+
+void event__print_totals(void)
+{
+        int i;
+        for (i = 0; i < PERF_RECORD_MAX; ++i)
+                pr_info("%10s events: %10ld\n",
+                        event__name[i], event__total[i]);
+}
+
+void mem_bswap_64(void *src, int byte_size)
+{
+        u64 *m = src;
+
+        while (byte_size > 0) {
+                *m = bswap_64(*m);
+                byte_size -= sizeof(u64);
+                ++m;
+        }
+}
+
+static void event__all64_swap(event_t *self)
+{
+        struct perf_event_header *hdr = &self->header;
+        mem_bswap_64(hdr + 1, self->header.size - sizeof(*hdr));
+}
+
+static void event__comm_swap(event_t *self)
+{
+        self->comm.pid = bswap_32(self->comm.pid);
+        self->comm.tid = bswap_32(self->comm.tid);
+}
+
+static void event__mmap_swap(event_t *self)
+{
+        self->mmap.pid   = bswap_32(self->mmap.pid);
+        self->mmap.tid   = bswap_32(self->mmap.tid);
+        self->mmap.start = bswap_64(self->mmap.start);
+        self->mmap.len   = bswap_64(self->mmap.len);
+        self->mmap.pgoff = bswap_64(self->mmap.pgoff);
+}
+
+static void event__task_swap(event_t *self)
+{
+        self->fork.pid  = bswap_32(self->fork.pid);
+        self->fork.tid  = bswap_32(self->fork.tid);
+        self->fork.ppid = bswap_32(self->fork.ppid);
+        self->fork.ptid = bswap_32(self->fork.ptid);
+        self->fork.time = bswap_64(self->fork.time);
+}
+
+static void event__read_swap(event_t *self)
+{
+        self->read.pid          = bswap_32(self->read.pid);
+        self->read.tid          = bswap_32(self->read.tid);
+        self->read.value        = bswap_64(self->read.value);
+        self->read.time_enabled = bswap_64(self->read.time_enabled);
+        self->read.time_running = bswap_64(self->read.time_running);
+        self->read.id           = bswap_64(self->read.id);
+}
+
+typedef void (*event__swap_op)(event_t *self);
+
+static event__swap_op event__swap_ops[] = {
+        [PERF_RECORD_MMAP]   = event__mmap_swap,
+        [PERF_RECORD_COMM]   = event__comm_swap,
+        [PERF_RECORD_FORK]   = event__task_swap,
+        [PERF_RECORD_EXIT]   = event__task_swap,
+        [PERF_RECORD_LOST]   = event__all64_swap,
+        [PERF_RECORD_READ]   = event__read_swap,
+        [PERF_RECORD_SAMPLE] = event__all64_swap,
+        [PERF_RECORD_MAX]    = NULL,
+};
+
+static int perf_session__process_event(struct perf_session *self,
+                                       event_t *event,
+                                       struct perf_event_ops *ops,
+                                       u64 offset, u64 head)
+{
+        trace_event(event);
+
+        if (event->header.type < PERF_RECORD_MAX) {
+                dump_printf("%#Lx [%#x]: PERF_RECORD_%s",
+                            offset + head, event->header.size,
+                            event__name[event->header.type]);
+                ++event__total[0];
+                ++event__total[event->header.type];
+        }
+
+        if (self->header.needs_swap && event__swap_ops[event->header.type])
+                event__swap_ops[event->header.type](event);
+
+        switch (event->header.type) {
+        case PERF_RECORD_SAMPLE:
+                return ops->sample(event, self);
+        case PERF_RECORD_MMAP:
+                return ops->mmap(event, self);
+        case PERF_RECORD_COMM:
+                return ops->comm(event, self);
+        case PERF_RECORD_FORK:
+                return ops->fork(event, self);
+        case PERF_RECORD_EXIT:
+                return ops->exit(event, self);
+        case PERF_RECORD_LOST:
+                return ops->lost(event, self);
+        case PERF_RECORD_READ:
+                return ops->read(event, self);
+        case PERF_RECORD_THROTTLE:
+                return ops->throttle(event, self);
+        case PERF_RECORD_UNTHROTTLE:
+                return ops->unthrottle(event, self);
+        default:
+                self->unknown_events++;
+                return -1;
+        }
+}
+
+void perf_event_header__bswap(struct perf_event_header *self)
+{
+        self->type = bswap_32(self->type);
+        self->misc = bswap_16(self->misc);
+        self->size = bswap_16(self->size);
+}
+
+int perf_header__read_build_ids(struct perf_header *self,
+                                int input, u64 offset, u64 size)
+{
+        struct build_id_event bev;
+        char filename[PATH_MAX];
+        u64 limit = offset + size;
+        int err = -1;
+
+        while (offset < limit) {
+                struct dso *dso;
+                ssize_t len;
+                struct list_head *head = &dsos__user;
+
+                if (read(input, &bev, sizeof(bev)) != sizeof(bev))
+                        goto out;
+
+                if (self->needs_swap)
+                        perf_event_header__bswap(&bev.header);
+
+                len = bev.header.size - sizeof(bev);
+                if (read(input, filename, len) != len)
+                        goto out;
+
+                if (bev.header.misc & PERF_RECORD_MISC_KERNEL)
+                        head = &dsos__kernel;
+
+                dso = __dsos__findnew(head, filename);
+                if (dso != NULL) {
+                        dso__set_build_id(dso, &bev.build_id);
+                        if (head == &dsos__kernel && filename[0] == '[')
+                                dso->kernel = 1;
+                }
+
+                offset += bev.header.size;
+        }
+        err = 0;
+out:
+        return err;
+}
+
+static struct thread *perf_session__register_idle_thread(struct perf_session *self)
+{
+        struct thread *thread = perf_session__findnew(self, 0);
+
+        if (thread == NULL || thread__set_comm(thread, "swapper")) {
+                pr_err("problem inserting idle task.\n");
+                thread = NULL;
+        }
+
+        return thread;
+}
+
+int __perf_session__process_events(struct perf_session *self,
+                                   u64 data_offset, u64 data_size,
+                                   u64 file_size, struct perf_event_ops *ops)
+{
+        int err, mmap_prot, mmap_flags;
+        u64 head, shift;
+        u64 offset = 0;
+        size_t  page_size;
+        event_t *event;
+        uint32_t size;
+        char *buf;
+
+        perf_event_ops__fill_defaults(ops);
+
+        page_size = sysconf(_SC_PAGESIZE);
+
+        head = data_offset;
+        shift = page_size * (head / page_size);
+        offset += shift;
+        head -= shift;
+
+        mmap_prot  = PROT_READ;
+        mmap_flags = MAP_SHARED;
+
+        if (self->header.needs_swap) {
+                mmap_prot  |= PROT_WRITE;
+                mmap_flags = MAP_PRIVATE;
+        }
+remap:
+        buf = mmap(NULL, page_size * self->mmap_window, mmap_prot,
+                   mmap_flags, self->fd, offset);
+        if (buf == MAP_FAILED) {
+                pr_err("failed to mmap file\n");
+                err = -errno;
+                goto out_err;
+        }
+
+more:
+        event = (event_t *)(buf + head);
+
+        if (self->header.needs_swap)
+                perf_event_header__bswap(&event->header);
+        size = event->header.size;
+        if (size == 0)
+                size = 8;
+
+        if (head + event->header.size >= page_size * self->mmap_window) {
+                int munmap_ret;
+
+                shift = page_size * (head / page_size);
+
+                munmap_ret = munmap(buf, page_size * self->mmap_window);
+                assert(munmap_ret == 0);
+
+                offset += shift;
+                head -= shift;
+                goto remap;
+        }
+
+        size = event->header.size;
+
+        dump_printf("\n%#Lx [%#x]: event: %d\n",
+                    offset + head, event->header.size, event->header.type);
+
+        if (size == 0 ||
+            perf_session__process_event(self, event, ops, offset, head) < 0) {
+                dump_printf("%#Lx [%#x]: skipping unknown header type: %d\n",
+                            offset + head, event->header.size,
+                            event->header.type);
+                /*
+                 * assume we lost track of the stream, check alignment, and
+                 * increment a single u64 in the hope to catch on again 'soon'.
+                 */
+                if (unlikely(head & 7))
+                        head &= ~7ULL;
+
+                size = 8;
+        }
+
+        head += size;
+
+        if (offset + head >= data_offset + data_size)
+                goto done;
+
+        if (offset + head < file_size)
+                goto more;
+done:
+        err = 0;
+out_err:
+        return err;
+}
+
+int perf_session__process_events(struct perf_session *self,
+                                 struct perf_event_ops *ops)
+{
+        int err;
+
+        if (perf_session__register_idle_thread(self) == NULL)
+                return -ENOMEM;
+
+        if (!symbol_conf.full_paths) {
+                char bf[PATH_MAX];
+
+                if (getcwd(bf, sizeof(bf)) == NULL) {
+                        err = -errno;
+out_getcwd_err:
+                        pr_err("failed to get the current directory\n");
+                        goto out_err;
+                }
+                self->cwd = strdup(bf);
+                if (self->cwd == NULL) {
+                        err = -ENOMEM;
+                        goto out_getcwd_err;
+                }
+                self->cwdlen = strlen(self->cwd);
+        }
+
+        err = __perf_session__process_events(self, self->header.data_offset,
+                                             self->header.data_size,
+                                             self->size, ops);
+out_err:
+        return err;
+}
+
+bool perf_session__has_traces(struct perf_session *self, const char *msg)
+{
+        if (!(self->sample_type & PERF_SAMPLE_RAW)) {
+                pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
+                return false;
+        }
+
+        return true;
+}
+
+int perf_session__set_kallsyms_ref_reloc_sym(struct perf_session *self,
+                                             const char *symbol_name,
+                                             u64 addr)
+{
+        char *bracket;
+        enum map_type i;
+
+        self->ref_reloc_sym.name = strdup(symbol_name);
+        if (self->ref_reloc_sym.name == NULL)
+                return -ENOMEM;
+
+        bracket = strchr(self->ref_reloc_sym.name, ']');
+        if (bracket)
+                *bracket = '\0';
+
+        self->ref_reloc_sym.addr = addr;
+
+        for (i = 0; i < MAP__NR_TYPES; ++i) {
+                struct kmap *kmap = map__kmap(self->vmlinux_maps[i]);
+                kmap->ref_reloc_sym = &self->ref_reloc_sym;
+        }
+
+        return 0;
+}
+
+static u64 map__reloc_map_ip(struct map *map, u64 ip)
+{
+        return ip + (s64)map->pgoff;
+}
+
+static u64 map__reloc_unmap_ip(struct map *map, u64 ip)
+{
+        return ip - (s64)map->pgoff;
+}
+
+void map__reloc_vmlinux(struct map *self)
+{
+        struct kmap *kmap = map__kmap(self);
+        s64 reloc;
+
+        if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->unrelocated_addr)
+                return;
+
+        reloc = (kmap->ref_reloc_sym->unrelocated_addr -
+                 kmap->ref_reloc_sym->addr);
+
+        if (!reloc)
+                return;
+
+        self->map_ip   = map__reloc_map_ip;
+        self->unmap_ip = map__reloc_unmap_ip;
+        self->pgoff    = reloc;
+}
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
new file mode 100644
index 000000000000..5c33417eebb3
--- /dev/null
+++ b/tools/perf/util/session.h
@@ -0,0 +1,89 @@
+#ifndef __PERF_SESSION_H
+#define __PERF_SESSION_H
+
+#include "event.h"
+#include "header.h"
+#include "symbol.h"
+#include "thread.h"
+#include <linux/rbtree.h>
+#include "../../../include/linux/perf_event.h"
+
+struct ip_callchain;
+struct thread;
+
+struct perf_session {
+        struct perf_header      header;
+        unsigned long           size;
+        unsigned long           mmap_window;
+        struct map_groups       kmaps;
+        struct rb_root          threads;
+        struct thread           *last_match;
+        struct map              *vmlinux_maps[MAP__NR_TYPES];
+        struct events_stats     events_stats;
+        struct rb_root          stats_by_id;
+        unsigned long           event_total[PERF_RECORD_MAX];
+        unsigned long           unknown_events;
+        struct rb_root          hists;
+        u64                     sample_type;
+        struct ref_reloc_sym    ref_reloc_sym;
+        int                     fd;
+        int                     cwdlen;
+        char                    *cwd;
+        char filename[0];
+};
+
+typedef int (*event_op)(event_t *self, struct perf_session *session);
+
+struct perf_event_ops {
+        event_op sample,
+                 mmap,
+                 comm,
+                 fork,
+                 exit,
+                 lost,
+                 read,
+                 throttle,
+                 unthrottle;
+};
+
+struct perf_session *perf_session__new(const char *filename, int mode, bool force);
+void perf_session__delete(struct perf_session *self);
+
+void perf_event_header__bswap(struct perf_event_header *self);
+
+int __perf_session__process_events(struct perf_session *self,
+                                   u64 data_offset, u64 data_size, u64 size,
+                                   struct perf_event_ops *ops);
+int perf_session__process_events(struct perf_session *self,
+                                 struct perf_event_ops *event_ops);
+
+struct symbol **perf_session__resolve_callchain(struct perf_session *self,
+                                                struct thread *thread,
+                                                struct ip_callchain *chain,
+                                                struct symbol **parent);
+
+bool perf_session__has_traces(struct perf_session *self, const char *msg);
+
+int perf_header__read_build_ids(struct perf_header *self, int input,
+                                u64 offset, u64 file_size);
+
+int perf_session__set_kallsyms_ref_reloc_sym(struct perf_session *self,
+                                             const char *symbol_name,
+                                             u64 addr);
+
+void mem_bswap_64(void *src, int byte_size);
+
+static inline int __perf_session__create_kernel_maps(struct perf_session *self,
+                                                struct dso *kernel)
+{
+        return __map_groups__create_kernel_maps(&self->kmaps,
+                                                self->vmlinux_maps, kernel);
+}
+
+static inline struct map *
+        perf_session__new_module_map(struct perf_session *self,
+                                     u64 start, const char *filename)
+{
+        return map_groups__new_module(&self->kmaps, start, filename);
+}
+#endif /* __PERF_SESSION_H */
diff --git a/tools/perf/util/sigchain.h b/tools/perf/util/sigchain.h
index 618083bce0c6..1a53c11265fd 100644
--- a/tools/perf/util/sigchain.h
+++ b/tools/perf/util/sigchain.h
@@ -1,5 +1,5 @@
-#ifndef SIGCHAIN_H
-#define SIGCHAIN_H
+#ifndef __PERF_SIGCHAIN_H
+#define __PERF_SIGCHAIN_H
 
 typedef void (*sigchain_fun)(int);
 
@@ -8,4 +8,4 @@ int sigchain_pop(int sig);
 
 void sigchain_push_common(sigchain_fun f);
 
-#endif /* SIGCHAIN_H */
+#endif /* __PERF_SIGCHAIN_H */
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
new file mode 100644
index 000000000000..cb0f327de9e8
--- /dev/null
+++ b/tools/perf/util/sort.c
@@ -0,0 +1,316 @@
+#include "sort.h"
+
+regex_t         parent_regex;
+char            default_parent_pattern[] = "^sys_|^do_page_fault";
+char            *parent_pattern = default_parent_pattern;
+char            default_sort_order[] = "comm,dso,symbol";
+char            *sort_order = default_sort_order;
+int             sort__need_collapse = 0;
+int             sort__has_parent = 0;
+
+enum sort_type  sort__first_dimension;
+
+unsigned int dsos__col_width;
+unsigned int comms__col_width;
+unsigned int threads__col_width;
+static unsigned int parent_symbol__col_width;
+char * field_sep;
+
+LIST_HEAD(hist_entry__sort_list);
+
+struct sort_entry sort_thread = {
+        .header = "Command:  Pid",
+        .cmp    = sort__thread_cmp,
+        .print  = sort__thread_print,
+        .width  = &threads__col_width,
+};
+
+struct sort_entry sort_comm = {
+        .header         = "Command",
+        .cmp            = sort__comm_cmp,
+        .collapse       = sort__comm_collapse,
+        .print          = sort__comm_print,
+        .width          = &comms__col_width,
+};
+
+struct sort_entry sort_dso = {
+        .header = "Shared Object",
+        .cmp    = sort__dso_cmp,
+        .print  = sort__dso_print,
+        .width  = &dsos__col_width,
+};
+
+struct sort_entry sort_sym = {
+        .header = "Symbol",
+        .cmp    = sort__sym_cmp,
+        .print  = sort__sym_print,
+};
+
+struct sort_entry sort_parent = {
+        .header = "Parent symbol",
+        .cmp    = sort__parent_cmp,
+        .print  = sort__parent_print,
+        .width  = &parent_symbol__col_width,
+};
+
+struct sort_dimension {
+        const char              *name;
+        struct sort_entry       *entry;
+        int                     taken;
+};
+
+static struct sort_dimension sort_dimensions[] = {
+        { .name = "pid",        .entry = &sort_thread,  },
+        { .name = "comm",       .entry = &sort_comm,    },
+        { .name = "dso",        .entry = &sort_dso,     },
+        { .name = "symbol",     .entry = &sort_sym,     },
+        { .name = "parent",     .entry = &sort_parent,  },
+};
+
+int64_t cmp_null(void *l, void *r)
+{
+        if (!l && !r)
+                return 0;
+        else if (!l)
+                return -1;
+        else
+                return 1;
+}
+
+/* --sort pid */
+
+int64_t
+sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return right->thread->pid - left->thread->pid;
+}
+
+int repsep_fprintf(FILE *fp, const char *fmt, ...)
+{
+        int n;
+        va_list ap;
+
+        va_start(ap, fmt);
+        if (!field_sep)
+                n = vfprintf(fp, fmt, ap);
+        else {
+                char *bf = NULL;
+                n = vasprintf(&bf, fmt, ap);
+                if (n > 0) {
+                        char *sep = bf;
+
+                        while (1) {
+                                sep = strchr(sep, *field_sep);
+                                if (sep == NULL)
+                                        break;
+                                *sep = '.';
+                        }
+                }
+                fputs(bf, fp);
+                free(bf);
+        }
+        va_end(ap);
+        return n;
+}
+
+size_t
+sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        return repsep_fprintf(fp, "%*s:%5d", width - 6,
+                              self->thread->comm ?: "", self->thread->pid);
+}
+
+size_t
+sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        return repsep_fprintf(fp, "%*s", width, self->thread->comm);
+}
+
+/* --sort dso */
+
+int64_t
+sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct dso *dso_l = left->map ? left->map->dso : NULL;
+        struct dso *dso_r = right->map ? right->map->dso : NULL;
+        const char *dso_name_l, *dso_name_r;
+
+        if (!dso_l || !dso_r)
+                return cmp_null(dso_l, dso_r);
+
+        if (verbose) {
+                dso_name_l = dso_l->long_name;
+                dso_name_r = dso_r->long_name;
+        } else {
+                dso_name_l = dso_l->short_name;
+                dso_name_r = dso_r->short_name;
+        }
+
+        return strcmp(dso_name_l, dso_name_r);
+}
+
+size_t
+sort__dso_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        if (self->map && self->map->dso) {
+                const char *dso_name = !verbose ? self->map->dso->short_name :
+                                                  self->map->dso->long_name;
+                return repsep_fprintf(fp, "%-*s", width, dso_name);
+        }
+
+        return repsep_fprintf(fp, "%*llx", width, (u64)self->ip);
+}
+
+/* --sort symbol */
+
+int64_t
+sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        u64 ip_l, ip_r;
+
+        if (left->sym == right->sym)
+                return 0;
+
+        ip_l = left->sym ? left->sym->start : left->ip;
+        ip_r = right->sym ? right->sym->start : right->ip;
+
+        return (int64_t)(ip_r - ip_l);
+}
+
+
+size_t
+sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
+{
+        size_t ret = 0;
+
+        if (verbose) {
+                char o = self->map ? dso__symtab_origin(self->map->dso) : '!';
+                ret += repsep_fprintf(fp, "%#018llx %c ", (u64)self->ip, o);
+        }
+
+        ret += repsep_fprintf(fp, "[%c] ", self->level);
+        if (self->sym)
+                ret += repsep_fprintf(fp, "%s", self->sym->name);
+        else
+                ret += repsep_fprintf(fp, "%#016llx", (u64)self->ip);
+
+        return ret;
+}
+
+/* --sort comm */
+
+int64_t
+sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return right->thread->pid - left->thread->pid;
+}
+
+int64_t
+sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
+{
+        char *comm_l = left->thread->comm;
+        char *comm_r = right->thread->comm;
+
+        if (!comm_l || !comm_r)
+                return cmp_null(comm_l, comm_r);
+
+        return strcmp(comm_l, comm_r);
+}
+
+/* --sort parent */
+
+int64_t
+sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct symbol *sym_l = left->parent;
+        struct symbol *sym_r = right->parent;
+
+        if (!sym_l || !sym_r)
+                return cmp_null(sym_l, sym_r);
+
+        return strcmp(sym_l->name, sym_r->name);
+}
+
+size_t
+sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        return repsep_fprintf(fp, "%-*s", width,
+                              self->parent ? self->parent->name : "[other]");
+}
+
+int sort_dimension__add(const char *tok)
+{
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
+                struct sort_dimension *sd = &sort_dimensions[i];
+
+                if (sd->taken)
+                        continue;
+
+                if (strncasecmp(tok, sd->name, strlen(tok)))
+                        continue;
+
+                if (sd->entry->collapse)
+                        sort__need_collapse = 1;
+
+                if (sd->entry == &sort_parent) {
+                        int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
+                        if (ret) {
+                                char err[BUFSIZ];
+
+                                regerror(ret, &parent_regex, err, sizeof(err));
+                                fprintf(stderr, "Invalid regex: %s\n%s",
+                                        parent_pattern, err);
+                                exit(-1);
+                        }
+                        sort__has_parent = 1;
+                }
+
+                if (list_empty(&hist_entry__sort_list)) {
+                        if (!strcmp(sd->name, "pid"))
+                                sort__first_dimension = SORT_PID;
+                        else if (!strcmp(sd->name, "comm"))
+                                sort__first_dimension = SORT_COMM;
+                        else if (!strcmp(sd->name, "dso"))
+                                sort__first_dimension = SORT_DSO;
+                        else if (!strcmp(sd->name, "symbol"))
+                                sort__first_dimension = SORT_SYM;
+                        else if (!strcmp(sd->name, "parent"))
+                                sort__first_dimension = SORT_PARENT;
+                }
+
+                list_add_tail(&sd->entry->list, &hist_entry__sort_list);
+                sd->taken = 1;
+
+                return 0;
+        }
+
+        return -ESRCH;
+}
+
+void setup_sorting(const char * const usagestr[], const struct option *opts)
+{
+        char *tmp, *tok, *str = strdup(sort_order);
+
+        for (tok = strtok_r(str, ", ", &tmp);
+                        tok; tok = strtok_r(NULL, ", ", &tmp)) {
+                if (sort_dimension__add(tok) < 0) {
+                        error("Unknown --sort key: `%s'", tok);
+                        usage_with_options(usagestr, opts);
+                }
+        }
+
+        free(str);
+}
+
+void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
+                             const char *list_name, FILE *fp)
+{
+        if (list && strlist__nr_entries(list) == 1) {
+                if (fp != NULL)
+                        fprintf(fp, "# %s: %s\n", list_name,
+                                strlist__entry(list, 0)->s);
+                self->elide = true;
+        }
+}
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
new file mode 100644
index 000000000000..753f9ea99fb0
--- /dev/null
+++ b/tools/perf/util/sort.h
@@ -0,0 +1,107 @@
+#ifndef __PERF_SORT_H
+#define __PERF_SORT_H
+#include "../builtin.h"
+
+#include "util.h"
+
+#include "color.h"
+#include <linux/list.h>
+#include "cache.h"
+#include <linux/rbtree.h>
+#include "symbol.h"
+#include "string.h"
+#include "callchain.h"
+#include "strlist.h"
+#include "values.h"
+
+#include "../perf.h"
+#include "debug.h"
+#include "header.h"
+
+#include "parse-options.h"
+#include "parse-events.h"
+
+#include "thread.h"
+#include "sort.h"
+
+extern regex_t parent_regex;
+extern char *sort_order;
+extern char default_parent_pattern[];
+extern char *parent_pattern;
+extern char default_sort_order[];
+extern int sort__need_collapse;
+extern int sort__has_parent;
+extern char *field_sep;
+extern struct sort_entry sort_comm;
+extern struct sort_entry sort_dso;
+extern struct sort_entry sort_sym;
+extern struct sort_entry sort_parent;
+extern unsigned int dsos__col_width;
+extern unsigned int comms__col_width;
+extern unsigned int threads__col_width;
+extern enum sort_type sort__first_dimension;
+
+struct hist_entry {
+        struct rb_node          rb_node;
+        u64                     count;
+        struct thread           *thread;
+        struct map              *map;
+        struct symbol           *sym;
+        u64                     ip;
+        char                    level;
+        struct symbol     *parent;
+        struct callchain_node   callchain;
+        union {
+                unsigned long     position;
+                struct hist_entry *pair;
+                struct rb_root    sorted_chain;
+        };
+};
+
+enum sort_type {
+        SORT_PID,
+        SORT_COMM,
+        SORT_DSO,
+        SORT_SYM,
+        SORT_PARENT
+};
+
+/*
+ * configurable sorting bits
+ */
+
+struct sort_entry {
+        struct list_head list;
+
+        const char *header;
+
+        int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
+        int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
+        size_t  (*print)(FILE *fp, struct hist_entry *, unsigned int width);
+        unsigned int *width;
+        bool    elide;
+};
+
+extern struct sort_entry sort_thread;
+extern struct list_head hist_entry__sort_list;
+
+void setup_sorting(const char * const usagestr[], const struct option *opts);
+
+extern int repsep_fprintf(FILE *fp, const char *fmt, ...);
+extern size_t sort__thread_print(FILE *, struct hist_entry *, unsigned int);
+extern size_t sort__comm_print(FILE *, struct hist_entry *, unsigned int);
+extern size_t sort__dso_print(FILE *, struct hist_entry *, unsigned int);
+extern size_t sort__sym_print(FILE *, struct hist_entry *, unsigned int __used);
+extern int64_t cmp_null(void *, void *);
+extern int64_t sort__thread_cmp(struct hist_entry *, struct hist_entry *);
+extern int64_t sort__comm_cmp(struct hist_entry *, struct hist_entry *);
+extern int64_t sort__comm_collapse(struct hist_entry *, struct hist_entry *);
+extern int64_t sort__dso_cmp(struct hist_entry *, struct hist_entry *);
+extern int64_t sort__sym_cmp(struct hist_entry *, struct hist_entry *);
+extern int64_t sort__parent_cmp(struct hist_entry *, struct hist_entry *);
+extern size_t sort__parent_print(FILE *, struct hist_entry *, unsigned int);
+extern int sort_dimension__add(const char *);
+void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
+                             const char *list_name, FILE *fp);
+
+#endif  /* __PERF_SORT_H */
diff --git a/tools/perf/util/strbuf.h b/tools/perf/util/strbuf.h
index d2aa86c014c1..a3d121d6c83e 100644
--- a/tools/perf/util/strbuf.h
+++ b/tools/perf/util/strbuf.h
@@ -1,5 +1,5 @@
-#ifndef STRBUF_H
-#define STRBUF_H
+#ifndef __PERF_STRBUF_H
+#define __PERF_STRBUF_H
 
 /*
  * Strbuf's can be use in many ways: as a byte array, or to store arbitrary
@@ -134,4 +134,4 @@ extern int launch_editor(const char *path, struct strbuf *buffer, const char *co
 extern int strbuf_branchname(struct strbuf *sb, const char *name);
 extern int strbuf_check_branch_ref(struct strbuf *sb, const char *name);
 
-#endif /* STRBUF_H */
+#endif /* __PERF_STRBUF_H */
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index c93eca9a7be3..a175949ed216 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -1,4 +1,5 @@
 #include "string.h"
+#include "util.h"
 
 static int hex(char ch)
 {
@@ -32,3 +33,307 @@ int hex2u64(const char *ptr, u64 *long_val)
 
         return p - ptr;
 }
+
+char *strxfrchar(char *s, char from, char to)
+{
+        char *p = s;
+
+        while ((p = strchr(p, from)) != NULL)
+                *p++ = to;
+
+        return s;
+}
+
+#define K 1024LL
+/*
+ * perf_atoll()
+ * Parse (\d+)(b|B|kb|KB|mb|MB|gb|GB|tb|TB) (e.g. "256MB")
+ * and return its numeric value
+ */
+s64 perf_atoll(const char *str)
+{
+        unsigned int i;
+        s64 length = -1, unit = 1;
+
+        if (!isdigit(str[0]))
+                goto out_err;
+
+        for (i = 1; i < strlen(str); i++) {
+                switch (str[i]) {
+                case 'B':
+                case 'b':
+                        break;
+                case 'K':
+                        if (str[i + 1] != 'B')
+                                goto out_err;
+                        else
+                                goto kilo;
+                case 'k':
+                        if (str[i + 1] != 'b')
+                                goto out_err;
+kilo:
+                        unit = K;
+                        break;
+                case 'M':
+                        if (str[i + 1] != 'B')
+                                goto out_err;
+                        else
+                                goto mega;
+                case 'm':
+                        if (str[i + 1] != 'b')
+                                goto out_err;
+mega:
+                        unit = K * K;
+                        break;
+                case 'G':
+                        if (str[i + 1] != 'B')
+                                goto out_err;
+                        else
+                                goto giga;
+                case 'g':
+                        if (str[i + 1] != 'b')
+                                goto out_err;
+giga:
+                        unit = K * K * K;
+                        break;
+                case 'T':
+                        if (str[i + 1] != 'B')
+                                goto out_err;
+                        else
+                                goto tera;
+                case 't':
+                        if (str[i + 1] != 'b')
+                                goto out_err;
+tera:
+                        unit = K * K * K * K;
+                        break;
+                case '\0':      /* only specified figures */
+                        unit = 1;
+                        break;
+                default:
+                        if (!isdigit(str[i]))
+                                goto out_err;
+                        break;
+                }
+        }
+
+        length = atoll(str) * unit;
+        goto out;
+
+out_err:
+        length = -1;
+out:
+        return length;
+}
+
+/*
+ * Helper function for splitting a string into an argv-like array.
+ * originaly copied from lib/argv_split.c
+ */
+static const char *skip_sep(const char *cp)
+{
+        while (*cp && isspace(*cp))
+                cp++;
+
+        return cp;
+}
+
+static const char *skip_arg(const char *cp)
+{
+        while (*cp && !isspace(*cp))
+                cp++;
+
+        return cp;
+}
+
+static int count_argc(const char *str)
+{
+        int count = 0;
+
+        while (*str) {
+                str = skip_sep(str);
+                if (*str) {
+                        count++;
+                        str = skip_arg(str);
+                }
+        }
+
+        return count;
+}
+
+/**
+ * argv_free - free an argv
+ * @argv - the argument vector to be freed
+ *
+ * Frees an argv and the strings it points to.
+ */
+void argv_free(char **argv)
+{
+        char **p;
+        for (p = argv; *p; p++)
+                free(*p);
+
+        free(argv);
+}
+
+/**
+ * argv_split - split a string at whitespace, returning an argv
+ * @str: the string to be split
+ * @argcp: returned argument count
+ *
+ * Returns an array of pointers to strings which are split out from
+ * @str.  This is performed by strictly splitting on white-space; no
+ * quote processing is performed.  Multiple whitespace characters are
+ * considered to be a single argument separator.  The returned array
+ * is always NULL-terminated.  Returns NULL on memory allocation
+ * failure.
+ */
+char **argv_split(const char *str, int *argcp)
+{
+        int argc = count_argc(str);
+        char **argv = zalloc(sizeof(*argv) * (argc+1));
+        char **argvp;
+
+        if (argv == NULL)
+                goto out;
+
+        if (argcp)
+                *argcp = argc;
+
+        argvp = argv;
+
+        while (*str) {
+                str = skip_sep(str);
+
+                if (*str) {
+                        const char *p = str;
+                        char *t;
+
+                        str = skip_arg(str);
+
+                        t = strndup(p, str-p);
+                        if (t == NULL)
+                                goto fail;
+                        *argvp++ = t;
+                }
+        }
+        *argvp = NULL;
+
+out:
+        return argv;
+
+fail:
+        argv_free(argv);
+        return NULL;
+}
+
+/* Character class matching */
+static bool __match_charclass(const char *pat, char c, const char **npat)
+{
+        bool complement = false, ret = true;
+
+        if (*pat == '!') {
+                complement = true;
+                pat++;
+        }
+        if (*pat++ == c)        /* First character is special */
+                goto end;
+
+        while (*pat && *pat != ']') {   /* Matching */
+                if (*pat == '-' && *(pat + 1) != ']') { /* Range */
+                        if (*(pat - 1) <= c && c <= *(pat + 1))
+                                goto end;
+                        if (*(pat - 1) > *(pat + 1))
+                                goto error;
+                        pat += 2;
+                } else if (*pat++ == c)
+                        goto end;
+        }
+        if (!*pat)
+                goto error;
+        ret = false;
+
+end:
+        while (*pat && *pat != ']')     /* Searching closing */
+                pat++;
+        if (!*pat)
+                goto error;
+        *npat = pat + 1;
+        return complement ? !ret : ret;
+
+error:
+        return false;
+}
+
+/* Glob/lazy pattern matching */
+static bool __match_glob(const char *str, const char *pat, bool ignore_space)
+{
+        while (*str && *pat && *pat != '*') {
+                if (ignore_space) {
+                        /* Ignore spaces for lazy matching */
+                        if (isspace(*str)) {
+                                str++;
+                                continue;
+                        }
+                        if (isspace(*pat)) {
+                                pat++;
+                                continue;
+                        }
+                }
+                if (*pat == '?') {      /* Matches any single character */
+                        str++;
+                        pat++;
+                        continue;
+                } else if (*pat == '[') /* Character classes/Ranges */
+                        if (__match_charclass(pat + 1, *str, &pat)) {
+                                str++;
+                                continue;
+                        } else
+                                return false;
+                else if (*pat == '\\') /* Escaped char match as normal char */
+                        pat++;
+                if (*str++ != *pat++)
+                        return false;
+        }
+        /* Check wild card */
+        if (*pat == '*') {
+                while (*pat == '*')
+                        pat++;
+                if (!*pat)      /* Tail wild card matches all */
+                        return true;
+                while (*str)
+                        if (strglobmatch(str++, pat))
+                                return true;
+        }
+        return !*str && !*pat;
+}
+
+/**
+ * strglobmatch - glob expression pattern matching
+ * @str: the target string to match
+ * @pat: the pattern string to match
+ *
+ * This returns true if the @str matches @pat. @pat can includes wildcards
+ * ('*','?') and character classes ([CHARS], complementation and ranges are
+ * also supported). Also, this supports escape character ('\') to use special
+ * characters as normal character.
+ *
+ * Note: if @pat syntax is broken, this always returns false.
+ */
+bool strglobmatch(const char *str, const char *pat)
+{
+        return __match_glob(str, pat, false);
+}
+
+/**
+ * strlazymatch - matching pattern strings lazily with glob pattern
+ * @str: the target string to match
+ * @pat: the pattern string to match
+ *
+ * This is similar to strglobmatch, except this ignores spaces in
+ * the target string.
+ */
+bool strlazymatch(const char *str, const char *pat)
+{
+        return __match_glob(str, pat, true);
+}
diff --git a/tools/perf/util/string.h b/tools/perf/util/string.h
index bf39dfadfd24..542e44de3719 100644
--- a/tools/perf/util/string.h
+++ b/tools/perf/util/string.h
@@ -1,11 +1,18 @@
-#ifndef _PERF_STRING_H_
-#define _PERF_STRING_H_
+#ifndef __PERF_STRING_H_
+#define __PERF_STRING_H_
 
+#include <stdbool.h>
 #include "types.h"
 
 int hex2u64(const char *ptr, u64 *val);
+char *strxfrchar(char *s, char from, char to);
+s64 perf_atoll(const char *str);
+char **argv_split(const char *str, int *argcp);
+void argv_free(char **argv);
+bool strglobmatch(const char *str, const char *pat);
+bool strlazymatch(const char *str, const char *pat);
 
 #define _STR(x) #x
 #define STR(x) _STR(x)
 
-#endif
+#endif /* __PERF_STRING_H */
diff --git a/tools/perf/util/strlist.c b/tools/perf/util/strlist.c
index 7ad38171dc2b..6783a2043555 100644
--- a/tools/perf/util/strlist.c
+++ b/tools/perf/util/strlist.c
@@ -102,7 +102,7 @@ void strlist__remove(struct strlist *self, struct str_node *sn)
         str_node__delete(sn, self->dupstr);
 }
 
-bool strlist__has_entry(struct strlist *self, const char *entry)
+struct str_node *strlist__find(struct strlist *self, const char *entry)
 {
         struct rb_node **p = &self->entries.rb_node;
         struct rb_node *parent = NULL;
@@ -120,10 +120,10 @@ bool strlist__has_entry(struct strlist *self, const char *entry)
                 else if (rc < 0)
                         p = &(*p)->rb_right;
                 else
-                        return true;
+                        return sn;
         }
 
-        return false;
+        return NULL;
 }
 
 static int strlist__parse_list_entry(struct strlist *self, const char *s)
diff --git a/tools/perf/util/strlist.h b/tools/perf/util/strlist.h
index 921818e44a54..3ba839007d2c 100644
--- a/tools/perf/util/strlist.h
+++ b/tools/perf/util/strlist.h
@@ -1,5 +1,5 @@
-#ifndef STRLIST_H_
-#define STRLIST_H_
+#ifndef __PERF_STRLIST_H
+#define __PERF_STRLIST_H
 
 #include <linux/rbtree.h>
 #include <stdbool.h>
@@ -23,7 +23,12 @@ int strlist__load(struct strlist *self, const char *filename);
 int strlist__add(struct strlist *self, const char *str);
 
 struct str_node *strlist__entry(const struct strlist *self, unsigned int idx);
-bool strlist__has_entry(struct strlist *self, const char *entry);
+struct str_node *strlist__find(struct strlist *self, const char *entry);
+
+static inline bool strlist__has_entry(struct strlist *self, const char *entry)
+{
+        return strlist__find(self, entry) != NULL;
+}
 
 static inline bool strlist__empty(const struct strlist *self)
 {
@@ -35,5 +40,39 @@ static inline unsigned int strlist__nr_entries(const struct strlist *self)
         return self->nr_entries;
 }
 
+/* For strlist iteration */
+static inline struct str_node *strlist__first(struct strlist *self)
+{
+        struct rb_node *rn = rb_first(&self->entries);
+        return rn ? rb_entry(rn, struct str_node, rb_node) : NULL;
+}
+static inline struct str_node *strlist__next(struct str_node *sn)
+{
+        struct rb_node *rn;
+        if (!sn)
+                return NULL;
+        rn = rb_next(&sn->rb_node);
+        return rn ? rb_entry(rn, struct str_node, rb_node) : NULL;
+}
+
+/**
+ * strlist_for_each      - iterate over a strlist
+ * @pos:        the &struct str_node to use as a loop cursor.
+ * @self:       the &struct strlist for loop.
+ */
+#define strlist__for_each(pos, self)    \
+        for (pos = strlist__first(self); pos; pos = strlist__next(pos))
+
+/**
+ * strlist_for_each_safe - iterate over a strlist safe against removal of
+ *                         str_node
+ * @pos:        the &struct str_node to use as a loop cursor.
+ * @n:          another &struct str_node to use as temporary storage.
+ * @self:       the &struct strlist for loop.
+ */
+#define strlist__for_each_safe(pos, n, self)    \
+        for (pos = strlist__first(self), n = strlist__next(pos); pos;\
+             pos = n, n = strlist__next(n))
+
 int strlist__parse_list(struct strlist *self, const char *s);
-#endif /* STRLIST_H_ */
+#endif /* __PERF_STRLIST_H */
diff --git a/tools/perf/util/svghelper.h b/tools/perf/util/svghelper.h
index cd93195aedb3..e0781989cc31 100644
--- a/tools/perf/util/svghelper.h
+++ b/tools/perf/util/svghelper.h
@@ -1,5 +1,5 @@
-#ifndef _INCLUDE_GUARD_SVG_HELPER_
-#define _INCLUDE_GUARD_SVG_HELPER_
+#ifndef __PERF_SVGHELPER_H
+#define __PERF_SVGHELPER_H
 
 #include "types.h"
 
@@ -25,4 +25,4 @@ extern void svg_close(void);
 
 extern int svg_page_width;
 
-#endif
+#endif /* __PERF_SVGHELPER_H */
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 226f44a2357d..c458c4a371d1 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1,111 +1,234 @@
 #include "util.h"
 #include "../perf.h"
+#include "sort.h"
 #include "string.h"
 #include "symbol.h"
+#include "thread.h"
 
 #include "debug.h"
 
+#include <asm/bug.h>
 #include <libelf.h>
 #include <gelf.h>
 #include <elf.h>
+#include <limits.h>
+#include <sys/utsname.h>
 
-const char *sym_hist_filter;
+#ifndef NT_GNU_BUILD_ID
+#define NT_GNU_BUILD_ID 3
+#endif
 
 enum dso_origin {
         DSO__ORIG_KERNEL = 0,
         DSO__ORIG_JAVA_JIT,
+        DSO__ORIG_BUILD_ID_CACHE,
         DSO__ORIG_FEDORA,
         DSO__ORIG_UBUNTU,
         DSO__ORIG_BUILDID,
         DSO__ORIG_DSO,
+        DSO__ORIG_KMODULE,
         DSO__ORIG_NOT_FOUND,
 };
 
-static struct symbol *symbol__new(u64 start, u64 len,
-                                  const char *name, unsigned int priv_size,
-                                  u64 obj_start, int v)
+static void dsos__add(struct list_head *head, struct dso *dso);
+static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
+static int dso__load_kernel_sym(struct dso *self, struct map *map,
+                                symbol_filter_t filter);
+static int vmlinux_path__nr_entries;
+static char **vmlinux_path;
+
+struct symbol_conf symbol_conf = {
+        .exclude_other    = true,
+        .use_modules      = true,
+        .try_vmlinux_path = true,
+};
+
+bool dso__loaded(const struct dso *self, enum map_type type)
 {
-        size_t namelen = strlen(name) + 1;
-        struct symbol *self = calloc(1, priv_size + sizeof(*self) + namelen);
+        return self->loaded & (1 << type);
+}
 
-        if (!self)
-                return NULL;
+bool dso__sorted_by_name(const struct dso *self, enum map_type type)
+{
+        return self->sorted_by_name & (1 << type);
+}
+
+static void dso__set_sorted_by_name(struct dso *self, enum map_type type)
+{
+        self->sorted_by_name |= (1 << type);
+}
+
+bool symbol_type__is_a(char symbol_type, enum map_type map_type)
+{
+        switch (map_type) {
+        case MAP__FUNCTION:
+                return symbol_type == 'T' || symbol_type == 'W';
+        case MAP__VARIABLE:
+                return symbol_type == 'D' || symbol_type == 'd';
+        default:
+                return false;
+        }
+}
 
-        if (v >= 2)
-                printf("new symbol: %016Lx [%08lx]: %s, hist: %p, obj_start: %p\n",
-                        (u64)start, (unsigned long)len, name, self->hist, (void *)(unsigned long)obj_start);
+static void symbols__fixup_end(struct rb_root *self)
+{
+        struct rb_node *nd, *prevnd = rb_first(self);
+        struct symbol *curr, *prev;
 
-        self->obj_start= obj_start;
-        self->hist = NULL;
-        self->hist_sum = 0;
+        if (prevnd == NULL)
+                return;
 
-        if (sym_hist_filter && !strcmp(name, sym_hist_filter))
-                self->hist = calloc(sizeof(u64), len);
+        curr = rb_entry(prevnd, struct symbol, rb_node);
 
-        if (priv_size) {
-                memset(self, 0, priv_size);
-                self = ((void *)self) + priv_size;
+        for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
+                prev = curr;
+                curr = rb_entry(nd, struct symbol, rb_node);
+
+                if (prev->end == prev->start)
+                        prev->end = curr->start - 1;
         }
+
+        /* Last entry */
+        if (curr->end == curr->start)
+                curr->end = roundup(curr->start, 4096);
+}
+
+static void __map_groups__fixup_end(struct map_groups *self, enum map_type type)
+{
+        struct map *prev, *curr;
+        struct rb_node *nd, *prevnd = rb_first(&self->maps[type]);
+
+        if (prevnd == NULL)
+                return;
+
+        curr = rb_entry(prevnd, struct map, rb_node);
+
+        for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
+                prev = curr;
+                curr = rb_entry(nd, struct map, rb_node);
+                prev->end = curr->start - 1;
+        }
+
+        /*
+         * We still haven't the actual symbols, so guess the
+         * last map final address.
+         */
+        curr->end = ~0UL;
+}
+
+static void map_groups__fixup_end(struct map_groups *self)
+{
+        int i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                __map_groups__fixup_end(self, i);
+}
+
+static struct symbol *symbol__new(u64 start, u64 len, const char *name)
+{
+        size_t namelen = strlen(name) + 1;
+        struct symbol *self = zalloc(symbol_conf.priv_size +
+                                     sizeof(*self) + namelen);
+        if (self == NULL)
+                return NULL;
+
+        if (symbol_conf.priv_size)
+                self = ((void *)self) + symbol_conf.priv_size;
+
         self->start = start;
         self->end   = len ? start + len - 1 : start;
+
+        pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
+
         memcpy(self->name, name, namelen);
 
         return self;
 }
 
-static void symbol__delete(struct symbol *self, unsigned int priv_size)
+void symbol__delete(struct symbol *self)
 {
-        free(((void *)self) - priv_size);
+        free(((void *)self) - symbol_conf.priv_size);
 }
 
 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
 {
-        if (!self->module)
-                return fprintf(fp, " %llx-%llx %s\n",
+        return fprintf(fp, " %llx-%llx %s\n",
                        self->start, self->end, self->name);
-        else
-                return fprintf(fp, " %llx-%llx %s \t[%s]\n",
-                       self->start, self->end, self->name, self->module->name);
 }
 
-struct dso *dso__new(const char *name, unsigned int sym_priv_size)
+void dso__set_long_name(struct dso *self, char *name)
 {
-        struct dso *self = malloc(sizeof(*self) + strlen(name) + 1);
+        if (name == NULL)
+                return;
+        self->long_name = name;
+        self->long_name_len = strlen(name);
+}
+
+static void dso__set_short_name(struct dso *self, const char *name)
+{
+        if (name == NULL)
+                return;
+        self->short_name = name;
+        self->short_name_len = strlen(name);
+}
+
+static void dso__set_basename(struct dso *self)
+{
+        dso__set_short_name(self, basename(self->long_name));
+}
+
+struct dso *dso__new(const char *name)
+{
+        struct dso *self = zalloc(sizeof(*self) + strlen(name) + 1);
 
         if (self != NULL) {
+                int i;
                 strcpy(self->name, name);
-                self->syms = RB_ROOT;
-                self->sym_priv_size = sym_priv_size;
-                self->find_symbol = dso__find_symbol;
+                dso__set_long_name(self, self->name);
+                dso__set_short_name(self, self->name);
+                for (i = 0; i < MAP__NR_TYPES; ++i)
+                        self->symbols[i] = self->symbol_names[i] = RB_ROOT;
                 self->slen_calculated = 0;
                 self->origin = DSO__ORIG_NOT_FOUND;
+                self->loaded = 0;
+                self->sorted_by_name = 0;
+                self->has_build_id = 0;
         }
 
         return self;
 }
 
-static void dso__delete_symbols(struct dso *self)
+static void symbols__delete(struct rb_root *self)
 {
         struct symbol *pos;
-        struct rb_node *next = rb_first(&self->syms);
+        struct rb_node *next = rb_first(self);
 
         while (next) {
                 pos = rb_entry(next, struct symbol, rb_node);
                 next = rb_next(&pos->rb_node);
-                rb_erase(&pos->rb_node, &self->syms);
-                symbol__delete(pos, self->sym_priv_size);
+                rb_erase(&pos->rb_node, self);
+                symbol__delete(pos);
         }
 }
 
 void dso__delete(struct dso *self)
 {
-        dso__delete_symbols(self);
+        int i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                symbols__delete(&self->symbols[i]);
+        if (self->long_name != self->name)
+                free(self->long_name);
         free(self);
 }
 
-static void dso__insert_symbol(struct dso *self, struct symbol *sym)
+void dso__set_build_id(struct dso *self, void *build_id)
 {
-        struct rb_node **p = &self->syms.rb_node;
+        memcpy(self->build_id, build_id, sizeof(self->build_id));
+        self->has_build_id = 1;
+}
+
+static void symbols__insert(struct rb_root *self, struct symbol *sym)
+{
+        struct rb_node **p = &self->rb_node;
         struct rb_node *parent = NULL;
         const u64 ip = sym->start;
         struct symbol *s;
@@ -119,17 +242,17 @@ static void dso__insert_symbol(struct dso *self, struct symbol *sym)
                         p = &(*p)->rb_right;
         }
         rb_link_node(&sym->rb_node, parent, p);
-        rb_insert_color(&sym->rb_node, &self->syms);
+        rb_insert_color(&sym->rb_node, self);
 }
 
-struct symbol *dso__find_symbol(struct dso *self, u64 ip)
+static struct symbol *symbols__find(struct rb_root *self, u64 ip)
 {
         struct rb_node *n;
 
         if (self == NULL)
                 return NULL;
 
-        n = self->syms.rb_node;
+        n = self->rb_node;
 
         while (n) {
                 struct symbol *s = rb_entry(n, struct symbol, rb_node);
@@ -145,12 +268,120 @@ struct symbol *dso__find_symbol(struct dso *self, u64 ip)
         return NULL;
 }
 
-size_t dso__fprintf(struct dso *self, FILE *fp)
+struct symbol_name_rb_node {
+        struct rb_node  rb_node;
+        struct symbol   sym;
+};
+
+static void symbols__insert_by_name(struct rb_root *self, struct symbol *sym)
+{
+        struct rb_node **p = &self->rb_node;
+        struct rb_node *parent = NULL;
+        struct symbol_name_rb_node *symn = ((void *)sym) - sizeof(*parent), *s;
+
+        while (*p != NULL) {
+                parent = *p;
+                s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
+                if (strcmp(sym->name, s->sym.name) < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+        rb_link_node(&symn->rb_node, parent, p);
+        rb_insert_color(&symn->rb_node, self);
+}
+
+static void symbols__sort_by_name(struct rb_root *self, struct rb_root *source)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(source); nd; nd = rb_next(nd)) {
+                struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
+                symbols__insert_by_name(self, pos);
+        }
+}
+
+static struct symbol *symbols__find_by_name(struct rb_root *self, const char *name)
+{
+        struct rb_node *n;
+
+        if (self == NULL)
+                return NULL;
+
+        n = self->rb_node;
+
+        while (n) {
+                struct symbol_name_rb_node *s;
+                int cmp;
+
+                s = rb_entry(n, struct symbol_name_rb_node, rb_node);
+                cmp = strcmp(name, s->sym.name);
+
+                if (cmp < 0)
+                        n = n->rb_left;
+                else if (cmp > 0)
+                        n = n->rb_right;
+                else
+                        return &s->sym;
+        }
+
+        return NULL;
+}
+
+struct symbol *dso__find_symbol(struct dso *self,
+                                enum map_type type, u64 addr)
+{
+        return symbols__find(&self->symbols[type], addr);
+}
+
+struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
+                                        const char *name)
+{
+        return symbols__find_by_name(&self->symbol_names[type], name);
+}
+
+void dso__sort_by_name(struct dso *self, enum map_type type)
+{
+        dso__set_sorted_by_name(self, type);
+        return symbols__sort_by_name(&self->symbol_names[type],
+                                     &self->symbols[type]);
+}
+
+int build_id__sprintf(const u8 *self, int len, char *bf)
+{
+        char *bid = bf;
+        const u8 *raw = self;
+        int i;
+
+        for (i = 0; i < len; ++i) {
+                sprintf(bid, "%02x", *raw);
+                ++raw;
+                bid += 2;
+        }
+
+        return raw - self;
+}
+
+size_t dso__fprintf_buildid(struct dso *self, FILE *fp)
 {
-        size_t ret = fprintf(fp, "dso: %s\n", self->name);
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        build_id__sprintf(self->build_id, sizeof(self->build_id), sbuild_id);
+        return fprintf(fp, "%s", sbuild_id);
+}
 
+size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp)
+{
         struct rb_node *nd;
-        for (nd = rb_first(&self->syms); nd; nd = rb_next(nd)) {
+        size_t ret = fprintf(fp, "dso: %s (", self->short_name);
+
+        if (self->short_name != self->long_name)
+                ret += fprintf(fp, "%s, ", self->long_name);
+        ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
+                       self->loaded ? "" : "NOT ");
+        ret += dso__fprintf_buildid(self, fp);
+        ret += fprintf(fp, ")\n");
+        for (nd = rb_first(&self->symbols[type]); nd; nd = rb_next(nd)) {
                 struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
                 ret += symbol__fprintf(pos, fp);
         }
@@ -158,22 +389,23 @@ size_t dso__fprintf(struct dso *self, FILE *fp)
         return ret;
 }
 
-static int dso__load_kallsyms(struct dso *self, symbol_filter_t filter, int v)
+int kallsyms__parse(const char *filename, void *arg,
+                    int (*process_symbol)(void *arg, const char *name,
+                                                     char type, u64 start))
 {
-        struct rb_node *nd, *prevnd;
         char *line = NULL;
         size_t n;
-        FILE *file = fopen("/proc/kallsyms", "r");
-        int count = 0;
+        int err = 0;
+        FILE *file = fopen(filename, "r");
 
         if (file == NULL)
                 goto out_failure;
 
         while (!feof(file)) {
                 u64 start;
-                struct symbol *sym;
                 int line_len, len;
                 char symbol_type;
+                char *symbol_name;
 
                 line_len = getline(&line, &n, file);
                 if (line_len < 0)
@@ -191,64 +423,168 @@ static int dso__load_kallsyms(struct dso *self, symbol_filter_t filter, int v)
                         continue;
 
                 symbol_type = toupper(line[len]);
-                /*
-                 * We're interested only in code ('T'ext)
-                 */
-                if (symbol_type != 'T' && symbol_type != 'W')
-                        continue;
-                /*
-                 * Well fix up the end later, when we have all sorted.
-                 */
-                sym = symbol__new(start, 0xdead, line + len + 2,
-                                  self->sym_priv_size, 0, v);
+                symbol_name = line + len + 2;
 
-                if (sym == NULL)
-                        goto out_delete_line;
-
-                if (filter && filter(self, sym))
-                        symbol__delete(sym, self->sym_priv_size);
-                else {
-                        dso__insert_symbol(self, sym);
-                        count++;
-                }
+                err = process_symbol(arg, symbol_name, symbol_type, start);
+                if (err)
+                        break;
         }
 
+        free(line);
+        fclose(file);
+        return err;
+
+out_failure:
+        return -1;
+}
+
+struct process_kallsyms_args {
+        struct map *map;
+        struct dso *dso;
+};
+
+static int map__process_kallsym_symbol(void *arg, const char *name,
+                                       char type, u64 start)
+{
+        struct symbol *sym;
+        struct process_kallsyms_args *a = arg;
+        struct rb_root *root = &a->dso->symbols[a->map->type];
+
+        if (!symbol_type__is_a(type, a->map->type))
+                return 0;
+
         /*
-         * Now that we have all sorted out, just set the ->end of all
-         * symbols
+         * Will fix up the end later, when we have all symbols sorted.
          */
-        prevnd = rb_first(&self->syms);
+        sym = symbol__new(start, 0, name);
 
-        if (prevnd == NULL)
-                goto out_delete_line;
+        if (sym == NULL)
+                return -ENOMEM;
+        /*
+         * We will pass the symbols to the filter later, in
+         * map__split_kallsyms, when we have split the maps per module
+         */
+        symbols__insert(root, sym);
+        return 0;
+}
 
-        for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
-                struct symbol *prev = rb_entry(prevnd, struct symbol, rb_node),
-                              *curr = rb_entry(nd, struct symbol, rb_node);
+/*
+ * Loads the function entries in /proc/kallsyms into kernel_map->dso,
+ * so that we can in the next step set the symbol ->end address and then
+ * call kernel_maps__split_kallsyms.
+ */
+static int dso__load_all_kallsyms(struct dso *self, const char *filename,
+                                  struct map *map)
+{
+        struct process_kallsyms_args args = { .map = map, .dso = self, };
+        return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
+}
 
-                prev->end = curr->start - 1;
-                prevnd = nd;
-        }
+/*
+ * Split the symbols into maps, making sure there are no overlaps, i.e. the
+ * kernel range is broken in several maps, named [kernel].N, as we don't have
+ * the original ELF section names vmlinux have.
+ */
+static int dso__split_kallsyms(struct dso *self, struct map *map,
+                               symbol_filter_t filter)
+{
+        struct map_groups *kmaps = map__kmap(map)->kmaps;
+        struct map *curr_map = map;
+        struct symbol *pos;
+        int count = 0;
+        struct rb_root *root = &self->symbols[map->type];
+        struct rb_node *next = rb_first(root);
+        int kernel_range = 0;
 
-        free(line);
-        fclose(file);
+        while (next) {
+                char *module;
+
+                pos = rb_entry(next, struct symbol, rb_node);
+                next = rb_next(&pos->rb_node);
+
+                module = strchr(pos->name, '\t');
+                if (module) {
+                        if (!symbol_conf.use_modules)
+                                goto discard_symbol;
+
+                        *module++ = '\0';
+
+                        if (strcmp(curr_map->dso->short_name, module)) {
+                                curr_map = map_groups__find_by_name(kmaps, map->type, module);
+                                if (curr_map == NULL) {
+                                        pr_debug("/proc/{kallsyms,modules} "
+                                                 "inconsistency while looking "
+                                                 "for \"%s\" module!\n", module);
+                                        return -1;
+                                }
+
+                                if (curr_map->dso->loaded)
+                                        goto discard_symbol;
+                        }
+                        /*
+                         * So that we look just like we get from .ko files,
+                         * i.e. not prelinked, relative to map->start.
+                         */
+                        pos->start = curr_map->map_ip(curr_map, pos->start);
+                        pos->end   = curr_map->map_ip(curr_map, pos->end);
+                } else if (curr_map != map) {
+                        char dso_name[PATH_MAX];
+                        struct dso *dso;
+
+                        snprintf(dso_name, sizeof(dso_name), "[kernel].%d",
+                                 kernel_range++);
+
+                        dso = dso__new(dso_name);
+                        if (dso == NULL)
+                                return -1;
+
+                        curr_map = map__new2(pos->start, dso, map->type);
+                        if (curr_map == NULL) {
+                                dso__delete(dso);
+                                return -1;
+                        }
+
+                        curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
+                        map_groups__insert(kmaps, curr_map);
+                        ++kernel_range;
+                }
+
+                if (filter && filter(curr_map, pos)) {
+discard_symbol:         rb_erase(&pos->rb_node, root);
+                        symbol__delete(pos);
+                } else {
+                        if (curr_map != map) {
+                                rb_erase(&pos->rb_node, root);
+                                symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
+                        }
+                        count++;
+                }
+        }
 
         return count;
+}
 
-out_delete_line:
-        free(line);
-out_failure:
-        return -1;
+int dso__load_kallsyms(struct dso *self, const char *filename,
+                       struct map *map, symbol_filter_t filter)
+{
+        if (dso__load_all_kallsyms(self, filename, map) < 0)
+                return -1;
+
+        symbols__fixup_end(&self->symbols[map->type]);
+        self->origin = DSO__ORIG_KERNEL;
+
+        return dso__split_kallsyms(self, map, filter);
 }
 
-static int dso__load_perf_map(struct dso *self, symbol_filter_t filter, int v)
+static int dso__load_perf_map(struct dso *self, struct map *map,
+                              symbol_filter_t filter)
 {
         char *line = NULL;
         size_t n;
         FILE *file;
         int nr_syms = 0;
 
-        file = fopen(self->name, "r");
+        file = fopen(self->long_name, "r");
         if (file == NULL)
                 goto out_failure;
 
@@ -278,16 +614,15 @@ static int dso__load_perf_map(struct dso *self, symbol_filter_t filter, int v)
                 if (len + 2 >= line_len)
                         continue;
 
-                sym = symbol__new(start, size, line + len,
-                                  self->sym_priv_size, start, v);
+                sym = symbol__new(start, size, line + len);
 
                 if (sym == NULL)
                         goto out_delete_line;
 
-                if (filter && filter(self, sym))
-                        symbol__delete(sym, self->sym_priv_size);
+                if (filter && filter(map, sym))
+                        symbol__delete(sym);
                 else {
-                        dso__insert_symbol(self, sym);
+                        symbols__insert(&self->symbols[map->type], sym);
                         nr_syms++;
                 }
         }
@@ -327,6 +662,13 @@ static inline int elf_sym__is_function(const GElf_Sym *sym)
                sym->st_shndx != SHN_UNDEF;
 }
 
+static inline bool elf_sym__is_object(const GElf_Sym *sym)
+{
+        return elf_sym__type(sym) == STT_OBJECT &&
+                sym->st_name != 0 &&
+                sym->st_shndx != SHN_UNDEF;
+}
+
 static inline int elf_sym__is_label(const GElf_Sym *sym)
 {
         return elf_sym__type(sym) == STT_NOTYPE &&
@@ -347,6 +689,12 @@ static inline int elf_sec__is_text(const GElf_Shdr *shdr,
         return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 }
 
+static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
+                                    const Elf_Data *secstrs)
+{
+        return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
+}
+
 static inline const char *elf_sym__name(const GElf_Sym *sym,
                                         const Elf_Data *symstrs)
 {
@@ -393,7 +741,8 @@ static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
  * And always look at the original dso, not at debuginfo packages, that
  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
  */
-static int dso__synthesize_plt_symbols(struct  dso *self, int v)
+static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
+                                       symbol_filter_t filter)
 {
         uint32_t nr_rel_entries, idx;
         GElf_Sym sym;
@@ -409,7 +758,7 @@ static int dso__synthesize_plt_symbols(struct  dso *self, int v)
         Elf *elf;
         int nr = 0, symidx, fd, err = 0;
 
-        fd = open(self->name, O_RDONLY);
+        fd = open(self->long_name, O_RDONLY);
         if (fd < 0)
                 goto out;
 
@@ -477,12 +826,16 @@ static int dso__synthesize_plt_symbols(struct  dso *self, int v)
                                  "%s@plt", elf_sym__name(&sym, symstrs));
 
                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        sympltname, self->sym_priv_size, 0, v);
+                                        sympltname);
                         if (!f)
                                 goto out_elf_end;
 
-                        dso__insert_symbol(self, f);
-                        ++nr;
+                        if (filter && filter(map, f))
+                                symbol__delete(f);
+                        else {
+                                symbols__insert(&self->symbols[map->type], f);
+                                ++nr;
+                        }
                 }
         } else if (shdr_rel_plt.sh_type == SHT_REL) {
                 GElf_Rel pos_mem, *pos;
@@ -495,12 +848,16 @@ static int dso__synthesize_plt_symbols(struct  dso *self, int v)
                                  "%s@plt", elf_sym__name(&sym, symstrs));
 
                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        sympltname, self->sym_priv_size, 0, v);
+                                        sympltname);
                         if (!f)
                                 goto out_elf_end;
 
-                        dso__insert_symbol(self, f);
-                        ++nr;
+                        if (filter && filter(map, f))
+                                symbol__delete(f);
+                        else {
+                                symbols__insert(&self->symbols[map->type], f);
+                                ++nr;
+                        }
                 }
         }
 
@@ -513,14 +870,41 @@ out_close:
         if (err == 0)
                 return nr;
 out:
-        fprintf(stderr, "%s: problems reading %s PLT info.\n",
-                __func__, self->name);
+        pr_warning("%s: problems reading %s PLT info.\n",
+                   __func__, self->long_name);
         return 0;
 }
 
-static int dso__load_sym(struct dso *self, int fd, const char *name,
-                         symbol_filter_t filter, int v, struct module *mod)
+static bool elf_sym__is_a(GElf_Sym *self, enum map_type type)
 {
+        switch (type) {
+        case MAP__FUNCTION:
+                return elf_sym__is_function(self);
+        case MAP__VARIABLE:
+                return elf_sym__is_object(self);
+        default:
+                return false;
+        }
+}
+
+static bool elf_sec__is_a(GElf_Shdr *self, Elf_Data *secstrs, enum map_type type)
+{
+        switch (type) {
+        case MAP__FUNCTION:
+                return elf_sec__is_text(self, secstrs);
+        case MAP__VARIABLE:
+                return elf_sec__is_data(self, secstrs);
+        default:
+                return false;
+        }
+}
+
+static int dso__load_sym(struct dso *self, struct map *map, const char *name,
+                         int fd, symbol_filter_t filter, int kmodule)
+{
+        struct kmap *kmap = self->kernel ? map__kmap(map) : NULL;
+        struct map *curr_map = map;
+        struct dso *curr_dso = self;
         Elf_Data *symstrs, *secstrs;
         uint32_t nr_syms;
         int err = -1;
@@ -531,19 +915,16 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
         GElf_Sym sym;
         Elf_Scn *sec, *sec_strndx;
         Elf *elf;
-        int nr = 0, kernel = !strcmp("[kernel]", self->name);
+        int nr = 0;
 
         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
         if (elf == NULL) {
-                if (v)
-                        fprintf(stderr, "%s: cannot read %s ELF file.\n",
-                                __func__, name);
+                pr_err("%s: cannot read %s ELF file.\n", __func__, name);
                 goto out_close;
         }
 
         if (gelf_getehdr(elf, &ehdr) == NULL) {
-                if (v)
-                        fprintf(stderr, "%s: cannot get elf header.\n", __func__);
+                pr_err("%s: cannot get elf header.\n", __func__);
                 goto out_elf_end;
         }
 
@@ -577,7 +958,7 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
         nr_syms = shdr.sh_size / shdr.sh_entsize;
 
         memset(&sym, 0, sizeof(sym));
-        if (!kernel) {
+        if (!self->kernel) {
                 self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
                                 elf_section_by_name(elf, &ehdr, &shdr,
                                                      ".gnu.prelink_undo",
@@ -586,14 +967,16 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
 
         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
                 struct symbol *f;
-                const char *elf_name;
-                char *demangled;
-                u64 obj_start;
-                struct section *section = NULL;
+                const char *elf_name = elf_sym__name(&sym, symstrs);
+                char *demangled = NULL;
                 int is_label = elf_sym__is_label(&sym);
                 const char *section_name;
 
-                if (!is_label && !elf_sym__is_function(&sym))
+                if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
+                    strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
+                        kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
+
+                if (!is_label && !elf_sym__is_a(&sym, map->type))
                         continue;
 
                 sec = elf_getscn(elf, sym.st_shndx);
@@ -602,55 +985,98 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
 
                 gelf_getshdr(sec, &shdr);
 
-                if (is_label && !elf_sec__is_text(&shdr, secstrs))
+                if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
                         continue;
 
                 section_name = elf_sec__name(&shdr, secstrs);
-                obj_start = sym.st_value;
 
-                if (self->adjust_symbols) {
-                        if (v >= 2)
-                                printf("adjusting symbol: st_value: %Lx sh_addr: %Lx sh_offset: %Lx\n",
-                                        (u64)sym.st_value, (u64)shdr.sh_addr, (u64)shdr.sh_offset);
+                if (self->kernel || kmodule) {
+                        char dso_name[PATH_MAX];
 
-                        sym.st_value -= shdr.sh_addr - shdr.sh_offset;
-                }
+                        if (strcmp(section_name,
+                                   (curr_dso->short_name +
+                                    self->short_name_len)) == 0)
+                                goto new_symbol;
 
-                if (mod) {
-                        section = mod->sections->find_section(mod->sections, section_name);
-                        if (section)
-                                sym.st_value += section->vma;
-                        else {
-                                fprintf(stderr, "dso__load_sym() module %s lookup of %s failed\n",
-                                        mod->name, section_name);
-                                goto out_elf_end;
+                        if (strcmp(section_name, ".text") == 0) {
+                                curr_map = map;
+                                curr_dso = self;
+                                goto new_symbol;
                         }
+
+                        snprintf(dso_name, sizeof(dso_name),
+                                 "%s%s", self->short_name, section_name);
+
+                        curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
+                        if (curr_map == NULL) {
+                                u64 start = sym.st_value;
+
+                                if (kmodule)
+                                        start += map->start + shdr.sh_offset;
+
+                                curr_dso = dso__new(dso_name);
+                                if (curr_dso == NULL)
+                                        goto out_elf_end;
+                                curr_map = map__new2(start, curr_dso,
+                                                     map->type);
+                                if (curr_map == NULL) {
+                                        dso__delete(curr_dso);
+                                        goto out_elf_end;
+                                }
+                                curr_map->map_ip = identity__map_ip;
+                                curr_map->unmap_ip = identity__map_ip;
+                                curr_dso->origin = DSO__ORIG_KERNEL;
+                                map_groups__insert(kmap->kmaps, curr_map);
+                                dsos__add(&dsos__kernel, curr_dso);
+                                dso__set_loaded(curr_dso, map->type);
+                        } else
+                                curr_dso = curr_map->dso;
+
+                        goto new_symbol;
+                }
+
+                if (curr_dso->adjust_symbols) {
+                        pr_debug4("%s: adjusting symbol: st_value: %#Lx "
+                                  "sh_addr: %#Lx sh_offset: %#Lx\n", __func__,
+                                  (u64)sym.st_value, (u64)shdr.sh_addr,
+                                  (u64)shdr.sh_offset);
+                        sym.st_value -= shdr.sh_addr - shdr.sh_offset;
                 }
                 /*
                  * We need to figure out if the object was created from C++ sources
                  * DWARF DW_compile_unit has this, but we don't always have access
                  * to it...
                  */
-                elf_name = elf_sym__name(&sym, symstrs);
                 demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
                 if (demangled != NULL)
                         elf_name = demangled;
-
-                f = symbol__new(sym.st_value, sym.st_size, elf_name,
-                                self->sym_priv_size, obj_start, v);
+new_symbol:
+                f = symbol__new(sym.st_value, sym.st_size, elf_name);
                 free(demangled);
                 if (!f)
                         goto out_elf_end;
 
-                if (filter && filter(self, f))
-                        symbol__delete(f, self->sym_priv_size);
+                if (filter && filter(curr_map, f))
+                        symbol__delete(f);
                 else {
-                        f->module = mod;
-                        dso__insert_symbol(self, f);
+                        symbols__insert(&curr_dso->symbols[curr_map->type], f);
                         nr++;
                 }
         }
 
+        /*
+         * For misannotated, zeroed, ASM function sizes.
+         */
+        if (nr > 0) {
+                symbols__fixup_end(&self->symbols[map->type]);
+                if (kmap) {
+                        /*
+                         * We need to fixup this here too because we create new
+                         * maps here, for things like vsyscall sections.
+                         */
+                        __map_groups__fixup_end(kmap->kmaps, map->type);
+                }
+        }
         err = nr;
 out_elf_end:
         elf_end(elf);
@@ -658,63 +1084,157 @@ out_close:
         return err;
 }
 
-#define BUILD_ID_SIZE 128
+static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
+{
+        return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
+}
 
-static char *dso__read_build_id(struct dso *self, int v)
+static bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 {
-        int i;
+        bool have_build_id = false;
+        struct dso *pos;
+
+        list_for_each_entry(pos, head, node) {
+                if (with_hits && !pos->hit)
+                        continue;
+                if (filename__read_build_id(pos->long_name, pos->build_id,
+                                            sizeof(pos->build_id)) > 0) {
+                        have_build_id     = true;
+                        pos->has_build_id = true;
+                }
+        }
+
+        return have_build_id;
+}
+
+bool dsos__read_build_ids(bool with_hits)
+{
+        bool kbuildids = __dsos__read_build_ids(&dsos__kernel, with_hits),
+             ubuildids = __dsos__read_build_ids(&dsos__user, with_hits);
+        return kbuildids || ubuildids;
+}
+
+/*
+ * Align offset to 4 bytes as needed for note name and descriptor data.
+ */
+#define NOTE_ALIGN(n) (((n) + 3) & -4U)
+
+int filename__read_build_id(const char *filename, void *bf, size_t size)
+{
+        int fd, err = -1;
         GElf_Ehdr ehdr;
         GElf_Shdr shdr;
-        Elf_Data *build_id_data;
+        Elf_Data *data;
         Elf_Scn *sec;
-        char *build_id = NULL, *bid;
-        unsigned char *raw;
+        Elf_Kind ek;
+        void *ptr;
         Elf *elf;
-        int fd = open(self->name, O_RDONLY);
 
+        if (size < BUILD_ID_SIZE)
+                goto out;
+
+        fd = open(filename, O_RDONLY);
         if (fd < 0)
                 goto out;
 
         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
         if (elf == NULL) {
-                if (v)
-                        fprintf(stderr, "%s: cannot read %s ELF file.\n",
-                                __func__, self->name);
+                pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
                 goto out_close;
         }
 
+        ek = elf_kind(elf);
+        if (ek != ELF_K_ELF)
+                goto out_elf_end;
+
         if (gelf_getehdr(elf, &ehdr) == NULL) {
-                if (v)
-                        fprintf(stderr, "%s: cannot get elf header.\n", __func__);
+                pr_err("%s: cannot get elf header.\n", __func__);
                 goto out_elf_end;
         }
 
-        sec = elf_section_by_name(elf, &ehdr, &shdr, ".note.gnu.build-id", NULL);
-        if (sec == NULL)
-                goto out_elf_end;
+        sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                  ".note.gnu.build-id", NULL);
+        if (sec == NULL) {
+                sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                          ".notes", NULL);
+                if (sec == NULL)
+                        goto out_elf_end;
+        }
 
-        build_id_data = elf_getdata(sec, NULL);
-        if (build_id_data == NULL)
+        data = elf_getdata(sec, NULL);
+        if (data == NULL)
                 goto out_elf_end;
-        build_id = malloc(BUILD_ID_SIZE);
-        if (build_id == NULL)
-                goto out_elf_end;
-        raw = build_id_data->d_buf + 16;
-        bid = build_id;
 
-        for (i = 0; i < 20; ++i) {
-                sprintf(bid, "%02x", *raw);
-                ++raw;
-                bid += 2;
+        ptr = data->d_buf;
+        while (ptr < (data->d_buf + data->d_size)) {
+                GElf_Nhdr *nhdr = ptr;
+                int namesz = NOTE_ALIGN(nhdr->n_namesz),
+                    descsz = NOTE_ALIGN(nhdr->n_descsz);
+                const char *name;
+
+                ptr += sizeof(*nhdr);
+                name = ptr;
+                ptr += namesz;
+                if (nhdr->n_type == NT_GNU_BUILD_ID &&
+                    nhdr->n_namesz == sizeof("GNU")) {
+                        if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
+                                memcpy(bf, ptr, BUILD_ID_SIZE);
+                                err = BUILD_ID_SIZE;
+                                break;
+                        }
+                }
+                ptr += descsz;
         }
-        if (v >= 2)
-                printf("%s(%s): %s\n", __func__, self->name, build_id);
 out_elf_end:
         elf_end(elf);
 out_close:
         close(fd);
 out:
-        return build_id;
+        return err;
+}
+
+int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
+{
+        int fd, err = -1;
+
+        if (size < BUILD_ID_SIZE)
+                goto out;
+
+        fd = open(filename, O_RDONLY);
+        if (fd < 0)
+                goto out;
+
+        while (1) {
+                char bf[BUFSIZ];
+                GElf_Nhdr nhdr;
+                int namesz, descsz;
+
+                if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
+                        break;
+
+                namesz = NOTE_ALIGN(nhdr.n_namesz);
+                descsz = NOTE_ALIGN(nhdr.n_descsz);
+                if (nhdr.n_type == NT_GNU_BUILD_ID &&
+                    nhdr.n_namesz == sizeof("GNU")) {
+                        if (read(fd, bf, namesz) != namesz)
+                                break;
+                        if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
+                                if (read(fd, build_id,
+                                    BUILD_ID_SIZE) == BUILD_ID_SIZE) {
+                                        err = 0;
+                                        break;
+                                }
+                        } else if (read(fd, bf, descsz) != descsz)
+                                break;
+                } else {
+                        int n = namesz + descsz;
+                        if (read(fd, bf, n) != n)
+                                break;
+                }
+        }
+        close(fd);
+out:
+        return err;
 }
 
 char dso__symtab_origin(const struct dso *self)
@@ -722,10 +1242,12 @@ char dso__symtab_origin(const struct dso *self)
         static const char origin[] = {
                 [DSO__ORIG_KERNEL] =   'k',
                 [DSO__ORIG_JAVA_JIT] = 'j',
+                [DSO__ORIG_BUILD_ID_CACHE] = 'B',
                 [DSO__ORIG_FEDORA] =   'f',
                 [DSO__ORIG_UBUNTU] =   'u',
                 [DSO__ORIG_BUILDID] =  'b',
                 [DSO__ORIG_DSO] =      'd',
+                [DSO__ORIG_KMODULE] =  'K',
         };
 
         if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
@@ -733,60 +1255,90 @@ char dso__symtab_origin(const struct dso *self)
         return origin[self->origin];
 }
 
-int dso__load(struct dso *self, symbol_filter_t filter, int v)
+int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
 {
         int size = PATH_MAX;
-        char *name = malloc(size), *build_id = NULL;
+        char *name;
+        u8 build_id[BUILD_ID_SIZE];
+        char build_id_hex[BUILD_ID_SIZE * 2 + 1];
         int ret = -1;
         int fd;
 
+        dso__set_loaded(self, map->type);
+
+        if (self->kernel)
+                return dso__load_kernel_sym(self, map, filter);
+
+        name = malloc(size);
         if (!name)
                 return -1;
 
         self->adjust_symbols = 0;
 
         if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
-                ret = dso__load_perf_map(self, filter, v);
+                ret = dso__load_perf_map(self, map, filter);
                 self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
                                          DSO__ORIG_NOT_FOUND;
                 return ret;
         }
 
-        self->origin = DSO__ORIG_FEDORA - 1;
+        self->origin = DSO__ORIG_BUILD_ID_CACHE;
 
+        if (self->has_build_id) {
+                build_id__sprintf(self->build_id, sizeof(self->build_id),
+                                  build_id_hex);
+                snprintf(name, size, "%s/%s/.build-id/%.2s/%s",
+                         getenv("HOME"), DEBUG_CACHE_DIR,
+                         build_id_hex, build_id_hex + 2);
+                goto open_file;
+        }
 more:
         do {
                 self->origin++;
                 switch (self->origin) {
                 case DSO__ORIG_FEDORA:
-                        snprintf(name, size, "/usr/lib/debug%s.debug", self->name);
+                        snprintf(name, size, "/usr/lib/debug%s.debug",
+                                 self->long_name);
                         break;
                 case DSO__ORIG_UBUNTU:
-                        snprintf(name, size, "/usr/lib/debug%s", self->name);
+                        snprintf(name, size, "/usr/lib/debug%s",
+                                 self->long_name);
                         break;
                 case DSO__ORIG_BUILDID:
-                        build_id = dso__read_build_id(self, v);
-                        if (build_id != NULL) {
+                        if (filename__read_build_id(self->long_name, build_id,
+                                                    sizeof(build_id))) {
+                                build_id__sprintf(build_id, sizeof(build_id),
+                                                  build_id_hex);
                                 snprintf(name, size,
                                          "/usr/lib/debug/.build-id/%.2s/%s.debug",
-                                        build_id, build_id + 2);
-                                free(build_id);
+                                        build_id_hex, build_id_hex + 2);
+                                if (self->has_build_id)
+                                        goto compare_build_id;
                                 break;
                         }
                         self->origin++;
                         /* Fall thru */
                 case DSO__ORIG_DSO:
-                        snprintf(name, size, "%s", self->name);
+                        snprintf(name, size, "%s", self->long_name);
                         break;
 
                 default:
                         goto out;
                 }
 
+                if (self->has_build_id) {
+                        if (filename__read_build_id(name, build_id,
+                                                    sizeof(build_id)) < 0)
+                                goto more;
+compare_build_id:
+                        if (!dso__build_id_equal(self, build_id))
+                                goto more;
+                }
+open_file:
                 fd = open(name, O_RDONLY);
         } while (fd < 0);
 
-        ret = dso__load_sym(self, fd, name, filter, v, NULL);
+        ret = dso__load_sym(self, map, name, fd, filter, 0);
         close(fd);
 
         /*
@@ -796,7 +1348,7 @@ more:
                 goto more;
 
         if (ret > 0) {
-                int nr_plt = dso__synthesize_plt_symbols(self, v);
+                int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
                 if (nr_plt > 0)
                         ret += nr_plt;
         }
@@ -807,231 +1359,608 @@ out:
         return ret;
 }
 
-static int dso__load_module(struct dso *self, struct mod_dso *mods, const char *name,
-                             symbol_filter_t filter, int v)
+struct map *map_groups__find_by_name(struct map_groups *self,
+                                     enum map_type type, const char *name)
 {
-        struct module *mod = mod_dso__find_module(mods, name);
-        int err = 0, fd;
+        struct rb_node *nd;
 
-        if (mod == NULL || !mod->active)
-                return err;
+        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
+                struct map *map = rb_entry(nd, struct map, rb_node);
 
-        fd = open(mod->path, O_RDONLY);
+                if (map->dso && strcmp(map->dso->short_name, name) == 0)
+                        return map;
+        }
 
-        if (fd < 0)
-                return err;
+        return NULL;
+}
 
-        err = dso__load_sym(self, fd, name, filter, v, mod);
-        close(fd);
+static int dso__kernel_module_get_build_id(struct dso *self)
+{
+        char filename[PATH_MAX];
+        /*
+         * kernel module short names are of the form "[module]" and
+         * we need just "module" here.
+         */
+        const char *name = self->short_name + 1;
 
-        return err;
+        snprintf(filename, sizeof(filename),
+                 "/sys/module/%.*s/notes/.note.gnu.build-id",
+                 (int)strlen(name - 1), name);
+
+        if (sysfs__read_build_id(filename, self->build_id,
+                                 sizeof(self->build_id)) == 0)
+                self->has_build_id = true;
+
+        return 0;
 }
 
-int dso__load_modules(struct dso *self, symbol_filter_t filter, int v)
+static int map_groups__set_modules_path_dir(struct map_groups *self, char *dirname)
 {
-        struct mod_dso *mods = mod_dso__new_dso("modules");
-        struct module *pos;
-        struct rb_node *next;
-        int err, count = 0;
+        struct dirent *dent;
+        DIR *dir = opendir(dirname);
 
-        err = mod_dso__load_modules(mods);
+        if (!dir) {
+                pr_debug("%s: cannot open %s dir\n", __func__, dirname);
+                return -1;
+        }
 
-        if (err <= 0)
-                return err;
+        while ((dent = readdir(dir)) != NULL) {
+                char path[PATH_MAX];
+
+                if (dent->d_type == DT_DIR) {
+                        if (!strcmp(dent->d_name, ".") ||
+                            !strcmp(dent->d_name, ".."))
+                                continue;
+
+                        snprintf(path, sizeof(path), "%s/%s",
+                                 dirname, dent->d_name);
+                        if (map_groups__set_modules_path_dir(self, path) < 0)
+                                goto failure;
+                } else {
+                        char *dot = strrchr(dent->d_name, '.'),
+                             dso_name[PATH_MAX];
+                        struct map *map;
+                        char *long_name;
+
+                        if (dot == NULL || strcmp(dot, ".ko"))
+                                continue;
+                        snprintf(dso_name, sizeof(dso_name), "[%.*s]",
+                                 (int)(dot - dent->d_name), dent->d_name);
+
+                        strxfrchar(dso_name, '-', '_');
+                        map = map_groups__find_by_name(self, MAP__FUNCTION, dso_name);
+                        if (map == NULL)
+                                continue;
+
+                        snprintf(path, sizeof(path), "%s/%s",
+                                 dirname, dent->d_name);
+
+                        long_name = strdup(path);
+                        if (long_name == NULL)
+                                goto failure;
+                        dso__set_long_name(map->dso, long_name);
+                        dso__kernel_module_get_build_id(map->dso);
+                }
+        }
 
-        /*
-         * Iterate over modules, and load active symbols.
-         */
-        next = rb_first(&mods->mods);
-        while (next) {
-                pos = rb_entry(next, struct module, rb_node);
-                err = dso__load_module(self, mods, pos->name, filter, v);
+        return 0;
+failure:
+        closedir(dir);
+        return -1;
+}
 
-                if (err < 0)
-                        break;
+static int map_groups__set_modules_path(struct map_groups *self)
+{
+        struct utsname uts;
+        char modules_path[PATH_MAX];
 
-                next = rb_next(&pos->rb_node);
-                count += err;
-        }
+        if (uname(&uts) < 0)
+                return -1;
+
+        snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
+                 uts.release);
+
+        return map_groups__set_modules_path_dir(self, modules_path);
+}
 
-        if (err < 0) {
-                mod_dso__delete_modules(mods);
-                mod_dso__delete_self(mods);
-                return err;
+/*
+ * Constructor variant for modules (where we know from /proc/modules where
+ * they are loaded) and for vmlinux, where only after we load all the
+ * symbols we'll know where it starts and ends.
+ */
+static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
+{
+        struct map *self = zalloc(sizeof(*self) +
+                                  (dso->kernel ? sizeof(struct kmap) : 0));
+        if (self != NULL) {
+                /*
+                 * ->end will be filled after we load all the symbols
+                 */
+                map__init(self, type, start, 0, 0, dso);
         }
 
-        return count;
+        return self;
 }
 
-static inline void dso__fill_symbol_holes(struct dso *self)
+struct map *map_groups__new_module(struct map_groups *self, u64 start,
+                                   const char *filename)
 {
-        struct symbol *prev = NULL;
-        struct rb_node *nd;
+        struct map *map;
+        struct dso *dso = __dsos__findnew(&dsos__kernel, filename);
 
-        for (nd = rb_last(&self->syms); nd; nd = rb_prev(nd)) {
-                struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
+        if (dso == NULL)
+                return NULL;
 
-                if (prev) {
-                        u64 hole = 0;
-                        int alias = pos->start == prev->start;
+        map = map__new2(start, dso, MAP__FUNCTION);
+        if (map == NULL)
+                return NULL;
 
-                        if (!alias)
-                                hole = prev->start - pos->end - 1;
+        dso->origin = DSO__ORIG_KMODULE;
+        map_groups__insert(self, map);
+        return map;
+}
 
-                        if (hole || alias) {
-                                if (alias)
-                                        pos->end = prev->end;
-                                else if (hole)
-                                        pos->end = prev->start - 1;
-                        }
-                }
-                prev = pos;
+static int map_groups__create_modules(struct map_groups *self)
+{
+        char *line = NULL;
+        size_t n;
+        FILE *file = fopen("/proc/modules", "r");
+        struct map *map;
+
+        if (file == NULL)
+                return -1;
+
+        while (!feof(file)) {
+                char name[PATH_MAX];
+                u64 start;
+                char *sep;
+                int line_len;
+
+                line_len = getline(&line, &n, file);
+                if (line_len < 0)
+                        break;
+
+                if (!line)
+                        goto out_failure;
+
+                line[--line_len] = '\0'; /* \n */
+
+                sep = strrchr(line, 'x');
+                if (sep == NULL)
+                        continue;
+
+                hex2u64(sep + 1, &start);
+
+                sep = strchr(line, ' ');
+                if (sep == NULL)
+                        continue;
+
+                *sep = '\0';
+
+                snprintf(name, sizeof(name), "[%s]", line);
+                map = map_groups__new_module(self, start, name);
+                if (map == NULL)
+                        goto out_delete_line;
+                dso__kernel_module_get_build_id(map->dso);
         }
+
+        free(line);
+        fclose(file);
+
+        return map_groups__set_modules_path(self);
+
+out_delete_line:
+        free(line);
+out_failure:
+        return -1;
 }
 
-static int dso__load_vmlinux(struct dso *self, const char *vmlinux,
-                             symbol_filter_t filter, int v)
+static int dso__load_vmlinux(struct dso *self, struct map *map,
+                             const char *vmlinux, symbol_filter_t filter)
 {
-        int err, fd = open(vmlinux, O_RDONLY);
+        int err = -1, fd;
+
+        if (self->has_build_id) {
+                u8 build_id[BUILD_ID_SIZE];
+
+                if (filename__read_build_id(vmlinux, build_id,
+                                            sizeof(build_id)) < 0) {
+                        pr_debug("No build_id in %s, ignoring it\n", vmlinux);
+                        return -1;
+                }
+                if (!dso__build_id_equal(self, build_id)) {
+                        char expected_build_id[BUILD_ID_SIZE * 2 + 1],
+                             vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];
+
+                        build_id__sprintf(self->build_id,
+                                          sizeof(self->build_id),
+                                          expected_build_id);
+                        build_id__sprintf(build_id, sizeof(build_id),
+                                          vmlinux_build_id);
+                        pr_debug("build_id in %s is %s while expected is %s, "
+                                 "ignoring it\n", vmlinux, vmlinux_build_id,
+                                 expected_build_id);
+                        return -1;
+                }
+        }
 
+        fd = open(vmlinux, O_RDONLY);
         if (fd < 0)
                 return -1;
 
-        err = dso__load_sym(self, fd, vmlinux, filter, v, NULL);
+        dso__set_loaded(self, map->type);
+        err = dso__load_sym(self, map, vmlinux, fd, filter, 0);
+        close(fd);
 
         if (err > 0)
-                dso__fill_symbol_holes(self);
+                pr_debug("Using %s for symbols\n", vmlinux);
 
-        close(fd);
+        return err;
+}
+
+int dso__load_vmlinux_path(struct dso *self, struct map *map,
+                           symbol_filter_t filter)
+{
+        int i, err = 0;
+
+        pr_debug("Looking at the vmlinux_path (%d entries long)\n",
+                 vmlinux_path__nr_entries);
+
+        for (i = 0; i < vmlinux_path__nr_entries; ++i) {
+                err = dso__load_vmlinux(self, map, vmlinux_path[i], filter);
+                if (err > 0) {
+                        dso__set_long_name(self, strdup(vmlinux_path[i]));
+                        break;
+                }
+        }
 
         return err;
 }
 
-int dso__load_kernel(struct dso *self, const char *vmlinux,
-                     symbol_filter_t filter, int v, int use_modules)
+static int dso__load_kernel_sym(struct dso *self, struct map *map,
+                                symbol_filter_t filter)
 {
-        int err = -1;
+        int err;
+        const char *kallsyms_filename = NULL;
+        char *kallsyms_allocated_filename = NULL;
+        /*
+         * Step 1: if the user specified a vmlinux filename, use it and only
+         * it, reporting errors to the user if it cannot be used.
+         *
+         * For instance, try to analyse an ARM perf.data file _without_ a
+         * build-id, or if the user specifies the wrong path to the right
+         * vmlinux file, obviously we can't fallback to another vmlinux (a
+         * x86_86 one, on the machine where analysis is being performed, say),
+         * or worse, /proc/kallsyms.
+         *
+         * If the specified file _has_ a build-id and there is a build-id
+         * section in the perf.data file, we will still do the expected
+         * validation in dso__load_vmlinux and will bail out if they don't
+         * match.
+         */
+        if (symbol_conf.vmlinux_name != NULL) {
+                err = dso__load_vmlinux(self, map,
+                                        symbol_conf.vmlinux_name, filter);
+                goto out_try_fixup;
+        }
 
-        if (vmlinux) {
-                err = dso__load_vmlinux(self, vmlinux, filter, v);
-                if (err > 0 && use_modules) {
-                        int syms = dso__load_modules(self, filter, v);
+        if (vmlinux_path != NULL) {
+                err = dso__load_vmlinux_path(self, map, filter);
+                if (err > 0)
+                        goto out_fixup;
+        }
 
-                        if (syms < 0) {
-                                fprintf(stderr, "dso__load_modules failed!\n");
-                                return syms;
+        /*
+         * Say the kernel DSO was created when processing the build-id header table,
+         * we have a build-id, so check if it is the same as the running kernel,
+         * using it if it is.
+         */
+        if (self->has_build_id) {
+                u8 kallsyms_build_id[BUILD_ID_SIZE];
+                char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+                if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
+                                         sizeof(kallsyms_build_id)) == 0) {
+                        if (dso__build_id_equal(self, kallsyms_build_id)) {
+                                kallsyms_filename = "/proc/kallsyms";
+                                goto do_kallsyms;
                         }
-                        err += syms;
                 }
-        }
+                /*
+                 * Now look if we have it on the build-id cache in
+                 * $HOME/.debug/[kernel.kallsyms].
+                 */
+                build_id__sprintf(self->build_id, sizeof(self->build_id),
+                                  sbuild_id);
+
+                if (asprintf(&kallsyms_allocated_filename,
+                             "%s/.debug/[kernel.kallsyms]/%s",
+                             getenv("HOME"), sbuild_id) == -1) {
+                        pr_err("Not enough memory for kallsyms file lookup\n");
+                        return -1;
+                }
 
-        if (err <= 0)
-                err = dso__load_kallsyms(self, filter, v);
+                kallsyms_filename = kallsyms_allocated_filename;
 
+                if (access(kallsyms_filename, F_OK)) {
+                        pr_err("No kallsyms or vmlinux with build-id %s "
+                               "was found\n", sbuild_id);
+                        free(kallsyms_allocated_filename);
+                        return -1;
+                }
+        } else {
+                /*
+                 * Last resort, if we don't have a build-id and couldn't find
+                 * any vmlinux file, try the running kernel kallsyms table.
+                 */
+                kallsyms_filename = "/proc/kallsyms";
+        }
+
+do_kallsyms:
+        err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
         if (err > 0)
-                self->origin = DSO__ORIG_KERNEL;
+                pr_debug("Using %s for symbols\n", kallsyms_filename);
+        free(kallsyms_allocated_filename);
+
+out_try_fixup:
+        if (err > 0) {
+out_fixup:
+                if (kallsyms_filename != NULL)
+                        dso__set_long_name(self, strdup("[kernel.kallsyms]"));
+                map__fixup_start(map);
+                map__fixup_end(map);
+        }
 
         return err;
 }
 
-LIST_HEAD(dsos);
-struct dso      *kernel_dso;
-struct dso      *vdso;
-struct dso      *hypervisor_dso;
-
-const char      *vmlinux_name = "vmlinux";
-int             modules;
+LIST_HEAD(dsos__user);
+LIST_HEAD(dsos__kernel);
 
-static void dsos__add(struct dso *dso)
+static void dsos__add(struct list_head *head, struct dso *dso)
 {
-        list_add_tail(&dso->node, &dsos);
+        list_add_tail(&dso->node, head);
 }
 
-static struct dso *dsos__find(const char *name)
+static struct dso *dsos__find(struct list_head *head, const char *name)
 {
         struct dso *pos;
 
-        list_for_each_entry(pos, &dsos, node)
-                if (strcmp(pos->name, name) == 0)
+        list_for_each_entry(pos, head, node)
+                if (strcmp(pos->long_name, name) == 0)
                         return pos;
         return NULL;
 }
 
-struct dso *dsos__findnew(const char *name)
+struct dso *__dsos__findnew(struct list_head *head, const char *name)
 {
-        struct dso *dso = dsos__find(name);
-        int nr;
-
-        if (dso)
-                return dso;
-
-        dso = dso__new(name, 0);
-        if (!dso)
-                goto out_delete_dso;
+        struct dso *dso = dsos__find(head, name);
 
-        nr = dso__load(dso, NULL, verbose);
-        if (nr < 0) {
-                eprintf("Failed to open: %s\n", name);
-                goto out_delete_dso;
+        if (!dso) {
+                dso = dso__new(name);
+                if (dso != NULL) {
+                        dsos__add(head, dso);
+                        dso__set_basename(dso);
+                }
         }
-        if (!nr)
-                eprintf("No symbols found in: %s, maybe install a debug package?\n", name);
-
-        dsos__add(dso);
 
         return dso;
+}
 
-out_delete_dso:
-        dso__delete(dso);
-        return NULL;
+static void __dsos__fprintf(struct list_head *head, FILE *fp)
+{
+        struct dso *pos;
+
+        list_for_each_entry(pos, head, node) {
+                int i;
+                for (i = 0; i < MAP__NR_TYPES; ++i)
+                        dso__fprintf(pos, i, fp);
+        }
 }
 
 void dsos__fprintf(FILE *fp)
 {
+        __dsos__fprintf(&dsos__kernel, fp);
+        __dsos__fprintf(&dsos__user, fp);
+}
+
+static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
+                                      bool with_hits)
+{
         struct dso *pos;
+        size_t ret = 0;
 
-        list_for_each_entry(pos, &dsos, node)
-                dso__fprintf(pos, fp);
+        list_for_each_entry(pos, head, node) {
+                if (with_hits && !pos->hit)
+                        continue;
+                ret += dso__fprintf_buildid(pos, fp);
+                ret += fprintf(fp, " %s\n", pos->long_name);
+        }
+        return ret;
 }
 
-static struct symbol *vdso__find_symbol(struct dso *dso, u64 ip)
+size_t dsos__fprintf_buildid(FILE *fp, bool with_hits)
 {
-        return dso__find_symbol(dso, ip);
+        return (__dsos__fprintf_buildid(&dsos__kernel, fp, with_hits) +
+                __dsos__fprintf_buildid(&dsos__user, fp, with_hits));
 }
 
-int load_kernel(void)
+struct dso *dso__new_kernel(const char *name)
 {
-        int err;
+        struct dso *self = dso__new(name ?: "[kernel.kallsyms]");
 
-        kernel_dso = dso__new("[kernel]", 0);
-        if (!kernel_dso)
-                return -1;
+        if (self != NULL) {
+                dso__set_short_name(self, "[kernel]");
+                self->kernel     = 1;
+        }
 
-        err = dso__load_kernel(kernel_dso, vmlinux_name, NULL, verbose, modules);
-        if (err <= 0) {
-                dso__delete(kernel_dso);
-                kernel_dso = NULL;
-        } else
-                dsos__add(kernel_dso);
+        return self;
+}
 
-        vdso = dso__new("[vdso]", 0);
-        if (!vdso)
-                return -1;
+void dso__read_running_kernel_build_id(struct dso *self)
+{
+        if (sysfs__read_build_id("/sys/kernel/notes", self->build_id,
+                                 sizeof(self->build_id)) == 0)
+                self->has_build_id = true;
+}
+
+static struct dso *dsos__create_kernel(const char *vmlinux)
+{
+        struct dso *kernel = dso__new_kernel(vmlinux);
+
+        if (kernel != NULL) {
+                dso__read_running_kernel_build_id(kernel);
+                dsos__add(&dsos__kernel, kernel);
+        }
+
+        return kernel;
+}
+
+int __map_groups__create_kernel_maps(struct map_groups *self,
+                                     struct map *vmlinux_maps[MAP__NR_TYPES],
+                                     struct dso *kernel)
+{
+        enum map_type type;
+
+        for (type = 0; type < MAP__NR_TYPES; ++type) {
+                struct kmap *kmap;
+
+                vmlinux_maps[type] = map__new2(0, kernel, type);
+                if (vmlinux_maps[type] == NULL)
+                        return -1;
+
+                vmlinux_maps[type]->map_ip =
+                        vmlinux_maps[type]->unmap_ip = identity__map_ip;
+
+                kmap = map__kmap(vmlinux_maps[type]);
+                kmap->kmaps = self;
+                map_groups__insert(self, vmlinux_maps[type]);
+        }
+
+        return 0;
+}
+
+static void vmlinux_path__exit(void)
+{
+        while (--vmlinux_path__nr_entries >= 0) {
+                free(vmlinux_path[vmlinux_path__nr_entries]);
+                vmlinux_path[vmlinux_path__nr_entries] = NULL;
+        }
 
-        vdso->find_symbol = vdso__find_symbol;
+        free(vmlinux_path);
+        vmlinux_path = NULL;
+}
 
-        dsos__add(vdso);
+static int vmlinux_path__init(void)
+{
+        struct utsname uts;
+        char bf[PATH_MAX];
 
-        hypervisor_dso = dso__new("[hypervisor]", 0);
-        if (!hypervisor_dso)
+        if (uname(&uts) < 0)
                 return -1;
-        dsos__add(hypervisor_dso);
 
-        return err;
+        vmlinux_path = malloc(sizeof(char *) * 5);
+        if (vmlinux_path == NULL)
+                return -1;
+
+        vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+        vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+        snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
+        vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+        snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
+        vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+        snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
+                 uts.release);
+        vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
+        if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
+                goto out_fail;
+        ++vmlinux_path__nr_entries;
+
+        return 0;
+
+out_fail:
+        vmlinux_path__exit();
+        return -1;
 }
 
+static int setup_list(struct strlist **list, const char *list_str,
+                      const char *list_name)
+{
+        if (list_str == NULL)
+                return 0;
+
+        *list = strlist__new(true, list_str);
+        if (!*list) {
+                pr_err("problems parsing %s list\n", list_name);
+                return -1;
+        }
+        return 0;
+}
 
-void symbol__init(void)
+int symbol__init(void)
 {
         elf_version(EV_CURRENT);
+        if (symbol_conf.sort_by_name)
+                symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
+                                          sizeof(struct symbol));
+
+        if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
+                return -1;
+
+        if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
+                pr_err("'.' is the only non valid --field-separator argument\n");
+                return -1;
+        }
+
+        if (setup_list(&symbol_conf.dso_list,
+                       symbol_conf.dso_list_str, "dso") < 0)
+                return -1;
+
+        if (setup_list(&symbol_conf.comm_list,
+                       symbol_conf.comm_list_str, "comm") < 0)
+                goto out_free_dso_list;
+
+        if (setup_list(&symbol_conf.sym_list,
+                       symbol_conf.sym_list_str, "symbol") < 0)
+                goto out_free_comm_list;
+
+        return 0;
+
+out_free_dso_list:
+        strlist__delete(symbol_conf.dso_list);
+out_free_comm_list:
+        strlist__delete(symbol_conf.comm_list);
+        return -1;
+}
+
+int map_groups__create_kernel_maps(struct map_groups *self,
+                                   struct map *vmlinux_maps[MAP__NR_TYPES])
+{
+        struct dso *kernel = dsos__create_kernel(symbol_conf.vmlinux_name);
+
+        if (kernel == NULL)
+                return -1;
+
+        if (__map_groups__create_kernel_maps(self, vmlinux_maps, kernel) < 0)
+                return -1;
+
+        if (symbol_conf.use_modules && map_groups__create_modules(self) < 0)
+                pr_debug("Problems creating module maps, continuing anyway...\n");
+        /*
+         * Now that we have all the maps created, just set the ->end of them:
+         */
+        map_groups__fixup_end(self);
+        return 0;
 }
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 829da9edba64..f30a37428919 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -1,13 +1,15 @@
-#ifndef _PERF_SYMBOL_
-#define _PERF_SYMBOL_ 1
+#ifndef __PERF_SYMBOL
+#define __PERF_SYMBOL 1
 
 #include <linux/types.h>
+#include <stdbool.h>
 #include "types.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
-#include "module.h"
 #include "event.h"
 
+#define DEBUG_CACHE_DIR ".debug"
+
 #ifdef HAVE_CPLUS_DEMANGLE
 extern char *cplus_demangle(const char *, int);
 
@@ -46,57 +48,125 @@ struct symbol {
         struct rb_node  rb_node;
         u64             start;
         u64             end;
-        u64             obj_start;
-        u64             hist_sum;
-        u64             *hist;
-        struct module   *module;
-        void            *priv;
         char            name[0];
 };
 
+void symbol__delete(struct symbol *self);
+
+struct strlist;
+
+struct symbol_conf {
+        unsigned short  priv_size;
+        bool            try_vmlinux_path,
+                        use_modules,
+                        sort_by_name,
+                        show_nr_samples,
+                        use_callchain,
+                        exclude_other,
+                        full_paths;
+        const char      *vmlinux_name,
+                        *field_sep;
+        char            *dso_list_str,
+                        *comm_list_str,
+                        *sym_list_str,
+                        *col_width_list_str;
+       struct strlist   *dso_list,
+                        *comm_list,
+                        *sym_list;
+};
+
+extern struct symbol_conf symbol_conf;
+
+static inline void *symbol__priv(struct symbol *self)
+{
+        return ((void *)self) - symbol_conf.priv_size;
+}
+
+struct ref_reloc_sym {
+        const char      *name;
+        u64             addr;
+        u64             unrelocated_addr;
+};
+
+struct addr_location {
+        struct thread *thread;
+        struct map    *map;
+        struct symbol *sym;
+        u64           addr;
+        char          level;
+        bool          filtered;
+};
+
 struct dso {
         struct list_head node;
-        struct rb_root   syms;
-        struct symbol    *(*find_symbol)(struct dso *, u64 ip);
-        unsigned int     sym_priv_size;
-        unsigned char    adjust_symbols;
-        unsigned char    slen_calculated;
+        struct rb_root   symbols[MAP__NR_TYPES];
+        struct rb_root   symbol_names[MAP__NR_TYPES];
+        u8               adjust_symbols:1;
+        u8               slen_calculated:1;
+        u8               has_build_id:1;
+        u8               kernel:1;
+        u8               hit:1;
         unsigned char    origin;
+        u8               sorted_by_name;
+        u8               loaded;
+        u8               build_id[BUILD_ID_SIZE];
+        const char       *short_name;
+        char             *long_name;
+        u16              long_name_len;
+        u16              short_name_len;
         char             name[0];
 };
 
-extern const char *sym_hist_filter;
-
-typedef int (*symbol_filter_t)(struct dso *self, struct symbol *sym);
-
-struct dso *dso__new(const char *name, unsigned int sym_priv_size);
+struct dso *dso__new(const char *name);
+struct dso *dso__new_kernel(const char *name);
 void dso__delete(struct dso *self);
 
-static inline void *dso__sym_priv(struct dso *self, struct symbol *sym)
+bool dso__loaded(const struct dso *self, enum map_type type);
+bool dso__sorted_by_name(const struct dso *self, enum map_type type);
+
+static inline void dso__set_loaded(struct dso *self, enum map_type type)
 {
-        return ((void *)sym) - self->sym_priv_size;
+        self->loaded |= (1 << type);
 }
 
-struct symbol *dso__find_symbol(struct dso *self, u64 ip);
+void dso__sort_by_name(struct dso *self, enum map_type type);
 
-int dso__load_kernel(struct dso *self, const char *vmlinux,
-                     symbol_filter_t filter, int verbose, int modules);
-int dso__load_modules(struct dso *self, symbol_filter_t filter, int verbose);
-int dso__load(struct dso *self, symbol_filter_t filter, int verbose);
-struct dso *dsos__findnew(const char *name);
-void dsos__fprintf(FILE *fp);
+extern struct list_head dsos__user, dsos__kernel;
 
-size_t dso__fprintf(struct dso *self, FILE *fp);
-char dso__symtab_origin(const struct dso *self);
+struct dso *__dsos__findnew(struct list_head *head, const char *name);
 
-int load_kernel(void);
+static inline struct dso *dsos__findnew(const char *name)
+{
+        return __dsos__findnew(&dsos__user, name);
+}
 
-void symbol__init(void);
+int dso__load(struct dso *self, struct map *map, symbol_filter_t filter);
+int dso__load_vmlinux_path(struct dso *self, struct map *map,
+                           symbol_filter_t filter);
+int dso__load_kallsyms(struct dso *self, const char *filename, struct map *map,
+                       symbol_filter_t filter);
+void dsos__fprintf(FILE *fp);
+size_t dsos__fprintf_buildid(FILE *fp, bool with_hits);
 
-extern struct list_head dsos;
-extern struct dso *kernel_dso;
-extern struct dso *vdso;
-extern struct dso *hypervisor_dso;
-extern const char *vmlinux_name;
-extern int   modules;
-#endif /* _PERF_SYMBOL_ */
+size_t dso__fprintf_buildid(struct dso *self, FILE *fp);
+size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp);
+char dso__symtab_origin(const struct dso *self);
+void dso__set_long_name(struct dso *self, char *name);
+void dso__set_build_id(struct dso *self, void *build_id);
+void dso__read_running_kernel_build_id(struct dso *self);
+struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr);
+struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
+                                        const char *name);
+
+int filename__read_build_id(const char *filename, void *bf, size_t size);
+int sysfs__read_build_id(const char *filename, void *bf, size_t size);
+bool dsos__read_build_ids(bool with_hits);
+int build_id__sprintf(const u8 *self, int len, char *bf);
+int kallsyms__parse(const char *filename, void *arg,
+                    int (*process_symbol)(void *arg, const char *name,
+                                          char type, u64 start));
+
+int symbol__init(void);
+bool symbol_type__is_a(char symbol_type, enum map_type map_type);
+
+#endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 45efb5db0d19..fa968312ee7d 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -2,48 +2,151 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include "session.h"
 #include "thread.h"
 #include "util.h"
 #include "debug.h"
 
+void map_groups__init(struct map_groups *self)
+{
+        int i;
+        for (i = 0; i < MAP__NR_TYPES; ++i) {
+                self->maps[i] = RB_ROOT;
+                INIT_LIST_HEAD(&self->removed_maps[i]);
+        }
+}
+
 static struct thread *thread__new(pid_t pid)
 {
-        struct thread *self = calloc(1, sizeof(*self));
+        struct thread *self = zalloc(sizeof(*self));
 
         if (self != NULL) {
+                map_groups__init(&self->mg);
                 self->pid = pid;
                 self->comm = malloc(32);
                 if (self->comm)
                         snprintf(self->comm, 32, ":%d", self->pid);
-                INIT_LIST_HEAD(&self->maps);
         }
 
         return self;
 }
 
+static void map_groups__flush(struct map_groups *self)
+{
+        int type;
+
+        for (type = 0; type < MAP__NR_TYPES; type++) {
+                struct rb_root *root = &self->maps[type];
+                struct rb_node *next = rb_first(root);
+
+                while (next) {
+                        struct map *pos = rb_entry(next, struct map, rb_node);
+                        next = rb_next(&pos->rb_node);
+                        rb_erase(&pos->rb_node, root);
+                        /*
+                         * We may have references to this map, for
+                         * instance in some hist_entry instances, so
+                         * just move them to a separate list.
+                         */
+                        list_add_tail(&pos->node, &self->removed_maps[pos->type]);
+                }
+        }
+}
+
 int thread__set_comm(struct thread *self, const char *comm)
 {
+        int err;
+
         if (self->comm)
                 free(self->comm);
         self->comm = strdup(comm);
-        return self->comm ? 0 : -ENOMEM;
+        err = self->comm == NULL ? -ENOMEM : 0;
+        if (!err) {
+                self->comm_set = true;
+                map_groups__flush(&self->mg);
+        }
+        return err;
 }
 
-static size_t thread__fprintf(struct thread *self, FILE *fp)
+int thread__comm_len(struct thread *self)
+{
+        if (!self->comm_len) {
+                if (!self->comm)
+                        return 0;
+                self->comm_len = strlen(self->comm);
+        }
+
+        return self->comm_len;
+}
+
+size_t __map_groups__fprintf_maps(struct map_groups *self,
+                                  enum map_type type, FILE *fp)
+{
+        size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
+        struct rb_node *nd;
+
+        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node);
+                printed += fprintf(fp, "Map:");
+                printed += map__fprintf(pos, fp);
+                if (verbose > 2) {
+                        printed += dso__fprintf(pos->dso, type, fp);
+                        printed += fprintf(fp, "--\n");
+                }
+        }
+
+        return printed;
+}
+
+size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp)
+{
+        size_t printed = 0, i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                printed += __map_groups__fprintf_maps(self, i, fp);
+        return printed;
+}
+
+static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
+                                                 enum map_type type, FILE *fp)
 {
         struct map *pos;
-        size_t ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
+        size_t printed = 0;
+
+        list_for_each_entry(pos, &self->removed_maps[type], node) {
+                printed += fprintf(fp, "Map:");
+                printed += map__fprintf(pos, fp);
+                if (verbose > 1) {
+                        printed += dso__fprintf(pos->dso, type, fp);
+                        printed += fprintf(fp, "--\n");
+                }
+        }
+        return printed;
+}
 
-        list_for_each_entry(pos, &self->maps, node)
-                ret += map__fprintf(pos, fp);
+static size_t map_groups__fprintf_removed_maps(struct map_groups *self, FILE *fp)
+{
+        size_t printed = 0, i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                printed += __map_groups__fprintf_removed_maps(self, i, fp);
+        return printed;
+}
 
-        return ret;
+static size_t map_groups__fprintf(struct map_groups *self, FILE *fp)
+{
+        size_t printed = map_groups__fprintf_maps(self, fp);
+        printed += fprintf(fp, "Removed maps:\n");
+        return printed + map_groups__fprintf_removed_maps(self, fp);
 }
 
-struct thread *
-threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
+static size_t thread__fprintf(struct thread *self, FILE *fp)
+{
+        return fprintf(fp, "Thread %d %s\n", self->pid, self->comm) +
+               map_groups__fprintf(&self->mg, fp);
+}
+
+struct thread *perf_session__findnew(struct perf_session *self, pid_t pid)
 {
-        struct rb_node **p = &threads->rb_node;
+        struct rb_node **p = &self->threads.rb_node;
         struct rb_node *parent = NULL;
         struct thread *th;
 
@@ -52,15 +155,15 @@ threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
          * so most of the time we dont have to look up
          * the full rbtree:
          */
-        if (*last_match && (*last_match)->pid == pid)
-                return *last_match;
+        if (self->last_match && self->last_match->pid == pid)
+                return self->last_match;
 
         while (*p != NULL) {
                 parent = *p;
                 th = rb_entry(parent, struct thread, rb_node);
 
                 if (th->pid == pid) {
-                        *last_match = th;
+                        self->last_match = th;
                         return th;
                 }
 
@@ -73,99 +176,159 @@ threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
         th = thread__new(pid);
         if (th != NULL) {
                 rb_link_node(&th->rb_node, parent, p);
-                rb_insert_color(&th->rb_node, threads);
-                *last_match = th;
+                rb_insert_color(&th->rb_node, &self->threads);
+                self->last_match = th;
         }
 
         return th;
 }
 
-struct thread *
-register_idle_thread(struct rb_root *threads, struct thread **last_match)
+static int map_groups__fixup_overlappings(struct map_groups *self,
+                                          struct map *map)
 {
-        struct thread *thread = threads__findnew(0, threads, last_match);
+        struct rb_root *root = &self->maps[map->type];
+        struct rb_node *next = rb_first(root);
+
+        while (next) {
+                struct map *pos = rb_entry(next, struct map, rb_node);
+                next = rb_next(&pos->rb_node);
+
+                if (!map__overlap(pos, map))
+                        continue;
+
+                if (verbose >= 2) {
+                        fputs("overlapping maps:\n", stderr);
+                        map__fprintf(map, stderr);
+                        map__fprintf(pos, stderr);
+                }
+
+                rb_erase(&pos->rb_node, root);
+                /*
+                 * We may have references to this map, for instance in some
+                 * hist_entry instances, so just move them to a separate
+                 * list.
+                 */
+                list_add_tail(&pos->node, &self->removed_maps[map->type]);
+                /*
+                 * Now check if we need to create new maps for areas not
+                 * overlapped by the new map:
+                 */
+                if (map->start > pos->start) {
+                        struct map *before = map__clone(pos);
+
+                        if (before == NULL)
+                                return -ENOMEM;
+
+                        before->end = map->start - 1;
+                        map_groups__insert(self, before);
+                        if (verbose >= 2)
+                                map__fprintf(before, stderr);
+                }
+
+                if (map->end < pos->end) {
+                        struct map *after = map__clone(pos);
 
-        if (!thread || thread__set_comm(thread, "swapper")) {
-                fprintf(stderr, "problem inserting idle task.\n");
-                exit(-1);
+                        if (after == NULL)
+                                return -ENOMEM;
+
+                        after->start = map->end + 1;
+                        map_groups__insert(self, after);
+                        if (verbose >= 2)
+                                map__fprintf(after, stderr);
+                }
         }
 
-        return thread;
+        return 0;
 }
 
-void thread__insert_map(struct thread *self, struct map *map)
+void maps__insert(struct rb_root *maps, struct map *map)
 {
-        struct map *pos, *tmp;
-
-        list_for_each_entry_safe(pos, tmp, &self->maps, node) {
-                if (map__overlap(pos, map)) {
-                        if (verbose >= 2) {
-                                printf("overlapping maps:\n");
-                                map__fprintf(map, stdout);
-                                map__fprintf(pos, stdout);
-                        }
+        struct rb_node **p = &maps->rb_node;
+        struct rb_node *parent = NULL;
+        const u64 ip = map->start;
+        struct map *m;
 
-                        if (map->start <= pos->start && map->end > pos->start)
-                                pos->start = map->end;
+        while (*p != NULL) {
+                parent = *p;
+                m = rb_entry(parent, struct map, rb_node);
+                if (ip < m->start)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
 
-                        if (map->end >= pos->end && map->start < pos->end)
-                                pos->end = map->start;
+        rb_link_node(&map->rb_node, parent, p);
+        rb_insert_color(&map->rb_node, maps);
+}
 
-                        if (verbose >= 2) {
-                                printf("after collision:\n");
-                                map__fprintf(pos, stdout);
-                        }
+struct map *maps__find(struct rb_root *maps, u64 ip)
+{
+        struct rb_node **p = &maps->rb_node;
+        struct rb_node *parent = NULL;
+        struct map *m;
 
-                        if (pos->start >= pos->end) {
-                                list_del_init(&pos->node);
-                                free(pos);
-                        }
-                }
+        while (*p != NULL) {
+                parent = *p;
+                m = rb_entry(parent, struct map, rb_node);
+                if (ip < m->start)
+                        p = &(*p)->rb_left;
+                else if (ip > m->end)
+                        p = &(*p)->rb_right;
+                else
+                        return m;
         }
 
-        list_add_tail(&map->node, &self->maps);
+        return NULL;
 }
 
-int thread__fork(struct thread *self, struct thread *parent)
+void thread__insert_map(struct thread *self, struct map *map)
 {
-        struct map *map;
-
-        if (self->comm)
-                free(self->comm);
-        self->comm = strdup(parent->comm);
-        if (!self->comm)
-                return -ENOMEM;
+        map_groups__fixup_overlappings(&self->mg, map);
+        map_groups__insert(&self->mg, map);
+}
 
-        list_for_each_entry(map, &parent->maps, node) {
+/*
+ * XXX This should not really _copy_ te maps, but refcount them.
+ */
+static int map_groups__clone(struct map_groups *self,
+                             struct map_groups *parent, enum map_type type)
+{
+        struct rb_node *nd;
+        for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
+                struct map *map = rb_entry(nd, struct map, rb_node);
                 struct map *new = map__clone(map);
-                if (!new)
+                if (new == NULL)
                         return -ENOMEM;
-                thread__insert_map(self, new);
+                map_groups__insert(self, new);
         }
-
         return 0;
 }
 
-struct map *thread__find_map(struct thread *self, u64 ip)
+int thread__fork(struct thread *self, struct thread *parent)
 {
-        struct map *pos;
-
-        if (self == NULL)
-                return NULL;
+        int i;
 
-        list_for_each_entry(pos, &self->maps, node)
-                if (ip >= pos->start && ip <= pos->end)
-                        return pos;
+        if (parent->comm_set) {
+                if (self->comm)
+                        free(self->comm);
+                self->comm = strdup(parent->comm);
+                if (!self->comm)
+                        return -ENOMEM;
+                self->comm_set = true;
+        }
 
-        return NULL;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                if (map_groups__clone(&self->mg, &parent->mg, i) < 0)
+                        return -ENOMEM;
+        return 0;
 }
 
-size_t threads__fprintf(FILE *fp, struct rb_root *threads)
+size_t perf_session__fprintf(struct perf_session *self, FILE *fp)
 {
         size_t ret = 0;
         struct rb_node *nd;
 
-        for (nd = rb_first(threads); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&self->threads); nd; nd = rb_next(nd)) {
                 struct thread *pos = rb_entry(nd, struct thread, rb_node);
 
                 ret += thread__fprintf(pos, fp);
@@ -173,3 +336,15 @@ size_t threads__fprintf(FILE *fp, struct rb_root *threads)
 
         return ret;
 }
+
+struct symbol *map_groups__find_symbol(struct map_groups *self,
+                                       enum map_type type, u64 addr,
+                                       symbol_filter_t filter)
+{
+        struct map *map = map_groups__find(self, type, addr);
+
+        if (map != NULL)
+                return map__find_symbol(map, map->map_ip(map, addr), filter);
+
+        return NULL;
+}
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 32aea3c1c2ad..dcf70303e58e 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -1,22 +1,87 @@
+#ifndef __PERF_THREAD_H
+#define __PERF_THREAD_H
+
 #include <linux/rbtree.h>
-#include <linux/list.h>
 #include <unistd.h>
 #include "symbol.h"
 
+struct map_groups {
+        struct rb_root          maps[MAP__NR_TYPES];
+        struct list_head        removed_maps[MAP__NR_TYPES];
+};
+
+size_t __map_groups__fprintf_maps(struct map_groups *self,
+                                  enum map_type type, FILE *fp);
+
 struct thread {
         struct rb_node          rb_node;
-        struct list_head        maps;
+        struct map_groups       mg;
         pid_t                   pid;
         char                    shortname[3];
+        bool                    comm_set;
         char                    *comm;
+        int                     comm_len;
 };
 
+void map_groups__init(struct map_groups *self);
 int thread__set_comm(struct thread *self, const char *comm);
-struct thread *
-threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match);
-struct thread *
-register_idle_thread(struct rb_root *threads, struct thread **last_match);
+int thread__comm_len(struct thread *self);
+struct thread *perf_session__findnew(struct perf_session *self, pid_t pid);
 void thread__insert_map(struct thread *self, struct map *map);
 int thread__fork(struct thread *self, struct thread *parent);
-struct map *thread__find_map(struct thread *self, u64 ip);
-size_t threads__fprintf(FILE *fp, struct rb_root *threads);
+size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp);
+size_t perf_session__fprintf(struct perf_session *self, FILE *fp);
+
+void maps__insert(struct rb_root *maps, struct map *map);
+struct map *maps__find(struct rb_root *maps, u64 addr);
+
+static inline void map_groups__insert(struct map_groups *self, struct map *map)
+{
+         maps__insert(&self->maps[map->type], map);
+}
+
+static inline struct map *map_groups__find(struct map_groups *self,
+                                           enum map_type type, u64 addr)
+{
+        return maps__find(&self->maps[type], addr);
+}
+
+static inline struct map *thread__find_map(struct thread *self,
+                                           enum map_type type, u64 addr)
+{
+        return self ? map_groups__find(&self->mg, type, addr) : NULL;
+}
+
+void thread__find_addr_map(struct thread *self,
+                           struct perf_session *session, u8 cpumode,
+                           enum map_type type, u64 addr,
+                           struct addr_location *al);
+
+void thread__find_addr_location(struct thread *self,
+                                struct perf_session *session, u8 cpumode,
+                                enum map_type type, u64 addr,
+                                struct addr_location *al,
+                                symbol_filter_t filter);
+struct symbol *map_groups__find_symbol(struct map_groups *self,
+                                       enum map_type type, u64 addr,
+                                       symbol_filter_t filter);
+
+static inline struct symbol *map_groups__find_function(struct map_groups *self,
+                                                       u64 addr,
+                                                       symbol_filter_t filter)
+{
+        return map_groups__find_symbol(self, MAP__FUNCTION, addr, filter);
+}
+
+struct map *map_groups__find_by_name(struct map_groups *self,
+                                     enum map_type type, const char *name);
+
+int __map_groups__create_kernel_maps(struct map_groups *self,
+                                     struct map *vmlinux_maps[MAP__NR_TYPES],
+                                     struct dso *kernel);
+int map_groups__create_kernel_maps(struct map_groups *self,
+                                   struct map *vmlinux_maps[MAP__NR_TYPES]);
+
+struct map *map_groups__new_module(struct map_groups *self, u64 start,
+                                   const char *filename);
+#endif  /* __PERF_THREAD_H */
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index af4b0573b37f..5ea8973ad331 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -20,6 +20,7 @@
  */
 #define _GNU_SOURCE
 #include <dirent.h>
+#include <mntent.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -33,10 +34,11 @@
 #include <ctype.h>
 #include <errno.h>
 #include <stdbool.h>
+#include <linux/kernel.h>
 
 #include "../perf.h"
 #include "trace-event.h"
-
+#include "debugfs.h"
 
 #define VERSION "0.5"
 
@@ -101,32 +103,12 @@ void *malloc_or_die(unsigned int size)
 
 static const char *find_debugfs(void)
 {
-        static char debugfs[MAX_PATH+1];
-        static int debugfs_found;
-        char type[100];
-        FILE *fp;
-
-        if (debugfs_found)
-                return debugfs;
-
-        if ((fp = fopen("/proc/mounts","r")) == NULL)
-                die("Can't open /proc/mounts for read");
-
-        while (fscanf(fp, "%*s %"
-                      STR(MAX_PATH)
-                      "s %99s %*s %*d %*d\n",
-                      debugfs, type) == 2) {
-                if (strcmp(type, "debugfs") == 0)
-                        break;
-        }
-        fclose(fp);
-
-        if (strcmp(type, "debugfs") != 0)
-                die("debugfs not mounted, please mount");
+        const char *path = debugfs_mount(NULL);
 
-        debugfs_found = 1;
+        if (!path)
+                die("Your kernel not support debugfs filesystem");
 
-        return debugfs;
+        return path;
 }
 
 /*
@@ -271,6 +253,8 @@ static void read_header_files(void)
         write_or_die("header_page", 12);
         write_or_die(&size, 8);
         check_size = copy_file_fd(fd);
+        close(fd);
+
         if (size != check_size)
                 die("wrong size for '%s' size=%lld read=%lld",
                     path, size, check_size);
@@ -289,6 +273,7 @@ static void read_header_files(void)
         if (size != check_size)
                 die("wrong size for '%s'", path);
         put_tracing_file(path);
+        close(fd);
 }
 
 static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
@@ -317,7 +302,8 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
                 die("can't read directory '%s'", sys);
 
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
@@ -334,7 +320,8 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
 
         rewinddir(dir);
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
@@ -353,6 +340,7 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
 
                 free(format);
         }
+        closedir(dir);
 }
 
 static void read_ftrace_files(struct tracepoint_path *tps)
@@ -394,26 +382,21 @@ static void read_event_files(struct tracepoint_path *tps)
                 die("can't read directory '%s'", path);
 
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     strcmp(dent->d_name, "ftrace") == 0 ||
                     !system_in_tp_list(dent->d_name, tps))
                         continue;
-                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
-                sprintf(sys, "%s/%s", path, dent->d_name);
-                ret = stat(sys, &st);
-                free(sys);
-                if (ret < 0)
-                        continue;
-                if (S_ISDIR(st.st_mode))
-                        count++;
+                count++;
         }
 
         write_or_die(&count, 4);
 
         rewinddir(dir);
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     strcmp(dent->d_name, "ftrace") == 0 ||
                     !system_in_tp_list(dent->d_name, tps))
@@ -422,14 +405,13 @@ static void read_event_files(struct tracepoint_path *tps)
                 sprintf(sys, "%s/%s", path, dent->d_name);
                 ret = stat(sys, &st);
                 if (ret >= 0) {
-                        if (S_ISDIR(st.st_mode)) {
-                                write_or_die(dent->d_name, strlen(dent->d_name) + 1);
-                                copy_event_system(sys, tps);
-                        }
+                        write_or_die(dent->d_name, strlen(dent->d_name) + 1);
+                        copy_event_system(sys, tps);
                 }
                 free(sys);
         }
 
+        closedir(dir);
         put_tracing_file(path);
 }
 
@@ -483,27 +465,33 @@ static struct tracepoint_path *
 get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
 {
         struct tracepoint_path path, *ppath = &path;
-        int i;
+        int i, nr_tracepoints = 0;
 
         for (i = 0; i < nb_events; i++) {
                 if (pattrs[i].type != PERF_TYPE_TRACEPOINT)
                         continue;
+                ++nr_tracepoints;
                 ppath->next = tracepoint_id_to_path(pattrs[i].config);
                 if (!ppath->next)
                         die("%s\n", "No memory to alloc tracepoints list");
                 ppath = ppath->next;
         }
 
-        return path.next;
+        return nr_tracepoints > 0 ? path.next : NULL;
 }
-void read_tracing_data(struct perf_event_attr *pattrs, int nb_events)
+
+int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
 {
         char buf[BUFSIZ];
-        struct tracepoint_path *tps;
+        struct tracepoint_path *tps = get_tracepoints_path(pattrs, nb_events);
+
+        /*
+         * What? No tracepoints? No sense writing anything here, bail out.
+         */
+        if (tps == NULL)
+                return -1;
 
-        output_fd = open(output_file, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, 0644);
-        if (output_fd < 0)
-                die("creating file '%s'", output_file);
+        output_fd = fd;
 
         buf[0] = 23;
         buf[1] = 8;
@@ -527,14 +515,14 @@ void read_tracing_data(struct perf_event_attr *pattrs, int nb_events)
         write_or_die(buf, 1);
 
         /* save page_size */
-        page_size = getpagesize();
+        page_size = sysconf(_SC_PAGESIZE);
         write_or_die(&page_size, 4);
 
-        tps = get_tracepoints_path(pattrs, nb_events);
-
         read_header_files();
         read_ftrace_files(tps);
         read_event_files(tps);
         read_proc_kallsyms();
         read_ftrace_printk();
+
+        return 0;
 }
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 55c9659a56e2..613c9cc90570 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -40,12 +40,19 @@ int header_page_size_size;
 int header_page_data_offset;
 int header_page_data_size;
 
+int latency_format;
+
 static char *input_buf;
 static unsigned long long input_buf_ptr;
 static unsigned long long input_buf_siz;
 
 static int cpus;
 static int long_size;
+static int is_flag_field;
+static int is_symbolic_field;
+
+static struct format_field *
+find_any_field(struct event *event, const char *name);
 
 static void init_input_buf(char *buf, unsigned long long size)
 {
@@ -170,7 +177,7 @@ void parse_proc_kallsyms(char *file, unsigned int size __unused)
                 func_count++;
         }
 
-        func_list = malloc_or_die(sizeof(*func_list) * func_count + 1);
+        func_list = malloc_or_die(sizeof(*func_list) * (func_count + 1));
 
         i = 0;
         while (list) {
@@ -284,18 +291,19 @@ void parse_ftrace_printk(char *file, unsigned int size __unused)
         char *line;
         char *next = NULL;
         char *addr_str;
-        int ret;
         int i;
 
         line = strtok_r(file, "\n", &next);
         while (line) {
+                addr_str = strsep(&line, ":");
+                if (!line) {
+                        warning("error parsing print strings");
+                        break;
+                }
                 item = malloc_or_die(sizeof(*item));
-                ret = sscanf(line, "%as : %as",
-                             (float *)(void *)&addr_str, /* workaround gcc warning */
-                             (float *)(void *)&item->printk);
                 item->addr = strtoull(addr_str, NULL, 16);
-                free(addr_str);
-
+                /* fmt still has a space, skip it */
+                item->printk = strdup(line+1);
                 item->next = list;
                 list = item;
                 line = strtok_r(NULL, "\n", &next);
@@ -522,7 +530,10 @@ static enum event_type __read_token(char **tok)
                         last_ch = ch;
                         ch = __read_char();
                         buf[i++] = ch;
-                } while (ch != quote_ch && last_ch != '\\');
+                        /* the '\' '\' will cancel itself */
+                        if (ch == '\\' && last_ch == '\\')
+                                last_ch = 0;
+                } while (ch != quote_ch || last_ch == '\\');
                 /* remove the last quote */
                 i--;
                 goto out;
@@ -610,7 +621,7 @@ static enum event_type read_token_item(char **tok)
 static int test_type(enum event_type type, enum event_type expect)
 {
         if (type != expect) {
-                die("Error: expected type %d but read %d",
+                warning("Error: expected type %d but read %d",
                     expect, type);
                 return -1;
         }
@@ -621,13 +632,13 @@ static int test_type_token(enum event_type type, char *token,
                     enum event_type expect, const char *expect_tok)
 {
         if (type != expect) {
-                die("Error: expected type %d but read %d",
+                warning("Error: expected type %d but read %d",
                     expect, type);
                 return -1;
         }
 
         if (strcmp(token, expect_tok) != 0) {
-                die("Error: expected '%s' but read '%s'",
+                warning("Error: expected '%s' but read '%s'",
                     expect_tok, token);
                 return -1;
         }
@@ -665,7 +676,7 @@ static int __read_expected(enum event_type expect, const char *str, int newline_
 
         free_token(token);
 
-        return 0;
+        return ret;
 }
 
 static int read_expected(enum event_type expect, const char *str)
@@ -682,10 +693,10 @@ static char *event_read_name(void)
 {
         char *token;
 
-        if (read_expected(EVENT_ITEM, (char *)"name") < 0)
+        if (read_expected(EVENT_ITEM, "name") < 0)
                 return NULL;
 
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return NULL;
 
         if (read_expect_type(EVENT_ITEM, &token) < 0)
@@ -703,10 +714,10 @@ static int event_read_id(void)
         char *token;
         int id;
 
-        if (read_expected_item(EVENT_ITEM, (char *)"ID") < 0)
+        if (read_expected_item(EVENT_ITEM, "ID") < 0)
                 return -1;
 
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return -1;
 
         if (read_expect_type(EVENT_ITEM, &token) < 0)
@@ -721,6 +732,24 @@ static int event_read_id(void)
         return -1;
 }
 
+static int field_is_string(struct format_field *field)
+{
+        if ((field->flags & FIELD_IS_ARRAY) &&
+            (!strstr(field->type, "char") || !strstr(field->type, "u8") ||
+             !strstr(field->type, "s8")))
+                return 1;
+
+        return 0;
+}
+
+static int field_is_dynamic(struct format_field *field)
+{
+        if (!strcmp(field->type, "__data_loc"))
+                return 1;
+
+        return 0;
+}
+
 static int event_read_fields(struct event *event, struct format_field **fields)
 {
         struct format_field *field = NULL;
@@ -738,7 +767,7 @@ static int event_read_fields(struct event *event, struct format_field **fields)
 
                 count++;
 
-                if (test_type_token(type, token, EVENT_ITEM, (char *)"field"))
+                if (test_type_token(type, token, EVENT_ITEM, "field"))
                         goto fail;
                 free_token(token);
 
@@ -753,7 +782,7 @@ static int event_read_fields(struct event *event, struct format_field **fields)
                         type = read_token(&token);
                 }
 
-                if (test_type_token(type, token, EVENT_OP, (char *)":") < 0)
+                if (test_type_token(type, token, EVENT_OP, ":") < 0)
                         return -1;
 
                 if (read_expect_type(EVENT_ITEM, &token) < 0)
@@ -865,14 +894,20 @@ static int event_read_fields(struct event *event, struct format_field **fields)
                         free(brackets);
                 }
 
-                if (test_type_token(type, token,  EVENT_OP, (char *)";"))
+                if (field_is_string(field)) {
+                        field->flags |= FIELD_IS_STRING;
+                        if (field_is_dynamic(field))
+                                field->flags |= FIELD_IS_DYNAMIC;
+                }
+
+                if (test_type_token(type, token,  EVENT_OP, ";"))
                         goto fail;
                 free_token(token);
 
-                if (read_expected(EVENT_ITEM, (char *)"offset") < 0)
+                if (read_expected(EVENT_ITEM, "offset") < 0)
                         goto fail_expect;
 
-                if (read_expected(EVENT_OP, (char *)":") < 0)
+                if (read_expected(EVENT_OP, ":") < 0)
                         goto fail_expect;
 
                 if (read_expect_type(EVENT_ITEM, &token))
@@ -880,13 +915,13 @@ static int event_read_fields(struct event *event, struct format_field **fields)
                 field->offset = strtoul(token, NULL, 0);
                 free_token(token);
 
-                if (read_expected(EVENT_OP, (char *)";") < 0)
+                if (read_expected(EVENT_OP, ";") < 0)
                         goto fail_expect;
 
-                if (read_expected(EVENT_ITEM, (char *)"size") < 0)
+                if (read_expected(EVENT_ITEM, "size") < 0)
                         goto fail_expect;
 
-                if (read_expected(EVENT_OP, (char *)":") < 0)
+                if (read_expected(EVENT_OP, ":") < 0)
                         goto fail_expect;
 
                 if (read_expect_type(EVENT_ITEM, &token))
@@ -894,11 +929,34 @@ static int event_read_fields(struct event *event, struct format_field **fields)
                 field->size = strtoul(token, NULL, 0);
                 free_token(token);
 
-                if (read_expected(EVENT_OP, (char *)";") < 0)
+                if (read_expected(EVENT_OP, ";") < 0)
                         goto fail_expect;
 
-                if (read_expect_type(EVENT_NEWLINE, &token) < 0)
-                        goto fail;
+                type = read_token(&token);
+                if (type != EVENT_NEWLINE) {
+                        /* newer versions of the kernel have a "signed" type */
+                        if (test_type_token(type, token, EVENT_ITEM, "signed"))
+                                goto fail;
+
+                        free_token(token);
+
+                        if (read_expected(EVENT_OP, ":") < 0)
+                                goto fail_expect;
+
+                        if (read_expect_type(EVENT_ITEM, &token))
+                                goto fail;
+
+                        if (strtoul(token, NULL, 0))
+                                field->flags |= FIELD_IS_SIGNED;
+
+                        free_token(token);
+                        if (read_expected(EVENT_OP, ";") < 0)
+                                goto fail_expect;
+
+                        if (read_expect_type(EVENT_NEWLINE, &token))
+                                goto fail;
+                }
+
                 free_token(token);
 
                 *fields = field;
@@ -921,10 +979,10 @@ static int event_read_format(struct event *event)
         char *token;
         int ret;
 
-        if (read_expected_item(EVENT_ITEM, (char *)"format") < 0)
+        if (read_expected_item(EVENT_ITEM, "format") < 0)
                 return -1;
 
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return -1;
 
         if (read_expect_type(EVENT_NEWLINE, &token))
@@ -984,7 +1042,7 @@ process_cond(struct event *event, struct print_arg *top, char **tok)
 
         *tok = NULL;
         type = process_arg(event, left, &token);
-        if (test_type_token(type, token, EVENT_OP, (char *)":"))
+        if (test_type_token(type, token, EVENT_OP, ":"))
                 goto out_free;
 
         arg->op.op = token;
@@ -1004,6 +1062,35 @@ out_free:
         return EVENT_ERROR;
 }
 
+static enum event_type
+process_array(struct event *event, struct print_arg *top, char **tok)
+{
+        struct print_arg *arg;
+        enum event_type type;
+        char *token = NULL;
+
+        arg = malloc_or_die(sizeof(*arg));
+        memset(arg, 0, sizeof(*arg));
+
+        *tok = NULL;
+        type = process_arg(event, arg, &token);
+        if (test_type_token(type, token, EVENT_OP, "]"))
+                goto out_free;
+
+        top->op.right = arg;
+
+        free_token(token);
+        type = read_token_item(&token);
+        *tok = token;
+
+        return type;
+
+out_free:
+        free_token(*tok);
+        free_arg(arg);
+        return EVENT_ERROR;
+}
+
 static int get_op_prio(char *op)
 {
         if (!op[1]) {
@@ -1128,6 +1215,8 @@ process_op(struct event *event, struct print_arg *arg, char **tok)
                    strcmp(token, "*") == 0 ||
                    strcmp(token, "^") == 0 ||
                    strcmp(token, "/") == 0 ||
+                   strcmp(token, "<") == 0 ||
+                   strcmp(token, ">") == 0 ||
                    strcmp(token, "==") == 0 ||
                    strcmp(token, "!=") == 0) {
 
@@ -1144,17 +1233,46 @@ process_op(struct event *event, struct print_arg *arg, char **tok)
 
                 right = malloc_or_die(sizeof(*right));
 
-                type = process_arg(event, right, tok);
+                type = read_token_item(&token);
+                *tok = token;
+
+                /* could just be a type pointer */
+                if ((strcmp(arg->op.op, "*") == 0) &&
+                    type == EVENT_DELIM && (strcmp(token, ")") == 0)) {
+                        if (left->type != PRINT_ATOM)
+                                die("bad pointer type");
+                        left->atom.atom = realloc(left->atom.atom,
+                                            sizeof(left->atom.atom) + 3);
+                        strcat(left->atom.atom, " *");
+                        *arg = *left;
+                        free(arg);
+
+                        return type;
+                }
+
+                type = process_arg_token(event, right, tok, type);
 
                 arg->op.right = right;
 
+        } else if (strcmp(token, "[") == 0) {
+
+                left = malloc_or_die(sizeof(*left));
+                *left = *arg;
+
+                arg->type = PRINT_OP;
+                arg->op.op = token;
+                arg->op.left = left;
+
+                arg->op.prio = 0;
+                type = process_array(event, arg, tok);
+
         } else {
-                die("unknown op '%s'", token);
+                warning("unknown op '%s'", token);
+                event->flags |= EVENT_FL_FAILED;
                 /* the arg is now the left side */
                 return EVENT_NONE;
         }
 
-
         if (type == EVENT_OP) {
                 int prio;
 
@@ -1178,7 +1296,7 @@ process_entry(struct event *event __unused, struct print_arg *arg,
         char *field;
         char *token;
 
-        if (read_expected(EVENT_OP, (char *)"->") < 0)
+        if (read_expected(EVENT_OP, "->") < 0)
                 return EVENT_ERROR;
 
         if (read_expect_type(EVENT_ITEM, &token) < 0)
@@ -1188,6 +1306,16 @@ process_entry(struct event *event __unused, struct print_arg *arg,
         arg->type = PRINT_FIELD;
         arg->field.name = field;
 
+        if (is_flag_field) {
+                arg->field.field = find_any_field(event, arg->field.name);
+                arg->field.field->flags |= FIELD_IS_FLAG;
+                is_flag_field = 0;
+        } else if (is_symbolic_field) {
+                arg->field.field = find_any_field(event, arg->field.name);
+                arg->field.field->flags |= FIELD_IS_SYMBOLIC;
+                is_symbolic_field = 0;
+        }
+
         type = read_token(&token);
         *tok = token;
 
@@ -1338,25 +1466,25 @@ process_fields(struct event *event, struct print_flag_sym **list, char **tok)
         do {
                 free_token(token);
                 type = read_token_item(&token);
-                if (test_type_token(type, token, EVENT_OP, (char *)"{"))
+                if (test_type_token(type, token, EVENT_OP, "{"))
                         break;
 
                 arg = malloc_or_die(sizeof(*arg));
 
                 free_token(token);
                 type = process_arg(event, arg, &token);
-                if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+                if (test_type_token(type, token, EVENT_DELIM, ","))
                         goto out_free;
 
                 field = malloc_or_die(sizeof(*field));
-                memset(field, 0, sizeof(field));
+                memset(field, 0, sizeof(*field));
 
                 value = arg_eval(arg);
                 field->value = strdup(value);
 
                 free_token(token);
                 type = process_arg(event, arg, &token);
-                if (test_type_token(type, token, EVENT_OP, (char *)"}"))
+                if (test_type_token(type, token, EVENT_OP, "}"))
                         goto out_free;
 
                 value = arg_eval(arg);
@@ -1391,13 +1519,13 @@ process_flags(struct event *event, struct print_arg *arg, char **tok)
         memset(arg, 0, sizeof(*arg));
         arg->type = PRINT_FLAGS;
 
-        if (read_expected_item(EVENT_DELIM, (char *)"(") < 0)
+        if (read_expected_item(EVENT_DELIM, "(") < 0)
                 return EVENT_ERROR;
 
         field = malloc_or_die(sizeof(*field));
 
         type = process_arg(event, field, &token);
-        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+        if (test_type_token(type, token, EVENT_DELIM, ","))
                 goto out_free;
 
         arg->flags.field = field;
@@ -1408,11 +1536,11 @@ process_flags(struct event *event, struct print_arg *arg, char **tok)
                 type = read_token_item(&token);
         }
 
-        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+        if (test_type_token(type, token, EVENT_DELIM, ","))
                 goto out_free;
 
         type = process_fields(event, &arg->flags.flags, &token);
-        if (test_type_token(type, token, EVENT_DELIM, (char *)")"))
+        if (test_type_token(type, token, EVENT_DELIM, ")"))
                 goto out_free;
 
         free_token(token);
@@ -1434,19 +1562,19 @@ process_symbols(struct event *event, struct print_arg *arg, char **tok)
         memset(arg, 0, sizeof(*arg));
         arg->type = PRINT_SYMBOL;
 
-        if (read_expected_item(EVENT_DELIM, (char *)"(") < 0)
+        if (read_expected_item(EVENT_DELIM, "(") < 0)
                 return EVENT_ERROR;
 
         field = malloc_or_die(sizeof(*field));
 
         type = process_arg(event, field, &token);
-        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+        if (test_type_token(type, token, EVENT_DELIM, ","))
                 goto out_free;
 
         arg->symbol.field = field;
 
         type = process_fields(event, &arg->symbol.symbols, &token);
-        if (test_type_token(type, token, EVENT_DELIM, (char *)")"))
+        if (test_type_token(type, token, EVENT_DELIM, ")"))
                 goto out_free;
 
         free_token(token);
@@ -1463,7 +1591,6 @@ process_paren(struct event *event, struct print_arg *arg, char **tok)
 {
         struct print_arg *item_arg;
         enum event_type type;
-        int ptr_cast = 0;
         char *token;
 
         type = process_arg(event, arg, &token);
@@ -1471,28 +1598,13 @@ process_paren(struct event *event, struct print_arg *arg, char **tok)
         if (type == EVENT_ERROR)
                 return EVENT_ERROR;
 
-        if (type == EVENT_OP) {
-                /* handle the ptr casts */
-                if (!strcmp(token, "*")) {
-                        /*
-                         * FIXME: should we zapp whitespaces before ')' ?
-                         * (may require a peek_token_item())
-                         */
-                        if (__peek_char() == ')') {
-                                ptr_cast = 1;
-                                free_token(token);
-                                type = read_token_item(&token);
-                        }
-                }
-                if (!ptr_cast) {
-                        type = process_op(event, arg, &token);
+        if (type == EVENT_OP)
+                type = process_op(event, arg, &token);
 
-                        if (type == EVENT_ERROR)
-                                return EVENT_ERROR;
-                }
-        }
+        if (type == EVENT_ERROR)
+                return EVENT_ERROR;
 
-        if (test_type_token(type, token, EVENT_DELIM, (char *)")")) {
+        if (test_type_token(type, token, EVENT_DELIM, ")")) {
                 free_token(token);
                 return EVENT_ERROR;
         }
@@ -1516,13 +1628,6 @@ process_paren(struct event *event, struct print_arg *arg, char **tok)
                 item_arg = malloc_or_die(sizeof(*item_arg));
 
                 arg->type = PRINT_TYPE;
-                if (ptr_cast) {
-                        char *old = arg->atom.atom;
-
-                        arg->atom.atom = malloc_or_die(strlen(old + 3));
-                        sprintf(arg->atom.atom, "%s *", old);
-                        free(old);
-                }
                 arg->typecast.type = arg->atom.atom;
                 arg->typecast.item = item_arg;
                 type = process_arg_token(event, item_arg, &token, type);
@@ -1540,7 +1645,7 @@ process_str(struct event *event __unused, struct print_arg *arg, char **tok)
         enum event_type type;
         char *token;
 
-        if (read_expected(EVENT_DELIM, (char *)"(") < 0)
+        if (read_expected(EVENT_DELIM, "(") < 0)
                 return EVENT_ERROR;
 
         if (read_expect_type(EVENT_ITEM, &token) < 0)
@@ -1550,7 +1655,7 @@ process_str(struct event *event __unused, struct print_arg *arg, char **tok)
         arg->string.string = token;
         arg->string.offset = -1;
 
-        if (read_expected(EVENT_DELIM, (char *)")") < 0)
+        if (read_expected(EVENT_DELIM, ")") < 0)
                 return EVENT_ERROR;
 
         type = read_token(&token);
@@ -1578,9 +1683,11 @@ process_arg_token(struct event *event, struct print_arg *arg,
                         type = process_entry(event, arg, &token);
                 } else if (strcmp(token, "__print_flags") == 0) {
                         free_token(token);
+                        is_flag_field = 1;
                         type = process_flags(event, arg, &token);
                 } else if (strcmp(token, "__print_symbolic") == 0) {
                         free_token(token);
+                        is_symbolic_field = 1;
                         type = process_symbols(event, arg, &token);
                 } else if (strcmp(token, "__get_str") == 0) {
                         free_token(token);
@@ -1637,12 +1744,18 @@ process_arg_token(struct event *event, struct print_arg *arg,
 
 static int event_read_print_args(struct event *event, struct print_arg **list)
 {
-        enum event_type type;
+        enum event_type type = EVENT_ERROR;
         struct print_arg *arg;
         char *token;
         int args = 0;
 
         do {
+                if (type == EVENT_NEWLINE) {
+                        free_token(token);
+                        type = read_token_item(&token);
+                        continue;
+                }
+
                 arg = malloc_or_die(sizeof(*arg));
                 memset(arg, 0, sizeof(*arg));
 
@@ -1683,18 +1796,19 @@ static int event_read_print(struct event *event)
         char *token;
         int ret;
 
-        if (read_expected_item(EVENT_ITEM, (char *)"print") < 0)
+        if (read_expected_item(EVENT_ITEM, "print") < 0)
                 return -1;
 
-        if (read_expected(EVENT_ITEM, (char *)"fmt") < 0)
+        if (read_expected(EVENT_ITEM, "fmt") < 0)
                 return -1;
 
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return -1;
 
         if (read_expect_type(EVENT_DQUOTE, &token) < 0)
                 goto fail;
 
+ concat:
         event->print_fmt.format = token;
         event->print_fmt.args = NULL;
 
@@ -1704,7 +1818,22 @@ static int event_read_print(struct event *event)
         if (type == EVENT_NONE)
                 return 0;
 
-        if (test_type_token(type, token, EVENT_DELIM, (char *)","))
+        /* Handle concatination of print lines */
+        if (type == EVENT_DQUOTE) {
+                char *cat;
+
+                cat = malloc_or_die(strlen(event->print_fmt.format) +
+                                    strlen(token) + 1);
+                strcpy(cat, event->print_fmt.format);
+                strcat(cat, token);
+                free_token(token);
+                free_token(event->print_fmt.format);
+                event->print_fmt.format = NULL;
+                token = cat;
+                goto concat;
+        }
+
+        if (test_type_token(type, token, EVENT_DELIM, ","))
                 goto fail;
 
         free_token(token);
@@ -1713,7 +1842,7 @@ static int event_read_print(struct event *event)
         if (ret < 0)
                 return -1;
 
-        return 0;
+        return ret;
 
  fail:
         free_token(token);
@@ -1759,7 +1888,7 @@ find_any_field(struct event *event, const char *name)
         return find_field(event, name);
 }
 
-static unsigned long long read_size(void *ptr, int size)
+unsigned long long read_size(void *ptr, int size)
 {
         switch (size) {
         case 1:
@@ -1796,6 +1925,15 @@ void *raw_field_ptr(struct event *event, const char *name, void *data)
         if (!field)
                 return NULL;
 
+        if (field->flags & FIELD_IS_DYNAMIC) {
+                int offset;
+
+                offset = *(int *)(data + field->offset);
+                offset &= 0xffff;
+
+                return data + offset;
+        }
+
         return data + field->offset;
 }
 
@@ -1822,37 +1960,67 @@ static int get_common_info(const char *type, int *offset, int *size)
         return 0;
 }
 
-int trace_parse_common_type(void *data)
+static int __parse_common(void *data, int *size, int *offset,
+                          const char *name)
 {
-        static int type_offset;
-        static int type_size;
         int ret;
 
-        if (!type_size) {
-                ret = get_common_info("common_type",
-                                      &type_offset,
-                                      &type_size);
+        if (!*size) {
+                ret = get_common_info(name, offset, size);
                 if (ret < 0)
                         return ret;
         }
-        return read_size(data + type_offset, type_size);
+        return read_size(data + *offset, *size);
 }
 
-static int parse_common_pid(void *data)
+int trace_parse_common_type(void *data)
+{
+        static int type_offset;
+        static int type_size;
+
+        return __parse_common(data, &type_size, &type_offset,
+                              "common_type");
+}
+
+int trace_parse_common_pid(void *data)
 {
         static int pid_offset;
         static int pid_size;
+
+        return __parse_common(data, &pid_size, &pid_offset,
+                              "common_pid");
+}
+
+int parse_common_pc(void *data)
+{
+        static int pc_offset;
+        static int pc_size;
+
+        return __parse_common(data, &pc_size, &pc_offset,
+                              "common_preempt_count");
+}
+
+int parse_common_flags(void *data)
+{
+        static int flags_offset;
+        static int flags_size;
+
+        return __parse_common(data, &flags_size, &flags_offset,
+                              "common_flags");
+}
+
+int parse_common_lock_depth(void *data)
+{
+        static int ld_offset;
+        static int ld_size;
         int ret;
 
-        if (!pid_size) {
-                ret = get_common_info("common_pid",
-                                      &pid_offset,
-                                      &pid_size);
-                if (ret < 0)
-                        return ret;
-        }
+        ret = __parse_common(data, &ld_size, &ld_offset,
+                             "common_lock_depth");
+        if (ret < 0)
+                return -1;
 
-        return read_size(data + pid_offset, pid_size);
+        return ret;
 }
 
 struct event *trace_find_event(int id)
@@ -1866,11 +2034,20 @@ struct event *trace_find_event(int id)
         return event;
 }
 
+struct event *trace_find_next_event(struct event *event)
+{
+        if (!event)
+                return event_list;
+
+        return event->next;
+}
+
 static unsigned long long eval_num_arg(void *data, int size,
                                    struct event *event, struct print_arg *arg)
 {
         unsigned long long val = 0;
         unsigned long long left, right;
+        struct print_arg *larg;
 
         switch (arg->type) {
         case PRINT_NULL:
@@ -1897,6 +2074,26 @@ static unsigned long long eval_num_arg(void *data, int size,
                 return 0;
                 break;
         case PRINT_OP:
+                if (strcmp(arg->op.op, "[") == 0) {
+                        /*
+                         * Arrays are special, since we don't want
+                         * to read the arg as is.
+                         */
+                        if (arg->op.left->type != PRINT_FIELD)
+                                goto default_op; /* oops, all bets off */
+                        larg = arg->op.left;
+                        if (!larg->field.field) {
+                                larg->field.field =
+                                        find_any_field(event, larg->field.name);
+                                if (!larg->field.field)
+                                        die("field %s not found", larg->field.name);
+                        }
+                        right = eval_num_arg(data, size, event, arg->op.right);
+                        val = read_size(data + larg->field.field->offset +
+                                        right * long_size, long_size);
+                        break;
+                }
+ default_op:
                 left = eval_num_arg(data, size, event, arg->op.left);
                 right = eval_num_arg(data, size, event, arg->op.right);
                 switch (arg->op.op[0]) {
@@ -1947,6 +2144,12 @@ static unsigned long long eval_num_arg(void *data, int size,
                                 die("unknown op '%s'", arg->op.op);
                         val = left == right;
                         break;
+                case '-':
+                        val = left - right;
+                        break;
+                case '+':
+                        val = left + right;
+                        break;
                 default:
                         die("unknown op '%s'", arg->op.op);
                 }
@@ -1978,7 +2181,7 @@ static const struct flag flags[] = {
         { "HRTIMER_RESTART", 1 },
 };
 
-static unsigned long long eval_flag(const char *flag)
+unsigned long long eval_flag(const char *flag)
 {
         int i;
 
@@ -2145,8 +2348,9 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                         case 'u':
                         case 'x':
                         case 'i':
-                                bptr = (void *)(((unsigned long)bptr + (long_size - 1)) &
-                                                ~(long_size - 1));
+                                /* the pointers are always 4 bytes aligned */
+                                bptr = (void *)(((unsigned long)bptr + 3) &
+                                                ~3);
                                 switch (ls) {
                                 case 0:
                                 case 1:
@@ -2270,7 +2474,27 @@ static void pretty_print(void *data, int size, struct event *event)
 
         for (; *ptr; ptr++) {
                 ls = 0;
-                if (*ptr == '%') {
+                if (*ptr == '\\') {
+                        ptr++;
+                        switch (*ptr) {
+                        case 'n':
+                                printf("\n");
+                                break;
+                        case 't':
+                                printf("\t");
+                                break;
+                        case 'r':
+                                printf("\r");
+                                break;
+                        case '\\':
+                                printf("\\");
+                                break;
+                        default:
+                                printf("%c", *ptr);
+                                break;
+                        }
+
+                } else if (*ptr == '%') {
                         saveptr = ptr;
                         show_func = 0;
  cont_process:
@@ -2377,6 +2601,41 @@ static inline int log10_cpu(int nb)
         return 1;
 }
 
+static void print_lat_fmt(void *data, int size __unused)
+{
+        unsigned int lat_flags;
+        unsigned int pc;
+        int lock_depth;
+        int hardirq;
+        int softirq;
+
+        lat_flags = parse_common_flags(data);
+        pc = parse_common_pc(data);
+        lock_depth = parse_common_lock_depth(data);
+
+        hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
+        softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
+
+        printf("%c%c%c",
+               (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
+               (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
+               'X' : '.',
+               (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
+               'N' : '.',
+               (hardirq && softirq) ? 'H' :
+               hardirq ? 'h' : softirq ? 's' : '.');
+
+        if (pc)
+                printf("%x", pc);
+        else
+                printf(".");
+
+        if (lock_depth < 0)
+                printf(".");
+        else
+                printf("%d", lock_depth);
+}
+
 /* taken from Linux, written by Frederic Weisbecker */
 static void print_graph_cpu(int cpu)
 {
@@ -2452,7 +2711,7 @@ get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func,
         if (!(event->flags & EVENT_FL_ISFUNCRET))
                 return NULL;
 
-        pid = parse_common_pid(next->data);
+        pid = trace_parse_common_pid(next->data);
         field = find_field(event, "func");
         if (!field)
                 die("function return does not have field func");
@@ -2620,6 +2879,11 @@ pretty_print_func_ent(void *data, int size, struct event *event,
 
         printf(" | ");
 
+        if (latency_format) {
+                print_lat_fmt(data, size);
+                printf(" | ");
+        }
+
         field = find_field(event, "func");
         if (!field)
                 die("function entry does not have func field");
@@ -2663,6 +2927,11 @@ pretty_print_func_ret(void *data, int size __unused, struct event *event,
 
         printf(" | ");
 
+        if (latency_format) {
+                print_lat_fmt(data, size);
+                printf(" | ");
+        }
+
         field = find_field(event, "rettime");
         if (!field)
                 die("can't find rettime in return graph");
@@ -2724,19 +2993,30 @@ void print_event(int cpu, void *data, int size, unsigned long long nsecs,
 
         event = trace_find_event(type);
         if (!event) {
-                printf("ug! no event found for type %d\n", type);
+                warning("ug! no event found for type %d", type);
                 return;
         }
 
-        pid = parse_common_pid(data);
+        pid = trace_parse_common_pid(data);
 
         if (event->flags & (EVENT_FL_ISFUNCENT | EVENT_FL_ISFUNCRET))
                 return pretty_print_func_graph(data, size, event, cpu,
                                                pid, comm, secs, usecs);
 
-        printf("%16s-%-5d [%03d] %5lu.%09Lu: %s: ",
-               comm, pid,  cpu,
-               secs, nsecs, event->name);
+        if (latency_format) {
+                printf("%8.8s-%-5d %3d",
+                       comm, pid, cpu);
+                print_lat_fmt(data, size);
+        } else
+                printf("%16s-%-5d [%03d]", comm, pid,  cpu);
+
+        printf(" %5lu.%06lu: %s: ", secs, usecs, event->name);
+
+        if (event->flags & EVENT_FL_FAILED) {
+                printf("EVENT '%s' FAILED TO PARSE\n",
+                       event->name);
+                return;
+        }
 
         pretty_print(data, size, event);
         printf("\n");
@@ -2807,46 +3087,71 @@ static void print_args(struct print_arg *args)
         }
 }
 
-static void parse_header_field(char *type,
+static void parse_header_field(const char *field,
                                int *offset, int *size)
 {
         char *token;
+        int type;
 
-        if (read_expected(EVENT_ITEM, (char *)"field") < 0)
+        if (read_expected(EVENT_ITEM, "field") < 0)
                 return;
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return;
+
         /* type */
         if (read_expect_type(EVENT_ITEM, &token) < 0)
-                return;
+                goto fail;
         free_token(token);
 
-        if (read_expected(EVENT_ITEM, type) < 0)
+        if (read_expected(EVENT_ITEM, field) < 0)
                 return;
-        if (read_expected(EVENT_OP, (char *)";") < 0)
+        if (read_expected(EVENT_OP, ";") < 0)
                 return;
-        if (read_expected(EVENT_ITEM, (char *)"offset") < 0)
+        if (read_expected(EVENT_ITEM, "offset") < 0)
                 return;
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return;
         if (read_expect_type(EVENT_ITEM, &token) < 0)
-                return;
+                goto fail;
         *offset = atoi(token);
         free_token(token);
-        if (read_expected(EVENT_OP, (char *)";") < 0)
+        if (read_expected(EVENT_OP, ";") < 0)
                 return;
-        if (read_expected(EVENT_ITEM, (char *)"size") < 0)
+        if (read_expected(EVENT_ITEM, "size") < 0)
                 return;
-        if (read_expected(EVENT_OP, (char *)":") < 0)
+        if (read_expected(EVENT_OP, ":") < 0)
                 return;
         if (read_expect_type(EVENT_ITEM, &token) < 0)
-                return;
+                goto fail;
         *size = atoi(token);
         free_token(token);
-        if (read_expected(EVENT_OP, (char *)";") < 0)
-                return;
-        if (read_expect_type(EVENT_NEWLINE, &token) < 0)
+        if (read_expected(EVENT_OP, ";") < 0)
                 return;
+        type = read_token(&token);
+        if (type != EVENT_NEWLINE) {
+                /* newer versions of the kernel have a "signed" type */
+                if (type != EVENT_ITEM)
+                        goto fail;
+
+                if (strcmp(token, "signed") != 0)
+                        goto fail;
+
+                free_token(token);
+
+                if (read_expected(EVENT_OP, ":") < 0)
+                        return;
+
+                if (read_expect_type(EVENT_ITEM, &token))
+                        goto fail;
+
+                free_token(token);
+                if (read_expected(EVENT_OP, ";") < 0)
+                        return;
+
+                if (read_expect_type(EVENT_NEWLINE, &token))
+                        goto fail;
+        }
+ fail:
         free_token(token);
 }
 
@@ -2854,11 +3159,11 @@ int parse_header_page(char *buf, unsigned long size)
 {
         init_input_buf(buf, size);
 
-        parse_header_field((char *)"timestamp", &header_page_ts_offset,
+        parse_header_field("timestamp", &header_page_ts_offset,
                            &header_page_ts_size);
-        parse_header_field((char *)"commit", &header_page_size_offset,
+        parse_header_field("commit", &header_page_size_offset,
                            &header_page_size_size);
-        parse_header_field((char *)"data", &header_page_data_offset,
+        parse_header_field("data", &header_page_data_offset,
                            &header_page_data_size);
 
         return 0;
@@ -2909,6 +3214,9 @@ int parse_ftrace_file(char *buf, unsigned long size)
         if (ret < 0)
                 die("failed to read ftrace event print fmt");
 
+        /* New ftrace handles args */
+        if (ret > 0)
+                return 0;
         /*
          * The arguments for ftrace files are parsed by the fields.
          * Set up the fields as their arguments.
@@ -2926,7 +3234,7 @@ int parse_ftrace_file(char *buf, unsigned long size)
         return 0;
 }
 
-int parse_event_file(char *buf, unsigned long size, char *system__unused __unused)
+int parse_event_file(char *buf, unsigned long size, char *sys)
 {
         struct event *event;
         int ret;
@@ -2946,12 +3254,18 @@ int parse_event_file(char *buf, unsigned long size, char *system__unused __unuse
                 die("failed to read event id");
 
         ret = event_read_format(event);
-        if (ret < 0)
-                die("failed to read event format");
+        if (ret < 0) {
+                warning("failed to read event format for %s", event->name);
+                goto event_failed;
+        }
 
         ret = event_read_print(event);
-        if (ret < 0)
-                die("failed to read event print fmt");
+        if (ret < 0) {
+                warning("failed to read event print fmt for %s", event->name);
+                goto event_failed;
+        }
+
+        event->system = strdup(sys);
 
 #define PRINT_ARGS 0
         if (PRINT_ARGS && event->print_fmt.args)
@@ -2959,6 +3273,12 @@ int parse_event_file(char *buf, unsigned long size, char *system__unused __unuse
 
         add_event(event);
         return 0;
+
+ event_failed:
+        event->flags |= EVENT_FL_FAILED;
+        /* still add it even if it failed */
+        add_event(event);
+        return -1;
 }
 
 void parse_set_info(int nr_cpus, int long_sz)
@@ -2966,3 +3286,18 @@ void parse_set_info(int nr_cpus, int long_sz)
         cpus = nr_cpus;
         long_size = long_sz;
 }
+
+int common_pc(struct scripting_context *context)
+{
+        return parse_common_pc(context->event_data);
+}
+
+int common_flags(struct scripting_context *context)
+{
+        return parse_common_flags(context->event_data);
+}
+
+int common_lock_depth(struct scripting_context *context)
+{
+        return parse_common_lock_depth(context->event_data);
+}
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 1b5c847d2c22..7cd1193918c7 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -18,7 +18,7 @@
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
-#define _LARGEFILE64_SOURCE
+#define _FILE_OFFSET_BITS 64
 
 #include <dirent.h>
 #include <stdio.h>
@@ -83,7 +83,7 @@ static char *read_string(void)
         char *str = NULL;
         int size = 0;
         int i;
-        int r;
+        off_t r;
 
         for (;;) {
                 r = read(input_fd, buf, BUFSIZ);
@@ -118,7 +118,7 @@ static char *read_string(void)
 
         /* move the file descriptor to the end of the string */
         r = lseek(input_fd, -(r - i), SEEK_CUR);
-        if (r < 0)
+        if (r == (off_t)-1)
                 die("lseek");
 
         if (str) {
@@ -145,8 +145,9 @@ static void read_proc_kallsyms(void)
         if (!size)
                 return;
 
-        buf = malloc_or_die(size);
+        buf = malloc_or_die(size + 1);
         read_or_die(buf, size);
+        buf[size] = '\0';
 
         parse_proc_kallsyms(buf, size);
 
@@ -281,8 +282,8 @@ static void update_cpu_data_index(int cpu)
 
 static void get_next_page(int cpu)
 {
-        off64_t save_seek;
-        off64_t ret;
+        off_t save_seek;
+        off_t ret;
 
         if (!cpu_data[cpu].page)
                 return;
@@ -297,17 +298,17 @@ static void get_next_page(int cpu)
                 update_cpu_data_index(cpu);
 
                 /* other parts of the code may expect the pointer to not move */
-                save_seek = lseek64(input_fd, 0, SEEK_CUR);
+                save_seek = lseek(input_fd, 0, SEEK_CUR);
 
-                ret = lseek64(input_fd, cpu_data[cpu].offset, SEEK_SET);
-                if (ret < 0)
+                ret = lseek(input_fd, cpu_data[cpu].offset, SEEK_SET);
+                if (ret == (off_t)-1)
                         die("failed to lseek");
                 ret = read(input_fd, cpu_data[cpu].page, page_size);
                 if (ret < 0)
                         die("failed to read page");
 
                 /* reset the file pointer back */
-                lseek64(input_fd, save_seek, SEEK_SET);
+                lseek(input_fd, save_seek, SEEK_SET);
 
                 return;
         }
@@ -458,9 +459,8 @@ struct record *trace_read_data(int cpu)
         return data;
 }
 
-void trace_report(void)
+void trace_report(int fd)
 {
-        const char *input_file = "trace.info";
         char buf[BUFSIZ];
         char test[] = { 23, 8, 68 };
         char *version;
@@ -468,17 +468,15 @@ void trace_report(void)
         int show_funcs = 0;
         int show_printk = 0;
 
-        input_fd = open(input_file, O_RDONLY);
-        if (input_fd < 0)
-                die("opening '%s'\n", input_file);
+        input_fd = fd;
 
         read_or_die(buf, 3);
         if (memcmp(buf, test, 3) != 0)
-                die("not an trace data file");
+                die("no trace data in the file");
 
         read_or_die(buf, 7);
         if (memcmp(buf, "tracing", 7) != 0)
-                die("not a trace file (missing tracing)");
+                die("not a trace file (missing 'tracing' tag)");
 
         version = read_string();
         if (show_version)
diff --git a/tools/perf/util/trace-event-scripting.c b/tools/perf/util/trace-event-scripting.c
new file mode 100644
index 000000000000..7ea983acfaea
--- /dev/null
+++ b/tools/perf/util/trace-event-scripting.c
@@ -0,0 +1,167 @@
+/*
+ * trace-event-scripting.  Scripting engine common and initialization code.
+ *
+ * Copyright (C) 2009-2010 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "../perf.h"
+#include "util.h"
+#include "trace-event.h"
+
+struct scripting_context *scripting_context;
+
+static int stop_script_unsupported(void)
+{
+        return 0;
+}
+
+static void process_event_unsupported(int cpu __unused,
+                                      void *data __unused,
+                                      int size __unused,
+                                      unsigned long long nsecs __unused,
+                                      char *comm __unused)
+{
+}
+
+static void print_python_unsupported_msg(void)
+{
+        fprintf(stderr, "Python scripting not supported."
+                "  Install libpython and rebuild perf to enable it.\n"
+                "For example:\n  # apt-get install python-dev (ubuntu)"
+                "\n  # yum install python-devel (Fedora)"
+                "\n  etc.\n");
+}
+
+static int python_start_script_unsupported(const char *script __unused,
+                                           int argc __unused,
+                                           const char **argv __unused)
+{
+        print_python_unsupported_msg();
+
+        return -1;
+}
+
+static int python_generate_script_unsupported(const char *outfile __unused)
+{
+        print_python_unsupported_msg();
+
+        return -1;
+}
+
+struct scripting_ops python_scripting_unsupported_ops = {
+        .name = "Python",
+        .start_script = python_start_script_unsupported,
+        .stop_script = stop_script_unsupported,
+        .process_event = process_event_unsupported,
+        .generate_script = python_generate_script_unsupported,
+};
+
+static void register_python_scripting(struct scripting_ops *scripting_ops)
+{
+        int err;
+        err = script_spec_register("Python", scripting_ops);
+        if (err)
+                die("error registering Python script extension");
+
+        err = script_spec_register("py", scripting_ops);
+        if (err)
+                die("error registering py script extension");
+
+        scripting_context = malloc(sizeof(struct scripting_context));
+}
+
+#ifdef NO_LIBPYTHON
+void setup_python_scripting(void)
+{
+        register_python_scripting(&python_scripting_unsupported_ops);
+}
+#else
+struct scripting_ops python_scripting_ops;
+
+void setup_python_scripting(void)
+{
+        register_python_scripting(&python_scripting_ops);
+}
+#endif
+
+static void print_perl_unsupported_msg(void)
+{
+        fprintf(stderr, "Perl scripting not supported."
+                "  Install libperl and rebuild perf to enable it.\n"
+                "For example:\n  # apt-get install libperl-dev (ubuntu)"
+                "\n  # yum install 'perl(ExtUtils::Embed)' (Fedora)"
+                "\n  etc.\n");
+}
+
+static int perl_start_script_unsupported(const char *script __unused,
+                                         int argc __unused,
+                                         const char **argv __unused)
+{
+        print_perl_unsupported_msg();
+
+        return -1;
+}
+
+static int perl_generate_script_unsupported(const char *outfile __unused)
+{
+        print_perl_unsupported_msg();
+
+        return -1;
+}
+
+struct scripting_ops perl_scripting_unsupported_ops = {
+        .name = "Perl",
+        .start_script = perl_start_script_unsupported,
+        .stop_script = stop_script_unsupported,
+        .process_event = process_event_unsupported,
+        .generate_script = perl_generate_script_unsupported,
+};
+
+static void register_perl_scripting(struct scripting_ops *scripting_ops)
+{
+        int err;
+        err = script_spec_register("Perl", scripting_ops);
+        if (err)
+                die("error registering Perl script extension");
+
+        err = script_spec_register("pl", scripting_ops);
+        if (err)
+                die("error registering pl script extension");
+
+        scripting_context = malloc(sizeof(struct scripting_context));
+}
+
+#ifdef NO_LIBPERL
+void setup_perl_scripting(void)
+{
+        register_perl_scripting(&perl_scripting_unsupported_ops);
+}
+#else
+struct scripting_ops perl_scripting_ops;
+
+void setup_perl_scripting(void)
+{
+        register_perl_scripting(&perl_scripting_ops);
+}
+#endif
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 693f815c9429..c3269b937db4 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -1,5 +1,5 @@
-#ifndef _TRACE_EVENTS_H
-#define _TRACE_EVENTS_H
+#ifndef __PERF_TRACE_EVENTS_H
+#define __PERF_TRACE_EVENTS_H
 
 #include "parse-events.h"
 
@@ -26,6 +26,11 @@ enum {
 enum format_flags {
         FIELD_IS_ARRAY          = 1,
         FIELD_IS_POINTER        = 2,
+        FIELD_IS_SIGNED         = 4,
+        FIELD_IS_STRING         = 8,
+        FIELD_IS_DYNAMIC        = 16,
+        FIELD_IS_FLAG           = 32,
+        FIELD_IS_SYMBOLIC       = 64,
 };
 
 struct format_field {
@@ -132,15 +137,18 @@ struct event {
         int                     flags;
         struct format           format;
         struct print_fmt        print_fmt;
+        char                    *system;
 };
 
 enum {
-        EVENT_FL_ISFTRACE       = 1,
-        EVENT_FL_ISPRINT        = 2,
-        EVENT_FL_ISBPRINT       = 4,
-        EVENT_FL_ISFUNC         = 8,
-        EVENT_FL_ISFUNCENT      = 16,
-        EVENT_FL_ISFUNCRET      = 32,
+        EVENT_FL_ISFTRACE       = 0x01,
+        EVENT_FL_ISPRINT        = 0x02,
+        EVENT_FL_ISBPRINT       = 0x04,
+        EVENT_FL_ISFUNC         = 0x08,
+        EVENT_FL_ISFUNCENT      = 0x10,
+        EVENT_FL_ISFUNCRET      = 0x20,
+
+        EVENT_FL_FAILED         = 0x80000000
 };
 
 struct record {
@@ -154,7 +162,7 @@ struct record *trace_read_data(int cpu);
 
 void parse_set_info(int nr_cpus, int long_sz);
 
-void trace_report(void);
+void trace_report(int fd);
 
 void *malloc_or_die(unsigned int size);
 
@@ -166,7 +174,7 @@ void print_funcs(void);
 void print_printk(void);
 
 int parse_ftrace_file(char *buf, unsigned long size);
-int parse_event_file(char *buf, unsigned long size, char *system);
+int parse_event_file(char *buf, unsigned long size, char *sys);
 void print_event(int cpu, void *data, int size, unsigned long long nsecs,
                   char *comm);
 
@@ -233,13 +241,53 @@ extern int header_page_size_size;
 extern int header_page_data_offset;
 extern int header_page_data_size;
 
+extern int latency_format;
+
 int parse_header_page(char *buf, unsigned long size);
 int trace_parse_common_type(void *data);
+int trace_parse_common_pid(void *data);
+int parse_common_pc(void *data);
+int parse_common_flags(void *data);
+int parse_common_lock_depth(void *data);
 struct event *trace_find_event(int id);
+struct event *trace_find_next_event(struct event *event);
+unsigned long long read_size(void *ptr, int size);
 unsigned long long
 raw_field_value(struct event *event, const char *name, void *data);
 void *raw_field_ptr(struct event *event, const char *name, void *data);
+unsigned long long eval_flag(const char *flag);
+
+int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events);
+
+/* taken from kernel/trace/trace.h */
+enum trace_flag_type {
+        TRACE_FLAG_IRQS_OFF             = 0x01,
+        TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
+        TRACE_FLAG_NEED_RESCHED         = 0x04,
+        TRACE_FLAG_HARDIRQ              = 0x08,
+        TRACE_FLAG_SOFTIRQ              = 0x10,
+};
+
+struct scripting_ops {
+        const char *name;
+        int (*start_script) (const char *script, int argc, const char **argv);
+        int (*stop_script) (void);
+        void (*process_event) (int cpu, void *data, int size,
+                               unsigned long long nsecs, char *comm);
+        int (*generate_script) (const char *outfile);
+};
+
+int script_spec_register(const char *spec, struct scripting_ops *ops);
+
+void setup_perl_scripting(void);
+void setup_python_scripting(void);
+
+struct scripting_context {
+        void *event_data;
+};
 
-void read_tracing_data(struct perf_event_attr *pattrs, int nb_events);
+int common_pc(struct scripting_context *context);
+int common_flags(struct scripting_context *context);
+int common_lock_depth(struct scripting_context *context);
 
-#endif /* _TRACE_EVENTS_H */
+#endif /* __PERF_TRACE_EVENTS_H */
diff --git a/tools/perf/util/types.h b/tools/perf/util/types.h
index 5e75f9005940..7d6b8331f898 100644
--- a/tools/perf/util/types.h
+++ b/tools/perf/util/types.h
@@ -1,5 +1,5 @@
-#ifndef _PERF_TYPES_H
-#define _PERF_TYPES_H
+#ifndef __PERF_TYPES_H
+#define __PERF_TYPES_H
 
 /*
  * We define u64 as unsigned long long for every architecture
@@ -14,4 +14,4 @@ typedef signed short	   s16;
 typedef unsigned char      u8;
 typedef signed char        s8;
 
-#endif /* _PERF_TYPES_H */
+#endif /* __PERF_TYPES_H */
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
new file mode 100644
index 000000000000..f9b890fde681
--- /dev/null
+++ b/tools/perf/util/util.c
@@ -0,0 +1,94 @@
+#include "util.h"
+#include <sys/mman.h>
+
+int mkdir_p(char *path, mode_t mode)
+{
+        struct stat st;
+        int err;
+        char *d = path;
+
+        if (*d != '/')
+                return -1;
+
+        if (stat(path, &st) == 0)
+                return 0;
+
+        while (*++d == '/');
+
+        while ((d = strchr(d, '/'))) {
+                *d = '\0';
+                err = stat(path, &st) && mkdir(path, mode);
+                *d++ = '/';
+                if (err)
+                        return -1;
+                while (*d == '/')
+                        ++d;
+        }
+        return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
+}
+
+static int slow_copyfile(const char *from, const char *to)
+{
+        int err = 0;
+        char *line = NULL;
+        size_t n;
+        FILE *from_fp = fopen(from, "r"), *to_fp;
+
+        if (from_fp == NULL)
+                goto out;
+
+        to_fp = fopen(to, "w");
+        if (to_fp == NULL)
+                goto out_fclose_from;
+
+        while (getline(&line, &n, from_fp) > 0)
+                if (fputs(line, to_fp) == EOF)
+                        goto out_fclose_to;
+        err = 0;
+out_fclose_to:
+        fclose(to_fp);
+        free(line);
+out_fclose_from:
+        fclose(from_fp);
+out:
+        return err;
+}
+
+int copyfile(const char *from, const char *to)
+{
+        int fromfd, tofd;
+        struct stat st;
+        void *addr;
+        int err = -1;
+
+        if (stat(from, &st))
+                goto out;
+
+        if (st.st_size == 0) /* /proc? do it slowly... */
+                return slow_copyfile(from, to);
+
+        fromfd = open(from, O_RDONLY);
+        if (fromfd < 0)
+                goto out;
+
+        tofd = creat(to, 0755);
+        if (tofd < 0)
+                goto out_close_from;
+
+        addr = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fromfd, 0);
+        if (addr == MAP_FAILED)
+                goto out_close_to;
+
+        if (write(tofd, addr, st.st_size) == st.st_size)
+                err = 0;
+
+        munmap(addr, st.st_size);
+out_close_to:
+        close(tofd);
+        if (err)
+                unlink(to);
+out_close_from:
+        close(fromfd);
+out:
+        return err;
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 9de2329dd44d..0f5b2a6f1080 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -84,6 +84,9 @@
 #include <iconv.h>
 #endif
 
+extern const char *graph_line;
+extern const char *graph_dotted_line;
+
 /* On most systems <limits.h> would have given us this, but
  * not on some systems (e.g. GNU/Hurd).
  */
@@ -134,6 +137,15 @@ extern void die(const char *err, ...) NORETURN __attribute__((format (printf, 1,
 extern int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 extern void warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 
+#include "../../../include/linux/stringify.h"
+
+#define DIE_IF(cnd)     \
+        do { if (cnd)   \
+                die(" at (" __FILE__ ":" __stringify(__LINE__) "): "    \
+                    __stringify(cnd) "\n");                             \
+        } while (0)
+
+
 extern void set_die_routine(void (*routine)(const char *err, va_list params) NORETURN);
 
 extern int prefixcmp(const char *str, const char *prefix);
@@ -278,17 +290,15 @@ static inline char *gitstrchrnul(const char *s, int c)
  * Wrappers:
  */
 extern char *xstrdup(const char *str);
-extern void *xmalloc(size_t size);
+extern void *xmalloc(size_t size) __attribute__((weak));
 extern void *xmemdupz(const void *data, size_t len);
 extern char *xstrndup(const char *str, size_t len);
-extern void *xrealloc(void *ptr, size_t size);
-extern void *xcalloc(size_t nmemb, size_t size);
-extern void *xmmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
-extern ssize_t xread(int fd, void *buf, size_t len);
-extern ssize_t xwrite(int fd, const void *buf, size_t len);
-extern int xdup(int fd);
-extern FILE *xfdopen(int fd, const char *mode);
-extern int xmkstemp(char *template);
+extern void *xrealloc(void *ptr, size_t size) __attribute__((weak));
+
+static inline void *zalloc(size_t size)
+{
+        return calloc(1, size);
+}
 
 static inline size_t xsize_t(off_t len)
 {
@@ -306,6 +316,7 @@ static inline int has_extension(const char *filename, const char *ext)
 #undef isascii
 #undef isspace
 #undef isdigit
+#undef isxdigit
 #undef isalpha
 #undef isprint
 #undef isalnum
@@ -323,6 +334,8 @@ extern unsigned char sane_ctype[256];
 #define isascii(x) (((x) & ~0x7f) == 0)
 #define isspace(x) sane_istest(x,GIT_SPACE)
 #define isdigit(x) sane_istest(x,GIT_DIGIT)
+#define isxdigit(x)     \
+        (sane_istest(toupper(x), GIT_ALPHA | GIT_DIGIT) && toupper(x) < 'G')
 #define isalpha(x) sane_istest(x,GIT_ALPHA)
 #define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
 #define isprint(x) sane_istest(x,GIT_PRINT)
@@ -390,4 +403,7 @@ void git_qsort(void *base, size_t nmemb, size_t size,
 #endif
 #endif
 
+int mkdir_p(char *path, mode_t mode);
+int copyfile(const char *from, const char *to);
+
 #endif
diff --git a/tools/perf/util/values.c b/tools/perf/util/values.c
index 1c15e39f99e3..cfa55d686e3b 100644
--- a/tools/perf/util/values.c
+++ b/tools/perf/util/values.c
@@ -169,6 +169,7 @@ static void perf_read_values__display_pretty(FILE *fp,
                                 counterwidth[j], values->value[i][j]);
                 fprintf(fp, "\n");
         }
+        free(counterwidth);
 }
 
 static void perf_read_values__display_raw(FILE *fp,
diff --git a/tools/perf/util/values.h b/tools/perf/util/values.h
index cadf8cf2a590..2fa967e1a88a 100644
--- a/tools/perf/util/values.h
+++ b/tools/perf/util/values.h
@@ -1,5 +1,5 @@
-#ifndef _PERF_VALUES_H
-#define _PERF_VALUES_H
+#ifndef __PERF_VALUES_H
+#define __PERF_VALUES_H
 
 #include "types.h"
 
@@ -24,4 +24,4 @@ void perf_read_values_add_value(struct perf_read_values *values,
 void perf_read_values_display(FILE *fp, struct perf_read_values *values,
                               int raw);
 
-#endif /* _PERF_VALUES_H */
+#endif /* __PERF_VALUES_H */
diff --git a/tools/perf/util/wrapper.c b/tools/perf/util/wrapper.c
index 4574ac28396f..bf44ca85d23b 100644
--- a/tools/perf/util/wrapper.c
+++ b/tools/perf/util/wrapper.c
@@ -79,43 +79,12 @@ void *xrealloc(void *ptr, size_t size)
         return ret;
 }
 
-void *xcalloc(size_t nmemb, size_t size)
-{
-        void *ret = calloc(nmemb, size);
-        if (!ret && (!nmemb || !size))
-                ret = calloc(1, 1);
-        if (!ret) {
-                release_pack_memory(nmemb * size, -1);
-                ret = calloc(nmemb, size);
-                if (!ret && (!nmemb || !size))
-                        ret = calloc(1, 1);
-                if (!ret)
-                        die("Out of memory, calloc failed");
-        }
-        return ret;
-}
-
-void *xmmap(void *start, size_t length,
-        int prot, int flags, int fd, off_t offset)
-{
-        void *ret = mmap(start, length, prot, flags, fd, offset);
-        if (ret == MAP_FAILED) {
-                if (!length)
-                        return NULL;
-                release_pack_memory(length, fd);
-                ret = mmap(start, length, prot, flags, fd, offset);
-                if (ret == MAP_FAILED)
-                        die("Out of memory? mmap failed: %s", strerror(errno));
-        }
-        return ret;
-}
-
 /*
  * xread() is the same a read(), but it automatically restarts read()
  * operations with a recoverable error (EAGAIN and EINTR). xread()
  * DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
  */
-ssize_t xread(int fd, void *buf, size_t len)
+static ssize_t xread(int fd, void *buf, size_t len)
 {
         ssize_t nr;
         while (1) {
@@ -131,7 +100,7 @@ ssize_t xread(int fd, void *buf, size_t len)
  * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
  * GUARANTEE that "len" bytes is written even if the operation is successful.
  */
-ssize_t xwrite(int fd, const void *buf, size_t len)
+static ssize_t xwrite(int fd, const void *buf, size_t len)
 {
         ssize_t nr;
         while (1) {
@@ -179,29 +148,3 @@ ssize_t write_in_full(int fd, const void *buf, size_t count)
 
         return total;
 }
-
-int xdup(int fd)
-{
-        int ret = dup(fd);
-        if (ret < 0)
-                die("dup failed: %s", strerror(errno));
-        return ret;
-}
-
-FILE *xfdopen(int fd, const char *mode)
-{
-        FILE *stream = fdopen(fd, mode);
-        if (stream == NULL)
-                die("Out of memory? fdopen failed: %s", strerror(errno));
-        return stream;
-}
-
-int xmkstemp(char *template)
-{
-        int fd;
-
-        fd = mkstemp(template);
-        if (fd < 0)
-                die("Unable to create temporary file: %s", strerror(errno));
-        return fd;
-}