128 files changed, 13878 insertions, 4972 deletions

diff --git a/tools/perf/.gitignore b/tools/perf/.gitignore
index 0854f110bf7f..fe08660ce0bd 100644
--- a/tools/perf/.gitignore
+++ b/tools/perf/.gitignore
@@ -12,6 +12,7 @@ perf*.1
 perf*.xml
 perf*.html
 common-cmds.h
+perf.data
 tags
 TAGS
 cscope*
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-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-probe.txt b/tools/perf/Documentation/perf-probe.txt
new file mode 100644
index 000000000000..250e391b4bc8
--- /dev/null
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -0,0 +1,61 @@
+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
+
+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 a probe event.
+
+-l::
+--list::
+        List up current probe events.
+
+PROBE SYNTAX
+------------
+Probe points are defined by following syntax.
+
+ "[EVENT=]FUNC[+OFFS|:RLN|%return][@SRC]|SRC:ALN [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. 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 by using 'SRC:ALN' syntax, where 'SRC' is the source file path and 'ALN' is the line number.
+'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).
+
+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-trace-perl.txt b/tools/perf/Documentation/perf-trace-perl.txt
new file mode 100644
index 000000000000..c5f55f439091
--- /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 [lang]:script[.ext] ]
+
+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.txt b/tools/perf/Documentation/perf-trace.txt
index 41ed75398ca9..60e5900da483 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -8,18 +8,52 @@ 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.
+
+  '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.
+
 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::
+--script=::
+        Process trace data with the given script ([lang]:script[.ext]).
+
+-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]
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 7e190d522cd5..4390d225686d 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,8 +191,15 @@ 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
+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)
 ALL_LDFLAGS = $(LDFLAGS)
 STRIP ?= strip
@@ -239,8 +237,8 @@ lib = lib
 
 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 +250,9 @@ PTHREAD_LIBS = -lpthread
 # explicitly what architecture to check for. Fix this up for yours..
 SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
 
+ifeq ($(shell sh -c "echo 'int foo(void) {char X[2]; return 3;}' | $(CC) -x c -c -Werror -fstack-protector-all - -o /dev/null "$(QUIET_STDERR)" && echo y"), y)
+  CFLAGS := $(CFLAGS) -fstack-protector-all
+endif
 
 
 ### --- END CONFIGURATION SECTION ---
@@ -327,30 +328,58 @@ 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/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/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/debugfs.h
+LIB_H += util/event.h
 LIB_H += util/types.h
 LIB_H += util/levenshtein.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/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/probe-finder.h
+LIB_H += util/probe-event.h
 
 LIB_OBJS += util/abspath.o
 LIB_OBJS += util/alias.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 +387,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 +399,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 +406,31 @@ 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-perl.o
 LIB_OBJS += util/svghelper.o
+LIB_OBJS += util/sort.o
+LIB_OBJS += util/hist.o
+LIB_OBJS += util/data_map.o
+LIB_OBJS += util/probe-event.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-list.o
 BUILTIN_OBJS += builtin-record.o
 BUILTIN_OBJS += builtin-report.o
@@ -391,9 +438,16 @@ 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
 
 PERFLIBS = $(LIB_FILE)
 
+ifeq ($(V), 2)
+        QUIET_STDERR = ">/dev/null"
+else
+        QUIET_STDERR = ">/dev/null 2>&1"
+endif
 #
 # Platform specific tweaks
 #
@@ -421,36 +475,61 @@ 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) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o /dev/null $(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) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o /dev/null $(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) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o /dev/null $(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 '\#ifndef _MIPS_SZLONG'; echo '\#define _MIPS_SZLONG 0'; echo '\#endif'; echo '\#include <dwarf.h>'; echo '\#include <libdwarf.h>'; echo 'int main(void) { Dwarf_Debug dbg; Dwarf_Error err; Dwarf_Ranges *rng; dwarf_init(0, DW_DLC_READ, 0, 0, &dbg, &err); dwarf_get_ranges(dbg, 0, &rng, 0, 0, &err); return (long)dbg; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -I/usr/include/libdwarf -ldwarf -lelf -o /dev/null $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y)
+        msg := $(warning No libdwarf.h found or old libdwarf.h found, disables dwarf support. Please install libdwarf-dev/libdwarf-devel >= 20081231);
+        BASIC_CFLAGS += -DNO_LIBDWARF
+else
+        BASIC_CFLAGS += -I/usr/include/libdwarf
+        EXTLIBS += -lelf -ldwarf
+        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 /dev/null $(PERL_EMBED_LDOPTS) > /dev/null 2>&1 && echo y"), y)
+        BASIC_CFLAGS += -DNO_LIBPERL
+else
+        ALL_LDFLAGS += $(PERL_EMBED_LDOPTS)
+        LIB_OBJS += scripts/perl/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 /dev/null $(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 /dev/null $(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 /dev/null $(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 /dev/null $(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
@@ -787,6 +866,25 @@ 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/trace-event-perl.o: util/trace-event-perl.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o util/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 $<
+
 perf-%$X: %.o $(PERFLIBS)
         $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)
 
@@ -894,6 +992,11 @@ 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) 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'
 ifdef BUILT_INS
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
         $(INSTALL) $(BUILT_INS) '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
@@ -979,7 +1082,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*
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..593ff25006de 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,247 +46,33 @@ 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,
+struct sym_priv {
+        struct sym_hist *hist;
+        struct sym_ext  *ext;
 };
 
-/* --sort symbol */
+static const char *sym_hist_filter;
 
-static int64_t
-sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
+static int symbol_filter(struct map *map __used, struct symbol *sym)
 {
-        u64 ip_l, ip_r;
+        if (sym_hist_filter == NULL ||
+            strcmp(sym->name, sym_hist_filter) == 0) {
+                struct sym_priv *priv = symbol__priv(sym);
+                const int size = (sizeof(*priv->hist) +
+                                  (sym->end - sym->start) * sizeof(u64));
 
-        if (left->sym == right->sym)
+                priv->hist = malloc(size);
+                if (priv->hist)
+                        memset(priv->hist, 0, size);
                 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;
-};
-
-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 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;
+        /*
+         * FIXME: We should really filter it out, as we don't want to go thru symbols
+         * we're not interested, and if a DSO ends up with no symbols, delete it too,
+         * but right now the kernel loading routines in symbol.c bail out if no symbols
+         * are found, fix it later.
+         */
+        return 0;
 }
 
 /*
@@ -299,380 +82,83 @@ static void 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)
+        if (!sym || !he->map)
+                return;
+
+        priv = symbol__priv(sym);
+        if (!priv->hist)
                 return;
 
         sym_size = sym->end - sym->start;
         offset = ip - sym->start;
 
+        if (verbose)
+                fprintf(stderr, "%s: ip=%Lx\n", __func__,
+                        he->map->unmap_ip(he->map, ip));
+
         if (offset >= sym_size)
                 return;
 
-        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]);
+                        h->ip[offset]);
 }
 
-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;
-        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 (cmp < 0)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-
-        he = malloc(sizeof(*he));
-        if (!he)
+        bool hit;
+        struct hist_entry *he = __perf_session__add_hist_entry(self, 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);
-
+        hist_hit(he, al->addr);
         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);
-}
-
-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);
+        struct addr_location al;
 
-        while (next) {
-                n = rb_entry(next, struct hist_entry, rb_node);
-                next = rb_next(&n->rb_node);
+        dump_printf("(IP, %d): %d: %p\n", event->header.misc,
+                    event->ip.pid, (void *)(long)event->ip.ip);
 
-                rb_erase(&n->rb_node, tree);
-                output__insert_entry(n);
-        }
-}
-
-static unsigned long total = 0,
-                     total_mmap = 0,
-                     total_comm = 0,
-                     total_fork = 0,
-                     total_unknown = 0;
-
-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) {
+        if (event__preprocess_sample(event, session, &al, symbol_filter) < 0) {
                 fprintf(stderr, "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;
-                }
-        }
-        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;
-}
-
-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(thread, event->comm.comm)) {
-                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
-                return -1;
-        }
-        total_comm++;
-
-        return 0;
-}
-
-static int
-process_fork_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);
-        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");
+        if (!al.filtered && perf_session__add_hist_entry(session, &al, 1)) {
+                fprintf(stderr, "problem incrementing symbol count, "
+                                "skipping event\n");
                 return -1;
         }
-        total_fork++;
 
         return 0;
 }
 
-static int
-process_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        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;
-
-        default:
-                return -1;
-        }
-
-        return 0;
-}
-
-static int
-parse_line(FILE *file, struct symbol *sym, u64 start, u64 len)
+static int parse_line(FILE *file, struct hist_entry *he, u64 len)
 {
+        struct symbol *sym = he->sym;
         char *line = NULL, *tmp, *tmp2;
         static const char *prev_line;
         static const char *prev_color;
         unsigned int offset;
         size_t line_len;
+        u64 start;
         s64 line_ip;
         int ret;
         char *c;
@@ -709,22 +195,26 @@ parse_line(FILE *file, struct symbol *sym, u64 start, u64 len)
                         line_ip = -1;
         }
 
+        start = he->map->unmap_ip(he->map, sym->start);
+
         if (line_ip != -1) {
                 const char *path = NULL;
                 unsigned int hits = 0;
                 double percent = 0.0;
                 const char *color;
-                struct sym_ext *sym_ext = sym->priv;
+                struct sym_priv *priv = symbol__priv(sym);
+                struct sym_ext *sym_ext = priv->ext;
+                struct sym_hist *h = priv->hist;
 
                 offset = line_ip - start;
                 if (offset < len)
-                        hits = sym->hist[offset];
+                        hits = h->ip[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;
+                } else if (h->sum)
+                        percent = 100.0 * hits / h->sum;
 
                 color = get_percent_color(percent);
 
@@ -777,9 +267,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 +280,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 +311,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 +365,34 @@ static void print_summary(const char *filename)
         }
 }
 
-static void annotate_sym(struct dso *dso, struct symbol *sym)
+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;
 
         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;
+
+        if (verbose)
+                fprintf(stderr, "%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 +401,12 @@ 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->unmap_ip(map, sym->start), map->unmap_ip(map, sym->end),
+                filename, filename);
 
         if (verbose >= 3)
                 printf("doing: %s\n", command);
@@ -918,159 +416,78 @@ 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, len) < 0)
                         break;
         }
 
         pclose(file);
         if (print_line)
-                free_source_line(sym, len);
+                free_source_line(he, len);
 }
 
-static void find_annotations(void)
+static void perf_session__find_annotations(struct perf_session *self)
 {
         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 (sym->hist) {
-                                annotate_sym(dso, sym);
-                                count++;
-                        }
-                }
-        }
-
-        if (!count)
-                printf(" Error: symbol '%s' not present amongst the samples.\n", sym_hist_filter);
-}
-
-static int __cmd_annotate(void)
-{
-        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;
+        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;
 
-                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);
-
-        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);
+                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 = {
+        .process_sample_event   = process_sample_event,
+        .process_mmap_event     = event__process_mmap,
+        .process_comm_event     = event__process_comm,
+        .process_fork_event     = 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);
+        perf_session__output_resort(session, 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 +505,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 +516,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 +539,13 @@ 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 == '.') {
+                fputs("'.' is the only non valid --field-separator argument\n",
+                                stderr);
+                exit(129);
+        }
+
         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-list.c b/tools/perf/builtin-buildid-list.c
new file mode 100644
index 000000000000..e693e6777af5
--- /dev/null
+++ b/tools/perf/builtin-buildid-list.c
@@ -0,0 +1,77 @@
+/*
+ * 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/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 const char *const buildid_list_usage[] = {
+        "perf buildid-list [<options>]",
+        NULL
+};
+
+static const struct option options[] = {
+        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 perf_file_section__process_buildids(struct perf_file_section *self,
+                                               int feat, int fd)
+{
+        if (feat != HEADER_BUILD_ID)
+                return 0;
+
+        if (lseek(fd, self->offset, SEEK_SET) < 0) {
+                pr_warning("Failed to lseek to %Ld offset for buildids!\n",
+                           self->offset);
+                return -1;
+        }
+
+        if (perf_header__read_build_ids(fd, self->offset, self->size)) {
+                pr_warning("Failed to read buildids!\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+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;
+
+        err = perf_header__process_sections(&session->header, session->fd,
+                                         perf_file_section__process_buildids);
+        if (err >= 0)
+                dsos__fprintf_buildid(stdout);
+
+        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..4d33b55d5584
--- /dev/null
+++ b/tools/perf/builtin-diff.c
@@ -0,0 +1,248 @@
+/*
+ * 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, 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: %p\n", event->header.misc,
+                    event->ip.pid, (void *)(long)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)
+                return 0;
+
+        event__parse_sample(event, session->sample_type, &data);
+
+        if (al.sym && 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 = {
+        .process_sample_event = diff__process_sample_event,
+        .process_mmap_event   = event__process_mmap,
+        .process_comm_event   = event__process_comm,
+        .process_exit_event   = event__process_task,
+        .process_fork_event   = event__process_task,
+        .process_lost_event   = 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) {
+                int cmp;
+                parent = *p;
+                iter = rb_entry(parent, struct hist_entry, rb_node);
+
+                cmp = strcmp(he->map->dso->name, iter->map->dso->name);
+                if (cmp > 0)
+                        p = &(*p)->rb_left;
+                else if (cmp < 0)
+                        p = &(*p)->rb_right;
+                else {
+                        cmp = strcmp(he->sym->name, iter->sym->name);
+                        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);
+}
+
+static void perf_session__resort_by_name(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 struct hist_entry *
+perf_session__find_hist_entry_by_name(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);
+                int cmp = strcmp(he->map->dso->name, iter->map->dso->name);
+
+                if (cmp > 0)
+                        n = n->rb_left;
+                else if (cmp < 0)
+                        n = n->rb_right;
+                else {
+                        cmp = strcmp(he->sym->name, iter->sym->name);
+                        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;
+
+        perf_session__resort_by_name(old_session);
+
+        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_by_name(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[i], session[i]->events_stats.total);
+        }
+
+        perf_session__match_hists(session[0], session[1]);
+        perf_session__fprintf_hists(session[1], session[0],
+                                    show_displacement, stdout);
+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]",
+};
+
+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", &event_ops.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..9f810b17c25c 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);
@@ -364,9 +363,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..fc21ad79dd83
--- /dev/null
+++ b/tools/perf/builtin-kmem.c
@@ -0,0 +1,791 @@
+#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 (true) {
+                dent1 = readdir(dir1);
+                if (!dent1)
+                        break;
+
+                if (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 (true) {
+                        dent2 = readdir(dir2);
+                        if (!dent2)
+                                break;
+                        if (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_req;
+        } 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_req;
+        } 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: %p period: %Ld\n",
+                event->header.misc,
+                data.pid, data.tid,
+                (void *)(long)data.ip,
+                (long long)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 int sample_type_check(struct perf_session *session)
+{
+        if (!(session->sample_type & PERF_SAMPLE_RAW)) {
+                fprintf(stderr,
+                        "No trace sample to read. Did you call perf record "
+                        "without -R?");
+                return -1;
+        }
+
+        return 0;
+}
+
+static struct perf_event_ops event_ops = {
+        .process_sample_event   = process_sample_event,
+        .process_comm_event     = event__process_comm,
+        .sample_type_check      = sample_type_check,
+};
+
+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, session, 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 | %6lu | %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;
+        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
+        if (session == NULL)
+                return -ENOMEM;
+
+        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();
+        }
+
+        return 0;
+}
+
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
new file mode 100644
index 000000000000..c1e6774fd3ed
--- /dev/null
+++ b/tools/perf/builtin-probe.c
@@ -0,0 +1,309 @@
+/*
+ * 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/session.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
+#define MAX_PROBES 128
+
+/* Session management structure */
+static struct {
+        bool need_dwarf;
+        bool list_events;
+        bool force_add;
+        int nr_probe;
+        struct probe_point probes[MAX_PROBES];
+        struct strlist *dellist;
+        struct perf_session *psession;
+        struct map *kmap;
+} 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.kmap, pp->function,
+                                       session.psession, NULL);
+        if (!sym)
+                die("Kernel symbol \'%s\' not found - probe not added.",
+                    pp->function);
+}
+
+#ifndef NO_LIBDWARF
+static int open_vmlinux(void)
+{
+        if (map__load(session.kmap, session.psession, NULL) < 0) {
+                pr_debug("Failed to load kernel map.\n");
+                return -EINVAL;
+        }
+        pr_debug("Try to open %s\n", session.kmap->dso->long_name);
+        return open(session.kmap->dso->long_name, O_RDONLY);
+}
+#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",
+        NULL
+};
+
+static const struct option options[] = {
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose (show parsed arguments, etc)"),
+#ifndef NO_LIBDWARF
+        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_LIBDWARF
+                "[EVENT=]FUNC[+OFFS|%return] [ARG ...]",
+#else
+                "[EVENT=]FUNC[+OFFS|%return|:RLN][@SRC]|SRC:ALN [ARG ...]",
+#endif
+                "probe point definition, where\n"
+                "\t\tGROUP:\tGroup name (optional)\n"
+                "\t\tEVENT:\tEvent name\n"
+                "\t\tFUNC:\tFunction name\n"
+                "\t\tOFFS:\tOffset from function entry (in byte)\n"
+                "\t\t%return:\tPut the probe at function return\n"
+#ifdef NO_LIBDWARF
+                "\t\tARG:\tProbe argument (only \n"
+#else
+                "\t\tSRC:\tSource code path\n"
+                "\t\tRLN:\tRelative line number from function entry.\n"
+                "\t\tALN:\tAbsolute line number in file.\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"),
+        OPT_END()
+};
+
+int cmd_probe(int argc, const char **argv, const char *prefix __used)
+{
+        int i, ret;
+#ifndef NO_LIBDWARF
+        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))
+                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);
+                }
+                show_perf_probe_events();
+                return 0;
+        }
+
+        if (session.dellist) {
+                del_trace_kprobe_events(session.dellist);
+                strlist__delete(session.dellist);
+                if (session.nr_probe == 0)
+                        return 0;
+        }
+
+        /* Initialize symbol maps for vmlinux */
+        symbol_conf.sort_by_name = true;
+        if (symbol_conf.vmlinux_name == NULL)
+                symbol_conf.try_vmlinux_path = true;
+        if (symbol__init() < 0)
+                die("Failed to init symbol map.");
+        session.psession = perf_session__new(NULL, O_WRONLY, false);
+        if (session.psession == NULL)
+                die("Failed to init perf_session.");
+        session.kmap = map_groups__find_by_name(&session.psession->kmaps,
+                                                MAP__FUNCTION,
+                                                "[kernel.kallsyms]");
+        if (!session.kmap)
+                die("Could not find kernel map.\n");
+
+        if (session.need_dwarf)
+#ifdef NO_LIBDWARF
+                die("Debuginfo-analysis is not supported");
+#else   /* !NO_LIBDWARF */
+                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_probepoint(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_LIBDWARF */
+
+        /* 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..63136d0534d4 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -17,55 +17,53 @@
 #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 <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;
 
-struct perf_header              *header;
+static struct perf_session      *session;
 
 struct mmap_data {
         int                     counter;
@@ -113,6 +111,25 @@ static void write_output(void *buf, size_t size)
         }
 }
 
+static void write_event(event_t *buf, size_t size)
+{
+        /*
+        * Add it to the list of DSOs, so that when we finish this
+         * record session we can pick the available build-ids.
+         */
+        if (buf->header.type == PERF_RECORD_MMAP)
+                dsos__findnew(buf->mmap.filename);
+
+        write_output(buf, size);
+}
+
+static int process_synthesized_event(event_t *event,
+                                     struct perf_session *self __used)
+{
+        write_event(event, event->header.size);
+        return 0;
+}
+
 static void mmap_read(struct mmap_data *md)
 {
         unsigned int head = mmap_read_head(md);
@@ -161,14 +178,14 @@ static void mmap_read(struct mmap_data *md)
                 size = md->mask + 1 - (old & md->mask);
                 old += size;
 
-                write_output(buf, size);
+                write_event(buf, size);
         }
 
         buf = &data[old & md->mask];
         size = head - old;
         old += size;
 
-        write_output(buf, size);
+        write_event(buf, size);
 
         md->prev = old;
         mmap_write_tail(md, old);
@@ -195,179 +212,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 +234,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;
@@ -417,7 +278,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 +309,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 +335,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 +352,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 +371,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);
 }
 
@@ -516,19 +397,21 @@ static void open_counters(int cpu, pid_t pid)
 
 static void atexit_header(void)
 {
-        header->data_size += bytes_written;
+        session->header.data_size += bytes_written;
 
-        perf_header__write(header, output);
+        perf_header__write(&session->header, output, true);
 }
 
-static int __cmd_record(int argc, const char **argv)
+static int __cmd_record(int argc __used, const char **argv)
 {
         int i, counter;
         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];
+        char buf;
 
         page_size = sysconf(_SC_PAGE_SIZE);
         nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
@@ -539,11 +422,25 @@ static int __cmd_record(int argc, const char **argv)
         signal(SIGCHLD, sig_handler);
         signal(SIGINT, sig_handler);
 
+        if (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 +458,119 @@ 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();
-
-                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 (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();
+        atexit(atexit_header);
 
-        if (target_pid == -1 && argc) {
+        if (target_pid == -1) {
                 pid = fork();
-                if (pid < 0)
+                if (pid < 0) {
                         perror("failed to fork");
+                        exit(-1);
+                }
 
                 if (!pid) {
-                        if (execvp(argv[0], (char **)argv)) {
-                                perror(argv[0]);
-                                exit(-1);
-                        }
+                        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 ((!system_wide && !inherit) || profile_cpu != -1) {
+                open_counters(profile_cpu, target_pid);
+        } else {
+                for (i = 0; i < nr_cpus; i++)
+                        open_counters(i, target_pid);
+        }
+
+        if (file_new) {
+                err = perf_header__write(&session->header, output, false);
+                if (err < 0)
+                        return err;
+        }
+
+        if (!system_wide)
+                event__synthesize_thread(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
+         */
+        close(go_pipe[1]);
+
         for (;;) {
                 int hits = samples;
 
@@ -641,7 +584,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 +620,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 +666,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..5c2ab5357ec6 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -22,27 +22,18 @@
 #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 int              show_threads;
 static struct perf_read_values  show_threads_values;
@@ -50,1043 +41,36 @@ 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)
-{
-        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)
+static int perf_session__add_hist_entry(struct perf_session *self,
+                                        struct addr_location *al,
+                                        struct ip_callchain *chain, u64 count)
 {
-        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 *parent = NULL;
+        struct symbol **syms = NULL, *parent = NULL;
+        bool hit;
         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);
-
-        while (*p != NULL) {
-                parent = *p;
-                he = rb_entry(parent, struct hist_entry, rb_node);
-
-                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
-                        p = &(*p)->rb_right;
-        }
 
-        he = malloc(sizeof(*he));
-        if (!he)
+        if ((sort__has_parent || symbol_conf.use_callchain) && chain)
+                syms = perf_session__resolve_callchain(self, al->thread,
+                                                       chain, &parent);
+        he = __perf_session__add_hist_entry(self, al, parent, count, &hit);
+        if (he == NULL)
                 return -ENOMEM;
-        *he = entry;
-        if (callchain) {
-                callchain_init(&he->callchain);
+
+        if (hit)
+                he->count += count;
+
+        if (symbol_conf.use_callchain) {
+                if (!hit)
+                        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);
-        }
-}
-
-static size_t output__fprintf(FILE *fp, u64 total_samples)
-{
-        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;
-
-                fprintf(fp, "  ");
-                if (se->width)
-                        width = *se->width;
-                else
-                        width = strlen(se->header);
-                for (i = 0; i < width; i++)
-                        fprintf(fp, ".");
-        }
-        fprintf(fp, "\n");
-
-        fprintf(fp, "#\n");
-
-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 (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");
-        }
-        fprintf(fp, "\n");
-
-        free(rem_sq_bracket);
-
-        if (show_threads)
-                perf_read_values_display(fp, &show_threads_values,
-                                         raw_printing_style);
-
-        return ret;
-}
-
-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 +84,60 @@ 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 process_sample_event(event_t *event, struct perf_session *session)
 {
-        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 sample_data data = { .period = 1, };
+        struct addr_location al;
+
+        event__parse_sample(event, session->sample_type, &data);
 
-        dump_printf("%p [%p]: PERF_RECORD_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
+        dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
                 event->header.misc,
-                event->ip.pid, event->ip.tid,
-                (void *)(long)ip,
-                (long long)period);
+                data.pid, data.tid,
+                (void *)(long)data.ip,
+                (long long)data.period);
 
-        if (sample_type & PERF_SAMPLE_CALLCHAIN) {
+        if (session->sample_type & PERF_SAMPLE_CALLCHAIN) {
                 unsigned int i;
 
-                chain = (void *)more_data;
+                dump_printf("... chain: nr:%Lu\n", data.callchain->nr);
 
-                dump_printf("... chain: nr:%Lu\n", chain->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))
-                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");
-                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);
-
-        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)
+        if (al.filtered)
                 return 0;
 
-        if (!thread || !parent || thread__fork(thread, parent)) {
-                dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
+        if (perf_session__add_hist_entry(session, &al, data.callchain, data.period)) {
+                pr_debug("problem incrementing symbol count, skipping event\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;
 
+        session->events_stats.total += data.period;
         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,238 +149,96 @@ 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 sample_type_check(struct perf_session *session)
 {
-        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 (!(session->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 -1;
                 }
-                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 (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 -1;
                         }
         }
 
-        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;
-
-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 munmap_ret;
-
-                shift = page_size * (head / page_size);
-
-                munmap_ret = munmap(buf, page_size * mmap_window);
-                assert(munmap_ret == 0);
-
-                offset += shift;
-                head -= shift;
-                goto remap;
-        }
-
-        size = event->header.size;
+        return 0;
+}
 
-        dump_printf("\n%p [%p]: event: %d\n",
-                        (void *)(offset + head),
-                        (void *)(long)event->header.size,
-                        event->header.type);
+static struct perf_event_ops event_ops = {
+        .process_sample_event   = process_sample_event,
+        .process_mmap_event     = event__process_mmap,
+        .process_comm_event     = event__process_comm,
+        .process_exit_event     = event__process_task,
+        .process_fork_event     = event__process_task,
+        .process_lost_event     = event__process_lost,
+        .process_read_event     = process_read_event,
+        .sample_type_check      = sample_type_check,
+};
 
-        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);
+static int __cmd_report(void)
+{
+        int ret;
+        struct perf_session *session;
 
-                total_unknown++;
+        session = perf_session__new(input_name, O_RDONLY, force);
+        if (session == NULL)
+                return -ENOMEM;
 
-                /*
-                 * assume we lost track of the stream, check alignment, and
-                 * increment a single u64 in the hope to catch on again 'soon'.
-                 */
+        if (show_threads)
+                perf_read_values_init(&show_threads_values);
 
-                if (unlikely(head & 7))
-                        head &= ~7ULL;
+        ret = perf_session__process_events(session, &event_ops);
+        if (ret)
+                goto out_delete;
 
-                size = 8;
+        if (dump_trace) {
+                event__print_totals();
+                goto out_delete;
         }
 
-        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 (verbose > 3)
+                perf_session__fprintf(session, stdout);
 
-        if (dump_trace)
-                return 0;
-
-        if (verbose >= 3)
-                threads__fprintf(stdout, &threads);
-
-        if (verbose >= 2)
+        if (verbose > 2)
                 dsos__fprintf(stdout);
 
-        collapse__resort();
-        output__resort(total);
-        output__fprintf(stdout, total);
+        perf_session__collapse_resort(session);
+        perf_session__output_resort(session, session->events_stats.total);
+        fprintf(stdout, "# Samples: %Ld\n#\n", session->events_stats.total);
+        perf_session__fprintf_hists(session, NULL, false, stdout);
+        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
@@ -1560,7 +248,7 @@ parse_callchain_opt(const struct option *opt __used, const char *arg,
         char *tok;
         char *endptr;
 
-        callchain = 1;
+        symbol_conf.use_callchain = true;
 
         if (!arg)
                 return 0;
@@ -1581,7 +269,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 = true;
 
                 return 0;
         }
@@ -1606,7 +294,8 @@ setup:
         return 0;
 }
 
-static const char * const report_usage[] = {
+//static const char * const report_usage[] = {
+const char * const report_usage[] = {
         "perf report [<options>] <command>",
         NULL
 };
@@ -1618,11 +307,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 +320,46 @@ 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", &event_ops.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_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 +367,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..80209df6cfe8 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,129 @@ 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: %p period: %Ld\n",
+                event->header.misc,
+                data.pid, data.tid,
+                (void *)(long)data.ip,
+                (long long)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;
+        nr_lost_chunks++;
+        nr_lost_events += event->lost.lost;
 
-        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);
+        return 0;
+}
 
-        case PERF_RECORD_MAX:
-        default:
+static int sample_type_check(struct perf_session *session __used)
+{
+        if (!(session->sample_type & PERF_SAMPLE_RAW)) {
+                fprintf(stderr,
+                        "No trace sample to read. Did you call perf record "
+                        "without -R?");
                 return -1;
         }
 
         return 0;
 }
 
+static struct perf_event_ops event_ops = {
+        .process_sample_event   = process_sample_event,
+        .process_comm_event     = event__process_comm,
+        .process_lost_event     = process_lost_event,
+        .sample_type_check      = sample_type_check,
+};
+
 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;
-
-
-        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);
+        int err;
+        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
+        if (session == NULL)
+                return -ENOMEM;
 
-        return rc;
+        err = perf_session__process_events(session, &event_ops);
+        perf_session__delete(session);
+        return err;
 }
 
 static void print_bad_events(void)
@@ -1784,9 +1722,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 +1821,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 +1900,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 +1935,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..c70d72003557 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -50,15 +50,17 @@
 
 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_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_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_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            },
 
 };
 
@@ -125,6 +127,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 &&        \
@@ -235,6 +238,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)
@@ -352,7 +357,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)
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index e8a510d935e5..a589a43112d6 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);
         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,42 @@ static void process_samples(void)
         while (cursor) {
                 event = (void *)&cursor->data;
                 cursor = cursor->next;
-                process_sample_event(event);
+                process_sample_event(event, session);
         }
 }
 
-
-static int __cmd_timechart(void)
+static int sample_type_check(struct perf_session *session)
 {
-        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);
-        }
-
-        header = perf_header__read(input);
-        head = header->data_offset;
-
-        sample_type = perf_header__sample_type(header);
-
-        shift = page_size * (head / page_size);
-        offset += shift;
-        head -= shift;
-
-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;
+        if (!(session->sample_type & PERF_SAMPLE_RAW)) {
+                fprintf(stderr, "No trace samples found in the file.\n"
+                                "Have you used 'perf timechart record' to record it?\n");
+                return -1;
         }
 
-        head += size;
+        return 0;
+}
 
-        if (offset + head >= header->data_offset + header->data_size)
-                goto done;
+static struct perf_event_ops event_ops = {
+        .process_comm_event     = process_comm_event,
+        .process_fork_event     = process_fork_event,
+        .process_exit_event     = process_exit_event,
+        .process_sample_event   = queue_sample_event,
+        .sample_type_check      = sample_type_check,
+};
 
-        if (offset + head < (unsigned long)statbuf.st_size)
-                goto more;
+static int __cmd_timechart(void)
+{
+        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
+        int ret;
 
-done:
-        rc = EXIT_SUCCESS;
-        close(input);
+        if (session == NULL)
+                return -ENOMEM;
 
+        ret = perf_session__process_events(session, &event_ops);
+        if (ret)
+                goto out_delete;
 
-        process_samples();
+        process_samples(session);
 
         end_sample_processing();
 
@@ -1112,9 +1068,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 +1111,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 +1126,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..ddc584b64871 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -20,8 +20,10 @@
 
 #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"
@@ -54,26 +56,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,83 +92,126 @@ 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;
+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;
+        source = syme->src;
 
-        start = sym->obj_start;
-        if (!start)
-                start = sym->start;
-
-        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=0x%016Lx "
+                         "--stop-address=0x%016Lx -dS %s",
+                map->unmap_ip(map, sym->start),
+                map->unmap_ip(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;
@@ -182,24 +231,22 @@ static void parse_source(struct sym_entry *syme)
                         *c = 0;
 
                 src->next = NULL;
-                *syme->lines_tail = src;
-                syme->lines_tail = &src->next;
+                *source->lines_tail = src;
+                source->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;
+                        src->eip = map->unmap_ip(map, src->eip);
                 }
                 if (strlen(src->line)>8 && src->line[16] == ':') {
                         src->eip = strtoull(src->line, NULL, 16);
-                        if (section)
-                                src->eip += section->vma;
+                        src->eip = map->unmap_ip(map, src->eip);
                 }
         }
         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 +254,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 +269,13 @@ 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) {
                 if (line->eip == ip) {
                         line->count[counter]++;
                         break;
@@ -237,32 +284,25 @@ 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);
 }
 
 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);
 
-        if (symbol->module) {
-                idx = strstr(pattern, "\t");
-                if (idx)
-                        *idx = 0;
-        }
-
-        pthread_mutex_lock(&syme->source_lock);
-        for (line = syme->lines; line; line = line->next) {
+        pthread_mutex_lock(&syme->src->lock);
+        for (line = syme->src->lines; line; line = line->next) {
                 if (strstr(line->line, pattern)) {
-                        syme->source = line;
+                        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 +332,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 +374,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 +451,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, max_dso_width;
+        const int win_width = winsize.ws_col - 1;
 
         samples = userspace_samples = 0;
 
@@ -422,6 +464,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 +484,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 +522,57 @@ 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->name_len > sym_width)
+                        sym_width = syme->name_len;
+        }
+
+        printed = 0;
+
+        max_dso_width = winsize.ws_col - sym_width - 29;
+        if (dso_width > max_dso_width)
+                dso_width = max_dso_width;
+        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 +581,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 +639,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 +658,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;
@@ -608,7 +682,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,7 +695,7 @@ static void print_mapped_keys(void)
 
         fprintf(stdout, "\t[f]     profile display filter (count).    \t(%d)\n", count_filter);
 
-        if (vmlinux_name) {
+        if (symbol_conf.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");
@@ -630,6 +704,12 @@ static void print_mapped_keys(void)
         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,6 +723,8 @@ static int key_mapped(int c)
                 case 'z':
                 case 'q':
                 case 'Q':
+                case 'K':
+                case 'U':
                         return 1;
                 case 'E':
                 case 'w':
@@ -650,7 +732,7 @@ static int key_mapped(int c)
                 case 'F':
                 case 's':
                 case 'S':
-                        return vmlinux_name ? 1 : 0;
+                        return symbol_conf.vmlinux_name ? 1 : 0;
                 default:
                         break;
         }
@@ -691,6 +773,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 +802,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 +820,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 +885,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,8 +907,9 @@ 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);
+        syme = symbol__priv(sym);
+        syme->map = map;
+        syme->src = NULL;
         if (!sym_filter_entry && sym_filter && !strcmp(name, sym_filter))
                 sym_filter_entry = syme;
 
@@ -824,75 +920,66 @@ static int symbol_filter(struct dso *self, struct symbol *sym)
                 }
         }
 
-        return 0;
-}
-
-static int parse_symbols(void)
-{
-        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;
-
-        node = rb_first(&kernel_dso->syms);
-        sym = rb_entry(node, struct symbol, rb_node);
-        min_ip = sym->start;
-
-        node = rb_last(&kernel_dso->syms);
-        sym = rb_entry(node, struct symbol, rb_node);
-        max_ip = sym->end;
-
-        if (dump_symtab)
-                dso__fprintf(kernel_dso, stderr);
+        if (!syme->skip)
+                syme->name_len = strlen(sym->name);
 
         return 0;
-
-out_delete_dso:
-        dso__delete(kernel_dso);
-        kernel_dso = NULL;
-        return -1;
 }
 
-/*
- * Binary search in the histogram table and record the hit:
- */
-static void record_ip(u64 ip, int counter)
+static void event__process_sample(const event_t *self,
+                                 struct perf_session *session, 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);
+        u64 ip = self->ip.ip;
+        struct sym_entry *syme;
+        struct addr_location al;
+        u8 origin = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+
+        switch (origin) {
+        case PERF_RECORD_MISC_USER:
+                if (hide_user_symbols)
                         return;
-                }
+                break;
+        case PERF_RECORD_MISC_KERNEL:
+                if (hide_kernel_symbols)
+                        return;
+                break;
+        default:
+                return;
         }
 
-        samples--;
+        if (event__preprocess_sample(self, session, &al, symbol_filter) < 0 ||
+            al.sym == NULL || al.filtered)
+                return;
+
+        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);
+                if (origin == PERF_RECORD_MISC_USER)
+                        ++userspace_samples;
+                ++samples;
+        }
 }
 
-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;
+        default:
+                break;
         }
 
-        record_ip(ip, counter);
+        return 0;
 }
 
 struct mmap_data {
@@ -913,17 +1000,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 +1018,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 +1026,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 +1053,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 +1066,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]);
         }
 }
 
@@ -1018,8 +1091,15 @@ static void start_counter(int i, int counter)
         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 +1157,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 +1179,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 +1199,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 +1225,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,
@@ -1156,6 +1251,8 @@ static const struct option options[] = {
                     "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 +1262,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,13 +1278,31 @@ 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));
+        if (symbol_conf.vmlinux_name == NULL)
+                symbol_conf.try_vmlinux_path = true;
+        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:
          */
         for (counter = 0; counter < nr_counters; counter++) {
@@ -1211,5 +1319,11 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
         if (target_pid != -1 || profile_cpu != -1)
                 nr_cpus = 1;
 
+        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..e2285e28720f 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -5,6 +5,53 @@
 #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"
+
+static char const               *script_name;
+static char const               *generate_script_lang;
+
+static int default_start_script(const char *script __unused,
+                                int argc __unused,
+                                const char **argv __unused)
+{
+        return 0;
+}
+
+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();
+
+        scripting_ops = &default_scripting_ops;
+}
+
+static int cleanup_scripting(void)
+{
+        return scripting_ops->stop_script();
+}
 
 #include "util/parse-options.h"
 
@@ -12,249 +59,457 @@
 #include "util/debug.h"
 
 #include "util/trace-event.h"
+#include "util/exec_cmd.h"
 
-static char             const *input_name = "perf.data";
-static int              input;
-static unsigned long    page_size;
-static unsigned long    mmap_window = 32;
+static char const               *input_name = "perf.data";
 
-static unsigned long    total = 0;
-static unsigned long    total_comm = 0;
+static int process_sample_event(event_t *event, struct perf_session *session)
+{
+        struct sample_data data;
+        struct thread *thread;
 
-static struct rb_root   threads;
-static struct thread    *last_match;
+        memset(&data, 0, sizeof(data));
+        data.time = -1;
+        data.cpu = -1;
+        data.period = 1;
 
-static struct perf_header *header;
-static u64              sample_type;
+        event__parse_sample(event, session->sample_type, &data);
 
+        dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
+                event->header.misc,
+                data.pid, data.tid,
+                (void *)(long)data.ip,
+                (long long)data.period);
 
-static int
-process_comm_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        struct thread *thread;
+        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;
+        }
 
-        thread = threads__findnew(event->comm.pid, &threads, &last_match);
+        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);
+        }
 
-        dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->comm.comm, event->comm.pid);
+        session->events_stats.total += data.period;
+        return 0;
+}
 
-        if (thread == NULL ||
-            thread__set_comm(thread, event->comm.comm)) {
-                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
+static int sample_type_check(struct perf_session *session)
+{
+        if (!(session->sample_type & PERF_SAMPLE_RAW)) {
+                fprintf(stderr,
+                        "No trace sample to read. Did you call perf record "
+                        "without -R?");
                 return -1;
         }
-        total_comm++;
 
         return 0;
 }
 
-static int
-process_sample_event(event_t *event, unsigned long offset, unsigned long head)
+static struct perf_event_ops event_ops = {
+        .process_sample_event   = process_sample_event,
+        .process_comm_event     = event__process_comm,
+        .sample_type_check      = sample_type_check,
+};
+
+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);
 
-        if (sample_type & PERF_SAMPLE_PERIOD) {
-                period = *(u64 *)more_data;
-                more_data += sizeof(u64);
+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 (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);
+}
 
-        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+static struct script_spec *script_spec__find(const char *spec)
+{
+        struct script_spec *s;
 
-        if (cpumode == PERF_RECORD_MISC_KERNEL) {
-                show = SHOW_KERNEL;
-                level = 'k';
+        list_for_each_entry(s, &script_specs, node)
+                if (strcasecmp(s->spec, spec) == 0)
+                        return s;
+        return NULL;
+}
 
-                dso = kernel_dso;
+static struct script_spec *script_spec__findnew(const char *spec,
+                                                struct scripting_ops *ops)
+{
+        struct script_spec *s = script_spec__find(spec);
 
-                dump_printf(" ...... dso: %s\n", dso->name);
+        if (s)
+                return s;
 
-        } else if (cpumode == PERF_RECORD_MISC_USER) {
+        s = script_spec__new(spec, ops);
+        if (!s)
+                goto out_delete_spec;
 
-                show = SHOW_USER;
-                level = '.';
+        script_spec__add(s);
 
-        } else {
-                show = SHOW_HV;
-                level = 'H';
+        return s;
 
-                dso = hypervisor_dso;
+out_delete_spec:
+        script_spec__delete(s);
 
-                dump_printf(" ...... dso: [hypervisor]\n");
-        }
+        return NULL;
+}
 
-        if (sample_type & PERF_SAMPLE_RAW) {
-                struct {
-                        u32 size;
-                        char data[0];
-                } *raw = more_data;
+int script_spec_register(const char *spec, struct scripting_ops *ops)
+{
+        struct script_spec *s;
 
-                /*
-                 * 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__find(spec);
+        if (s)
+                return -1;
+
+        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, "list") == 0) {
+                list_available_languages();
+                return 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);
 
-        if (!(sample_type & PERF_SAMPLE_RAW))
-                die("No trace sample to read. Did you call perf record "
-                    "without -R?");
+        return s;
 
-        if (load_kernel() < 0) {
-                perror("failed to load kernel symbols");
-                return EXIT_FAILURE;
+out_delete_desc:
+        script_desc__delete(s);
+
+        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;
+        fclose(fp);
 
-        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'.
-                 */
+        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[] = {
@@ -267,25 +522,117 @@ 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_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, annotate_usage,
+                             PARSE_OPT_STOP_AT_NON_OPTION);
+
+        if (symbol__init() < 0)
+                return -1;
         setup_pager();
 
-        return __cmd_trace();
+        session = perf_session__new(input_name, O_RDONLY, 0);
+        if (session == NULL)
+                return -ENOMEM;
+
+        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;
+                }
+
+                perf_header__read(&session->header, input);
+                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;
+        }
+
+        err = __cmd_trace(session);
+
+        perf_session__delete(session);
+        cleanup_scripting();
+out:
+        return err;
 }
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index e11d8d231c3b..18035b1f16c7 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -15,6 +15,9 @@ 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_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 +28,7 @@ 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);
 
 #endif
diff --git a/tools/perf/command-list.txt b/tools/perf/command-list.txt
index 00326e230d87..71dc7c3fe7b2 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -3,6 +3,9 @@
 # command name                  category [deprecated] [common]
 #
 perf-annotate                   mainporcelain common
+perf-bench                      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 +14,5 @@ perf-stat			mainporcelain common
 perf-timechart                  mainporcelain common
 perf-top                        mainporcelain common
 perf-trace                      mainporcelain common
+perf-probe                      mainporcelain common
+perf-kmem                       mainporcelain common
diff --git a/tools/perf/design.txt b/tools/perf/design.txt
index fdd42a824c98..f000c30877ac 100644
--- a/tools/perf/design.txt
+++ b/tools/perf/design.txt
@@ -137,6 +137,8 @@ enum sw_event_ids {
         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
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 19fc7feb9d59..873e55fab375 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]";
@@ -89,8 +90,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 {
@@ -117,8 +118,8 @@ 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")) {
@@ -131,8 +132,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 +147,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;
@@ -284,17 +285,22 @@ 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-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 },
         };
         unsigned int i;
         static const char ext[] = STRIP_EXTENSION;
@@ -382,45 +388,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];
+        const char *path = debugfs_find_mountpoint();
 
-        /*
-         * 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;
-        }
-
-        /*
-         * 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)
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 8cc4623afd6f..75f941bfba9e 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -47,6 +47,30 @@
 #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()           asm volatile("mov r0, #0xffff0fff; mov lr, pc;" \
+                                     "sub pc, r0, #95" ::: "r0", "lr", "cc", \
+                                     "memory")
+#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..af78d9a52a7d
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Context.c
@@ -0,0 +1,134 @@
+/*
+ * 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 "../../../util/trace-event-perl.h"
+
+#ifndef PERL_UNUSED_VAR
+#  define PERL_UNUSED_VAR(var) if (0) var = var
+#endif
+
+#line 41 "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..fb78006c165e
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs
@@ -0,0 +1,41 @@
+/*
+ * 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 "../../../util/trace-event-perl.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..052f132ced24
--- /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_secs($nsecs);
+}
+
+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..c7ec5de2f535
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/check-perf-trace-record
@@ -0,0 +1,7 @@
+#!/bin/bash
+perf record -c 1 -f -a -M -R -e kmem:kmalloc -e irq:softirq_entry
+
+
+
+
+
diff --git a/tools/perf/scripts/perl/bin/check-perf-trace-report b/tools/perf/scripts/perl/bin/check-perf-trace-report
new file mode 100644
index 000000000000..7fc4a033dd49
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/check-perf-trace-report
@@ -0,0 +1,6 @@
+#!/bin/bash
+# description: useless but exhaustive test script
+perf trace -s ~/libexec/perf-core/scripts/perl/check-perf-trace.pl
+
+
+
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/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/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/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/data_map.c b/tools/perf/util/data_map.c
new file mode 100644
index 000000000000..b557b836de3d
--- /dev/null
+++ b/tools/perf/util/data_map.c
@@ -0,0 +1,252 @@
+#include "symbol.h"
+#include "util.h"
+#include "debug.h"
+#include "thread.h"
+#include "session.h"
+
+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->process_sample_event)
+                handler->process_sample_event = process_event_stub;
+        if (!handler->process_mmap_event)
+                handler->process_mmap_event = process_event_stub;
+        if (!handler->process_comm_event)
+                handler->process_comm_event = process_event_stub;
+        if (!handler->process_fork_event)
+                handler->process_fork_event = process_event_stub;
+        if (!handler->process_exit_event)
+                handler->process_exit_event = process_event_stub;
+        if (!handler->process_lost_event)
+                handler->process_lost_event = process_event_stub;
+        if (!handler->process_read_event)
+                handler->process_read_event = process_event_stub;
+        if (!handler->process_throttle_event)
+                handler->process_throttle_event = process_event_stub;
+        if (!handler->process_unthrottle_event)
+                handler->process_unthrottle_event = 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]);
+}
+
+static int process_event(event_t *event, struct perf_session *session,
+                         struct perf_event_ops *ops,
+                         unsigned long offset, unsigned long head)
+{
+        trace_event(event);
+
+        if (event->header.type < PERF_RECORD_MAX) {
+                dump_printf("%p [%p]: PERF_RECORD_%s",
+                            (void *)(offset + head),
+                            (void *)(long)(event->header.size),
+                            event__name[event->header.type]);
+                ++event__total[0];
+                ++event__total[event->header.type];
+        }
+
+        switch (event->header.type) {
+        case PERF_RECORD_SAMPLE:
+                return ops->process_sample_event(event, session);
+        case PERF_RECORD_MMAP:
+                return ops->process_mmap_event(event, session);
+        case PERF_RECORD_COMM:
+                return ops->process_comm_event(event, session);
+        case PERF_RECORD_FORK:
+                return ops->process_fork_event(event, session);
+        case PERF_RECORD_EXIT:
+                return ops->process_exit_event(event, session);
+        case PERF_RECORD_LOST:
+                return ops->process_lost_event(event, session);
+        case PERF_RECORD_READ:
+                return ops->process_read_event(event, session);
+        case PERF_RECORD_THROTTLE:
+                return ops->process_throttle_event(event, session);
+        case PERF_RECORD_UNTHROTTLE:
+                return ops->process_unthrottle_event(event, session);
+        default:
+                ops->total_unknown++;
+                return -1;
+        }
+}
+
+int perf_header__read_build_ids(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;
+
+                if (read(input, &bev, sizeof(bev)) != sizeof(bev))
+                        goto out;
+
+                len = bev.header.size - sizeof(bev);
+                if (read(input, filename, len) != len)
+                        goto out;
+
+                dso = dsos__findnew(filename);
+                if (dso != NULL)
+                        dso__set_build_id(dso, &bev.build_id);
+
+                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 || 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,
+                                 struct perf_event_ops *ops)
+{
+        int err;
+        unsigned long head, shift;
+        unsigned long offset = 0;
+        size_t  page_size;
+        event_t *event;
+        uint32_t size;
+        char *buf;
+
+        if (perf_session__register_idle_thread(self) == NULL)
+                return -ENOMEM;
+
+        perf_event_ops__fill_defaults(ops);
+
+        page_size = getpagesize();
+
+        head = self->header.data_offset;
+        self->sample_type = perf_header__sample_type(&self->header);
+
+        err = -EINVAL;
+        if (ops->sample_type_check && ops->sample_type_check(self) < 0)
+                goto out_err;
+
+        if (!ops->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);
+        }
+
+        shift = page_size * (head / page_size);
+        offset += shift;
+        head -= shift;
+
+remap:
+        buf = mmap(NULL, page_size * self->mmap_window, PROT_READ,
+                   MAP_SHARED, 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);
+
+        size = event->header.size;
+        if (!size)
+                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%p [%p]: event: %d\n",
+                        (void *)(offset + head),
+                        (void *)(long)event->header.size,
+                        event->header.type);
+
+        if (!size || process_event(event, self, ops, offset, head) < 0) {
+
+                dump_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 >= self->header.data_offset + self->header.data_size)
+                goto done;
+
+        if (offset + head < self->size)
+                goto more;
+
+done:
+        err = 0;
+out_err:
+        return err;
+}
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index e8ca98fe0bd4..28d520d5a1fb 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -13,12 +13,12 @@
 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..06b73ee02c49
--- /dev/null
+++ b/tools/perf/util/debugfs.c
@@ -0,0 +1,241 @@
+#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 */
+
+int debugfs_mount(const char *mountpoint)
+{
+        char mountcmd[128];
+
+        /* see if it's already mounted */
+        if (debugfs_find_mountpoint()) {
+                debugfs_premounted = 1;
+                return 0;
+        }
+
+        /* 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";
+        }
+
+        /* save the mountpoint */
+        strncpy(debugfs_mountpoint, mountpoint, sizeof(debugfs_mountpoint));
+
+        /* mount it */
+        snprintf(mountcmd, sizeof(mountcmd),
+                 "/bin/mount -t debugfs debugfs %s", mountpoint);
+        return system(mountcmd);
+}
+
+/* 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..3cd14f9ae784
--- /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 int 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..bb0fd6da2d56
--- /dev/null
+++ b/tools/perf/util/event.c
@@ -0,0 +1,456 @@
+#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,
+                                    int (*process)(event_t *event,
+                                                   struct perf_session *session),
+                                    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,
+                                         int (*process)(event_t *event,
+                                                        struct perf_session *session),
+                                         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 },
+                };
+                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_thread(pid_t pid,
+                             int (*process)(event_t *event,
+                                            struct perf_session *session),
+                             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(int (*process)(event_t *event,
+                                              struct perf_session *session),
+                               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);
+}
+
+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 = perf_session__findnew(session, self->mmap.pid);
+        struct map *map = map__new(&self->mmap, MAP__FUNCTION,
+                                   session->cwd, session->cwdlen);
+
+        dump_printf(" %d/%d: [%p(%p) @ %p]: %s\n",
+                    self->mmap.pid, self->mmap.tid,
+                    (void *)(long)self->mmap.start,
+                    (void *)(long)self->mmap.len,
+                    (void *)(long)self->mmap.pgoff,
+                    self->mmap.filename);
+
+        if (thread == NULL || map == NULL)
+                dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
+        else
+                thread__insert_map(thread, map);
+
+        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_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 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;
+                al->sym = 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;
+                }
+                al->sym = NULL;
+        } else {
+                al->addr = al->map->map_ip(al->map, al->addr);
+                al->sym = map__find_symbol(al->map, session, al->addr, filter);
+        }
+}
+
+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..690a96d0467c 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 <linux/rbtree.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,12 +94,31 @@ typedef union event_union {
         struct sample_event             sample;
 } event_t;
 
+struct events_stats {
+        u64 total;
+        u64 lost;
+};
+
+void event__print_totals(void);
+
+enum map_type {
+        MAP__FUNCTION = 0,
+        MAP__VARIABLE,
+};
+
+#define MAP__NR_TYPES (MAP__VARIABLE + 1)
+
 struct map {
-        struct list_head        node;
+        union {
+                struct rb_node  rb_node;
+                struct list_head node;
+        };
         u64                     start;
         u64                     end;
+        enum map_type           type;
         u64                     pgoff;
         u64                     (*map_ip)(struct map *, u64);
+        u64                     (*unmap_ip)(struct map *, u64);
         struct dso              *dso;
 };
 
@@ -91,14 +127,57 @@ static inline u64 map__map_ip(struct map *map, u64 ip)
         return ip - map->start + map->pgoff;
 }
 
-static inline u64 vdso__map_ip(struct map *map __used, u64 ip)
+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;
 }
 
-struct map *map__new(struct mmap_event *event, char *cwd, int cwdlen);
+struct symbol;
+
+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);
 
-#endif
+struct perf_session;
+
+int map__load(struct map *self, struct perf_session *session,
+              symbol_filter_t filter);
+struct symbol *map__find_symbol(struct map *self, struct perf_session *session,
+                                u64 addr, symbol_filter_t filter);
+struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
+                                        struct perf_session *session,
+                                        symbol_filter_t filter);
+void map__fixup_start(struct map *self);
+void map__fixup_end(struct map *self);
+
+int event__synthesize_thread(pid_t pid,
+                             int (*process)(event_t *event,
+                                            struct perf_session *session),
+                             struct perf_session *session);
+void event__synthesize_threads(int (*process)(event_t *event,
+                                              struct perf_session *session),
+                               struct perf_session *session);
+
+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 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 /* __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..8a0bca55106f 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -2,9 +2,15 @@
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <linux/list.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 +19,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");
+                return -1;
 
-        self->attrs++;
-        if (self->attrs > self->size) {
-                self->size *= 2;
-                self->attr = realloc(self->attr, self->size * sizeof(void *));
-                if (!self->attr)
-                        die("nomem");
+        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
@@ -97,7 +108,7 @@ static struct perf_trace_event_type *events;
 void 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));
@@ -128,44 +139,142 @@ 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);
+}
+
+bool perf_header__has_feat(const struct perf_header *self, int feat)
+{
+        return test_bit(feat, self->adds_features);
+}
 
-static void do_write(int fd, void *buf, size_t size)
+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;
+}
+
+static int __dsos__write_buildid_table(struct list_head *head, int fd)
+{
+#define NAME_ALIGN      64
+        struct dso *pos;
+        static const char zero_buf[NAME_ALIGN];
+
+        list_for_each_entry(pos, head, node) {
+                int err;
+                struct build_id_event b;
+                size_t len;
+
+                if (!pos->has_build_id)
+                        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.size = sizeof(b) + len;
+                err = do_write(fd, &b, sizeof(b));
+                if (err < 0)
+                        return err;
+                err = do_write(fd, pos->long_name, pos->long_name_len + 1);
+                if (err < 0)
+                        return err;
+                err = do_write(fd, zero_buf, len - pos->long_name_len - 1);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+static int dsos__write_buildid_table(int fd)
+{
+        int err = __dsos__write_buildid_table(&dsos__kernel, fd);
+        if (err == 0)
+                err = __dsos__write_buildid_table(&dsos__user, fd);
+        return err;
+}
+
+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())
+                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;
+        }
+
+        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 +283,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 +303,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,11 +346,18 @@ 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)
@@ -241,22 +375,109 @@ static void do_read(int fd, void *buf, size_t size)
         }
 }
 
-struct perf_header *perf_header__read(int fd)
+int perf_header__process_sections(struct perf_header *self, int fd,
+                                  int (*process)(struct perf_file_section *self,
+                                                 int feat, int fd))
+{
+        struct perf_file_section *feat_sec;
+        int nr_sections;
+        int sec_size;
+        int idx = 0;
+        int err = 0, 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);
+
+        do_read(fd, feat_sec, sec_size);
+
+        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, feat, fd);
+                        if (err < 0)
+                                break;
+                }
+                ++feat;
+        }
+
+        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, self, sizeof(*self));
+
+        if (self->magic     != PERF_MAGIC ||
+            self->attr_size != sizeof(struct perf_file_attr))
+                return -1;
+
+        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(self->adds_features));
+
+        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,
+                                      int feat, int fd)
+{
+        if (lseek(fd, self->offset, SEEK_SET) < 0) {
+                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(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_header      *self = perf_header__new();
         struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
         u64                     f_id;
-
         int nr_attrs, nr_ids, i, j;
 
-        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 (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);
@@ -269,6 +490,8 @@ struct perf_header *perf_header__read(int fd)
                 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);
@@ -276,31 +499,34 @@ struct perf_header *perf_header__read(int fd)
                 for (j = 0; j < nr_ids; j++) {
                         do_read(fd, &f_id, sizeof(f_id));
 
-                        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");
+                if (events == NULL)
+                        return -ENOMEM;
                 do_read(fd, events, f_header.event_types.size);
                 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;
 }
 
 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..d118d05d3abe 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -1,10 +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 <linux/bitmap.h>
+
 struct perf_header_attr {
         struct perf_event_attr attr;
         int ids, size;
@@ -12,36 +15,71 @@ 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;
+        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);
 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,
+                                                 int feat, int fd));
 
-struct perf_header *perf_header__new(void);
-
-#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..e8daf5ca6fd2
--- /dev/null
+++ b/tools/perf/util/hist.c
@@ -0,0 +1,662 @@
+#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 perf_session *self,
+                                                  struct addr_location *al,
+                                                  struct symbol *sym_parent,
+                                                  u64 count, bool *hit)
+{
+        struct rb_node **p = &self->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, &self->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 perf_session *self)
+{
+        struct rb_root tmp;
+        struct rb_node *next;
+        struct hist_entry *n;
+
+        if (!sort__need_collapse)
+                return;
+
+        tmp = RB_ROOT;
+        next = rb_first(&self->hists);
+
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                next = rb_next(&n->rb_node);
+
+                rb_erase(&n->rb_node, &self->hists);
+                collapse__insert_entry(&tmp, n);
+        }
+
+        self->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 perf_session *self, 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(&self->hists);
+
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                next = rb_next(&n->rb_node);
+
+                rb_erase(&n->rb_node, &self->hists);
+                perf_session__insert_output_hist_entry(&tmp, n,
+                                                       min_callchain_hits);
+        }
+
+        self->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 seperator
+                 * 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 *session,
+                                  struct perf_session *pair_session,
+                                  bool show_displacement,
+                                  long displacement, FILE *fp)
+{
+        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->events_stats.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->events_stats.total > 0)
+                        new_percent = (self->count * 100.0) / session->events_stats.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->events_stats.total,
+                                              left_margin);
+        }
+
+        return ret;
+}
+
+size_t perf_session__fprintf_hists(struct perf_session *self,
+                                   struct perf_session *pair,
+                                   bool show_displacement, FILE *fp)
+{
+        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(&self->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, self, pair, show_displacement,
+                                           displacement, fp);
+        }
+
+        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..e5f99b24048b
--- /dev/null
+++ b/tools/perf/util/hist.h
@@ -0,0 +1,27 @@
+#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 hist_entry *__perf_session__add_hist_entry(struct perf_session *self,
+                                                  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 perf_session *self, u64 total_samples);
+void perf_session__collapse_resort(struct perf_session *self);
+size_t perf_session__fprintf_hists(struct perf_session *self,
+                                   struct perf_session *pair,
+                                   bool show_displacement, FILE *fp);
+#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/kernel.h b/tools/perf/util/include/linux/kernel.h
index a6b87390cb52..21c0274c02fa 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,70 @@
         _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__)
+
 #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..c4d55a0da2ea 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include "debug.h"
 
 static inline int is_anon_memory(const char *filename)
 {
@@ -19,13 +20,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 +61,15 @@ 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;
 
+                map__init(self, type, event->start, event->start + event->len,
+                          event->pgoff, dso);
+
                 if (self->dso == vdso || anon)
-                        self->map_ip = vdso__map_ip;
-                else
-                        self->map_ip = map__map_ip;
+                        self->map_ip = self->unmap_ip = identity__map_ip;
         }
         return self;
 out_delete:
@@ -64,6 +77,99 @@ 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, struct perf_session *session,
+              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, session, 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;
+        }
+
+        return 0;
+}
+
+struct symbol *map__find_symbol(struct map *self, struct perf_session *session,
+                                u64 addr, symbol_filter_t filter)
+{
+        if (map__load(self, session, 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,
+                                        struct perf_session *session,
+                                        symbol_filter_t filter)
+{
+        if (map__load(self, session, 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));
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..e5bc0fb016b2 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);
@@ -471,7 +467,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 +474,12 @@ 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);
+                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 +496,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, ':');
@@ -544,6 +531,81 @@ static enum event_result parse_tracepoint_event(const char **strp,
                                                      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 +739,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:
@@ -708,7 +776,6 @@ static void store_event_type(const char *orgname)
         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;
@@ -745,6 +812,28 @@ 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",
@@ -764,7 +853,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,7 +871,7 @@ 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,
+                        printf("  %-42s [%s]\n", evt_path,
                                 event_type_descriptors[PERF_TYPE_TRACEPOINT+1]);
                 }
                 closedir(evt_dir);
@@ -799,8 +888,8 @@ 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;
@@ -808,19 +897,19 @@ void print_events(void)
                         type = 0;
 
                 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 +917,20 @@ 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]);
                         }
                 }
         }
 
-        fprintf(stderr, "\n");
-        fprintf(stderr, "  %-42s [raw hardware event descriptor]\n",
+        printf("\n");
+        printf("  %-42s [raw hardware event descriptor]\n",
                 "rNNN");
-        fprintf(stderr, "\n");
+        printf("\n");
+
+        printf("  %-42s [hardware breakpoint]\n", "mem:<addr>[:access]");
+        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..29465d440043
--- /dev/null
+++ b/tools/perf/util/probe-event.c
@@ -0,0 +1,677 @@
+/*
+ * 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 "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;
+}
+
+/* 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
+         * perf probe [EVENT=]FUNC[+OFFS|%return][@SRC]
+         *
+         * TODO:Group name support
+         */
+
+        ptr = strchr(arg, '=');
+        if (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;
+                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 charactor"
+                                                " 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 charactor"
+                                                " 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);
+                        if (ptr)
+                                semantic_error("@SRC must be the last "
+                                               "option.");
+                        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->line && pp->offset)
+                semantic_error("Offset can't be used with line number.");
+
+        if (!pp->line && pp->file && !pp->function)
+                semantic_error("File always requires line number.");
+
+        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->retprobe)
+                semantic_error("Offset/Line can't be used with return probe.");
+
+        pr_debug("symbol:%s file:%s line:%d offset:%d, return:%d\n",
+                 pp->function, pp->file, pp->line, pp->offset, pp->retprobe);
+}
+
+/* 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)
+                *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);
+        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;
+        }
+        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_TRACER.");
+                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);
+        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;
+
+        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);
+}
+
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
new file mode 100644
index 000000000000..7f1d499118c0
--- /dev/null
+++ b/tools/perf/util/probe-event.h
@@ -0,0 +1,22 @@
+#ifndef _PROBE_EVENT_H
+#define _PROBE_EVENT_H
+
+#include <stdbool.h>
+#include "probe-finder.h"
+#include "strlist.h"
+
+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);
+
+/* 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..4b852c0d16a5
--- /dev/null
+++ b/tools/perf/util/probe-finder.c
@@ -0,0 +1,730 @@
+/*
+ * 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 "event.h"
+#include "debug.h"
+#include "util.h"
+#include "probe-finder.h"
+
+
+/* Dwarf_Die Linkage to parent Die */
+struct die_link {
+        struct die_link *parent;        /* Parent die */
+        Dwarf_Die die;                  /* Current die */
+};
+
+static Dwarf_Debug __dw_debug;
+static Dwarf_Error __dw_error;
+
+/*
+ * 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;
+}
+
+/* Find the fileno of the target file. */
+static Dwarf_Unsigned cu_find_fileno(Dwarf_Die cu_die, const char *fname)
+{
+        Dwarf_Signed cnt, i;
+        Dwarf_Unsigned found = 0;
+        char **srcs;
+        int ret;
+
+        if (!fname)
+                return 0;
+
+        ret = dwarf_srcfiles(cu_die, &srcs, &cnt, &__dw_error);
+        if (ret == DW_DLV_OK) {
+                for (i = 0; i < cnt && !found; i++) {
+                        if (strtailcmp(srcs[i], fname) == 0)
+                                found = i + 1;
+                        dwarf_dealloc(__dw_debug, srcs[i], DW_DLA_STRING);
+                }
+                for (; i < cnt; i++)
+                        dwarf_dealloc(__dw_debug, srcs[i], DW_DLA_STRING);
+                dwarf_dealloc(__dw_debug, srcs, DW_DLA_LIST);
+        }
+        if (found)
+                pr_debug("found fno: %d\n", (int)found);
+        return found;
+}
+
+/* Compare diename and tname */
+static int die_compare_name(Dwarf_Die dw_die, const char *tname)
+{
+        char *name;
+        int ret;
+        ret = dwarf_diename(dw_die, &name, &__dw_error);
+        DIE_IF(ret == DW_DLV_ERROR);
+        if (ret == DW_DLV_OK) {
+                ret = strcmp(tname, name);
+                dwarf_dealloc(__dw_debug, name, DW_DLA_STRING);
+        } else
+                ret = -1;
+        return ret;
+}
+
+/* Check the address is in the subprogram(function). */
+static int die_within_subprogram(Dwarf_Die sp_die, Dwarf_Addr addr,
+                                 Dwarf_Signed *offs)
+{
+        Dwarf_Addr lopc, hipc;
+        int ret;
+
+        /* TODO: check ranges */
+        ret = dwarf_lowpc(sp_die, &lopc, &__dw_error);
+        DIE_IF(ret == DW_DLV_ERROR);
+        if (ret == DW_DLV_NO_ENTRY)
+                return 0;
+        ret = dwarf_highpc(sp_die, &hipc, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        if (lopc <= addr && addr < hipc) {
+                *offs = addr - lopc;
+                return 1;
+        } else
+                return 0;
+}
+
+/* Check the die is inlined function */
+static Dwarf_Bool die_inlined_subprogram(Dwarf_Die dw_die)
+{
+        /* TODO: check strictly */
+        Dwarf_Bool inl;
+        int ret;
+
+        ret = dwarf_hasattr(dw_die, DW_AT_inline, &inl, &__dw_error);
+        DIE_IF(ret == DW_DLV_ERROR);
+        return inl;
+}
+
+/* Get the offset of abstruct_origin */
+static Dwarf_Off die_get_abstract_origin(Dwarf_Die dw_die)
+{
+        Dwarf_Attribute attr;
+        Dwarf_Off cu_offs;
+        int ret;
+
+        ret = dwarf_attr(dw_die, DW_AT_abstract_origin, &attr, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        ret = dwarf_formref(attr, &cu_offs, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
+        return cu_offs;
+}
+
+/* Get entry pc(or low pc, 1st entry of ranges)  of the die */
+static Dwarf_Addr die_get_entrypc(Dwarf_Die dw_die)
+{
+        Dwarf_Attribute attr;
+        Dwarf_Addr addr;
+        Dwarf_Off offs;
+        Dwarf_Ranges *ranges;
+        Dwarf_Signed cnt;
+        int ret;
+
+        /* Try to get entry pc */
+        ret = dwarf_attr(dw_die, DW_AT_entry_pc, &attr, &__dw_error);
+        DIE_IF(ret == DW_DLV_ERROR);
+        if (ret == DW_DLV_OK) {
+                ret = dwarf_formaddr(attr, &addr, &__dw_error);
+                DIE_IF(ret != DW_DLV_OK);
+                dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
+                return addr;
+        }
+
+        /* Try to get low pc */
+        ret = dwarf_lowpc(dw_die, &addr, &__dw_error);
+        DIE_IF(ret == DW_DLV_ERROR);
+        if (ret == DW_DLV_OK)
+                return addr;
+
+        /* Try to get ranges */
+        ret = dwarf_attr(dw_die, DW_AT_ranges, &attr, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        ret = dwarf_formref(attr, &offs, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        ret = dwarf_get_ranges(__dw_debug, offs, &ranges, &cnt, NULL,
+                                &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        addr = ranges[0].dwr_addr1;
+        dwarf_ranges_dealloc(__dw_debug, ranges, cnt);
+        return addr;
+}
+
+/*
+ * Search a Die from Die tree.
+ * Note: cur_link->die should be deallocated in this function.
+ */
+static int __search_die_tree(struct die_link *cur_link,
+                             int (*die_cb)(struct die_link *, void *),
+                             void *data)
+{
+        Dwarf_Die new_die;
+        struct die_link new_link;
+        int ret;
+
+        if (!die_cb)
+                return 0;
+
+        /* Check current die */
+        while (!(ret = die_cb(cur_link, data))) {
+                /* Check child die */
+                ret = dwarf_child(cur_link->die, &new_die, &__dw_error);
+                DIE_IF(ret == DW_DLV_ERROR);
+                if (ret == DW_DLV_OK) {
+                        new_link.parent = cur_link;
+                        new_link.die = new_die;
+                        ret = __search_die_tree(&new_link, die_cb, data);
+                        if (ret)
+                                break;
+                }
+
+                /* Move to next sibling */
+                ret = dwarf_siblingof(__dw_debug, cur_link->die, &new_die,
+                                      &__dw_error);
+                DIE_IF(ret == DW_DLV_ERROR);
+                dwarf_dealloc(__dw_debug, cur_link->die, DW_DLA_DIE);
+                cur_link->die = new_die;
+                if (ret == DW_DLV_NO_ENTRY)
+                        return 0;
+        }
+        dwarf_dealloc(__dw_debug, cur_link->die, DW_DLA_DIE);
+        return ret;
+}
+
+/* Search a die in its children's die tree */
+static int search_die_from_children(Dwarf_Die parent_die,
+                                    int (*die_cb)(struct die_link *, void *),
+                                    void *data)
+{
+        struct die_link new_link;
+        int ret;
+
+        new_link.parent = NULL;
+        ret = dwarf_child(parent_die, &new_link.die, &__dw_error);
+        DIE_IF(ret == DW_DLV_ERROR);
+        if (ret == DW_DLV_OK)
+                return __search_die_tree(&new_link, die_cb, data);
+        else
+                return 0;
+}
+
+/* Find a locdesc corresponding to the address */
+static int attr_get_locdesc(Dwarf_Attribute attr, Dwarf_Locdesc *desc,
+                            Dwarf_Addr addr)
+{
+        Dwarf_Signed lcnt;
+        Dwarf_Locdesc **llbuf;
+        int ret, i;
+
+        ret = dwarf_loclist_n(attr, &llbuf, &lcnt, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        ret = DW_DLV_NO_ENTRY;
+        for (i = 0; i < lcnt; ++i) {
+                if (llbuf[i]->ld_lopc <= addr &&
+                    llbuf[i]->ld_hipc > addr) {
+                        memcpy(desc, llbuf[i], sizeof(Dwarf_Locdesc));
+                        desc->ld_s =
+                                malloc(sizeof(Dwarf_Loc) * llbuf[i]->ld_cents);
+                        DIE_IF(desc->ld_s == NULL);
+                        memcpy(desc->ld_s, llbuf[i]->ld_s,
+                                sizeof(Dwarf_Loc) * llbuf[i]->ld_cents);
+                        ret = DW_DLV_OK;
+                        break;
+                }
+                dwarf_dealloc(__dw_debug, llbuf[i]->ld_s, DW_DLA_LOC_BLOCK);
+                dwarf_dealloc(__dw_debug, llbuf[i], DW_DLA_LOCDESC);
+        }
+        /* Releasing loop */
+        for (; i < lcnt; ++i) {
+                dwarf_dealloc(__dw_debug, llbuf[i]->ld_s, DW_DLA_LOC_BLOCK);
+                dwarf_dealloc(__dw_debug, llbuf[i], DW_DLA_LOCDESC);
+        }
+        dwarf_dealloc(__dw_debug, llbuf, DW_DLA_LIST);
+        return ret;
+}
+
+/* Get decl_file attribute value (file number) */
+static Dwarf_Unsigned die_get_decl_file(Dwarf_Die sp_die)
+{
+        Dwarf_Attribute attr;
+        Dwarf_Unsigned fno;
+        int ret;
+
+        ret = dwarf_attr(sp_die, DW_AT_decl_file, &attr, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        dwarf_formudata(attr, &fno, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
+        return fno;
+}
+
+/* Get decl_line attribute value (line number) */
+static Dwarf_Unsigned die_get_decl_line(Dwarf_Die sp_die)
+{
+        Dwarf_Attribute attr;
+        Dwarf_Unsigned lno;
+        int ret;
+
+        ret = dwarf_attr(sp_die, DW_AT_decl_line, &attr, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        dwarf_formudata(attr, &lno, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
+        return lno;
+}
+
+/*
+ * Probe finder related functions
+ */
+
+/* Show a location */
+static void show_location(Dwarf_Loc *loc, struct probe_finder *pf)
+{
+        Dwarf_Small op;
+        Dwarf_Unsigned regn;
+        Dwarf_Signed offs;
+        int deref = 0, ret;
+        const char *regs;
+
+        op = loc->lr_atom;
+
+        /* If this is based on frame buffer, set the offset */
+        if (op == DW_OP_fbreg) {
+                deref = 1;
+                offs = (Dwarf_Signed)loc->lr_number;
+                op = pf->fbloc.ld_s[0].lr_atom;
+                loc = &pf->fbloc.ld_s[0];
+        } else
+                offs = 0;
+
+        if (op >= DW_OP_breg0 && op <= DW_OP_breg31) {
+                regn = op - DW_OP_breg0;
+                offs += (Dwarf_Signed)loc->lr_number;
+                deref = 1;
+        } else if (op >= DW_OP_reg0 && op <= DW_OP_reg31) {
+                regn = op - DW_OP_reg0;
+        } else if (op == DW_OP_bregx) {
+                regn = loc->lr_number;
+                offs += (Dwarf_Signed)loc->lr_number2;
+                deref = 1;
+        } else if (op == DW_OP_regx) {
+                regn = loc->lr_number;
+        } else
+                die("Dwarf_OP %d is not supported.\n", op);
+
+        regs = get_arch_regstr(regn);
+        if (!regs)
+                die("%lld exceeds max register number.\n", regn);
+
+        if (deref)
+                ret = snprintf(pf->buf, pf->len,
+                                 " %s=%+lld(%s)", pf->var, 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_Locdesc ld;
+        int ret;
+
+        ret = dwarf_attr(vr_die, DW_AT_location, &attr, &__dw_error);
+        if (ret != DW_DLV_OK)
+                goto error;
+        ret = attr_get_locdesc(attr, &ld, (pf->addr - pf->cu_base));
+        if (ret != DW_DLV_OK)
+                goto error;
+        /* TODO? */
+        DIE_IF(ld.ld_cents != 1);
+        show_location(&ld.ld_s[0], pf);
+        free(ld.ld_s);
+        dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
+        return ;
+error:
+        die("Failed to find the location of %s at this address.\n"
+            " Perhaps, it has been optimized out.\n", pf->var);
+}
+
+static int variable_callback(struct die_link *dlink, void *data)
+{
+        struct probe_finder *pf = (struct probe_finder *)data;
+        Dwarf_Half tag;
+        int ret;
+
+        ret = dwarf_tag(dlink->die, &tag, &__dw_error);
+        DIE_IF(ret == DW_DLV_ERROR);
+        if ((tag == DW_TAG_formal_parameter ||
+             tag == DW_TAG_variable) &&
+            (die_compare_name(dlink->die, pf->var) == 0)) {
+                show_variable(dlink->die, pf);
+                return 1;
+        }
+        /* TODO: Support struct members and arrays */
+        return 0;
+}
+
+/* Find a variable in a subprogram die */
+static void find_variable(Dwarf_Die sp_die, struct probe_finder *pf)
+{
+        int ret;
+
+        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. */
+        ret = search_die_from_children(sp_die, variable_callback, pf);
+        if (!ret)
+                die("Failed to find '%s' in this function.\n", pf->var);
+}
+
+/* Get a frame base on the address */
+static void get_current_frame_base(Dwarf_Die sp_die, struct probe_finder *pf)
+{
+        Dwarf_Attribute attr;
+        int ret;
+
+        ret = dwarf_attr(sp_die, DW_AT_frame_base, &attr, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+        ret = attr_get_locdesc(attr, &pf->fbloc, (pf->addr - pf->cu_base));
+        DIE_IF(ret != DW_DLV_OK);
+        dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
+}
+
+static void free_current_frame_base(struct probe_finder *pf)
+{
+        free(pf->fbloc.ld_s);
+        memset(&pf->fbloc, 0, sizeof(Dwarf_Locdesc));
+}
+
+/* Show a probe point to output buffer */
+static void show_probepoint(Dwarf_Die sp_die, Dwarf_Signed offs,
+                            struct probe_finder *pf)
+{
+        struct probe_point *pp = pf->pp;
+        char *name;
+        char tmp[MAX_PROBE_BUFFER];
+        int ret, i, len;
+
+        /* Output name of probe point */
+        ret = dwarf_diename(sp_die, &name, &__dw_error);
+        DIE_IF(ret == DW_DLV_ERROR);
+        if (ret == DW_DLV_OK) {
+                ret = snprintf(tmp, MAX_PROBE_BUFFER, "%s+%u", name,
+                                (unsigned int)offs);
+                /* Copy the function name if possible */
+                if (!pp->function) {
+                        pp->function = strdup(name);
+                        pp->offset = offs;
+                }
+                dwarf_dealloc(__dw_debug, name, DW_DLA_STRING);
+        } else {
+                /* This function has no name. */
+                ret = snprintf(tmp, MAX_PROBE_BUFFER, "0x%llx", pf->addr);
+                if (!pp->function) {
+                        /* TODO: Use _stext */
+                        pp->function = strdup("");
+                        pp->offset = (int)pf->addr;
+                }
+        }
+        DIE_IF(ret < 0);
+        DIE_IF(ret >= MAX_PROBE_BUFFER);
+        len = ret;
+        pr_debug("Probe point found: %s\n", tmp);
+
+        /* Find each argument */
+        get_current_frame_base(sp_die, pf);
+        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);
+        }
+        free_current_frame_base(pf);
+
+        pp->probes[pp->found] = strdup(tmp);
+        pp->found++;
+}
+
+static int probeaddr_callback(struct die_link *dlink, void *data)
+{
+        struct probe_finder *pf = (struct probe_finder *)data;
+        Dwarf_Half tag;
+        Dwarf_Signed offs;
+        int ret;
+
+        ret = dwarf_tag(dlink->die, &tag, &__dw_error);
+        DIE_IF(ret == DW_DLV_ERROR);
+        /* Check the address is in this subprogram */
+        if (tag == DW_TAG_subprogram &&
+            die_within_subprogram(dlink->die, pf->addr, &offs)) {
+                show_probepoint(dlink->die, offs, pf);
+                return 1;
+        }
+        return 0;
+}
+
+/* Find probe point from its line number */
+static void find_by_line(struct probe_finder *pf)
+{
+        Dwarf_Signed cnt, i, clm;
+        Dwarf_Line *lines;
+        Dwarf_Unsigned lineno = 0;
+        Dwarf_Addr addr;
+        Dwarf_Unsigned fno;
+        int ret;
+
+        ret = dwarf_srclines(pf->cu_die, &lines, &cnt, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+
+        for (i = 0; i < cnt; i++) {
+                ret = dwarf_line_srcfileno(lines[i], &fno, &__dw_error);
+                DIE_IF(ret != DW_DLV_OK);
+                if (fno != pf->fno)
+                        continue;
+
+                ret = dwarf_lineno(lines[i], &lineno, &__dw_error);
+                DIE_IF(ret != DW_DLV_OK);
+                if (lineno != pf->lno)
+                        continue;
+
+                ret = dwarf_lineoff(lines[i], &clm, &__dw_error);
+                DIE_IF(ret != DW_DLV_OK);
+
+                ret = dwarf_lineaddr(lines[i], &addr, &__dw_error);
+                DIE_IF(ret != DW_DLV_OK);
+                pr_debug("Probe line found: line[%d]:%u,%d addr:0x%llx\n",
+                         (int)i, (unsigned)lineno, (int)clm, addr);
+                pf->addr = addr;
+                /* Search a real subprogram including this line, */
+                ret = search_die_from_children(pf->cu_die,
+                                               probeaddr_callback, pf);
+                if (ret == 0)
+                        die("Probe point is not found in subprograms.\n");
+                /* Continuing, because target line might be inlined. */
+        }
+        dwarf_srclines_dealloc(__dw_debug, lines, cnt);
+}
+
+/* Search function from function name */
+static int probefunc_callback(struct die_link *dlink, void *data)
+{
+        struct probe_finder *pf = (struct probe_finder *)data;
+        struct probe_point *pp = pf->pp;
+        struct die_link *lk;
+        Dwarf_Signed offs;
+        Dwarf_Half tag;
+        int ret;
+
+        ret = dwarf_tag(dlink->die, &tag, &__dw_error);
+        DIE_IF(ret == DW_DLV_ERROR);
+        if (tag == DW_TAG_subprogram) {
+                if (die_compare_name(dlink->die, pp->function) == 0) {
+                        if (pp->line) { /* Function relative line */
+                                pf->fno = die_get_decl_file(dlink->die);
+                                pf->lno = die_get_decl_line(dlink->die)
+                                         + pp->line;
+                                find_by_line(pf);
+                                return 1;
+                        }
+                        if (die_inlined_subprogram(dlink->die)) {
+                                /* Inlined function, save it. */
+                                ret = dwarf_die_CU_offset(dlink->die,
+                                                          &pf->inl_offs,
+                                                          &__dw_error);
+                                DIE_IF(ret != DW_DLV_OK);
+                                pr_debug("inline definition offset %lld\n",
+                                         pf->inl_offs);
+                                return 0;       /* Continue to search */
+                        }
+                        /* Get probe address */
+                        pf->addr = die_get_entrypc(dlink->die);
+                        pf->addr += pp->offset;
+                        /* TODO: Check the address in this function */
+                        show_probepoint(dlink->die, pp->offset, pf);
+                        return 1; /* Exit; no same symbol in this CU. */
+                }
+        } else if (tag == DW_TAG_inlined_subroutine && pf->inl_offs) {
+                if (die_get_abstract_origin(dlink->die) == pf->inl_offs) {
+                        /* Get probe address */
+                        pf->addr = die_get_entrypc(dlink->die);
+                        pf->addr += pp->offset;
+                        pr_debug("found inline addr: 0x%llx\n", pf->addr);
+                        /* Inlined function. Get a real subprogram */
+                        for (lk = dlink->parent; lk != NULL; lk = lk->parent) {
+                                tag = 0;
+                                dwarf_tag(lk->die, &tag, &__dw_error);
+                                DIE_IF(ret == DW_DLV_ERROR);
+                                if (tag == DW_TAG_subprogram &&
+                                    !die_inlined_subprogram(lk->die))
+                                        goto found;
+                        }
+                        die("Failed to find real subprogram.\n");
+found:
+                        /* Get offset from subprogram */
+                        ret = die_within_subprogram(lk->die, pf->addr, &offs);
+                        DIE_IF(!ret);
+                        show_probepoint(lk->die, offs, pf);
+                        /* Continue to search */
+                }
+        }
+        return 0;
+}
+
+static void find_by_func(struct probe_finder *pf)
+{
+        search_die_from_children(pf->cu_die, probefunc_callback, pf);
+}
+
+/* Find a probe point */
+int find_probepoint(int fd, struct probe_point *pp)
+{
+        Dwarf_Half addr_size = 0;
+        Dwarf_Unsigned next_cuh = 0;
+        int cu_number = 0, ret;
+        struct probe_finder pf = {.pp = pp};
+
+        ret = dwarf_init(fd, DW_DLC_READ, 0, 0, &__dw_debug, &__dw_error);
+        if (ret != DW_DLV_OK)
+                return -ENOENT;
+
+        pp->found = 0;
+        while (++cu_number) {
+                /* Search CU (Compilation Unit) */
+                ret = dwarf_next_cu_header(__dw_debug, NULL, NULL, NULL,
+                        &addr_size, &next_cuh, &__dw_error);
+                DIE_IF(ret == DW_DLV_ERROR);
+                if (ret == DW_DLV_NO_ENTRY)
+                        break;
+
+                /* Get the DIE(Debugging Information Entry) of this CU */
+                ret = dwarf_siblingof(__dw_debug, 0, &pf.cu_die, &__dw_error);
+                DIE_IF(ret != DW_DLV_OK);
+
+                /* Check if target file is included. */
+                if (pp->file)
+                        pf.fno = cu_find_fileno(pf.cu_die, pp->file);
+
+                if (!pp->file || pf.fno) {
+                        /* Save CU base address (for frame_base) */
+                        ret = dwarf_lowpc(pf.cu_die, &pf.cu_base, &__dw_error);
+                        DIE_IF(ret == DW_DLV_ERROR);
+                        if (ret == DW_DLV_NO_ENTRY)
+                                pf.cu_base = 0;
+                        if (pp->function)
+                                find_by_func(&pf);
+                        else {
+                                pf.lno = pp->line;
+                                find_by_line(&pf);
+                        }
+                }
+                dwarf_dealloc(__dw_debug, pf.cu_die, DW_DLA_DIE);
+        }
+        ret = dwarf_finish(__dw_debug, &__dw_error);
+        DIE_IF(ret != DW_DLV_OK);
+
+        return pp->found;
+}
+
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
new file mode 100644
index 000000000000..a4086aaddb73
--- /dev/null
+++ b/tools/perf/util/probe-finder.h
@@ -0,0 +1,65 @@
+#ifndef _PROBE_FINDER_H
+#define _PROBE_FINDER_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                    *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)*/
+};
+
+#ifndef NO_LIBDWARF
+extern int find_probepoint(int fd, struct probe_point *pp);
+
+/* Workaround for undefined _MIPS_SZLONG bug in libdwarf.h: */
+#ifndef _MIPS_SZLONG
+# define _MIPS_SZLONG           0
+#endif
+
+#include <dwarf.h>
+#include <libdwarf.h>
+
+struct probe_finder {
+        struct probe_point      *pp;                    /* Target probe point */
+
+        /* For function searching */
+        Dwarf_Addr              addr;                   /* Address */
+        Dwarf_Unsigned          fno;                    /* File number */
+        Dwarf_Unsigned          lno;                    /* Line number */
+        Dwarf_Off               inl_offs;               /* Inline offset */
+        Dwarf_Die               cu_die;                 /* Current CU */
+
+        /* For variable searching */
+        Dwarf_Addr              cu_base;                /* Current CU base address */
+        Dwarf_Locdesc           fbloc;                  /* Location of Current Frame Base */
+        const char              *var;                   /* Current variable name */
+        char                    *buf;                   /* Current output buffer */
+        int                     len;                    /* Length of output buffer */
+};
+#endif /* NO_LIBDWARF */
+
+#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/session.c b/tools/perf/util/session.c
new file mode 100644
index 000000000000..ce3a6c8abe76
--- /dev/null
+++ b/tools/perf/util/session.c
@@ -0,0 +1,150 @@
+#include <linux/kernel.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;
+}
+
+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->last_match = NULL;
+        self->mmap_window = 32;
+        self->cwd = NULL;
+        self->cwdlen = 0;
+        map_groups__init(&self->kmaps);
+
+        if (perf_session__create_kernel_maps(self) < 0)
+                goto out_delete;
+
+        if (mode == O_RDONLY && perf_session__open(self, force) < 0)
+                goto out_delete;
+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;
+}
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
new file mode 100644
index 000000000000..32eaa1bada06
--- /dev/null
+++ b/tools/perf/util/session.h
@@ -0,0 +1,61 @@
+#ifndef __PERF_SESSION_H
+#define __PERF_SESSION_H
+
+#include "event.h"
+#include "header.h"
+#include "thread.h"
+#include <linux/rbtree.h>
+#include "../../../include/linux/perf_event.h"
+
+struct ip_callchain;
+struct thread;
+struct symbol;
+
+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 events_stats     events_stats;
+        unsigned long           event_total[PERF_RECORD_MAX];
+        struct rb_root          hists;
+        u64                     sample_type;
+        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        process_sample_event;
+        event_op        process_mmap_event;
+        event_op        process_comm_event;
+        event_op        process_fork_event;
+        event_op        process_exit_event;
+        event_op        process_lost_event;
+        event_op        process_read_event;
+        event_op        process_throttle_event;
+        event_op        process_unthrottle_event;
+        int             (*sample_type_check)(struct perf_session *session);
+        unsigned long   total_unknown;
+        bool            full_paths;
+};
+
+struct perf_session *perf_session__new(const char *filename, int mode, bool force);
+void perf_session__delete(struct perf_session *self);
+
+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);
+
+int perf_header__read_build_ids(int input, u64 offset, u64 file_size);
+
+#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..5352d7dccc61 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,221 @@ 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;
+}
+
+/* Glob expression pattern matching */
+bool strglobmatch(const char *str, const char *pat)
+{
+        while (*str && *pat && *pat != '*') {
+                if (*pat == '?') {
+                        str++;
+                        pat++;
+                } else
+                        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;
+}
+
diff --git a/tools/perf/util/string.h b/tools/perf/util/string.h
index bf39dfadfd24..02ede58c54b4 100644
--- a/tools/perf/util/string.h
+++ b/tools/perf/util/string.h
@@ -1,11 +1,17 @@
-#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);
 
 #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..ab92763edb03 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1,15 +1,23 @@
 #include "util.h"
 #include "../perf.h"
+#include "session.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,
@@ -18,94 +26,206 @@ enum dso_origin {
         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,
+                                struct perf_session *session, 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_loaded(struct dso *self, enum map_type type)
+{
+        self->loaded |= (1 << type);
+}
+
+static void dso__set_sorted_by_name(struct dso *self, enum map_type type)
+{
+        self->sorted_by_name |= (1 << type);
+}
+
+static 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;
+        }
+}
+
+static void symbols__fixup_end(struct rb_root *self)
+{
+        struct rb_node *nd, *prevnd = rb_first(self);
+        struct symbol *curr, *prev;
+
+        if (prevnd == NULL)
+                return;
+
+        curr = rb_entry(prevnd, struct symbol, rb_node);
+
+        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);
+}
 
-        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 __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]);
 
-        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 map, 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 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_debug3("%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)
+static 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)
+static void dso__set_long_name(struct dso *self, char *name)
+{
+        if (name == NULL)
+                return;
+        self->long_name = name;
+        self->long_name_len = strlen(name);
+}
+
+static void dso__set_basename(struct dso *self)
+{
+        self->short_name = basename(self->long_name);
+}
+
+struct dso *dso__new(const char *name)
 {
         struct dso *self = malloc(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);
+                self->short_name = 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 +239,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 +265,116 @@ 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)
 {
-        size_t ret = fprintf(fp, "dso: %s\n", self->name);
+        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(&self->syms); nd; nd = rb_next(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(u8 *self, int len, char *bf)
+{
+        char *bid = bf;
+        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)
+{
+        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;
+        size_t ret = fprintf(fp, "dso: %s (", self->short_name);
+
+        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,13 +382,17 @@ 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)
+/*
+ * 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, struct map *map)
 {
-        struct rb_node *nd, *prevnd;
         char *line = NULL;
         size_t n;
+        struct rb_root *root = &self->symbols[map->type];
         FILE *file = fopen("/proc/kallsyms", "r");
-        int count = 0;
 
         if (file == NULL)
                 goto out_failure;
@@ -174,6 +402,7 @@ static int dso__load_kallsyms(struct dso *self, symbol_filter_t filter, int v)
                 struct symbol *sym;
                 int line_len, len;
                 char symbol_type;
+                char *symbol_name;
 
                 line_len = getline(&line, &n, file);
                 if (line_len < 0)
@@ -191,49 +420,28 @@ 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')
+                if (!symbol_type__is_a(symbol_type, map->type))
                         continue;
+
+                symbol_name = line + len + 2;
                 /*
-                 * Well fix up the end later, when we have all sorted.
+                 * Will fix up the end later, when we have all symbols sorted.
                  */
-                sym = symbol__new(start, 0xdead, line + len + 2,
-                                  self->sym_priv_size, 0, v);
+                sym = symbol__new(start, 0, symbol_name);
 
                 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++;
-                }
-        }
-
-        /*
-         * Now that we have all sorted out, just set the ->end of all
-         * symbols
-         */
-        prevnd = rb_first(&self->syms);
-
-        if (prevnd == NULL)
-                goto out_delete_line;
-
-        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);
-
-                prev->end = curr->start - 1;
-                prevnd = nd;
+                /*
+                 * 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);
         }
 
         free(line);
         fclose(file);
 
-        return count;
+        return 0;
 
 out_delete_line:
         free(line);
@@ -241,14 +449,107 @@ out_failure:
         return -1;
 }
 
-static int dso__load_perf_map(struct dso *self, symbol_filter_t filter, int v)
+/*
+ * 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,
+                               struct perf_session *session, symbol_filter_t filter)
+{
+        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;
+
+        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(self->name, module)) {
+                                curr_map = map_groups__find_by_name(&session->kmaps, map->type, module);
+                                if (curr_map == NULL) {
+                                        pr_debug("/proc/{kallsyms,modules} "
+                                                 "inconsistency!\n");
+                                        return -1;
+                                }
+                        }
+                        /*
+                         * 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 (map == NULL) {
+                                dso__delete(dso);
+                                return -1;
+                        }
+
+                        curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
+                        map_groups__insert(&session->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;
+}
+
+
+static int dso__load_kallsyms(struct dso *self, struct map *map,
+                              struct perf_session *session, symbol_filter_t filter)
+{
+        if (dso__load_all_kallsyms(self, map) < 0)
+                return -1;
+
+        symbols__fixup_end(&self->symbols[map->type]);
+        self->origin = DSO__ORIG_KERNEL;
+
+        return dso__split_kallsyms(self, map, session, filter);
+}
+
+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 +579,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 +627,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 +654,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 +706,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 +723,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 +791,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 +813,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 +835,42 @@ 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,
+                         struct perf_session *session, const char *name, int fd,
+                         symbol_filter_t filter, int kernel, int kmodule)
+{
+        struct map *curr_map = map;
+        struct dso *curr_dso = self;
+        size_t dso_name_len = strlen(self->short_name);
         Elf_Data *symstrs, *secstrs;
         uint32_t nr_syms;
         int err = -1;
@@ -531,19 +881,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;
         }
 
@@ -587,13 +934,11 @@ 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;
+                char *demangled = NULL;
                 int is_label = elf_sym__is_label(&sym);
                 const char *section_name;
 
-                if (!is_label && !elf_sym__is_function(&sym))
+                if (!is_label && !elf_sym__is_a(&sym, map->type))
                         continue;
 
                 sec = elf_getscn(elf, sym.st_shndx);
@@ -602,55 +947,88 @@ 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;
 
+                elf_name = elf_sym__name(&sym, symstrs);
                 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 (kernel || kmodule) {
+                        char dso_name[PATH_MAX];
 
-                        sym.st_value -= shdr.sh_addr - shdr.sh_offset;
-                }
+                        if (strcmp(section_name,
+                                   curr_dso->short_name + dso_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(&session->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__FUNCTION);
+                                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(&session->kmaps, curr_map);
+                                dsos__add(&dsos__kernel, curr_dso);
+                        } else
+                                curr_dso = curr_map->dso;
+
+                        goto new_symbol;
+                }
+
+                if (curr_dso->adjust_symbols) {
+                        pr_debug2("adjusting symbol: st_value: %Lx sh_addr: "
+                                  "%Lx sh_offset: %Lx\n", (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]);
         err = nr;
 out_elf_end:
         elf_end(elf);
@@ -658,63 +1036,154 @@ 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)
 {
-        int i;
+        bool have_build_id = false;
+        struct dso *pos;
+
+        list_for_each_entry(pos, head, node)
+                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(void)
+{
+        bool kbuildids = __dsos__read_build_ids(&dsos__kernel),
+             ubuildids = __dsos__read_build_ids(&dsos__user);
+        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)
-                goto out_elf_end;
-        build_id = malloc(BUILD_ID_SIZE);
-        if (build_id == NULL)
+        data = elf_getdata(sec, NULL);
+        if (data == 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)
@@ -726,6 +1195,7 @@ char dso__symtab_origin(const struct dso *self)
                 [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,20 +1203,28 @@ 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, struct perf_session *session,
+              symbol_filter_t filter)
 {
         int size = PATH_MAX;
-        char *name = malloc(size), *build_id = NULL;
+        char *name;
+        u8 build_id[BUILD_ID_SIZE];
         int ret = -1;
         int fd;
 
+        dso__set_loaded(self, map->type);
+
+        if (self->kernel)
+                return dso__load_kernel_sym(self, map, session, 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;
@@ -759,34 +1237,50 @@ more:
                 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))) {
+                                char build_id_hex[BUILD_ID_SIZE * 2 + 1];
+
+                                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;
+                }
+
                 fd = open(name, O_RDONLY);
         } while (fd < 0);
 
-        ret = dso__load_sym(self, fd, name, filter, v, NULL);
+        ret = dso__load_sym(self, map, NULL, name, fd, filter, 0, 0);
         close(fd);
 
         /*
@@ -796,7 +1290,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,151 +1301,281 @@ 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->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 perf_session__set_modules_path_dir(struct perf_session *self, char *dirname)
+{
+        struct dirent *dent;
+        DIR *dir = opendir(dirname);
 
-        return err;
+        if (!dir) {
+                pr_debug("%s: cannot open %s dir\n", __func__, dirname);
+                return -1;
+        }
+
+        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 (perf_session__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->kmaps, 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);
+                }
+        }
+
+        return 0;
+failure:
+        closedir(dir);
+        return -1;
 }
 
-int dso__load_modules(struct dso *self, symbol_filter_t filter, int v)
+static int perf_session__set_modules_path(struct perf_session *self)
 {
-        struct mod_dso *mods = mod_dso__new_dso("modules");
-        struct module *pos;
-        struct rb_node *next;
-        int err, count = 0;
+        struct utsname uts;
+        char modules_path[PATH_MAX];
 
-        err = mod_dso__load_modules(mods);
+        if (uname(&uts) < 0)
+                return -1;
 
-        if (err <= 0)
-                return err;
+        snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
+                 uts.release);
 
-        /*
-         * 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);
-
-                if (err < 0)
-                        break;
+        return perf_session__set_modules_path_dir(self, modules_path);
+}
 
-                next = rb_next(&pos->rb_node);
-                count += 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 = malloc(sizeof(*self));
 
-        if (err < 0) {
-                mod_dso__delete_modules(mods);
-                mod_dso__delete_self(mods);
-                return err;
+        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)
+static int perf_session__create_module_maps(struct perf_session *self)
 {
-        struct symbol *prev = NULL;
-        struct rb_node *nd;
+        char *line = NULL;
+        size_t n;
+        FILE *file = fopen("/proc/modules", "r");
+        struct map *map;
 
-        for (nd = rb_last(&self->syms); nd; nd = rb_prev(nd)) {
-                struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
+        if (file == NULL)
+                return -1;
 
-                if (prev) {
-                        u64 hole = 0;
-                        int alias = pos->start == prev->start;
+        while (!feof(file)) {
+                char name[PATH_MAX];
+                u64 start;
+                struct dso *dso;
+                char *sep;
+                int line_len;
 
-                        if (!alias)
-                                hole = prev->start - pos->end - 1;
+                line_len = getline(&line, &n, file);
+                if (line_len < 0)
+                        break;
 
-                        if (hole || alias) {
-                                if (alias)
-                                        pos->end = prev->end;
-                                else if (hole)
-                                        pos->end = prev->start - 1;
-                        }
+                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);
+                dso = dso__new(name);
+
+                if (dso == NULL)
+                        goto out_delete_line;
+
+                map = map__new2(start, dso, MAP__FUNCTION);
+                if (map == NULL) {
+                        dso__delete(dso);
+                        goto out_delete_line;
                 }
-                prev = pos;
+
+                snprintf(name, sizeof(name),
+                         "/sys/module/%s/notes/.note.gnu.build-id", line);
+                if (sysfs__read_build_id(name, dso->build_id,
+                                         sizeof(dso->build_id)) == 0)
+                        dso->has_build_id = true;
+
+                dso->origin = DSO__ORIG_KMODULE;
+                map_groups__insert(&self->kmaps, map);
+                dsos__add(&dsos__kernel, dso);
         }
+
+        free(line);
+        fclose(file);
+
+        return perf_session__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,
+                             struct perf_session *session,
+                             const char *vmlinux, symbol_filter_t filter)
 {
-        int err, fd = open(vmlinux, O_RDONLY);
+        int err = -1, fd;
 
-        if (fd < 0)
-                return -1;
+        if (self->has_build_id) {
+                u8 build_id[BUILD_ID_SIZE];
 
-        err = dso__load_sym(self, fd, vmlinux, filter, v, NULL);
+                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;
+                }
+        }
 
-        if (err > 0)
-                dso__fill_symbol_holes(self);
+        fd = open(vmlinux, O_RDONLY);
+        if (fd < 0)
+                return -1;
 
+        dso__set_loaded(self, map->type);
+        err = dso__load_sym(self, map, session, self->long_name, fd, filter, 1, 0);
         close(fd);
 
         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,
+                                struct perf_session *session, symbol_filter_t filter)
 {
-        int err = -1;
-
-        if (vmlinux) {
-                err = dso__load_vmlinux(self, vmlinux, filter, v);
-                if (err > 0 && use_modules) {
-                        int syms = dso__load_modules(self, filter, v);
-
-                        if (syms < 0) {
-                                fprintf(stderr, "dso__load_modules failed!\n");
-                                return syms;
+        int err;
+        bool is_kallsyms;
+
+        if (vmlinux_path != NULL) {
+                int i;
+                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, session,
+                                                vmlinux_path[i], filter);
+                        if (err > 0) {
+                                pr_debug("Using %s for symbols\n",
+                                         vmlinux_path[i]);
+                                dso__set_long_name(self,
+                                                   strdup(vmlinux_path[i]));
+                                goto out_fixup;
                         }
-                        err += syms;
                 }
         }
 
-        if (err <= 0)
-                err = dso__load_kallsyms(self, filter, v);
+        is_kallsyms = self->long_name[0] == '[';
+        if (is_kallsyms)
+                goto do_kallsyms;
 
-        if (err > 0)
-                self->origin = DSO__ORIG_KERNEL;
+        err = dso__load_vmlinux(self, map, session, self->long_name, filter);
+        if (err <= 0) {
+                pr_info("The file %s cannot be used, "
+                        "trying to use /proc/kallsyms...", self->long_name);
+do_kallsyms:
+                err = dso__load_kallsyms(self, map, session, filter);
+                if (err > 0 && !is_kallsyms)
+                        dso__set_long_name(self, strdup("[kernel.kallsyms]"));
+        }
+
+        if (err > 0) {
+out_fixup:
+                map__fixup_start(map);
+                map__fixup_end(map);
+        }
 
         return err;
 }
 
-LIST_HEAD(dsos);
-struct dso      *kernel_dso;
-struct dso      *vdso;
-struct dso      *hypervisor_dso;
+LIST_HEAD(dsos__user);
+LIST_HEAD(dsos__kernel);
+struct dso *vdso;
 
-const char      *vmlinux_name = "vmlinux";
-int             modules;
-
-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)
+        list_for_each_entry(pos, head, node)
                 if (strcmp(pos->name, name) == 0)
                         return pos;
         return NULL;
@@ -959,79 +1583,227 @@ static struct dso *dsos__find(const char *name)
 
 struct dso *dsos__findnew(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(&dsos__user, 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(&dsos__user, 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)
+{
         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) {
+                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)
 {
-        return dso__find_symbol(dso, ip);
+        return (__dsos__fprintf_buildid(&dsos__kernel, fp) +
+                __dsos__fprintf_buildid(&dsos__user, fp));
 }
 
-int load_kernel(void)
+static struct dso *dsos__create_kernel( const char *vmlinux)
 {
-        int err;
+        struct dso *kernel = dso__new(vmlinux ?: "[kernel.kallsyms]");
+
+        if (kernel == NULL)
+                return NULL;
+
+        kernel->short_name = "[kernel]";
+        kernel->kernel     = 1;
+
+        vdso = dso__new("[vdso]");
+        if (vdso == NULL)
+                goto out_delete_kernel_dso;
+        dso__set_loaded(vdso, MAP__FUNCTION);
+
+        if (sysfs__read_build_id("/sys/kernel/notes", kernel->build_id,
+                                 sizeof(kernel->build_id)) == 0)
+                kernel->has_build_id = true;
+
+        dsos__add(&dsos__kernel, kernel);
+        dsos__add(&dsos__user, vdso);
 
-        kernel_dso = dso__new("[kernel]", 0);
-        if (!kernel_dso)
+        return kernel;
+
+out_delete_kernel_dso:
+        dso__delete(kernel);
+        return NULL;
+}
+
+static int map_groups__create_kernel_maps(struct map_groups *self, const char *vmlinux)
+{
+        struct map *functions, *variables;
+        struct dso *kernel = dsos__create_kernel(vmlinux);
+
+        if (kernel == NULL)
                 return -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);
+        functions = map__new2(0, kernel, MAP__FUNCTION);
+        if (functions == NULL)
+                return -1;
 
-        vdso = dso__new("[vdso]", 0);
-        if (!vdso)
+        variables = map__new2(0, kernel, MAP__VARIABLE);
+        if (variables == NULL) {
+                map__delete(functions);
                 return -1;
+        }
 
-        vdso->find_symbol = vdso__find_symbol;
+        functions->map_ip = functions->unmap_ip =
+                variables->map_ip = variables->unmap_ip = identity__map_ip;
+        map_groups__insert(self, functions);
+        map_groups__insert(self, variables);
 
-        dsos__add(vdso);
+        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;
+        }
 
-        hypervisor_dso = dso__new("[hypervisor]", 0);
-        if (!hypervisor_dso)
+        free(vmlinux_path);
+        vmlinux_path = NULL;
+}
+
+static int vmlinux_path__init(void)
+{
+        struct utsname uts;
+        char bf[PATH_MAX];
+
+        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;
 
-void symbol__init(void)
+        *list = strlist__new(true, list_str);
+        if (!*list) {
+                pr_err("problems parsing %s list\n", list_name);
+                return -1;
+        }
+        return 0;
+}
+
+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 perf_session__create_kernel_maps(struct perf_session *self)
+{
+        if (map_groups__create_kernel_maps(&self->kmaps,
+                                           symbol_conf.vmlinux_name) < 0)
+                return -1;
+
+        if (symbol_conf.use_modules &&
+            perf_session__create_module_maps(self) < 0)
+                pr_debug("Failed to load list of modules for session %s, "
+                         "continuing...\n", self->filename);
+        /*
+         * Now that we have all the maps created, just set the ->end of them:
+         */
+        map_groups__fixup_end(&self->kmaps);
+        return 0;
 }
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 829da9edba64..8aded2356f79 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -1,11 +1,11 @@
-#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"
 
 #ifdef HAVE_CPLUS_DEMANGLE
@@ -46,57 +46,96 @@ 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];
 };
 
+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;
+        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 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;
         unsigned char    origin;
+        u8               sorted_by_name;
+        u8               loaded;
+        u8               build_id[BUILD_ID_SIZE];
+        u16              long_name_len;
+        const char       *short_name;
+        char             *long_name;
         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);
 void dso__delete(struct dso *self);
 
-static inline void *dso__sym_priv(struct dso *self, struct symbol *sym)
-{
-        return ((void *)sym) - self->sym_priv_size;
-}
+bool dso__loaded(const struct dso *self, enum map_type type);
+bool dso__sorted_by_name(const struct dso *self, enum map_type type);
+
+void dso__sort_by_name(struct dso *self, enum map_type type);
 
-struct symbol *dso__find_symbol(struct dso *self, u64 ip);
+struct perf_session;
 
-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);
+int dso__load(struct dso *self, struct map *map, struct perf_session *session,
+              symbol_filter_t filter);
 void dsos__fprintf(FILE *fp);
+size_t dsos__fprintf_buildid(FILE *fp);
 
-size_t dso__fprintf(struct dso *self, FILE *fp);
+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_build_id(struct dso *self, void *build_id);
+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 load_kernel(void);
+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(void);
+int build_id__sprintf(u8 *self, int len, char *bf);
 
-void symbol__init(void);
+int symbol__init(void);
+int perf_session__create_kernel_maps(struct perf_session *self);
 
-extern struct list_head dsos;
-extern struct dso *kernel_dso;
+extern struct list_head dsos__user, dsos__kernel;
 extern struct dso *vdso;
-extern struct dso *hypervisor_dso;
-extern const char *vmlinux_name;
-extern int   modules;
-#endif /* _PERF_SYMBOL_ */
+#endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 45efb5db0d19..4a08dcf50b68 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -2,20 +2,30 @@
 #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;
@@ -29,21 +39,90 @@ int thread__set_comm(struct thread *self, const char *comm)
         return self->comm ? 0 : -ENOMEM;
 }
 
-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;
+}
+
+static const char *map_type__name[MAP__NR_TYPES] = {
+        [MAP__FUNCTION] = "Functions",
+        [MAP__VARIABLE] = "Variables",
+};
+
+static 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 > 1) {
+                        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);
+}
+
+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 *
-threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
+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 +131,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 +152,127 @@ 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 void map_groups__remove_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);
 
-        if (!thread || thread__set_comm(thread, "swapper")) {
-                fprintf(stderr, "problem inserting idle task.\n");
-                exit(-1);
-        }
+        while (next) {
+                struct map *pos = rb_entry(next, struct map, rb_node);
+                next = rb_next(&pos->rb_node);
+
+                if (!map__overlap(pos, map))
+                        continue;
 
-        return thread;
+                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]);
+        }
 }
 
-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__remove_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;
+        int i;
 
-        if (self == NULL)
-                return NULL;
-
-        list_for_each_entry(pos, &self->maps, node)
-                if (ip >= pos->start && ip <= pos->end)
-                        return pos;
+        if (self->comm)
+                free(self->comm);
+        self->comm = strdup(parent->comm);
+        if (!self->comm)
+                return -ENOMEM;
 
-        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 +280,16 @@ size_t threads__fprintf(FILE *fp, struct rb_root *threads)
 
         return ret;
 }
+
+struct symbol *map_groups__find_symbol(struct map_groups *self,
+                                       struct perf_session *session,
+                                       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, session, map->map_ip(map, addr), filter);
+
+        return NULL;
+}
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 32aea3c1c2ad..c206f72c8881 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -1,22 +1,70 @@
+#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];
+};
+
 struct thread {
         struct rb_node          rb_node;
-        struct list_head        maps;
+        struct map_groups       mg;
         pid_t                   pid;
         char                    shortname[3];
         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_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,
+                                       struct perf_session *session,
+                                       enum map_type type, u64 addr,
+                                       symbol_filter_t filter);
+
+static inline struct symbol *
+map_groups__find_function(struct map_groups *self, struct perf_session *session,
+                          u64 addr, symbol_filter_t filter)
+{
+        return map_groups__find_symbol(self, session, MAP__FUNCTION, addr, filter);
+}
+
+struct map *map_groups__find_by_name(struct map_groups *self,
+                                     enum map_type type, const char *name);
+#endif  /* __PERF_THREAD_H */
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index af4b0573b37f..cace35595530 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -33,11 +33,11 @@
 #include <ctype.h>
 #include <errno.h>
 #include <stdbool.h>
+#include <linux/kernel.h>
 
 #include "../perf.h"
 #include "trace-event.h"
 
-
 #define VERSION "0.5"
 
 #define _STR(x) #x
@@ -483,27 +483,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;
@@ -530,11 +536,11 @@ void read_tracing_data(struct perf_event_attr *pattrs, int nb_events)
         page_size = getpagesize();
         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..c5c32be040bf 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:
@@ -1822,37 +1951,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);
+}
+
+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");
 }
 
-static int parse_common_pid(void *data)
+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 +2025,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 +2065,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 +2135,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 +2172,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 +2339,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 +2465,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 +2592,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 +2702,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 +2870,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 +2918,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 +2984,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 +3078,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 +3150,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 +3205,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 +3225,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 +3245,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 +3264,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)
diff --git a/tools/perf/util/trace-event-perl.c b/tools/perf/util/trace-event-perl.c
new file mode 100644
index 000000000000..6d6d76b8a21e
--- /dev/null
+++ b/tools/perf/util/trace-event-perl.c
@@ -0,0 +1,661 @@
+/*
+ * 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 "trace-event-perl.h"
+
+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];
+
+static 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;
+}
+
+int common_pc(struct scripting_context *context)
+{
+        int pc;
+
+        pc = parse_common_pc(context->event_data);
+
+        return pc;
+}
+
+int common_flags(struct scripting_context *context)
+{
+        int flags;
+
+        flags = parse_common_flags(context->event_data);
+
+        return flags;
+}
+
+int common_lock_depth(struct scripting_context *context)
+{
+        int lock_depth;
+
+        lock_depth = parse_common_lock_depth(context->event_data);
+
+        return lock_depth;
+}
+
+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,
+};
+
+static void print_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_unsupported_msg();
+
+        return -1;
+}
+
+static int perl_stop_script_unsupported(void)
+{
+        return 0;
+}
+
+static void perl_process_event_unsupported(int cpu __unused,
+                                           void *data __unused,
+                                           int size __unused,
+                                           unsigned long long nsecs __unused,
+                                           char *comm __unused)
+{
+}
+
+static int perl_generate_script_unsupported(const char *outfile __unused)
+{
+        print_unsupported_msg();
+
+        return -1;
+}
+
+struct scripting_ops perl_scripting_unsupported_ops = {
+        .name = "Perl",
+        .start_script = perl_start_script_unsupported,
+        .stop_script = perl_stop_script_unsupported,
+        .process_event = perl_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
+void setup_perl_scripting(void)
+{
+        register_perl_scripting(&perl_scripting_ops);
+}
+#endif
diff --git a/tools/perf/util/trace-event-perl.h b/tools/perf/util/trace-event-perl.h
new file mode 100644
index 000000000000..e88fb26137bb
--- /dev/null
+++ b/tools/perf/util/trace-event-perl.h
@@ -0,0 +1,55 @@
+#ifndef __PERF_TRACE_EVENT_PERL_H
+#define __PERF_TRACE_EVENT_PERL_H
+#ifdef NO_LIBPERL
+typedef int INTERP;
+#define dSP
+#define ENTER
+#define SAVETMPS
+#define PUTBACK
+#define SPAGAIN
+#define FREETMPS
+#define LEAVE
+#define SP
+#define ERRSV
+#define G_SCALAR                (0)
+#define G_DISCARD               (0)
+#define G_NOARGS                (0)
+#define PUSHMARK(a)
+#define SvTRUE(a)               (0)
+#define XPUSHs(s)
+#define sv_2mortal(a)
+#define newSVpv(a,b)
+#define newSVuv(a)
+#define newSViv(a)
+#define get_cv(a,b)             (0)
+#define call_pv(a,b)            (0)
+#define perl_alloc()            (0)
+#define perl_construct(a)       (0)
+#define perl_parse(a,b,c,d,e)   (0)
+#define perl_run(a)             (0)
+#define perl_destruct(a)        (0)
+#define perl_free(a)            (0)
+#define pTHX                    void
+#define CV                      void
+#define dXSUB_SYS
+#define pTHX_
+static inline void newXS(const char *a, void *b, const char *c) {}
+static void boot_Perf__Trace__Context(pTHX_ CV *cv) {}
+static void boot_DynaLoader(pTHX_ CV *cv) {}
+#else
+#include <EXTERN.h>
+#include <perl.h>
+void boot_Perf__Trace__Context(pTHX_ CV *cv);
+void boot_DynaLoader(pTHX_ CV *cv);
+typedef PerlInterpreter * INTERP;
+#endif
+
+struct scripting_context {
+        void *event_data;
+};
+
+int common_pc(struct scripting_context *context);
+int common_flags(struct scripting_context *context);
+int common_lock_depth(struct scripting_context *context);
+
+#endif /* __PERF_TRACE_EVENT_PERL_H */
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 1b5c847d2c22..1744422cafcb 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -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);
 
@@ -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.h b/tools/perf/util/trace-event.h
index 693f815c9429..6ad405620c9b 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,45 @@ 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 read_tracing_data(struct perf_event_attr *pattrs, int nb_events);
+extern struct scripting_ops perl_scripting_ops;
+void setup_perl_scripting(void);
 
-#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.h b/tools/perf/util/util.h
index 9de2329dd44d..c673d8825883 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)
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;
-}