109 files changed, 10121 insertions, 2212 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-kmem.txt b/tools/perf/Documentation/perf-kmem.txt
new file mode 100644
index 000000000000..44b0ce35c28a
--- /dev/null
+++ b/tools/perf/Documentation/perf-kmem.txt
@@ -0,0 +1,44 @@
+perf-kmem(1)
+==============
+
+NAME
+----
+perf-kmem - Tool to trace/measure kernel memory(slab) properties
+
+SYNOPSIS
+--------
+[verse]
+'perf kmem' {record} [<options>]
+
+DESCRIPTION
+-----------
+There's two variants of perf kmem:
+
+  'perf kmem record <command>' to record the kmem events
+  of an arbitrary workload.
+
+  'perf kmem' to report kernel memory statistics.
+
+OPTIONS
+-------
+-i <file>::
+--input=<file>::
+        Select the input file (default: perf.data)
+
+--stat=<caller|alloc>::
+        Select per callsite or 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..9270594e6dfd
--- /dev/null
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -0,0 +1,49 @@
+perf-probe(1)
+=============
+
+NAME
+----
+perf-probe - Define new dynamic tracepoints
+
+SYNOPSIS
+--------
+[verse]
+'perf probe' [options] --add 'PROBE' [--add 'PROBE' ...]
+or
+'perf probe' [options] 'PROBE' ['PROBE' ...]
+
+
+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 point (see PROBE SYNTAX for detail)
+
+PROBE SYNTAX
+------------
+Probe points are defined by following syntax.
+
+ "FUNC[+OFFS|:RLN|%return][@SRC]|SRC:ALN [ARG ...]"
+
+'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..9dccb180b7af 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=::
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..07065efa60e0 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -20,6 +20,15 @@ OPTIONS
 --dump-raw-trace=::
         Display verbose dump of the trace data.
 
+-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 106c15055b50..23ec66098bdc 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,28 +162,13 @@ 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.
 
 #
 # Include saner warnings here, which can catch bugs:
 #
 
-EXTRA_WARNINGS := -Wcast-align
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat
+EXTRA_WARNINGS := -Wformat
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-security
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-y2k
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wshadow
@@ -201,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
@@ -253,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 ---
@@ -328,8 +328,27 @@ 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
@@ -350,12 +369,16 @@ LIB_H += util/sort.h
 LIB_H += util/hist.h
 LIB_H += util/thread.h
 LIB_H += util/data_map.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
@@ -363,6 +386,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
@@ -383,14 +409,25 @@ 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-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
@@ -398,9 +435,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
 #
@@ -428,32 +472,58 @@ ifeq ($(uname_S),Darwin)
         PTHREAD_LIBS =
 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) > /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 '\#include <libdwarf/dwarf.h>'; echo '\#include <libdwarf/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 -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
+        EXTLIBS += -lelf -ldwarf
+        LIB_OBJS += util/probe-finder.o
+endif
+
+PERL_EMBED_LDOPTS = `perl -MExtUtils::Embed -e ldopts 2>/dev/null`
+PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`
+
+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
@@ -790,6 +860,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)
 
@@ -897,6 +986,13 @@ 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'
+        $(INSTALL) scripts/perl/Perf-Trace-Util/Makefile.PL -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util'
+        $(INSTALL) scripts/perl/Perf-Trace-Util/README -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util'
 ifdef BUILT_INS
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
         $(INSTALL) $(BUILT_INS) '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
@@ -982,7 +1078,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..605a2a959aa8
--- /dev/null
+++ b/tools/perf/bench/sched-messaging.c
@@ -0,0 +1,336 @@
+/*
+ *
+ * builtin-bench-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, diff.tv_usec/1000);
+                break;
+        case BENCH_FORMAT_SIMPLE:
+                printf("%lu.%03lu\n", diff.tv_sec, 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..238185f97977
--- /dev/null
+++ b/tools/perf/bench/sched-pipe.c
@@ -0,0 +1,124 @@
+/*
+ *
+ * builtin-bench-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));
+                return 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, 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, 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 8c84320ecb06..0bf2e8f9af57 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -19,27 +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/data_map.h"
 
 static char             const *input_name = "perf.data";
 
 static int              force;
-static int              input;
 
 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;
@@ -47,6 +46,39 @@ struct sym_ext {
         char            *path;
 };
 
+struct sym_priv {
+        struct sym_hist *hist;
+        struct sym_ext  *ext;
+};
+
+static struct symbol_conf symbol_conf = {
+        .priv_size        = sizeof(struct sym_priv),
+        .try_vmlinux_path = true,
+};
+
+static const char *sym_hist_filter;
+
+static int symbol_filter(struct map *map __used, struct symbol *sym)
+{
+        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));
+
+                priv->hist = malloc(size);
+                if (priv->hist)
+                        memset(priv->hist, 0, size);
+                return 0;
+        }
+        /*
+         * 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;
+}
 
 /*
  * collect histogram counts
@@ -55,230 +87,81 @@ 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;
-        ip = he->map->map_ip(he->map, ip);
         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 symbol *sym, u64 ip, u64 count, char level)
+static int hist_entry__add(struct addr_location *al, u64 count)
 {
         bool hit;
-        struct hist_entry *he = __hist_entry__add(thread, map, sym, NULL, ip,
-                                                  count, level, &hit);
+        struct hist_entry *he = __hist_entry__add(al, NULL, count, &hit);
         if (he == NULL)
                 return -ENOMEM;
-        if (hit)
-                hist_hit(he, ip);
+        hist_hit(he, al->addr);
         return 0;
 }
 
-static int
-process_sample_event(event_t *event, unsigned long offset, unsigned long head)
+static int process_sample_event(event_t *event)
 {
-        char level;
-        struct thread *thread;
-        u64 ip = event->ip.ip;
-        struct map *map = NULL;
-        struct symbol *sym = NULL;
-
-        thread = threads__findnew(event->ip.pid, &threads, &last_match);
+        struct addr_location al;
 
-        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("(IP, %d): %d: %p\n", event->header.misc,
+                    event->ip.pid, (void *)(long)event->ip.ip);
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
-
-        if (thread == NULL) {
+        if (event__preprocess_sample(event, &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) {
-                level = 'k';
-                sym = kernel_maps__find_symbol(ip, &map);
-                dump_printf(" ...... dso: %s\n",
-                            map ? map->dso->long_name : "<not found>");
-        } else if (event->header.misc & PERF_RECORD_MISC_USER) {
-                level = '.';
-                map = thread__find_map(thread, ip);
-                if (map != NULL) {
-got_map:
-                        ip = map->map_ip(map, ip);
-                        sym = map->dso->find_symbol(map->dso, ip);
-                } 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 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)ip < 0) {
-                                map = kernel_map;
-                                goto got_map;
-                        }
-                }
-                dump_printf(" ...... dso: %s\n",
-                            map ? map->dso->long_name : "<not found>");
-        } else {
-                level = 'H';
-                dump_printf(" ...... dso: [hypervisor]\n");
-        }
-
-        if (hist_entry__add(thread, map, sym, ip, 1, level)) {
+        if (hist_entry__add(&al, 1)) {
                 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");
-                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 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;
@@ -315,22 +198,26 @@ parse_line(FILE *file, struct symbol *sym, 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 - sym->start;
+                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);
 
@@ -383,9 +270,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)
@@ -395,26 +283,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, 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;
@@ -422,11 +314,11 @@ get_source_line(struct symbol *sym, 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;
 
-                offset = sym->start + i;
+                offset = start + i;
                 sprintf(cmd, "addr2line -e %s %016llx", filename, offset);
                 fp = popen(cmd, "r");
                 if (!fp)
@@ -476,8 +368,11 @@ 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)
 {
+        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];
@@ -486,6 +381,12 @@ static void annotate_sym(struct dso *dso, struct symbol *sym)
         if (!filename)
                 return;
 
+        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
@@ -494,7 +395,7 @@ static void annotate_sym(struct dso *dso, struct symbol *sym)
         len = sym->end - sym->start;
 
         if (print_line) {
-                get_source_line(sym, len, filename);
+                get_source_line(he, len, filename);
                 print_summary(filename);
         }
 
@@ -507,7 +408,8 @@ static void annotate_sym(struct dso *dso, struct symbol *sym)
                        dso, dso->long_name, sym, sym->name);
 
         sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s|grep -v %s",
-                sym->start, sym->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);
@@ -517,159 +419,78 @@ static void annotate_sym(struct dso *dso, struct symbol *sym)
                 return;
 
         while (!feof(file)) {
-                if (parse_line(file, sym, 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)
 {
         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;
-
-                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) {
+        for (nd = rb_first(&output_hists); nd; nd = rb_next(nd)) {
+                struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
+                struct sym_priv *priv;
 
-                dump_printf("%p [%p]: skipping unknown header type: %d\n",
-                        (void *)(offset + head),
-                        (void *)(long)(event->header.size),
-                        event->header.type);
+                if (he->sym == NULL)
+                        continue;
 
-                total_unknown++;
+                priv = symbol__priv(he->sym);
+                if (priv->hist == NULL)
+                        continue;
 
+                annotate_sym(he);
                 /*
-                 * assume we lost track of the stream, check alignment, and
-                 * increment a single u64 in the hope to catch on again 'soon'.
+                 * Since we have a hist_entry per IP for the same symbol, free
+                 * he->sym->hist to signal we already processed this symbol.
                  */
-
-                if (unlikely(head & 7))
-                        head &= ~7ULL;
-
-                size = 8;
+                free(priv->hist);
+                priv->hist = NULL;
         }
+}
 
-        head += size;
+static struct perf_file_handler file_handler = {
+        .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)
+{
+        struct perf_header *header;
+        struct thread *idle;
+        int ret;
 
-        rc = EXIT_SUCCESS;
-        close(input);
+        idle = register_idle_thread();
+        register_perf_file_handler(&file_handler);
 
-        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 = mmap_dispatch_perf_file(&header, input_name, 0, 0,
+                                      &event__cwdlen, &event__cwd);
+        if (ret)
+                return ret;
 
-        if (dump_trace)
+        if (dump_trace) {
+                event__print_totals();
                 return 0;
+        }
 
         if (verbose > 3)
-                threads__fprintf(stdout, &threads);
+                threads__fprintf(stdout);
 
         if (verbose > 2)
                 dsos__fprintf(stdout);
 
         collapse__resort();
-        output__resort(total);
+        output__resort(event__total[0]);
 
         find_annotations();
 
-        return rc;
+        return ret;
 }
 
 static const char * const annotate_usage[] = {
@@ -687,8 +508,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)"),
@@ -714,9 +536,8 @@ static void setup_sorting(void)
 
 int cmd_annotate(int argc, const char **argv, const char *prefix __used)
 {
-        symbol__init();
-
-        page_size = getpagesize();
+        if (symbol__init(&symbol_conf) < 0)
+                return -1;
 
         argc = parse_options(argc, argv, options, annotate_usage, 0);
 
@@ -733,9 +554,6 @@ 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 == '.') {
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
new file mode 100644
index 000000000000..e043eb83092a
--- /dev/null
+++ b/tools/perf/builtin-bench.c
@@ -0,0 +1,196 @@
+/*
+ *
+ * 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 *);
+};
+
+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      },
+        { NULL,
+          NULL,
+          NULL                  }
+};
+
+static struct bench_suite mem_suites[] = {
+        { "memcpy",
+          "Simple memory copy in various ways",
+          bench_mem_memcpy },
+        { 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 },
+        { 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("\t%s: %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("\t%s: %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;
+}
+
+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;
+        }
+
+        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;
+                }
+
+                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..7dee9d19ab7a
--- /dev/null
+++ b/tools/perf/builtin-buildid-list.c
@@ -0,0 +1,116 @@
+/*
+ * 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/data_map.h"
+#include "util/debug.h"
+#include "util/header.h"
+#include "util/parse-options.h"
+#include "util/symbol.h"
+
+static char const *input_name = "perf.data";
+static int force;
+
+static const char *const buildid_list_usage[] = {
+        "perf report [<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_header *header;
+        struct perf_file_header f_header;
+        struct stat input_stat;
+        int input = open(input_name, O_RDONLY);
+
+        if (input < 0) {
+                pr_err("failed to open file: %s", input_name);
+                if (!strcmp(input_name, "perf.data"))
+                        pr_err("  (try 'perf record' first)");
+                pr_err("\n");
+                goto out;
+        }
+
+        err = fstat(input, &input_stat);
+        if (err < 0) {
+                perror("failed to stat file");
+                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",
+                       input_name);
+                goto out_close;
+        }
+
+        if (!input_stat.st_size) {
+                pr_info("zero-sized file, nothing to do!\n");
+                goto out_close;
+        }
+
+        err = -1;
+        header = perf_header__new();
+        if (header == NULL)
+                goto out_close;
+
+        if (perf_file_header__read(&f_header, header, input) < 0) {
+                pr_warning("incompatible file format");
+                goto out_close;
+        }
+
+        err = perf_header__process_sections(header, input,
+                                         perf_file_section__process_buildids);
+
+        if (err < 0)
+                goto out_close;
+
+        dsos__fprintf_buildid(stdout);
+out_close:
+        close(input);
+out:
+        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-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..047fef74bd52
--- /dev/null
+++ b/tools/perf/builtin-kmem.c
@@ -0,0 +1,807 @@
+#include "builtin.h"
+#include "perf.h"
+
+#include "util/util.h"
+#include "util/cache.h"
+#include "util/symbol.h"
+#include "util/thread.h"
+#include "util/header.h"
+
+#include "util/parse-options.h"
+#include "util/trace-event.h"
+
+#include "util/debug.h"
+#include "util/data_map.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 struct perf_header       *header;
+static u64                      sample_type;
+
+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;
+
+struct raw_event_sample {
+        u32 size;
+        char data[0];
+};
+
+#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(struct raw_event_sample *raw,
+                                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", raw->data);
+        call_site = raw_field_value(event, "call_site", raw->data);
+        bytes_req = raw_field_value(event, "bytes_req", raw->data);
+        bytes_alloc = raw_field_value(event, "bytes_alloc", raw->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", raw->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(struct raw_event_sample *raw,
+                               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", raw->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 *more_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);
+        event = trace_find_event(type);
+
+        if (!strcmp(event->name, "kmalloc") ||
+            !strcmp(event->name, "kmem_cache_alloc")) {
+                process_alloc_event(raw, event, cpu, timestamp, thread, 0);
+                return;
+        }
+
+        if (!strcmp(event->name, "kmalloc_node") ||
+            !strcmp(event->name, "kmem_cache_alloc_node")) {
+                process_alloc_event(raw, event, cpu, timestamp, thread, 1);
+                return;
+        }
+
+        if (!strcmp(event->name, "kfree") ||
+            !strcmp(event->name, "kmem_cache_free")) {
+                process_free_event(raw, event, cpu, timestamp, thread);
+                return;
+        }
+}
+
+static int process_sample_event(event_t *event)
+{
+        u64 ip = event->ip.ip;
+        u64 timestamp = -1;
+        u32 cpu = -1;
+        u64 period = 1;
+        void *more_data = event->ip.__more_data;
+        struct thread *thread = threads__findnew(event->ip.pid);
+
+        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 (sample_type & PERF_SAMPLE_PERIOD) {
+                period = *(u64 *)more_data;
+                more_data += sizeof(u64);
+        }
+
+        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);
+
+        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, more_data, cpu, timestamp, thread);
+
+        return 0;
+}
+
+static int sample_type_check(u64 type)
+{
+        sample_type = type;
+
+        if (!(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_file_handler file_handler = {
+        .process_sample_event   = process_sample_event,
+        .process_comm_event     = event__process_comm,
+        .sample_type_check      = sample_type_check,
+};
+
+static int read_events(void)
+{
+        register_idle_thread();
+        register_perf_file_handler(&file_handler);
+
+        return mmap_dispatch_perf_file(&header, input_name, 0, 0,
+                                       &event__cwdlen, &event__cwd);
+}
+
+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, 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 = thread__find_function(kthread, 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(void)
+{
+        if (caller_flag)
+                __print_result(&root_caller_sorted, caller_lines, 1);
+        if (alloc_flag)
+                __print_result(&root_alloc_sorted, 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)
+{
+        setup_pager();
+        read_events();
+        sort_result();
+        print_result();
+
+        return 0;
+}
+
+static const char * const kmem_usage[] = {
+        "perf kmem [<options>] {record}",
+        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_stat_opt(const struct option *opt __used,
+                          const char *arg, int unset __used)
+{
+        if (!arg)
+                return -1;
+
+        if (strcmp(arg, "alloc") == 0)
+                alloc_flag = (caller_flag + 1);
+        else if (strcmp(arg, "caller") == 0)
+                caller_flag = (alloc_flag + 1);
+        else
+                return -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(0, "stat", NULL, "<alloc>|<caller>",
+                     "stat selector, Pass 'alloc' or 'caller'.",
+                     parse_stat_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 lins",
+                     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)
+{
+        symbol__init(0);
+
+        argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);
+
+        if (argc && !strncmp(argv[0], "rec", 3))
+                return __cmd_record(argc, argv);
+        else if (argc)
+                usage_with_options(kmem_usage, kmem_options);
+
+        if (list_empty(&caller_sort))
+                setup_sorting(&caller_sort, default_sort_order);
+        if (list_empty(&alloc_sort))
+                setup_sorting(&alloc_sort, default_sort_order);
+
+        setup_cpunode_map();
+
+        return __cmd_kmem();
+}
+
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
new file mode 100644
index 000000000000..a58e11b7ea80
--- /dev/null
+++ b/tools/perf/builtin-probe.c
@@ -0,0 +1,242 @@
+/*
+ * 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/event.h"
+#include "util/debug.h"
+#include "util/parse-options.h"
+#include "util/parse-events.h"  /* For debugfs_path */
+#include "util/probe-finder.h"
+#include "util/probe-event.h"
+
+/* Default vmlinux search paths */
+#define NR_SEARCH_PATH 3
+const char *default_search_path[NR_SEARCH_PATH] = {
+"/lib/modules/%s/build/vmlinux",                /* Custom build kernel */
+"/usr/lib/debug/lib/modules/%s/vmlinux",        /* Red Hat debuginfo */
+"/boot/vmlinux-debug-%s",                       /* Ubuntu */
+};
+
+#define MAX_PATH_LEN 256
+#define MAX_PROBES 128
+
+/* Session management structure */
+static struct {
+        char *vmlinux;
+        char *release;
+        int need_dwarf;
+        int nr_probe;
+        struct probe_point probes[MAX_PROBES];
+} session;
+
+static bool listing;
+
+/* 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 */
+        session.need_dwarf = parse_perf_probe_event(str, pp);
+
+        pr_debug("%d arguments\n", pp->nr_args);
+}
+
+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;
+}
+
+#ifndef NO_LIBDWARF
+static int open_default_vmlinux(void)
+{
+        struct utsname uts;
+        char fname[MAX_PATH_LEN];
+        int fd, ret, i;
+
+        ret = uname(&uts);
+        if (ret) {
+                pr_debug("uname() failed.\n");
+                return -errno;
+        }
+        session.release = uts.release;
+        for (i = 0; i < NR_SEARCH_PATH; i++) {
+                ret = snprintf(fname, MAX_PATH_LEN,
+                               default_search_path[i], session.release);
+                if (ret >= MAX_PATH_LEN || ret < 0) {
+                        pr_debug("Filename(%d,%s) is too long.\n", i,
+                                uts.release);
+                        errno = E2BIG;
+                        return -E2BIG;
+                }
+                pr_debug("try to open %s\n", fname);
+                fd = open(fname, O_RDONLY);
+                if (fd >= 0)
+                        break;
+        }
+        return fd;
+}
+#endif
+
+static const char * const probe_usage[] = {
+        "perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
+        "perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
+        "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", &session.vmlinux, "file",
+                "vmlinux/module pathname"),
+#endif
+        OPT_BOOLEAN('l', "list", &listing, "list up current probes"),
+        OPT_CALLBACK('a', "add", NULL,
+#ifdef NO_LIBDWARF
+                "FUNC[+OFFS|%return] [ARG ...]",
+#else
+                "FUNC[+OFFS|%return|:RLN][@SRC]|SRC:ALN [ARG ...]",
+#endif
+                "probe point definition, where\n"
+                "\t\tGRP:\tGroup name (optional)\n"
+                "\t\tNAME:\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_END()
+};
+
+int cmd_probe(int argc, const char **argv, const char *prefix __used)
+{
+        int i, j, 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);
+        for (i = 0; i < argc; i++)
+                parse_probe_event(argv[i]);
+
+        if ((session.nr_probe == 0 && !listing) ||
+            (session.nr_probe != 0 && listing))
+                usage_with_options(probe_usage, options);
+
+        if (listing) {
+                show_perf_probe_events();
+                return 0;
+        }
+
+        if (session.need_dwarf)
+#ifdef NO_LIBDWARF
+                die("Debuginfo-analysis is not supported");
+#else   /* !NO_LIBDWARF */
+                pr_debug("Some probes require debuginfo.\n");
+
+        if (session.vmlinux)
+                fd = open(session.vmlinux, O_RDONLY);
+        else
+                fd = open_default_vmlinux();
+        if (fd < 0) {
+                if (session.need_dwarf)
+                        die("Could not open vmlinux/module file.");
+
+                pr_warning("Could not open vmlinux/module file."
+                           " Try to use symbols.\n");
+                goto end_dwarf;
+        }
+
+        /* Searching probe points */
+        for (j = 0; j < session.nr_probe; j++) {
+                pp = &session.probes[j];
+                if (pp->found)
+                        continue;
+
+                lseek(fd, SEEK_SET, 0);
+                ret = find_probepoint(fd, pp);
+                if (ret < 0) {
+                        if (session.need_dwarf)
+                                die("Could not analyze debuginfo.");
+
+                        pr_warning("An error occurred in debuginfo analysis. Try to use symbols.\n");
+                        break;
+                }
+                if (ret == 0)   /* No error but failed to find probe point. */
+                        die("No probe point found.");
+        }
+        close(fd);
+
+end_dwarf:
+#endif /* !NO_LIBDWARF */
+
+        /* Synthesize probes without dwarf */
+        for (j = 0; j < session.nr_probe; j++) {
+                pp = &session.probes[j];
+                if (pp->found)  /* This probe is already found. */
+                        continue;
+
+                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);
+        return 0;
+}
+
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 4e3a374e7aa7..0e519c667e3a 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -17,13 +17,11 @@
 #include "util/header.h"
 #include "util/event.h"
 #include "util/debug.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                =      0;
@@ -112,6 +110,24 @@ 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)
+{
+        write_event(event, event->header.size);
+        return 0;
+}
+
 static void mmap_read(struct mmap_data *md)
 {
         unsigned int head = mmap_read_head(md);
@@ -160,14 +176,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);
@@ -194,168 +210,6 @@ 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)
@@ -366,7 +220,11 @@ static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int n
                 h_attr = 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(header, h_attr) < 0) {
+                                perf_header_attr__delete(h_attr);
+                                h_attr = NULL;
+                        }
         }
 
         return h_attr;
@@ -374,9 +232,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;
@@ -425,7 +285,7 @@ try_again:
         if (fd[nr_cpu][counter] < 0) {
                 int err = errno;
 
-                if (err == EPERM)
+                if (err == EPERM || err == EACCES)
                         die("Permission error - are you root?\n");
                 else if (err ==  ENODEV && profile_cpu != -1)
                         die("No such device - did you specify an out-of-range profile CPU?\n");
@@ -447,11 +307,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))) {
@@ -465,7 +333,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);
@@ -479,7 +350,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);
@@ -499,6 +369,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);
 }
 
@@ -517,7 +397,7 @@ static void atexit_header(void)
 {
         header->data_size += bytes_written;
 
-        perf_header__write(header, output);
+        perf_header__write(header, output, true);
 }
 
 static int __cmd_record(int argc, const char **argv)
@@ -526,7 +406,7 @@ static int __cmd_record(int argc, const char **argv)
         struct stat st;
         pid_t pid = 0;
         int flags;
-        int ret;
+        int err;
         unsigned long waking = 0;
 
         page_size = sysconf(_SC_PAGE_SIZE);
@@ -560,17 +440,24 @@ static int __cmd_record(int argc, const char **argv)
                 exit(-1);
         }
 
-        if (!file_new)
-                header = perf_header__read(output);
-        else
-                header = perf_header__new();
+        header = perf_header__new();
+        if (header == NULL) {
+                pr_err("Not enough memory for reading perf file header\n");
+                return -1;
+        }
+
+        if (!file_new) {
+                err = perf_header__read(header, output);
+                if (err < 0)
+                        return err;
+        }
 
         if (raw_samples) {
-                perf_header__set_trace_info();
+                perf_header__set_feat(header, HEADER_TRACE_INFO);
         } else {
                 for (i = 0; i < nr_counters; i++) {
                         if (attrs[i].sample_type & PERF_SAMPLE_RAW) {
-                                perf_header__set_trace_info();
+                                perf_header__set_feat(header, HEADER_TRACE_INFO);
                                 break;
                         }
                 }
@@ -593,25 +480,36 @@ static int __cmd_record(int argc, const char **argv)
                 }
         }
 
-        if (file_new)
-                perf_header__write(header, output);
+        if (file_new) {
+                err = perf_header__write(header, output, false);
+                if (err < 0)
+                        return err;
+        }
 
-        if (!system_wide) {
-                pid_t tgid = pid_synthesize_comm_event(pid, 0);
-                pid_synthesize_mmap_samples(pid, tgid);
-        } else
-                synthesize_all();
+        if (!system_wide)
+                event__synthesize_thread(pid, process_synthesized_event);
+        else
+                event__synthesize_threads(process_synthesized_event);
 
         if (target_pid == -1 && argc) {
                 pid = fork();
                 if (pid < 0)
-                        perror("failed to fork");
+                        die("failed to fork");
 
                 if (!pid) {
                         if (execvp(argv[0], (char **)argv)) {
                                 perror(argv[0]);
                                 exit(-1);
                         }
+                } else {
+                        /*
+                         * Wait a bit for the execv'ed child to appear
+                         * and be updated in /proc
+                         * FIXME: Do you know a less heuristical solution?
+                         */
+                        usleep(1000);
+                        event__synthesize_thread(pid,
+                                                 process_synthesized_event);
                 }
 
                 child_pid = pid;
@@ -622,7 +520,7 @@ static int __cmd_record(int argc, const char **argv)
 
                 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);
                 }
         }
@@ -640,7 +538,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++;
                 }
 
@@ -676,6 +574,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,
@@ -719,6 +619,8 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
 {
         int counter;
 
+        symbol__init(0);
+
         argc = parse_options(argc, argv, options, record_usage,
                 PARSE_OPT_STOP_AT_NON_OPTION);
         if (!argc && target_pid == -1 && !system_wide)
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index f57a23b19f3c..383c4ab4f9af 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -52,22 +52,34 @@ static int		exclude_other = 1;
 
 static char             callchain_default_opt[] = "fractal,0.5";
 
-static char             *cwd;
-static int              cwdlen;
-
-static struct rb_root   threads;
-static struct thread    *last_match;
-
 static struct perf_header *header;
 
 static u64              sample_type;
 
-static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask)
+struct symbol_conf      symbol_conf;
+
+
+static size_t
+callchain__fprintf_left_margin(FILE *fp, int left_margin)
+{
+        int i;
+        int ret;
+
+        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 = 0;
 
-        ret += fprintf(fp, "%s", "                ");
+        ret += callchain__fprintf_left_margin(fp, left_margin);
 
         for (i = 0; i < depth; i++)
                 if (depth_mask & (1 << i))
@@ -82,12 +94,12 @@ static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask)
 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 hits, int left_margin)
 {
         int i;
         size_t ret = 0;
 
-        ret += fprintf(fp, "%s", "                ");
+        ret += callchain__fprintf_left_margin(fp, left_margin);
         for (i = 0; i < depth; i++) {
                 if (depth_mask & (1 << i))
                         ret += fprintf(fp, "|");
@@ -125,8 +137,9 @@ static void init_rem_hits(void)
 }
 
 static size_t
-callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
-                        u64 total_samples, int depth, int depth_mask)
+__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;
@@ -167,7 +180,8 @@ callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                  * 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);
+                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)
@@ -175,11 +189,13 @@ callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                         ret += ipchain__fprintf_graph(fp, chain, depth,
                                                       new_depth_mask, i++,
                                                       new_total,
-                                                      cumul);
+                                                      cumul,
+                                                      left_margin);
                 }
-                ret += callchain__fprintf_graph(fp, child, new_total,
-                                                depth + 1,
-                                                new_depth_mask | (1 << depth));
+                ret += __callchain__fprintf_graph(fp, child, new_total,
+                                                  depth + 1,
+                                                  new_depth_mask | (1 << depth),
+                                                  left_margin);
                 node = next;
         }
 
@@ -193,12 +209,51 @@ callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
 
                 ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
                                               new_depth_mask, 0, new_total,
-                                              remaining);
+                                              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)
@@ -227,7 +282,7 @@ callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
 
 static size_t
 hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
-                              u64 total_samples)
+                              u64 total_samples, int left_margin)
 {
         struct rb_node *rb_node;
         struct callchain_node *chain;
@@ -247,8 +302,8 @@ hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
                         break;
                 case CHAIN_GRAPH_ABS: /* Falldown */
                 case CHAIN_GRAPH_REL:
-                        ret += callchain__fprintf_graph(fp, chain,
-                                                        total_samples, 1, 1);
+                        ret += callchain__fprintf_graph(fp, chain, total_samples,
+                                                        left_margin);
                 case CHAIN_NONE:
                 default:
                         break;
@@ -293,8 +348,19 @@ hist_entry__fprintf(FILE *fp, struct hist_entry *self, u64 total_samples)
 
         ret += fprintf(fp, "\n");
 
-        if (callchain)
-                hist_entry_callchain__fprintf(fp, self, total_samples);
+        if (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, total_samples,
+                                              left_margin);
+        }
 
         return ret;
 }
@@ -342,55 +408,6 @@ static int thread__set_comm_adjust(struct thread *self, const char *comm)
         return 0;
 }
 
-
-static struct symbol *
-resolve_symbol(struct thread *thread, struct map **mapp, u64 *ipp)
-{
-        struct map *map = mapp ? *mapp : NULL;
-        u64 ip = *ipp;
-
-        if (map)
-                goto got_map;
-
-        if (!thread)
-                return NULL;
-
-        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);
-        } 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 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)ip < 0)
-                        return kernel_maps__find_symbol(ip, mapp);
-        }
-        dump_printf(" ...... dso: %s\n",
-                    map ? map->dso->long_name : "<not found>");
-        dump_printf(" ...... map: %Lx -> %Lx\n", *ipp, ip);
-        *ipp  = ip;
-
-        return map ? map->dso->find_symbol(map->dso, ip) : NULL;
-}
-
 static int call__match(struct symbol *sym)
 {
         if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
@@ -399,11 +416,11 @@ static int call__match(struct symbol *sym)
         return 0;
 }
 
-static struct symbol **resolve_callchain(struct thread *thread, struct map *map,
+static struct symbol **resolve_callchain(struct thread *thread,
                                          struct ip_callchain *chain,
                                          struct symbol **parent)
 {
-        u64 context = PERF_CONTEXT_MAX;
+        u8 cpumode = PERF_RECORD_MISC_USER;
         struct symbol **syms = NULL;
         unsigned int i;
 
@@ -417,30 +434,31 @@ static struct symbol **resolve_callchain(struct thread *thread, struct map *map,
 
         for (i = 0; i < chain->nr; i++) {
                 u64 ip = chain->ips[i];
-                struct symbol *sym = NULL;
+                struct addr_location al;
 
                 if (ip >= PERF_CONTEXT_MAX) {
-                        context = ip;
+                        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;
                 }
 
-                switch (context) {
-                case PERF_CONTEXT_HV:
-                        break;
-                case PERF_CONTEXT_KERNEL:
-                        sym = kernel_maps__find_symbol(ip, &map);
-                        break;
-                default:
-                        sym = resolve_symbol(thread, &map, &ip);
-                        break;
-                }
-
-                if (sym) {
-                        if (sort__has_parent && !*parent && call__match(sym))
-                                *parent = sym;
+                thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
+                                           ip, &al, NULL);
+                if (al.sym != NULL) {
+                        if (sort__has_parent && !*parent &&
+                            call__match(al.sym))
+                                *parent = al.sym;
                         if (!callchain)
                                 break;
-                        syms[i] = sym;
+                        syms[i] = al.sym;
                 }
         }
 
@@ -451,20 +469,17 @@ static struct symbol **resolve_callchain(struct thread *thread, struct map *map,
  * collect histogram counts
  */
 
-static int
-hist_entry__add(struct thread *thread, struct map *map,
-                struct symbol *sym, u64 ip, struct ip_callchain *chain,
-                char level, u64 count)
+static int hist_entry__add(struct addr_location *al,
+                           struct ip_callchain *chain, u64 count)
 {
         struct symbol **syms = NULL, *parent = NULL;
         bool hit;
         struct hist_entry *he;
 
         if ((sort__has_parent || callchain) && chain)
-                syms = resolve_callchain(thread, map, chain, &parent);
+                syms = resolve_callchain(al->thread, chain, &parent);
 
-        he = __hist_entry__add(thread, map, sym, parent,
-                               ip, count, level, &hit);
+        he = __hist_entry__add(al, parent, count, &hit);
         if (he == NULL)
                 return -ENOMEM;
 
@@ -588,29 +603,22 @@ 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)
 {
-        char level;
-        struct symbol *sym = 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);
+        struct addr_location al;
+        struct thread *thread = threads__findnew(event->ip.pid);
 
         if (sample_type & PERF_SAMPLE_PERIOD) {
                 period = *(u64 *)more_data;
                 more_data += sizeof(u64);
         }
 
-        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,
@@ -624,7 +632,8 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                 dump_printf("... chain: nr:%Lu\n", chain->nr);
 
                 if (validate_chain(chain, event) < 0) {
-                        eprintf("call-chain problem with event, skipping it.\n");
+                        pr_debug("call-chain problem with event, "
+                                 "skipping it.\n");
                         return 0;
                 }
 
@@ -634,156 +643,64 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                 }
         }
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
-
         if (thread == NULL) {
-                eprintf("problem processing %d event, skipping it.\n",
+                pr_debug("problem processing %d event, skipping it.\n",
                         event->header.type);
                 return -1;
         }
 
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
         if (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) {
-                level = 'k';
-                sym = kernel_maps__find_symbol(ip, &map);
-                dump_printf(" ...... dso: %s\n",
-                            map ? map->dso->long_name : "<not found>");
-        } else if (cpumode == PERF_RECORD_MISC_USER) {
-                level = '.';
-                sym = resolve_symbol(thread, &map, &ip);
-
-        } else {
-                level = 'H';
-                dump_printf(" ...... dso: [hypervisor]\n");
-        }
+        thread__find_addr_location(thread, cpumode,
+                                   MAP__FUNCTION, ip, &al, 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 (al.map && !sort_dso.elide && !al.map->dso->slen_calculated)
+                dso__calc_col_width(al.map->dso);
 
         if (dso_list &&
-            (!map || !map->dso ||
-             !(strlist__has_entry(dso_list, map->dso->short_name) ||
-               (map->dso->short_name != map->dso->long_name &&
-                strlist__has_entry(dso_list, map->dso->long_name)))))
+            (!al.map || !al.map->dso ||
+             !(strlist__has_entry(dso_list, al.map->dso->short_name) ||
+               (al.map->dso->short_name != al.map->dso->long_name &&
+                strlist__has_entry(dso_list, al.map->dso->long_name)))))
                 return 0;
 
-        if (sym_list && sym && !strlist__has_entry(sym_list, sym->name))
+        if (sym_list && al.sym && !strlist__has_entry(sym_list, al.sym->name))
                 return 0;
 
-        if (hist_entry__add(thread, map, sym, ip,
-                            chain, level, period)) {
-                eprintf("problem incrementing symbol count, skipping event\n");
+        if (hist_entry__add(&al, chain, period)) {
+                pr_debug("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++;
+        event__stats.total += period;
 
         return 0;
 }
 
-static int
-process_comm_event(event_t *event, unsigned long offset, unsigned long head)
+static int process_comm_event(event_t *event)
 {
-        struct thread *thread;
-
-        thread = threads__findnew(event->comm.pid, &threads, &last_match);
+        struct thread *thread = threads__findnew(event->comm.pid);
 
-        dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->comm.comm, event->comm.pid);
+        dump_printf(": %s:%d\n", 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)
-                return 0;
-
-        if (!thread || !parent || thread__fork(thread, parent)) {
-                dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
-                return -1;
-        }
-        total_fork++;
-
-        return 0;
-}
-
-static int
-process_lost_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        dump_printf("%p [%p]: PERF_RECORD_LOST: id:%Ld: lost:%Ld\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->lost.id,
-                event->lost.lost);
-
-        total_lost += event->lost.lost;
-
-        return 0;
-}
-
-static int
-process_read_event(event_t *event, unsigned long offset, unsigned long head)
+static int process_read_event(event_t *event)
 {
         struct perf_event_attr *attr;
 
@@ -799,14 +716,9 @@ 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;
 }
@@ -842,11 +754,11 @@ static int sample_type_check(u64 type)
 
 static struct perf_file_handler file_handler = {
         .process_sample_event   = process_sample_event,
-        .process_mmap_event     = process_mmap_event,
+        .process_mmap_event     = event__process_mmap,
         .process_comm_event     = process_comm_event,
-        .process_exit_event     = process_task_event,
-        .process_fork_event     = process_task_event,
-        .process_lost_event     = process_lost_event,
+        .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,
 };
@@ -857,7 +769,7 @@ static int __cmd_report(void)
         struct thread *idle;
         int ret;
 
-        idle = register_idle_thread(&threads, &last_match);
+        idle = register_idle_thread();
         thread__comm_adjust(idle);
 
         if (show_threads)
@@ -865,30 +777,25 @@ static int __cmd_report(void)
 
         register_perf_file_handler(&file_handler);
 
-        ret = mmap_dispatch_perf_file(&header, input_name, force, full_paths,
-                                      &cwdlen, &cwd);
+        ret = mmap_dispatch_perf_file(&header, input_name, force,
+                                      full_paths, &event__cwdlen, &event__cwd);
         if (ret)
                 return ret;
 
-        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", file_handler.total_unknown);
-
-        if (dump_trace)
+        if (dump_trace) {
+                event__print_totals();
                 return 0;
+        }
 
         if (verbose > 3)
-                threads__fprintf(stdout, &threads);
+                threads__fprintf(stdout);
 
         if (verbose > 2)
                 dsos__fprintf(stdout);
 
         collapse__resort();
-        output__resort(total);
-        output__fprintf(stdout, total);
+        output__resort(event__stats.total);
+        output__fprintf(stdout, event__stats.total);
 
         if (show_threads)
                 perf_read_values_destroy(&show_threads_values);
@@ -962,9 +869,10 @@ 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,
                     "Show a column with the number of samples"),
@@ -1034,7 +942,8 @@ static void setup_list(struct strlist **list, const char *list_str,
 
 int cmd_report(int argc, const char **argv, const char *prefix __used)
 {
-        symbol__init();
+        if (symbol__init(&symbol_conf) < 0)
+                return -1;
 
         argc = parse_options(argc, argv, options, report_usage, 0);
 
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index 62585b20dd0c..26b782f26ee1 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -22,11 +22,6 @@
 
 static char                     const *input_name = "perf.data";
 
-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;
 
@@ -35,14 +30,9 @@ static char			*sort_order = default_sort_order;
 
 static int                      profile_cpu = -1;
 
-static char                     *cwd;
-static int                      cwdlen;
-
 #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;
 
@@ -230,7 +220,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;
 
@@ -298,7 +288,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;
@@ -328,7 +318,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);
@@ -638,29 +628,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.tid, &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];
@@ -969,9 +936,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");
 
@@ -1003,9 +968,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");
 
@@ -1086,8 +1049,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 = threads__findnew(switch_event->prev_pid);
+        sched_in = threads__findnew(switch_event->next_pid);
 
         out_events = thread_atoms_search(&atom_root, sched_out, &cmp_pid);
         if (!out_events) {
@@ -1120,13 +1083,10 @@ latency_runtime_event(struct trace_runtime_event *runtime_event,
                      u64 timestamp,
                      struct thread *this_thread __used)
 {
-        struct work_atoms *atoms;
-        struct thread *thread;
+        struct thread *thread = threads__findnew(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);
@@ -1153,7 +1113,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 = threads__findnew(wakeup_event->pid);
         atoms = thread_atoms_search(&atom_root, wakee, &cmp_pid);
         if (!atoms) {
                 thread_atoms_insert(wakee);
@@ -1202,7 +1162,7 @@ latency_migrate_task_event(struct trace_migrate_task_event *migrate_task_event,
         if (profile_cpu == -1)
                 return;
 
-        migrant = threads__findnew(migrate_task_event->pid, &threads, &last_match);
+        migrant = threads__findnew(migrate_task_event->pid);
         atoms = thread_atoms_search(&atom_root, migrant, &cmp_pid);
         if (!atoms) {
                 thread_atoms_insert(migrant);
@@ -1458,8 +1418,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 = threads__findnew(switch_event->prev_pid);
+        sched_in = threads__findnew(switch_event->next_pid);
 
         curr_thread[this_cpu] = sched_in;
 
@@ -1636,8 +1596,7 @@ process_raw_event(event_t *raw_event __used, void *more_data,
                 process_sched_migrate_task_event(raw, 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 thread *thread;
         u64 ip = event->ip.ip;
@@ -1649,7 +1608,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
         if (!(sample_type & PERF_SAMPLE_RAW))
                 return 0;
 
-        thread = threads__findnew(event->ip.pid, &threads, &last_match);
+        thread = threads__findnew(event->ip.pid);
 
         if (sample_type & PERF_SAMPLE_TIME) {
                 timestamp = *(u64 *)more_data;
@@ -1667,22 +1626,20 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                 more_data += sizeof(u64);
         }
 
-        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);
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->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;
         }
 
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
         if (profile_cpu != -1 && profile_cpu != (int) cpu)
                 return 0;
 
@@ -1691,10 +1648,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
         return 0;
 }
 
-static int
-process_lost_event(event_t *event __used,
-                   unsigned long offset __used,
-                   unsigned long head __used)
+static int process_lost_event(event_t *event __used)
 {
         nr_lost_chunks++;
         nr_lost_events += event->lost.lost;
@@ -1718,17 +1672,18 @@ static int sample_type_check(u64 type)
 
 static struct perf_file_handler file_handler = {
         .process_sample_event   = process_sample_event,
-        .process_comm_event     = process_comm_event,
+        .process_comm_event     = event__process_comm,
         .process_lost_event     = process_lost_event,
         .sample_type_check      = sample_type_check,
 };
 
 static int read_events(void)
 {
-        register_idle_thread(&threads, &last_match);
+        register_idle_thread();
         register_perf_file_handler(&file_handler);
 
-        return mmap_dispatch_perf_file(&header, input_name, 0, 0, &cwdlen, &cwd);
+        return mmap_dispatch_perf_file(&header, input_name, 0, 0,
+                                       &event__cwdlen, &event__cwd);
 }
 
 static void print_bad_events(void)
@@ -1947,7 +1902,7 @@ static int __cmd_record(int argc, const char **argv)
 
 int cmd_sched(int argc, const char **argv, const char *prefix __used)
 {
-        symbol__init();
+        symbol__init(0);
 
         argc = parse_options(argc, argv, sched_options, sched_usage,
                              PARSE_OPT_STOP_AT_NON_OPTION);
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 702d8fe58fbc..cb58b6605fcc 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -29,14 +29,14 @@
 #include "util/header.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
+#include "util/event.h"
+#include "util/data_map.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;
@@ -49,8 +49,6 @@ static u64		first_time, last_time;
 static int              power_only;
 
 
-static struct perf_header       *header;
-
 struct per_pid;
 struct per_pidcomm;
 
@@ -153,6 +151,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;
@@ -763,21 +772,42 @@ 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 = c->comm;
+                                                        task_from = strdup(c->comm);
                                                 }
-                                                if (p->pid == we->wakee) {
+                                                if (p->pid == we->wakee && !to) {
                                                         to = c->Y;
-                                                        task_to = c->comm;
+                                                        task_to = strdup(c->comm);
                                                 }
                                         }
                                         c = c->next;
                                 }
+                                c = p->all;
+                                while (c) {
+                                        if (p->pid == we->waker && !from) {
+                                                from = c->Y;
+                                                task_from = strdup(c->comm);
+                                        }
+                                        if (p->pid == we->wakee && !to) {
+                                                to = c->Y;
+                                                task_to = strdup(c->comm);
+                                        }
+                                        c = c->next;
+                                }
                         }
                         p = p->next;
                 }
 
+                if (!task_from) {
+                        task_from = malloc(40);
+                        sprintf(task_from, "[%i]", we->waker);
+                }
+                if (!task_to) {
+                        task_to = malloc(40);
+                        sprintf(task_to, "[%i]", we->wakee);
+                }
+
                 if (we->waker == -1)
                         svg_interrupt(we->time, to);
                 else if (from && to && abs(from - to) == 1)
@@ -785,6 +815,9 @@ static void draw_wakeups(void)
                 else
                         svg_partial_wakeline(we->time, from, task_from, to, task_to);
                 we = we->next;
+
+                free(task_from);
+                free(task_to);
         }
 }
 
@@ -858,12 +891,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;
@@ -933,36 +1043,6 @@ 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)
 {
         struct sample_wrapper *cursor;
@@ -978,107 +1058,38 @@ static void process_samples(void)
         }
 }
 
-
-static int __cmd_timechart(void)
+static int sample_type_check(u64 type)
 {
-        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) {
+        sample_type = type;
 
-                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 (!(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_file_handler file_handler = {
+        .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_header *header;
+        int ret;
 
-done:
-        rc = EXIT_SUCCESS;
-        close(input);
+        register_perf_file_handler(&file_handler);
 
+        ret = mmap_dispatch_perf_file(&header, input_name, 0, 0,
+                                      &event__cwdlen, &event__cwd);
+        if (ret)
+                return EXIT_FAILURE;
 
         process_samples();
 
@@ -1088,9 +1099,10 @@ done:
 
         write_svg_file(output_name);
 
-        printf("Written %2.1f seconds of trace to %s.\n", (last_time - first_time) / 1000000000.0, output_name);
+        pr_info("Written %2.1f seconds of trace to %s.\n",
+                (last_time - first_time) / 1000000000.0, output_name);
 
-        return rc;
+        return EXIT_SUCCESS;
 }
 
 static const char * const timechart_usage[] = {
@@ -1129,6 +1141,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"),
@@ -1136,17 +1156,18 @@ 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();
+        symbol__init(0);
 
         argc = parse_options(argc, argv, options, timechart_usage,
                         PARSE_OPT_STOP_AT_NON_OPTION);
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index c0f69e80b2cc..e0a374d0e43a 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -60,7 +60,7 @@ static int			system_wide			=      0;
 static int                      default_interval                =      0;
 
 static int                      count_filter                    =      5;
-static int                      print_entries                   =     15;
+static int                      print_entries;
 
 static int                      target_pid                      =     -1;
 static int                      inherit                         =      0;
@@ -76,6 +76,11 @@ 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;
+struct symbol_conf              symbol_conf;
+
 /*
  * Source
  */
@@ -97,27 +102,75 @@ static int			display_weighted		=     -1;
  * Symbols
  */
 
+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;
+        u16                     name_len;
+        u8                      origin;
         struct map              *map;
-        struct source_line      *source;
-        struct source_line      *lines;
-        struct source_line      **lines_tail;
-        pthread_mutex_t         source_lock;
+        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 sym_entry_source *source;
         struct map *map;
         FILE *file;
         char command[PATH_MAX*2];
@@ -127,12 +180,21 @@ static void parse_source(struct sym_entry *syme)
         if (!syme)
                 return;
 
-        if (syme->lines) {
-                pthread_mutex_lock(&syme->source_lock);
+        if (syme->src == NULL) {
+                syme->src = zalloc(sizeof(*source));
+                if (syme->src == NULL)
+                        return;
+                pthread_mutex_init(&syme->src->lock, NULL);
+        }
+
+        source = syme->src;
+
+        if (source->lines) {
+                pthread_mutex_lock(&source->lock);
                 goto out_assign;
         }
 
-        sym = (struct symbol *)(syme + 1);
+        sym = sym_entry__symbol(syme);
         map = syme->map;
         path = map->dso->long_name;
 
@@ -141,14 +203,15 @@ static void parse_source(struct sym_entry *syme)
         sprintf(command,
                 "objdump --start-address=0x%016Lx "
                          "--stop-address=0x%016Lx -dS %s",
-                sym->start, sym->end, path);
+                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;
@@ -168,22 +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);
-                        src->eip += map->start;
+                        src->eip = map->unmap_ip(map, src->eip);
                 }
                 if (strlen(src->line)>8 && src->line[16] == ':') {
                         src->eip = strtoull(src->line, NULL, 16);
-                        src->eip += map->start;
+                        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)
@@ -191,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;
@@ -206,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;
@@ -221,25 +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];
 
         sprintf(pattern, "<%s>:", symbol->name);
 
-        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)
@@ -269,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;
 
@@ -311,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);
@@ -388,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;
 
@@ -399,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;
@@ -411,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)));
@@ -450,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;
@@ -485,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 (syme->map->dso->name[0] == '[')
-                        printf(" \t%s", syme->map->dso->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);
         }
 }
 
@@ -542,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);
@@ -561,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;
@@ -585,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;
         }
 
@@ -598,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");
@@ -607,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");
 }
@@ -620,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':
@@ -627,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;
         }
@@ -663,9 +768,16 @@ static void handle_keypress(int c)
         switch (c) {
                 case 'd':
                         prompt_integer(&delay_secs, "Enter display delay");
+                        if (delay_secs < 1)
+                                delay_secs = 1;
                         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) {
@@ -690,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");
@@ -703,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;
@@ -787,9 +907,9 @@ static int symbol_filter(struct map *map, struct symbol *sym)
             strstr(name, "_text_end"))
                 return 1;
 
-        syme = dso__sym_priv(map->dso, sym);
+        syme = symbol__priv(sym);
         syme->map = map;
-        pthread_mutex_init(&syme->source_lock, NULL);
+        syme->src = NULL;
         if (!sym_filter_entry && sym_filter && !strcmp(name, sym_filter))
                 sym_filter_entry = syme;
 
@@ -800,56 +920,65 @@ static int symbol_filter(struct map *map, struct symbol *sym)
                 }
         }
 
-        return 0;
-}
-
-static int parse_symbols(void)
-{
-        if (dsos__load_kernel(vmlinux_name, sizeof(struct sym_entry),
-                              symbol_filter, verbose, 1) <= 0)
-                return -1;
-
-        if (dump_symtab)
-                dsos__fprintf(stderr);
+        if (!syme->skip)
+                syme->name_len = strlen(sym->name);
 
         return 0;
 }
 
-/*
- * 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, int counter)
 {
-        struct map *map;
-        struct symbol *sym = kernel_maps__find_symbol(ip, &map);
-
-        if (sym != NULL) {
-                struct sym_entry *syme = dso__sym_priv(map->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, &al, symbol_filter) < 0 ||
+            al.sym == NULL)
+                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)
 {
-        samples++;
-
-        if (user) {
-                userspace_samples++;
-                return;
+        switch (event->header.type) {
+        case PERF_RECORD_COMM:
+                event__process_comm(event);
+                break;
+        case PERF_RECORD_MMAP:
+                event__process_mmap(event);
+                break;
+        default:
+                break;
         }
 
-        record_ip(ip, counter);
+        return 0;
 }
 
 struct mmap_data {
@@ -870,8 +999,6 @@ 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)
 {
         unsigned int head = mmap_read_head(md);
@@ -879,8 +1006,6 @@ static void mmap_read_counter(struct mmap_data *md)
         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.
@@ -891,14 +1016,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.
@@ -906,8 +1024,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];
 
@@ -935,13 +1051,11 @@ static void mmap_read_counter(struct mmap_data *md)
                         event = &event_copy;
                 }
 
+                if (event->header.type == PERF_RECORD_SAMPLE)
+                        event__process_sample(event, md->counter);
+                else
+                        event__process(event);
                 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;
@@ -983,6 +1097,7 @@ static void start_counter(int i, int counter)
         }
 
         attr->inherit           = (cpu < 0) && inherit;
+        attr->mmap              = 1;
 
 try_again:
         fd[i][counter] = sys_perf_event_open(attr, target_pid, cpu, group_fd, 0);
@@ -990,7 +1105,7 @@ try_again:
         if (fd[i][counter] < 0) {
                 int err = errno;
 
-                if (err == EPERM)
+                if (err == EPERM || err == EACCES)
                         die("No permission - are you root?\n");
                 /*
                  * If it's cycles then fall back to hrtimer
@@ -1041,6 +1156,11 @@ static int __cmd_top(void)
         int i, counter;
         int ret;
 
+        if (target_pid != -1)
+                event__synthesize_thread(target_pid, event__process);
+        else
+                event__synthesize_threads(event__process);
+
         for (i = 0; i < nr_cpus; i++) {
                 group_fd = -1;
                 for (counter = 0; counter < nr_counters; counter++)
@@ -1096,7 +1216,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,
@@ -1119,6 +1242,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()
@@ -1128,8 +1253,6 @@ 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);
@@ -1146,13 +1269,18 @@ 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(&symbol_conf) < 0)
+                return -1;
+
         if (delay_secs < 1)
                 delay_secs = 1;
 
-        parse_symbols();
         parse_source(sym_filter_entry);
 
-
         /*
          * User specified count overrides default frequency.
          */
@@ -1182,5 +1310,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 fb3f3c220211..abb914aa7be6 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -5,63 +5,73 @@
 #include "util/symbol.h"
 #include "util/thread.h"
 #include "util/header.h"
+#include "util/exec_cmd.h"
+#include "util/trace-event.h"
 
-#include "util/parse-options.h"
+static char const               *script_name;
+static char const               *generate_script_lang;
 
-#include "perf.h"
-#include "util/debug.h"
+static int default_start_script(const char *script __attribute((unused)))
+{
+        return 0;
+}
 
-#include "util/trace-event.h"
-#include "util/data_map.h"
+static int default_stop_script(void)
+{
+        return 0;
+}
 
-static char             const *input_name = "perf.data";
+static int default_generate_script(const char *outfile __attribute ((unused)))
+{
+        return 0;
+}
 
-static unsigned long    total = 0;
-static unsigned long    total_comm = 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 rb_root   threads;
-static struct thread    *last_match;
+static struct scripting_ops     *scripting_ops;
 
-static struct perf_header *header;
-static u64              sample_type;
+static void setup_scripting(void)
+{
+        /* make sure PERF_EXEC_PATH is set for scripts */
+        perf_set_argv_exec_path(perf_exec_path());
 
-static char             *cwd;
-static int              cwdlen;
+        setup_perl_scripting();
 
+        scripting_ops = &default_scripting_ops;
+}
 
-static int
-process_comm_event(event_t *event, unsigned long offset, unsigned long head)
+static int cleanup_scripting(void)
 {
-        struct thread *thread;
+        return scripting_ops->stop_script();
+}
 
-        thread = threads__findnew(event->comm.pid, &threads, &last_match);
+#include "util/parse-options.h"
 
-        dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->comm.comm, event->comm.pid);
+#include "perf.h"
+#include "util/debug.h"
 
-        if (thread == NULL ||
-            thread__set_comm(thread, event->comm.comm)) {
-                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
-                return -1;
-        }
-        total_comm++;
+#include "util/trace-event.h"
+#include "util/data_map.h"
+#include "util/exec_cmd.h"
 
-        return 0;
-}
+static char const               *input_name = "perf.data";
+
+static struct perf_header       *header;
+static u64                      sample_type;
 
-static int
-process_sample_event(event_t *event, unsigned long offset, unsigned long head)
+static int process_sample_event(event_t *event)
 {
-        struct thread *thread;
         u64 ip = event->ip.ip;
         u64 timestamp = -1;
         u32 cpu = -1;
         u64 period = 1;
         void *more_data = event->ip.__more_data;
-
-        thread = threads__findnew(event->ip.pid, &threads, &last_match);
+        struct thread *thread = threads__findnew(event->ip.pid);
 
         if (sample_type & PERF_SAMPLE_TIME) {
                 timestamp = *(u64 *)more_data;
@@ -79,22 +89,20 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                 more_data += sizeof(u64);
         }
 
-        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);
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->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;
         }
 
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
         if (sample_type & PERF_SAMPLE_RAW) {
                 struct {
                         u32 size;
@@ -106,9 +114,10 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
                  * field, although it should be the same than this perf
                  * event pid
                  */
-                print_event(cpu, raw->data, raw->size, timestamp, thread->comm);
+                scripting_ops->process_event(cpu, raw->data, raw->size,
+                                             timestamp, thread->comm);
         }
-        total += period;
+        event__stats.total += period;
 
         return 0;
 }
@@ -129,16 +138,165 @@ static int sample_type_check(u64 type)
 
 static struct perf_file_handler file_handler = {
         .process_sample_event   = process_sample_event,
-        .process_comm_event     = process_comm_event,
+        .process_comm_event     = event__process_comm,
         .sample_type_check      = sample_type_check,
 };
 
 static int __cmd_trace(void)
 {
-        register_idle_thread(&threads, &last_match);
+        register_idle_thread();
         register_perf_file_handler(&file_handler);
 
-        return mmap_dispatch_perf_file(&header, input_name, 0, 0, &cwdlen, &cwd);
+        return mmap_dispatch_perf_file(&header, input_name,
+                                       0, 0, &event__cwdlen, &event__cwd);
+}
+
+struct script_spec {
+        struct list_head        node;
+        struct scripting_ops    *ops;
+        char                    spec[0];
+};
+
+LIST_HEAD(script_specs);
+
+static struct script_spec *script_spec__new(const char *spec,
+                                            struct scripting_ops *ops)
+{
+        struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);
+
+        if (s != NULL) {
+                strcpy(s->spec, spec);
+                s->ops = ops;
+        }
+
+        return s;
+}
+
+static void script_spec__delete(struct script_spec *s)
+{
+        free(s->spec);
+        free(s);
+}
+
+static void script_spec__add(struct script_spec *s)
+{
+        list_add_tail(&s->node, &script_specs);
+}
+
+static struct script_spec *script_spec__find(const char *spec)
+{
+        struct script_spec *s;
+
+        list_for_each_entry(s, &script_specs, node)
+                if (strcasecmp(s->spec, spec) == 0)
+                        return s;
+        return NULL;
+}
+
+static struct script_spec *script_spec__findnew(const char *spec,
+                                                struct scripting_ops *ops)
+{
+        struct script_spec *s = script_spec__find(spec);
+
+        if (s)
+                return s;
+
+        s = script_spec__new(spec, ops);
+        if (!s)
+                goto out_delete_spec;
+
+        script_spec__add(s);
+
+        return s;
+
+out_delete_spec:
+        script_spec__delete(s);
+
+        return NULL;
+}
+
+int script_spec_register(const char *spec, struct scripting_ops *ops)
+{
+        struct script_spec *s;
+
+        s = script_spec__find(spec);
+        if (s)
+                return -1;
+
+        s = script_spec__findnew(spec, ops);
+        if (!s)
+                return -1;
+
+        return 0;
+}
+
+static struct scripting_ops *script_spec__lookup(const char *spec)
+{
+        struct script_spec *s = script_spec__find(spec);
+        if (!s)
+                return NULL;
+
+        return s->ops;
+}
+
+static void list_available_languages(void)
+{
+        struct script_spec *s;
+
+        fprintf(stderr, "\n");
+        fprintf(stderr, "Scripting language extensions (used in "
+                "perf trace -s [spec:]script.[spec]):\n\n");
+
+        list_for_each_entry(s, &script_specs, node)
+                fprintf(stderr, "  %-42s [%s]\n", s->spec, s->ops->name);
+
+        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 const char * const annotate_usage[] = {
@@ -151,12 +309,24 @@ 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('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();
+        int err;
+
+        symbol__init(0);
+
+        setup_scripting();
 
         argc = parse_options(argc, argv, options, annotate_usage, 0);
         if (argc) {
@@ -170,5 +340,50 @@ int cmd_trace(int argc, const char **argv, const char *prefix __used)
 
         setup_pager();
 
-        return __cmd_trace();
+        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;
+                }
+
+                header = perf_header__new();
+                if (header == NULL)
+                        return -1;
+
+                perf_header__read(header, input);
+                err = scripting_ops->generate_script("perf-trace");
+                goto out;
+        }
+
+        if (script_name) {
+                err = scripting_ops->start_script(script_name);
+                if (err)
+                        goto out;
+        }
+
+        err = __cmd_trace();
+
+        cleanup_scripting();
+out:
+        return err;
 }
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index e11d8d231c3b..a3d8bf65f26c 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -15,6 +15,8 @@ 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_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 +27,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..02b09ea17a3e 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -3,6 +3,8 @@
 # command name                  category [deprecated] [common]
 #
 perf-annotate                   mainporcelain common
+perf-bench                      mainporcelain common
+perf-buildid-list               mainporcelain common
 perf-list                       mainporcelain common
 perf-sched                      mainporcelain common
 perf-record                     mainporcelain common
@@ -11,3 +13,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..cf64049bc9bd 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,21 @@ 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 },
+                { "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 +387,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..454d5d55f32d 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -47,6 +47,18 @@
 #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
+
 #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..89948b015020
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/check-perf-trace-report
@@ -0,0 +1,5 @@
+#!/bin/bash
+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..f5dcf9cb5bd2
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/rw-by-file-report
@@ -0,0 +1,5 @@
+#!/bin/bash
+perf trace -s ~/libexec/perf-core/scripts/perl/rw-by-file.pl
+
+
+
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..cea16f78a3a2
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/rw-by-pid-report
@@ -0,0 +1,5 @@
+#!/bin/bash
+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..85769dc456eb
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/wakeup-latency-report
@@ -0,0 +1,5 @@
+#!/bin/bash
+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..aa68435be926
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/workqueue-stats-report
@@ -0,0 +1,6 @@
+#!/bin/bash
+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..61f91561d848
--- /dev/null
+++ b/tools/perf/scripts/perl/rw-by-file.pl
@@ -0,0 +1,105 @@
+#!/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;
+
+# change this to the comm of the program you're interested in
+my $for_comm = "perf";
+
+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/PERF-VERSION-GEN b/tools/perf/util/PERF-VERSION-GEN
index c561d1538c03..54552a00a117 100755
--- a/tools/perf/util/PERF-VERSION-GEN
+++ b/tools/perf/util/PERF-VERSION-GEN
@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=PERF-VERSION-FILE
-DEF_VER=v0.0.1.PERF
+DEF_VER=v0.0.2.PERF
 
 LF='
 '
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index f26172c0c919..918eb376abe3 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -5,6 +5,11 @@
 #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"
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/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
index 242b0555ab91..ca0bedf637c2 100644
--- a/tools/perf/util/data_map.c
+++ b/tools/perf/util/data_map.c
@@ -8,11 +8,9 @@ static struct perf_file_handler *curr_handler;
 static unsigned long    mmap_window = 32;
 static char             __cwd[PATH_MAX];
 
-static int
-process_event_stub(event_t *event __used,
-                   unsigned long offset __used,
-                   unsigned long head __used)
+static int process_event_stub(event_t *event __used)
 {
+        dump_printf(": unhandled!\n");
         return 0;
 }
 
@@ -40,36 +38,97 @@ void register_perf_file_handler(struct perf_file_handler *handler)
         curr_handler = handler;
 }
 
+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, 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 curr_handler->process_sample_event(event, offset, head);
+                return curr_handler->process_sample_event(event);
         case PERF_RECORD_MMAP:
-                return curr_handler->process_mmap_event(event, offset, head);
+                return curr_handler->process_mmap_event(event);
         case PERF_RECORD_COMM:
-                return curr_handler->process_comm_event(event, offset, head);
+                return curr_handler->process_comm_event(event);
         case PERF_RECORD_FORK:
-                return curr_handler->process_fork_event(event, offset, head);
+                return curr_handler->process_fork_event(event);
         case PERF_RECORD_EXIT:
-                return curr_handler->process_exit_event(event, offset, head);
+                return curr_handler->process_exit_event(event);
         case PERF_RECORD_LOST:
-                return curr_handler->process_lost_event(event, offset, head);
+                return curr_handler->process_lost_event(event);
         case PERF_RECORD_READ:
-                return curr_handler->process_read_event(event, offset, head);
+                return curr_handler->process_read_event(event);
         case PERF_RECORD_THROTTLE:
-                return curr_handler->process_throttle_event(event, offset, head);
+                return curr_handler->process_throttle_event(event);
         case PERF_RECORD_UNTHROTTLE:
-                return curr_handler->process_unthrottle_event(event, offset, head);
+                return curr_handler->process_unthrottle_event(event);
         default:
                 curr_handler->total_unknown++;
                 return -1;
         }
 }
 
+int perf_header__read_build_ids(int input, off_t offset, off_t size)
+{
+        struct build_id_event bev;
+        char filename[PATH_MAX];
+        off_t 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;
+}
+
 int mmap_dispatch_perf_file(struct perf_header **pheader,
                             const char *input_name,
                             int force,
@@ -77,7 +136,7 @@ int mmap_dispatch_perf_file(struct perf_header **pheader,
                             int *cwdlen,
                             char **cwd)
 {
-        int ret, rc = EXIT_FAILURE;
+        int err;
         struct perf_header *header;
         unsigned long head, shift;
         unsigned long offset = 0;
@@ -89,56 +148,63 @@ int mmap_dispatch_perf_file(struct perf_header **pheader,
         int input;
         char *buf;
 
-        if (!curr_handler)
-                die("Forgot to register perf file handler");
+        if (curr_handler == NULL) {
+                pr_debug("Forgot to register perf file handler\n");
+                return -EINVAL;
+        }
 
         page_size = getpagesize();
 
         input = open(input_name, O_RDONLY);
         if (input < 0) {
-                fprintf(stderr, " failed to open file: %s", input_name);
+                pr_err("Failed to open file: %s", input_name);
                 if (!strcmp(input_name, "perf.data"))
-                        fprintf(stderr, "  (try 'perf record' first)");
-                fprintf(stderr, "\n");
-                exit(-1);
+                        pr_err("  (try 'perf record' first)");
+                pr_err("\n");
+                return -errno;
         }
 
-        ret = fstat(input, &input_stat);
-        if (ret < 0) {
-                perror("failed to stat file");
-                exit(-1);
+        if (fstat(input, &input_stat) < 0) {
+                pr_err("failed to stat file");
+                err = -errno;
+                goto out_close;
         }
 
+        err = -EACCES;
         if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
-                fprintf(stderr, "file: %s not owned by current user or root\n",
+                pr_err("file: %s not owned by current user or root\n",
                         input_name);
-                exit(-1);
+                goto out_close;
         }
 
-        if (!input_stat.st_size) {
-                fprintf(stderr, "zero-sized file, nothing to do!\n");
-                exit(0);
+        if (input_stat.st_size == 0) {
+                pr_info("zero-sized file, nothing to do!\n");
+                goto done;
         }
 
-        *pheader = perf_header__read(input);
-        header = *pheader;
+        err = -ENOMEM;
+        header = perf_header__new();
+        if (header == NULL)
+                goto out_close;
+
+        err = perf_header__read(header, input);
+        if (err < 0)
+                goto out_delete;
+        *pheader = header;
         head = header->data_offset;
 
         sample_type = perf_header__sample_type(header);
 
-        if (curr_handler->sample_type_check)
-                if (curr_handler->sample_type_check(sample_type) < 0)
-                        exit(-1);
-
-        if (load_kernel() < 0) {
-                perror("failed to load kernel symbols");
-                return EXIT_FAILURE;
-        }
+        err = -EINVAL;
+        if (curr_handler->sample_type_check &&
+            curr_handler->sample_type_check(sample_type) < 0)
+                goto out_delete;
 
         if (!full_paths) {
                 if (getcwd(__cwd, sizeof(__cwd)) == NULL) {
-                        perror("failed to get the current directory");
-                        return EXIT_FAILURE;
+                        pr_err("failed to get the current directory\n");
+                        err = -errno;
+                        goto out_delete;
                 }
                 *cwd = __cwd;
                 *cwdlen = strlen(*cwd);
@@ -152,11 +218,12 @@ int mmap_dispatch_perf_file(struct perf_header **pheader,
         head -= shift;
 
 remap:
-        buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
-                           MAP_SHARED, input, offset);
+        buf = mmap(NULL, page_size * mmap_window, PROT_READ,
+                   MAP_SHARED, input, offset);
         if (buf == MAP_FAILED) {
-                perror("failed to mmap file");
-                exit(-1);
+                pr_err("failed to mmap file\n");
+                err = -errno;
+                goto out_delete;
         }
 
 more:
@@ -213,10 +280,12 @@ more:
                 goto more;
 
 done:
-        rc = EXIT_SUCCESS;
+        err = 0;
+out_close:
         close(input);
 
-        return rc;
+        return err;
+out_delete:
+        perf_header__delete(header);
+        goto out_close;
 }
-
-
diff --git a/tools/perf/util/data_map.h b/tools/perf/util/data_map.h
index 716d1053b074..3180ff7e3633 100644
--- a/tools/perf/util/data_map.h
+++ b/tools/perf/util/data_map.h
@@ -4,7 +4,7 @@
 #include "event.h"
 #include "header.h"
 
-typedef int (*event_type_handler_t)(event_t *, unsigned long, unsigned long);
+typedef int (*event_type_handler_t)(event_t *);
 
 struct perf_file_handler {
         event_type_handler_t    process_sample_event;
@@ -27,5 +27,6 @@ int mmap_dispatch_perf_file(struct perf_header **pheader,
                             int full_paths,
                             int *cwdlen,
                             char **cwd);
+int perf_header__read_build_ids(int input, off_t offset, off_t file_size);
 
 #endif
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 02d1fa1c2465..c6c24c522dea 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -2,10 +2,13 @@
 #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);
 
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..414b89d1bde9
--- /dev/null
+++ b/tools/perf/util/event.c
@@ -0,0 +1,312 @@
+#include <linux/types.h>
+#include "event.h"
+#include "debug.h"
+#include "string.h"
+#include "thread.h"
+
+static pid_t event__synthesize_comm(pid_t pid, int full,
+                                    int (*process)(event_t *event))
+{
+        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);
+                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);
+        }
+        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))
+{
+        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);
+                }
+        }
+
+        fclose(fp);
+        return 0;
+}
+
+int event__synthesize_thread(pid_t pid, int (*process)(event_t *event))
+{
+        pid_t tgid = event__synthesize_comm(pid, 1, process);
+        if (tgid == -1)
+                return -1;
+        return event__synthesize_mmap_events(pid, tgid, process);
+}
+
+void event__synthesize_threads(int (*process)(event_t *event))
+{
+        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);
+        }
+
+        closedir(proc);
+}
+
+char *event__cwd;
+int  event__cwdlen;
+
+struct events_stats event__stats;
+
+int event__process_comm(event_t *self)
+{
+        struct thread *thread = threads__findnew(self->comm.pid);
+
+        dump_printf(": %s:%d\n", self->comm.comm, self->comm.pid);
+
+        if (thread == NULL || thread__set_comm(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)
+{
+        dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost);
+        event__stats.lost += self->lost.lost;
+        return 0;
+}
+
+int event__process_mmap(event_t *self)
+{
+        struct thread *thread = threads__findnew(self->mmap.pid);
+        struct map *map = map__new(&self->mmap, MAP__FUNCTION,
+                                   event__cwd, event__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 thread *thread = threads__findnew(self->fork.pid);
+        struct thread *parent = threads__findnew(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, u8 cpumode,
+                                enum map_type type, u64 addr,
+                                struct addr_location *al,
+                                symbol_filter_t filter)
+{
+        struct thread *thread = al->thread = self;
+
+        al->addr = addr;
+
+        if (cpumode & PERF_RECORD_MISC_KERNEL) {
+                al->level = 'k';
+                thread = kthread;
+        } else if (cpumode & PERF_RECORD_MISC_USER)
+                al->level = '.';
+        else {
+                al->level = 'H';
+                al->map = NULL;
+                al->sym = NULL;
+                return;
+        }
+try_again:
+        al->map = thread__find_map(thread, 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 && thread != kthread) {
+                        thread = kthread;
+                        goto try_again;
+                }
+                al->sym = NULL;
+        } else {
+                al->addr = al->map->map_ip(al->map, al->addr);
+                al->sym = map__find_symbol(al->map, al->addr, filter);
+        }
+}
+
+int event__preprocess_sample(const event_t *self, struct addr_location *al,
+                             symbol_filter_t filter)
+{
+        u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        struct thread *thread = threads__findnew(self->ip.pid);
+
+        if (thread == NULL)
+                return -1;
+
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
+        thread__find_addr_location(thread, 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>");
+        return 0;
+}
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index c2e62be62798..a4cc8105cf67 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -61,6 +61,13 @@ struct sample_event{
         u64 array[];
 };
 
+#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;
@@ -73,6 +80,19 @@ typedef union event_union {
         struct sample_event             sample;
 } event_t;
 
+struct events_stats {
+        unsigned long total;
+        unsigned long lost;
+};
+
+void event__print_totals(void);
+
+enum map_type {
+        MAP__FUNCTION = 0,
+
+        MAP__NR_TYPES,
+};
+
 struct map {
         union {
                 struct rb_node  rb_node;
@@ -80,8 +100,10 @@ struct map {
         };
         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;
 };
 
@@ -90,14 +112,48 @@ 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);
+struct symbol *map__find_symbol(struct map *self, u64 addr,
+                                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));
+void event__synthesize_threads(int (*process)(event_t *event));
+
+extern char *event__cwd;
+extern int  event__cwdlen;
+extern struct events_stats event__stats;
+extern unsigned long event__total[PERF_RECORD_MAX];
+
+int event__process_comm(event_t *self);
+int event__process_lost(event_t *self);
+int event__process_mmap(event_t *self);
+int event__process_task(event_t *self);
+
+struct addr_location;
+int event__preprocess_sample(const event_t *self, struct addr_location *al,
+                             symbol_filter_t filter);
 
 #endif /* __PERF_RECORD_H */
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 9aae360c0f28..4805e6dfd23c 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -2,11 +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 "symbol.h"
+#include "data_map.h"
+#include "debug.h"
 
 /*
  * Create new perf.data header attribute:
@@ -15,32 +19,43 @@ 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;
 }
 
 /*
@@ -48,44 +63,52 @@ void perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
  */
 struct perf_header *perf_header__new(void)
 {
-        struct perf_header *self = malloc(sizeof(*self));
+        struct perf_header *self = zalloc(sizeof(*self));
 
-        if (!self)
-                die("nomem");
+        if (self != NULL) {
+                self->size = 1;
+                self->attr = malloc(sizeof(void *));
 
-        self->frozen = 0;
+                if (self->attr == NULL) {
+                        free(self);
+                        self = NULL;
+                }
+        }
 
-        self->attrs = 0;
-        self->size = 1;
-        self->attr = malloc(sizeof(void *));
+        return self;
+}
 
-        if (!self->attr)
-                die("nomem");
+void perf_header__delete(struct perf_header *self)
+{
+        int i;
 
-        self->data_offset = 0;
-        self->data_size = 0;
-        self->trace_info_offset = 0;
-        self->trace_info_size = 0;
+        for (i = 0; i < self->attrs; ++i)
+                perf_header_attr__delete(self->attr[i]);
 
-        return self;
+        free(self->attr);
+        free(self);
 }
 
-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)
 {
-        int pos = self->attrs;
-
         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
@@ -101,7 +124,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));
@@ -132,52 +155,137 @@ 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;
-        struct perf_file_section        trace_info;
-};
-
-static int trace_info;
+void perf_header__set_feat(struct perf_header *self, int feat)
+{
+        set_bit(feat, self->adds_features);
+}
 
-void perf_header__set_trace_info(void)
+bool perf_header__has_feat(const struct perf_header *self, int feat)
 {
-        trace_info = 1;
+        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)
+{
+        struct dso *pos;
+
+        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, 64);
+                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, len);
+                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);
 
@@ -186,7 +294,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;
+                }
         }
 
 
@@ -202,34 +314,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 (trace_info) {
-                static int trace_info_written;
-
-                /*
-                 * Write it only once
-                 */
-                if (!trace_info_written) {
-                        self->trace_info_offset = lseek(fd, 0, SEEK_CUR);
-                        read_tracing_data(fd, attrs, nr_counters);
-                        self->trace_info_size = lseek(fd, 0, SEEK_CUR) -
-                                                self->trace_info_offset;
-                        trace_info_written = 1;
-                } else {
-                        lseek(fd, self->trace_info_offset +
-                                self->trace_info_size, SEEK_SET);
+        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),
@@ -246,17 +355,20 @@ void perf_header__write(struct perf_header *self, int fd)
                         .offset = self->event_offset,
                         .size   = self->event_size,
                 },
-                .trace_info = {
-                        .offset = self->trace_info_offset,
-                        .size = self->trace_info_size,
-                },
         };
 
+        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)
@@ -274,29 +386,110 @@ 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_header      *self = perf_header__new();
-        struct perf_file_header f_header;
-        struct perf_file_attr   f_attr;
-        u64                     f_id;
+        struct perf_file_section *feat_sec;
+        int nr_sections;
+        int sec_size;
+        int idx = 0;
+        int err = 0, feat = 1;
 
-        int nr_attrs, nr_ids, i, j;
+        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, &f_header, sizeof(f_header));
+        do_read(fd, self, sizeof(*self));
 
-        if (f_header.magic      != PERF_MAGIC           ||
-            f_header.attr_size  != sizeof(f_attr))
-                die("incompatible file format");
+        if (self->magic     != PERF_MAGIC ||
+            self->attr_size != sizeof(struct perf_file_attr))
+                return -1;
 
-        if (f_header.size != sizeof(f_header)) {
+        if (self->size != sizeof(*self)) {
                 /* Support the previous format */
-                if (f_header.size == offsetof(typeof(f_header), trace_info))
-                        f_header.trace_info.size = 0;
+                if (self->size == offsetof(typeof(*self), adds_features))
+                        bitmap_zero(self->adds_features, HEADER_FEAT_BITS);
                 else
-                        die("incompatible file format");
+                        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_file_header f_header;
+        struct perf_file_attr   f_attr;
+        u64                     f_id;
+        int nr_attrs, nr_ids, i, j;
+
+        if (perf_file_header__read(&f_header, self, fd) < 0) {
+                pr_debug("incompatible file format\n");
+                return -EINVAL;
         }
+
         nr_attrs = f_header.attrs.size / sizeof(f_attr);
         lseek(fd, f_header.attrs.offset, SEEK_SET);
 
@@ -308,6 +501,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);
@@ -315,40 +510,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->trace_info_offset = f_header.trace_info.offset;
-        self->trace_info_size = f_header.trace_info.size;
-
-        if (self->trace_info_size) {
-                lseek(fd, self->trace_info_offset, SEEK_SET);
-                trace_report(fd);
-        }
-
-        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 30aee5160dc0..d1dbe2b79c42 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -3,8 +3,11 @@
 
 #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,38 +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;
-        u64 trace_info_offset;
-        u64 trace_info_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);
+struct perf_header *perf_header__new(void);
+void perf_header__delete(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_trace_info(void);
+void perf_header__set_feat(struct perf_header *self, int feat);
+bool perf_header__has_feat(const struct perf_header *self, int feat);
 
-struct perf_header *perf_header__new(void);
+int perf_header__process_sections(struct perf_header *self, int fd,
+                                  int (*process)(struct perf_file_section *self,
+                                                 int feat, int fd));
 
 #endif /* __PERF_HEADER_H */
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 7393a02fd8d4..0ebf6ee16caa 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -10,31 +10,23 @@ struct callchain_param	callchain_param = {
         .min_percent = 0.5
 };
 
-unsigned long total;
-unsigned long total_mmap;
-unsigned long total_comm;
-unsigned long total_fork;
-unsigned long total_unknown;
-unsigned long total_lost;
-
 /*
  * histogram, sorted on item, collects counts
  */
 
-struct hist_entry *__hist_entry__add(struct thread *thread, struct map *map,
-                                     struct symbol *sym,
+struct hist_entry *__hist_entry__add(struct addr_location *al,
                                      struct symbol *sym_parent,
-                                     u64 ip, u64 count, char level, bool *hit)
+                                     u64 count, bool *hit)
 {
         struct rb_node **p = &hist.rb_node;
         struct rb_node *parent = NULL;
         struct hist_entry *he;
         struct hist_entry entry = {
-                .thread = thread,
-                .map    = map,
-                .sym    = sym,
-                .ip     = ip,
-                .level  = level,
+                .thread = al->thread,
+                .map    = al->map,
+                .sym    = al->sym,
+                .ip     = al->addr,
+                .level  = al->level,
                 .count  = count,
                 .parent = sym_parent,
         };
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index ac2149c559b0..3020db0c9292 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -36,9 +36,9 @@ extern unsigned long total_fork;
 extern unsigned long total_unknown;
 extern unsigned long total_lost;
 
-struct hist_entry *__hist_entry__add(struct thread *thread, struct map *map,
-                                     struct symbol *sym, struct symbol *parent,
-                                     u64 ip, u64 count, char level, bool *hit);
+struct hist_entry *__hist_entry__add(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 *);
 extern void hist_entry__free(struct hist_entry *);
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/map.c b/tools/perf/util/map.c
index 804e02382739..69f94fe9db20 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,72 @@ 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)"
+
+struct symbol *map__find_symbol(struct map *self, u64 addr,
+                                symbol_filter_t filter)
+{
+        if (!dso__loaded(self->dso, self->type)) {
+                int nr = dso__load(self->dso, self, filter);
+
+                if (nr < 0) {
+                        if (self->dso->has_build_id) {
+                                char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+                                build_id__sprintf(self->dso->build_id,
+                                                  sizeof(self->dso->build_id),
+                                                  sbuild_id);
+                                pr_warning("%s with build id %s not found",
+                                           self->dso->long_name, sbuild_id);
+                        } else
+                                pr_warning("Failed to open %s",
+                                           self->dso->long_name);
+                        pr_warning(", continuing without symbols\n");
+                        return NULL;
+                } else if (nr == 0) {
+                        const char *name = self->dso->long_name;
+                        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 NULL;
+                }
+        }
+
+        return self->dso->find_symbol(self->dso, self->type, addr);
+}
+
 struct map *map__clone(struct map *self)
 {
         struct map *map = malloc(sizeof(*self));
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 8cfb48cbbea0..9e5dbd66d34d 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);
@@ -509,7 +505,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 +540,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 +748,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 +785,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 +821,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 +862,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 +880,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 +897,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 +906,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 +926,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 8626a439033d..b8c1f64bc935 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -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)
 
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
new file mode 100644
index 000000000000..cd7fbda5e2a5
--- /dev/null
+++ b/tools/perf/util/probe-event.c
@@ -0,0 +1,484 @@
+/*
+ * 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, ...)
+{
+        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;
+}
+
+/* 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 SRC:LN
+         * perf probe FUNC[+OFFS|%return][@SRC]
+         */
+
+        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 */
+int parse_perf_probe_event(const char *str, struct probe_point *pp)
+{
+        char **argv;
+        int argc, i, need_dwarf = 0;
+
+        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 = 1;
+
+        /* 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 = 1;
+                }
+        }
+
+        argv_free(argv);
+        return need_dwarf;
+}
+
+/* Parse kprobe_events event into struct probe_point */
+void parse_trace_kprobe_event(const char *str, char **group, char **event,
+                              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 *)group, (float *)(void *)event);
+        if (ret != 3)
+                semantic_error("Failed to parse event name: %s", argv[0]);
+        pr_debug("Group:%s Event:%s probe:%c\n", *group, *event, pr);
+
+        if (!pp)
+                goto end;
+
+        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.");
+        }
+
+end:
+        argv_free(argv);
+}
+
+int synthesize_perf_probe_event(struct probe_point *pp)
+{
+        char *buf;
+        char offs[64] = "", line[64] = "";
+        int i, len, 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%s%s", pp->file, line);
+        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]);
+
+        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]);
+
+        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->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));
+}
+
+/* List up current perf-probe events */
+void show_perf_probe_events(void)
+{
+        unsigned int i;
+        int fd;
+        char *group, *event;
+        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);
+
+        for (i = 0; i < strlist__nr_entries(rawlist); i++) {
+                ent = strlist__entry(rawlist, i);
+                parse_trace_kprobe_event(ent->s, &group, &event, &pp);
+                synthesize_perf_probe_event(&pp);
+                printf("[%s:%s]\t%s\n", group, event, pp.probes[0]);
+                free(group);
+                free(event);
+                clear_probe_point(&pp);
+        }
+
+        strlist__delete(rawlist);
+}
+
+/* Get current perf-probe event names */
+static struct strlist *get_perf_event_names(int fd)
+{
+        unsigned int i;
+        char *group, *event;
+        struct strlist *sl, *rawlist;
+        struct str_node *ent;
+
+        rawlist = get_trace_kprobe_event_rawlist(fd);
+
+        sl = strlist__new(false, NULL);
+        for (i = 0; i < strlist__nr_entries(rawlist); i++) {
+                ent = strlist__entry(rawlist, i);
+                parse_trace_kprobe_event(ent->s, &group, &event, NULL);
+                strlist__add(sl, event);
+                free(group);
+        }
+
+        strlist__delete(rawlist);
+
+        return sl;
+}
+
+static int write_trace_kprobe_event(int fd, const char *buf)
+{
+        int ret;
+
+        ret = write(fd, buf, strlen(buf));
+        if (ret <= 0)
+                die("Failed to create event.");
+        else
+                printf("Added new event: %s\n", buf);
+
+        return ret;
+}
+
+static void get_new_event_name(char *buf, size_t len, const char *base,
+                               struct strlist *namelist)
+{
+        int i, ret;
+        for (i = 0; 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)
+{
+        int i, j, fd;
+        struct probe_point *pp;
+        char buf[MAX_CMDLEN];
+        char event[64];
+        struct strlist *namelist;
+
+        fd = open_kprobe_events(O_RDWR, O_APPEND);
+        /* Get current event names */
+        namelist = get_perf_event_names(fd);
+
+        for (j = 0; j < nr_probes; j++) {
+                pp = probes + j;
+                for (i = 0; i < pp->found; i++) {
+                        /* Get an unused new event name */
+                        get_new_event_name(event, 64, pp->function, namelist);
+                        snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s\n",
+                                 pp->retprobe ? 'r' : 'p',
+                                 PERFPROBE_GROUP, event,
+                                 pp->probes[i]);
+                        write_trace_kprobe_event(fd, buf);
+                        /* Add added event name to namelist */
+                        strlist__add(namelist, event);
+                }
+        }
+        close(fd);
+}
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
new file mode 100644
index 000000000000..0c6fe56fe38a
--- /dev/null
+++ b/tools/perf/util/probe-event.h
@@ -0,0 +1,18 @@
+#ifndef _PROBE_EVENT_H
+#define _PROBE_EVENT_H
+
+#include "probe-finder.h"
+#include "strlist.h"
+
+extern int parse_perf_probe_event(const char *str, struct probe_point *pp);
+extern int synthesize_perf_probe_event(struct probe_point *pp);
+extern void parse_trace_kprobe_event(const char *str, char **group,
+                                     char **event, 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);
+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..293cdfc1b8ca
--- /dev/null
+++ b/tools/perf/util/probe-finder.c
@@ -0,0 +1,732 @@
+/*
+ * 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) {
+                pr_warning("No dwarf info found in the vmlinux - please rebuild with CONFIG_DEBUG_INFO.\n");
+                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..bdebca6697d2
--- /dev/null
+++ b/tools/perf/util/probe-finder.h
@@ -0,0 +1,57 @@
+#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 {
+        /* 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);
+
+#include <libdwarf/dwarf.h>
+#include <libdwarf/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/sort.c b/tools/perf/util/sort.c
index 40c9acd41cad..b490354d1b23 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -5,8 +5,10 @@ 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;
+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;
@@ -265,6 +267,19 @@ int sort_dimension__add(const char *tok)
                         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;
 
@@ -273,4 +288,3 @@ int sort_dimension__add(const char *tok)
 
         return -ESRCH;
 }
-
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 13806d782af6..333e664ff45f 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -39,6 +39,7 @@ 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;
@@ -53,6 +54,14 @@ struct hist_entry {
         struct rb_root          sorted_chain;
 };
 
+enum sort_type {
+        SORT_PID,
+        SORT_COMM,
+        SORT_DSO,
+        SORT_SYM,
+        SORT_PARENT
+};
+
 /*
  * configurable sorting bits
  */
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index 04743d3e9039..f24a8cc933d5 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -1,5 +1,5 @@
-#include <string.h>
 #include "string.h"
+#include "util.h"
 
 static int hex(char ch)
 {
@@ -43,3 +43,186 @@ char *strxfrchar(char *s, char from, char 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;
+}
diff --git a/tools/perf/util/string.h b/tools/perf/util/string.h
index 2c84bf65ba0f..bfecec265a1a 100644
--- a/tools/perf/util/string.h
+++ b/tools/perf/util/string.h
@@ -5,6 +5,9 @@
 
 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);
 
 #define _STR(x) #x
 #define STR(x) _STR(x)
diff --git a/tools/perf/util/svghelper.c b/tools/perf/util/svghelper.c
index 856655d8b0b8..b3637db025a2 100644
--- a/tools/perf/util/svghelper.c
+++ b/tools/perf/util/svghelper.c
@@ -103,7 +103,7 @@ void open_svg(const char *filename, int cpus, int rows, u64 start, u64 end)
         fprintf(svgfile, "      rect.process2 { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
         fprintf(svgfile, "      rect.sample   { fill:rgb(  0,  0,255); fill-opacity:0.8; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
         fprintf(svgfile, "      rect.blocked  { fill:rgb(255,  0,  0); fill-opacity:0.5; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
-        fprintf(svgfile, "      rect.waiting  { fill:rgb(214,214,  0); fill-opacity:0.3; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.waiting  { fill:rgb(224,214,  0); fill-opacity:0.8; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
         fprintf(svgfile, "      rect.WAITING  { fill:rgb(255,214, 48); fill-opacity:0.6; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
         fprintf(svgfile, "      rect.cpu      { fill:rgb(192,192,192); fill-opacity:0.2; stroke-width:0.5; stroke:rgb(128,128,128); } \n");
         fprintf(svgfile, "      rect.pstate   { fill:rgb(128,128,128); fill-opacity:0.8; stroke-width:0; } \n");
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index faa84f5d4f54..fffcb937cdcb 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -6,12 +6,16 @@
 
 #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,
@@ -24,16 +28,37 @@ enum dso_origin {
         DSO__ORIG_NOT_FOUND,
 };
 
-static void dsos__add(struct dso *dso);
-static struct dso *dsos__find(const char *name);
-static struct map *map__new2(u64 start, struct dso *dso);
-static void kernel_maps__insert(struct map *map);
+static void dsos__add(struct list_head *head, struct dso *dso);
+static struct map *thread__find_map_by_name(struct thread *self, char *name);
+static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
+struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr);
+static int dso__load_kernel_sym(struct dso *self, struct map *map,
+                                struct thread *thread, symbol_filter_t filter);
+unsigned int symbol__priv_size;
+static int vmlinux_path__nr_entries;
+static char **vmlinux_path;
+
+static struct symbol_conf symbol_conf__defaults = {
+        .use_modules      = true,
+        .try_vmlinux_path = true,
+};
+
+static struct thread kthread_mem;
+struct thread *kthread = &kthread_mem;
+
+bool dso__loaded(const struct dso *self, enum map_type type)
+{
+        return self->loaded & (1 << type);
+}
 
-static struct rb_root kernel_maps;
+static void dso__set_loaded(struct dso *self, enum map_type type)
+{
+        self->loaded |= (1 << type);
+}
 
-static void dso__fixup_sym_end(struct dso *self)
+static void symbols__fixup_end(struct rb_root *self)
 {
-        struct rb_node *nd, *prevnd = rb_first(&self->syms);
+        struct rb_node *nd, *prevnd = rb_first(self);
         struct symbol *curr, *prev;
 
         if (prevnd == NULL)
@@ -54,10 +79,10 @@ static void dso__fixup_sym_end(struct dso *self)
                 curr->end = roundup(curr->start, 4096);
 }
 
-static void kernel_maps__fixup_end(void)
+static void __thread__fixup_maps_end(struct thread *self, enum map_type type)
 {
         struct map *prev, *curr;
-        struct rb_node *nd, *prevnd = rb_first(&kernel_maps);
+        struct rb_node *nd, *prevnd = rb_first(&self->maps[type]);
 
         if (prevnd == NULL)
                 return;
@@ -70,46 +95,44 @@ static void kernel_maps__fixup_end(void)
                 prev->end = curr->start - 1;
         }
 
-        nd = rb_last(&curr->dso->syms);
-        if (nd) {
-                struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
-                curr->end = sym->end;
-        }
+        /*
+         * We still haven't the actual symbols, so guess the
+         * last map final address.
+         */
+        curr->end = ~0UL;
 }
 
-static struct symbol *symbol__new(u64 start, u64 len, const char *name,
-                                  unsigned int priv_size, int v)
+static void thread__fixup_maps_end(struct thread *self)
 {
-        size_t namelen = strlen(name) + 1;
-        struct symbol *self = calloc(1, priv_size + sizeof(*self) + namelen);
+        int i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                __thread__fixup_maps_end(self, i);
+}
 
-        if (!self)
+static struct symbol *symbol__new(u64 start, u64 len, const char *name)
+{
+        size_t namelen = strlen(name) + 1;
+        struct symbol *self = zalloc(symbol__priv_size +
+                                     sizeof(*self) + namelen);
+        if (self == NULL)
                 return NULL;
 
-        if (v > 2)
-                printf("new symbol: %016Lx [%08lx]: %s, hist: %p\n",
-                        start, (unsigned long)len, name, self->hist);
-
-        self->hist = NULL;
-        self->hist_sum = 0;
+        if (symbol__priv_size)
+                self = ((void *)self) + symbol__priv_size;
 
-        if (sym_hist_filter && !strcmp(name, sym_hist_filter))
-                self->hist = calloc(sizeof(u64), len);
-
-        if (priv_size) {
-                memset(self, 0, priv_size);
-                self = ((void *)self) + 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__priv_size);
 }
 
 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
@@ -118,48 +141,72 @@ static size_t symbol__fprintf(struct symbol *self, FILE *fp)
                        self->start, self->end, self->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->long_name = self->name;
+                dso__set_long_name(self, self->name);
                 self->short_name = self->name;
-                self->syms = RB_ROOT;
-                self->sym_priv_size = sym_priv_size;
+                for (i = 0; i < MAP__NR_TYPES; ++i)
+                        self->symbols[i] = RB_ROOT;
                 self->find_symbol = dso__find_symbol;
                 self->slen_calculated = 0;
                 self->origin = DSO__ORIG_NOT_FOUND;
+                self->loaded = 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;
@@ -173,17 +220,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);
@@ -199,12 +246,42 @@ struct symbol *dso__find_symbol(struct dso *self, u64 ip)
         return NULL;
 }
 
-size_t dso__fprintf(struct dso *self, FILE *fp)
+struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr)
+{
+        return symbols__find(&self->symbols[type], addr);
+}
+
+int build_id__sprintf(u8 *self, int len, char *bf)
 {
-        size_t ret = fprintf(fp, "dso: %s\n", self->short_name);
+        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;
-        for (nd = rb_first(&self->syms); nd; nd = rb_next(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);
         }
@@ -217,10 +294,11 @@ size_t dso__fprintf(struct dso *self, FILE *fp)
  * so that we can in the next step set the symbol ->end address and then
  * call kernel_maps__split_kallsyms.
  */
-static int kernel_maps__load_all_kallsyms(int v)
+static int dso__load_all_kallsyms(struct dso *self, struct map *map)
 {
         char *line = NULL;
         size_t n;
+        struct rb_root *root = &self->symbols[map->type];
         FILE *file = fopen("/proc/kallsyms", "r");
 
         if (file == NULL)
@@ -259,13 +337,15 @@ static int kernel_maps__load_all_kallsyms(int v)
                 /*
                  * Will fix up the end later, when we have all symbols sorted.
                  */
-                sym = symbol__new(start, 0, symbol_name,
-                                  kernel_map->dso->sym_priv_size, v);
+                sym = symbol__new(start, 0, symbol_name);
 
                 if (sym == NULL)
                         goto out_delete_line;
-
-                dso__insert_symbol(kernel_map->dso, sym);
+                /*
+                 * 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);
@@ -284,12 +364,14 @@ out_failure:
  * kernel range is broken in several maps, named [kernel].N, as we don't have
  * the original ELF section names vmlinux have.
  */
-static int kernel_maps__split_kallsyms(symbol_filter_t filter, int use_modules)
+static int dso__split_kallsyms(struct dso *self, struct map *map, struct thread *thread,
+                               symbol_filter_t filter)
 {
-        struct map *map = kernel_map;
+        struct map *curr_map = map;
         struct symbol *pos;
         int count = 0;
-        struct rb_node *next = rb_first(&kernel_map->dso->syms);
+        struct rb_root *root = &self->symbols[map->type];
+        struct rb_node *next = rb_first(root);
         int kernel_range = 0;
 
         while (next) {
@@ -300,16 +382,16 @@ static int kernel_maps__split_kallsyms(symbol_filter_t filter, int use_modules)
 
                 module = strchr(pos->name, '\t');
                 if (module) {
-                        if (!use_modules)
-                                goto delete_symbol;
+                        if (!thread->use_modules)
+                                goto discard_symbol;
 
                         *module++ = '\0';
 
-                        if (strcmp(map->dso->name, module)) {
-                                map = kernel_maps__find_by_dso_name(module);
-                                if (!map) {
-                                        fputs("/proc/{kallsyms,modules} "
-                                              "inconsistency!\n", stderr);
+                        if (strcmp(self->name, module)) {
+                                curr_map = thread__find_map_by_name(thread, module);
+                                if (curr_map == NULL) {
+                                        pr_debug("/proc/{kallsyms,modules} "
+                                                 "inconsistency!\n");
                                         return -1;
                                 }
                         }
@@ -317,39 +399,37 @@ static int kernel_maps__split_kallsyms(symbol_filter_t filter, int use_modules)
                          * So that we look just like we get from .ko files,
                          * i.e. not prelinked, relative to map->start.
                          */
-                        pos->start = map->map_ip(map, pos->start);
-                        pos->end   = map->map_ip(map, pos->end);
-                } else if (map != kernel_map) {
+                        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,
-                                       kernel_map->dso->sym_priv_size);
+                        dso = dso__new(dso_name);
                         if (dso == NULL)
                                 return -1;
 
-                        map = map__new2(pos->start, dso);
+                        curr_map = map__new2(pos->start, dso, map->type);
                         if (map == NULL) {
                                 dso__delete(dso);
                                 return -1;
                         }
 
-                        map->map_ip = vdso__map_ip;
-                        kernel_maps__insert(map);
+                        curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
+                        __thread__insert_map(thread, curr_map);
                         ++kernel_range;
                 }
 
-                if (filter && filter(map, pos)) {
-delete_symbol:
-                        rb_erase(&pos->rb_node, &kernel_map->dso->syms);
-                        symbol__delete(pos, kernel_map->dso->sym_priv_size);
+                if (filter && filter(curr_map, pos)) {
+discard_symbol:         rb_erase(&pos->rb_node, root);
+                        symbol__delete(pos);
                 } else {
-                        if (map != kernel_map) {
-                                rb_erase(&pos->rb_node, &kernel_map->dso->syms);
-                                dso__insert_symbol(map->dso, pos);
+                        if (curr_map != map) {
+                                rb_erase(&pos->rb_node, root);
+                                symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
                         }
                         count++;
                 }
@@ -359,38 +439,27 @@ delete_symbol:
 }
 
 
-static int kernel_maps__load_kallsyms(symbol_filter_t filter,
-                                      int use_modules, int v)
+static int dso__load_kallsyms(struct dso *self, struct map *map,
+                              struct thread *thread, symbol_filter_t filter)
 {
-        if (kernel_maps__load_all_kallsyms(v))
+        if (dso__load_all_kallsyms(self, map) < 0)
                 return -1;
 
-        dso__fixup_sym_end(kernel_map->dso);
+        symbols__fixup_end(&self->symbols[map->type]);
+        self->origin = DSO__ORIG_KERNEL;
 
-        return kernel_maps__split_kallsyms(filter, use_modules);
+        return dso__split_kallsyms(self, map, thread, filter);
 }
 
-static size_t kernel_maps__fprintf(FILE *fp, int v)
+size_t kernel_maps__fprintf(FILE *fp)
 {
-        size_t printed = fprintf(stderr, "Kernel maps:\n");
-        struct rb_node *nd;
-
-        for (nd = rb_first(&kernel_maps); 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 (v > 1) {
-                        printed += dso__fprintf(pos->dso, fp);
-                        printed += fprintf(fp, "--\n");
-                }
-        }
-
-        return printed + fprintf(stderr, "END kernel maps\n");
+        size_t printed = fprintf(fp, "Kernel maps:\n");
+        printed += thread__fprintf_maps(kthread, fp);
+        return printed + fprintf(fp, "END kernel maps\n");
 }
 
 static int dso__load_perf_map(struct dso *self, struct map *map,
-                              symbol_filter_t filter, int v)
+                              symbol_filter_t filter)
 {
         char *line = NULL;
         size_t n;
@@ -427,16 +496,15 @@ static int dso__load_perf_map(struct dso *self, struct map *map,
                 if (len + 2 >= line_len)
                         continue;
 
-                sym = symbol__new(start, size, line + len,
-                                  self->sym_priv_size, v);
+                sym = symbol__new(start, size, line + len);
 
                 if (sym == NULL)
                         goto out_delete_line;
 
                 if (filter && filter(map, sym))
-                        symbol__delete(sym, self->sym_priv_size);
+                        symbol__delete(sym);
                 else {
-                        dso__insert_symbol(self, sym);
+                        symbols__insert(&self->symbols[map->type], sym);
                         nr_syms++;
                 }
         }
@@ -542,7 +610,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;
@@ -562,7 +631,7 @@ static int dso__synthesize_plt_symbols(struct  dso *self, int v)
         if (fd < 0)
                 goto out;
 
-        elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
+        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
         if (elf == NULL)
                 goto out_close;
 
@@ -626,12 +695,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, 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;
@@ -644,12 +717,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, 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;
+                        }
                 }
         }
 
@@ -662,14 +739,14 @@ out_close:
         if (err == 0)
                 return nr;
 out:
-        fprintf(stderr, "%s: problems reading %s PLT info.\n",
-                __func__, self->long_name);
+        pr_warning("%s: problems reading %s PLT info.\n",
+                   __func__, self->long_name);
         return 0;
 }
 
-static int dso__load_sym(struct dso *self, struct map *map, const char *name,
-                         int fd, symbol_filter_t filter, int kernel,
-                         int kmodule, int v)
+static int dso__load_sym(struct dso *self, struct map *map,
+                         struct thread *thread, const char *name, int fd,
+                         symbol_filter_t filter, int kernel, int kmodule)
 {
         struct map *curr_map = map;
         struct dso *curr_dso = self;
@@ -686,17 +763,14 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
         Elf *elf;
         int nr = 0;
 
-        elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
+        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;
         }
 
@@ -775,25 +849,27 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                         snprintf(dso_name, sizeof(dso_name),
                                  "%s%s", self->short_name, section_name);
 
-                        curr_map = kernel_maps__find_by_dso_name(dso_name);
+                        curr_map = thread__find_map_by_name(thread, 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, self->sym_priv_size);
+                                curr_dso = dso__new(dso_name);
                                 if (curr_dso == NULL)
                                         goto out_elf_end;
-                                curr_map = map__new2(start, curr_dso);
+                                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 = vdso__map_ip;
+                                curr_map->map_ip = identity__map_ip;
+                                curr_map->unmap_ip = identity__map_ip;
                                 curr_dso->origin = DSO__ORIG_KERNEL;
-                                kernel_maps__insert(curr_map);
-                                dsos__add(curr_dso);
+                                __thread__insert_map(kthread, curr_map);
+                                dsos__add(&dsos__kernel, curr_dso);
                         } else
                                 curr_dso = curr_map->dso;
 
@@ -801,10 +877,9 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                 }
 
                 if (curr_dso->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);
-
+                        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;
                 }
                 /*
@@ -816,16 +891,15 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                 if (demangled != NULL)
                         elf_name = demangled;
 new_symbol:
-                f = symbol__new(sym.st_value, sym.st_size, elf_name,
-                                curr_dso->sym_priv_size, v);
+                f = symbol__new(sym.st_value, sym.st_size, elf_name);
                 free(demangled);
                 if (!f)
                         goto out_elf_end;
 
                 if (filter && filter(curr_map, f))
-                        symbol__delete(f, curr_dso->sym_priv_size);
+                        symbol__delete(f);
                 else {
-                        dso__insert_symbol(curr_dso, f);
+                        symbols__insert(&curr_dso->symbols[curr_map->type], f);
                         nr++;
                 }
         }
@@ -834,7 +908,7 @@ new_symbol:
          * For misannotated, zeroed, ASM function sizes.
          */
         if (nr > 0)
-                dso__fixup_sym_end(self);
+                symbols__fixup_end(&self->symbols[map->type]);
         err = nr;
 out_elf_end:
         elf_end(elf);
@@ -842,63 +916,153 @@ 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)
+{
+        return __dsos__read_build_ids(&dsos__kernel) ||
+               __dsos__read_build_ids(&dsos__user);
+}
+
+/*
+ * 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->long_name, O_RDONLY);
 
+        if (size < BUILD_ID_SIZE)
+                goto out;
+
+        fd = open(filename, O_RDONLY);
         if (fd < 0)
                 goto out;
 
-        elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
+        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->long_name);
+                pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
                 goto out_close;
         }
 
+        ek = elf_kind(elf);
+        if (ek != ELF_K_ELF)
+                goto out_elf_end;
+
         if (gelf_getehdr(elf, &ehdr) == NULL) {
-                if (v)
-                        fprintf(stderr, "%s: cannot get elf header.\n", __func__);
+                pr_err("%s: cannot get elf header.\n", __func__);
                 goto out_elf_end;
         }
 
-        sec = elf_section_by_name(elf, &ehdr, &shdr, ".note.gnu.build-id", NULL);
-        if (sec == NULL)
-                goto out_elf_end;
+        sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                  ".note.gnu.build-id", NULL);
+        if (sec == NULL) {
+                sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                          ".notes", NULL);
+                if (sec == NULL)
+                        goto out_elf_end;
+        }
 
-        build_id_data = elf_getdata(sec, NULL);
-        if (build_id_data == NULL)
+        data = elf_getdata(sec, NULL);
+        if (data == NULL)
                 goto out_elf_end;
-        build_id = malloc(BUILD_ID_SIZE);
-        if (build_id == NULL)
-                goto out_elf_end;
-        raw = build_id_data->d_buf + 16;
-        bid = build_id;
 
-        for (i = 0; i < 20; ++i) {
-                sprintf(bid, "%02x", *raw);
-                ++raw;
-                bid += 2;
+        ptr = data->d_buf;
+        while (ptr < (data->d_buf + data->d_size)) {
+                GElf_Nhdr *nhdr = ptr;
+                int namesz = NOTE_ALIGN(nhdr->n_namesz),
+                    descsz = NOTE_ALIGN(nhdr->n_descsz);
+                const char *name;
+
+                ptr += sizeof(*nhdr);
+                name = ptr;
+                ptr += namesz;
+                if (nhdr->n_type == NT_GNU_BUILD_ID &&
+                    nhdr->n_namesz == sizeof("GNU")) {
+                        if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
+                                memcpy(bf, ptr, BUILD_ID_SIZE);
+                                err = BUILD_ID_SIZE;
+                                break;
+                        }
+                }
+                ptr += descsz;
         }
-        if (v >= 2)
-                printf("%s(%s): %s\n", __func__, self->long_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)
@@ -918,20 +1082,27 @@ char dso__symtab_origin(const struct dso *self)
         return origin[self->origin];
 }
 
-int dso__load(struct dso *self, struct map *map, symbol_filter_t filter, int v)
+int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
 {
         int size = PATH_MAX;
-        char *name = malloc(size), *build_id = NULL;
+        char *name;
+        u8 build_id[BUILD_ID_SIZE];
         int ret = -1;
         int fd;
 
+        dso__set_loaded(self, map->type);
+
+        if (self->kernel)
+                return dso__load_kernel_sym(self, map, kthread, 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, map, filter, v);
+                ret = dso__load_perf_map(self, map, filter);
                 self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
                                          DSO__ORIG_NOT_FOUND;
                 return ret;
@@ -952,12 +1123,17 @@ more:
                                  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++;
@@ -970,10 +1146,19 @@ more:
                         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, map, name, fd, filter, 0, 0, v);
+        ret = dso__load_sym(self, map, NULL, name, fd, filter, 0, 0);
         close(fd);
 
         /*
@@ -983,7 +1168,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;
         }
@@ -994,33 +1179,11 @@ out:
         return ret;
 }
 
-struct map *kernel_map;
-
-static void kernel_maps__insert(struct map *map)
-{
-        maps__insert(&kernel_maps, map);
-}
-
-struct symbol *kernel_maps__find_symbol(u64 ip, struct map **mapp)
-{
-        struct map *map = maps__find(&kernel_maps, ip);
-
-        if (mapp)
-                *mapp = map;
-
-        if (map) {
-                ip = map->map_ip(map, ip);
-                return map->dso->find_symbol(map->dso, ip);
-        }
-
-        return NULL;
-}
-
-struct map *kernel_maps__find_by_dso_name(const char *name)
+static struct map *thread__find_map_by_name(struct thread *self, char *name)
 {
         struct rb_node *nd;
 
-        for (nd = rb_first(&kernel_maps); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&self->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) {
                 struct map *map = rb_entry(nd, struct map, rb_node);
 
                 if (map->dso && strcmp(map->dso->name, name) == 0)
@@ -1030,35 +1193,13 @@ struct map *kernel_maps__find_by_dso_name(const char *name)
         return NULL;
 }
 
-static int dso__load_module_sym(struct dso *self, struct map *map,
-                                symbol_filter_t filter, int v)
-{
-        int err = 0, fd = open(self->long_name, O_RDONLY);
-
-        if (fd < 0) {
-                if (v)
-                        fprintf(stderr, "%s: cannot open %s\n",
-                                __func__, self->long_name);
-                return err;
-        }
-
-        err = dso__load_sym(self, map, self->long_name, fd, filter, 0, 1, v);
-        close(fd);
-
-        return err;
-}
-
-static int dsos__load_modules_sym_dir(char *dirname,
-                                      symbol_filter_t filter, int v)
+static int dsos__set_modules_path_dir(char *dirname)
 {
         struct dirent *dent;
-        int nr_symbols = 0, err;
         DIR *dir = opendir(dirname);
 
         if (!dir) {
-                if (v)
-                        fprintf(stderr, "%s: cannot open %s dir\n", __func__,
-                                dirname);
+                pr_debug("%s: cannot open %s dir\n", __func__, dirname);
                 return -1;
         }
 
@@ -1072,14 +1213,13 @@ static int dsos__load_modules_sym_dir(char *dirname,
 
                         snprintf(path, sizeof(path), "%s/%s",
                                  dirname, dent->d_name);
-                        err = dsos__load_modules_sym_dir(path, filter, v);
-                        if (err < 0)
+                        if (dsos__set_modules_path_dir(path) < 0)
                                 goto failure;
                 } else {
                         char *dot = strrchr(dent->d_name, '.'),
                              dso_name[PATH_MAX];
                         struct map *map;
-                        struct rb_node *last;
+                        char *long_name;
 
                         if (dot == NULL || strcmp(dot, ".ko"))
                                 continue;
@@ -1087,45 +1227,27 @@ static int dsos__load_modules_sym_dir(char *dirname,
                                  (int)(dot - dent->d_name), dent->d_name);
 
                         strxfrchar(dso_name, '-', '_');
-                        map = kernel_maps__find_by_dso_name(dso_name);
+                        map = thread__find_map_by_name(kthread, dso_name);
                         if (map == NULL)
                                 continue;
 
                         snprintf(path, sizeof(path), "%s/%s",
                                  dirname, dent->d_name);
 
-                        map->dso->long_name = strdup(path);
-                        if (map->dso->long_name == NULL)
+                        long_name = strdup(path);
+                        if (long_name == NULL)
                                 goto failure;
-
-                        err = dso__load_module_sym(map->dso, map, filter, v);
-                        if (err < 0)
-                                goto failure;
-                        last = rb_last(&map->dso->syms);
-                        if (last) {
-                                struct symbol *sym;
-                                /*
-                                 * We do this here as well, even having the
-                                 * symbol size found in the symtab because
-                                 * misannotated ASM symbols may have the size
-                                 * set to zero.
-                                 */
-                                dso__fixup_sym_end(map->dso);
-
-                                sym = rb_entry(last, struct symbol, rb_node);
-                                map->end = map->start + sym->end;
-                        }
+                        dso__set_long_name(map->dso, long_name);
                 }
-                nr_symbols += err;
         }
 
-        return nr_symbols;
+        return 0;
 failure:
         closedir(dir);
         return -1;
 }
 
-static int dsos__load_modules_sym(symbol_filter_t filter, int v)
+static int dsos__set_modules_path(void)
 {
         struct utsname uts;
         char modules_path[PATH_MAX];
@@ -1136,7 +1258,7 @@ static int dsos__load_modules_sym(symbol_filter_t filter, int v)
         snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
                  uts.release);
 
-        return dsos__load_modules_sym_dir(modules_path, filter, v);
+        return dsos__set_modules_path_dir(modules_path);
 }
 
 /*
@@ -1144,26 +1266,21 @@ static int dsos__load_modules_sym(symbol_filter_t filter, int v)
  * 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)
+static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
 {
         struct map *self = malloc(sizeof(*self));
 
         if (self != NULL) {
-                self->start = start;
                 /*
-                 * Will be filled after we load all the symbols
+                 * ->end will be filled after we load all the symbols
                  */
-                self->end = 0;
-
-                self->pgoff = 0;
-                self->dso = dso;
-                self->map_ip = map__map_ip;
-                RB_CLEAR_NODE(&self->rb_node);
+                map__init(self, type, start, 0, 0, dso);
         }
+
         return self;
 }
 
-static int dsos__load_modules(unsigned int sym_priv_size)
+static int thread__create_module_maps(struct thread *self)
 {
         char *line = NULL;
         size_t n;
@@ -1202,26 +1319,32 @@ static int dsos__load_modules(unsigned int sym_priv_size)
                 *sep = '\0';
 
                 snprintf(name, sizeof(name), "[%s]", line);
-                dso = dso__new(name, sym_priv_size);
+                dso = dso__new(name);
 
                 if (dso == NULL)
                         goto out_delete_line;
 
-                map = map__new2(start, dso);
+                map = map__new2(start, dso, MAP__FUNCTION);
                 if (map == NULL) {
                         dso__delete(dso);
                         goto out_delete_line;
                 }
 
+                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;
-                kernel_maps__insert(map);
-                dsos__add(dso);
+                __thread__insert_map(self, map);
+                dsos__add(&dsos__kernel, dso);
         }
 
         free(line);
         fclose(file);
 
-        return 0;
+        return dsos__set_modules_path();
 
 out_delete_line:
         free(line);
@@ -1229,105 +1352,106 @@ out_failure:
         return -1;
 }
 
-static int dso__load_vmlinux(struct dso *self, struct map *map,
-                             const char *vmlinux,
-                             symbol_filter_t filter, int v)
+static int dso__load_vmlinux(struct dso *self, struct map *map, struct thread *thread,
+                             const char *vmlinux, symbol_filter_t filter)
 {
-        int err, fd = open(vmlinux, O_RDONLY);
+        int err = -1, fd;
 
+        if (self->has_build_id) {
+                u8 build_id[BUILD_ID_SIZE];
+
+                if (filename__read_build_id(vmlinux, build_id,
+                                            sizeof(build_id)) < 0) {
+                        pr_debug("No build_id in %s, ignoring it\n", vmlinux);
+                        return -1;
+                }
+                if (!dso__build_id_equal(self, build_id)) {
+                        char expected_build_id[BUILD_ID_SIZE * 2 + 1],
+                             vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];
+
+                        build_id__sprintf(self->build_id,
+                                          sizeof(self->build_id),
+                                          expected_build_id);
+                        build_id__sprintf(build_id, sizeof(build_id),
+                                          vmlinux_build_id);
+                        pr_debug("build_id in %s is %s while expected is %s, "
+                                 "ignoring it\n", vmlinux, vmlinux_build_id,
+                                 expected_build_id);
+                        return -1;
+                }
+        }
+
+        fd = open(vmlinux, O_RDONLY);
         if (fd < 0)
                 return -1;
 
-        err = dso__load_sym(self, map, self->long_name, fd, filter, 1, 0, v);
-
+        dso__set_loaded(self, map->type);
+        err = dso__load_sym(self, map, thread, self->long_name, fd, filter, 1, 0);
         close(fd);
 
         return err;
 }
 
-int dsos__load_kernel(const char *vmlinux, unsigned int sym_priv_size,
-                      symbol_filter_t filter, int v, int use_modules)
+static int dso__load_kernel_sym(struct dso *self, struct map *map,
+                                struct thread *thread, symbol_filter_t filter)
 {
-        int err = -1;
-        struct dso *dso = dso__new(vmlinux, sym_priv_size);
-
-        if (dso == NULL)
-                return -1;
-
-        dso->short_name = "[kernel]";
-        kernel_map = map__new2(0, dso);
-        if (kernel_map == NULL)
-                goto out_delete_dso;
-
-        kernel_map->map_ip = vdso__map_ip;
-
-        if (use_modules && dsos__load_modules(sym_priv_size) < 0) {
-                fprintf(stderr, "Failed to load list of modules in use! "
-                                "Continuing...\n");
-                use_modules = 0;
-        }
-
-        if (vmlinux) {
-                err = dso__load_vmlinux(dso, kernel_map, vmlinux, filter, v);
-                if (err > 0 && use_modules) {
-                        int syms = dsos__load_modules_sym(filter, v);
-
-                        if (syms < 0)
-                                fprintf(stderr, "Failed to read module symbols!"
-                                        " Continuing...\n");
-                        else
-                                err += 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, thread,
+                                                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;
+                        }
                 }
         }
 
-        if (err <= 0)
-                err = kernel_maps__load_kallsyms(filter, use_modules, v);
+        is_kallsyms = self->long_name[0] == '[';
+        if (is_kallsyms)
+                goto do_kallsyms;
+
+        err = dso__load_vmlinux(self, map, thread, 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, thread, filter);
+                if (err > 0 && !is_kallsyms)
+                        dso__set_long_name(self, strdup("[kernel.kallsyms]"));
+        }
 
         if (err > 0) {
-                struct rb_node *node = rb_first(&dso->syms);
-                struct symbol *sym = rb_entry(node, struct symbol, rb_node);
-
-                kernel_map->start = sym->start;
-                node = rb_last(&dso->syms);
-                sym = rb_entry(node, struct symbol, rb_node);
-                kernel_map->end = sym->end;
-
-                dso->origin = DSO__ORIG_KERNEL;
-                kernel_maps__insert(kernel_map);
-                /*
-                 * Now that we have all sorted out, just set the ->end of all
-                 * maps:
-                 */
-                kernel_maps__fixup_end();
-                dsos__add(dso);
-
-                if (v > 0)
-                        kernel_maps__fprintf(stderr, v);
+out_fixup:
+                map__fixup_start(map);
+                map__fixup_end(map);
         }
 
         return err;
-
-out_delete_dso:
-        dso__delete(dso);
-        return -1;
 }
 
-LIST_HEAD(dsos);
-struct dso      *vdso;
-
-const char      *vmlinux_name = "vmlinux";
-int             modules;
+LIST_HEAD(dsos__user);
+LIST_HEAD(dsos__kernel);
+struct dso *vdso;
 
-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;
@@ -1335,56 +1459,170 @@ static struct dso *dsos__find(const char *name)
 
 struct dso *dsos__findnew(const char *name)
 {
-        struct dso *dso = dsos__find(name);
-        int nr;
+        struct dso *dso = dsos__find(&dsos__user, name);
 
-        if (dso)
-                return dso;
-
-        dso = dso__new(name, 0);
-        if (!dso)
-                goto out_delete_dso;
-
-        nr = dso__load(dso, NULL, 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;
+}
+
+size_t dsos__fprintf_buildid(FILE *fp)
+{
+        return (__dsos__fprintf_buildid(&dsos__kernel, fp) +
+                __dsos__fprintf_buildid(&dsos__user, fp));
 }
 
-int load_kernel(void)
+static int thread__create_kernel_map(struct thread *self, const char *vmlinux)
 {
-        if (dsos__load_kernel(vmlinux_name, 0, NULL, verbose, modules) <= 0)
+        struct map *kmap;
+        struct dso *kernel = dso__new(vmlinux ?: "[kernel.kallsyms]");
+
+        if (kernel == NULL)
                 return -1;
 
-        vdso = dso__new("[vdso]", 0);
-        if (!vdso)
+        kmap = map__new2(0, kernel, MAP__FUNCTION);
+        if (kmap == NULL)
+                goto out_delete_kernel_dso;
+
+        kmap->map_ip       = kmap->unmap_ip = identity__map_ip;
+        kernel->short_name = "[kernel]";
+        kernel->kernel     = 1;
+
+        vdso = dso__new("[vdso]");
+        if (vdso == NULL)
+                goto out_delete_kernel_map;
+        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;
+
+        __thread__insert_map(self, kmap);
+        dsos__add(&dsos__kernel, kernel);
+        dsos__add(&dsos__user, vdso);
+
+        return 0;
+
+out_delete_kernel_map:
+        map__delete(kmap);
+out_delete_kernel_dso:
+        dso__delete(kernel);
+        return -1;
+}
+
+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;
+        }
+
+        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;
+
+        vmlinux_path = malloc(sizeof(char *) * 5);
+        if (vmlinux_path == NULL)
                 return -1;
 
-        dsos__add(vdso);
+        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;
 }
 
-void symbol__init(void)
+int symbol__init(struct symbol_conf *conf)
 {
+        const struct symbol_conf *pconf = conf ?: &symbol_conf__defaults;
+
         elf_version(EV_CURRENT);
+        symbol__priv_size = pconf->priv_size;
+        thread__init(kthread, 0);
+
+        if (pconf->try_vmlinux_path && vmlinux_path__init() < 0)
+                return -1;
+
+        if (thread__create_kernel_map(kthread, pconf->vmlinux_name) < 0) {
+                vmlinux_path__exit();
+                return -1;
+        }
+
+        kthread->use_modules = pconf->use_modules;
+        if (pconf->use_modules && thread__create_module_maps(kthread) < 0)
+                pr_debug("Failed to load list of modules in use, "
+                         "continuing...\n");
+        /*
+         * Now that we have all the maps created, just set the ->end of them:
+         */
+        thread__fixup_maps_end(kthread);
+        return 0;
 }
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 2e4522edeb07..17003efa0b39 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -2,6 +2,7 @@
 #define __PERF_SYMBOL 1
 
 #include <linux/types.h>
+#include <stdbool.h>
 #include "types.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
@@ -26,6 +27,16 @@ static inline char *bfd_demangle(void __used *v, const char __used *c,
 #endif
 #endif
 
+/*
+ * libelf 0.8.x and earlier do not support ELF_C_READ_MMAP;
+ * for newer versions we can use mmap to reduce memory usage:
+ */
+#ifdef LIBELF_NO_MMAP
+# define PERF_ELF_C_READ_MMAP ELF_C_READ
+#else
+# define PERF_ELF_C_READ_MMAP ELF_C_READ_MMAP
+#endif
+
 #ifndef DMGL_PARAMS
 #define DMGL_PARAMS      (1 << 0)       /* Include function args */
 #define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
@@ -35,56 +46,75 @@ struct symbol {
         struct rb_node  rb_node;
         u64             start;
         u64             end;
-        u64             hist_sum;
-        u64             *hist;
-        void            *priv;
         char            name[0];
 };
 
+struct symbol_conf {
+        unsigned short  priv_size;
+        bool            try_vmlinux_path,
+                        use_modules;
+        const char      *vmlinux_name;
+};
+
+extern unsigned int symbol__priv_size;
+
+static inline void *symbol__priv(struct symbol *self)
+{
+        return ((void *)self) - symbol__priv_size;
+}
+
+struct addr_location {
+        struct thread *thread;
+        struct map    *map;
+        struct symbol *sym;
+        u64           addr;
+        char          level;
+};
+
 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 symbol    *(*find_symbol)(struct dso *self,
+                                         enum map_type type, u64 addr);
+        u8               adjust_symbols:1;
+        u8               slen_calculated:1;
+        u8               has_build_id:1;
+        u8               kernel:1;
         unsigned char    origin;
+        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 map *map, 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);
 
-struct symbol *dso__find_symbol(struct dso *self, u64 ip);
-
-int dsos__load_kernel(const char *vmlinux, unsigned int sym_priv_size,
-                      symbol_filter_t filter, int verbose, int modules);
-int dso__load(struct dso *self, struct map *map, symbol_filter_t filter,
-              int verbose);
 struct dso *dsos__findnew(const char *name);
+int dso__load(struct dso *self, struct map *map, 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);
+
+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);
 
-int load_kernel(void);
+size_t kernel_maps__fprintf(FILE *fp);
 
-void symbol__init(void);
+int symbol__init(struct symbol_conf *conf);
 
-extern struct list_head dsos;
-extern struct map *kernel_map;
+struct thread;
+struct thread *kthread;
+extern struct list_head dsos__user, dsos__kernel;
 extern struct dso *vdso;
-extern const char *vmlinux_name;
-extern int   modules;
 #endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 3b56aebb1f4b..603f5610861b 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -6,17 +6,29 @@
 #include "util.h"
 #include "debug.h"
 
+static struct rb_root threads;
+static struct thread *last_match;
+
+void thread__init(struct thread *self, pid_t pid)
+{
+        int i;
+        self->pid = pid;
+        self->comm = NULL;
+        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) {
-                self->pid = pid;
+                thread__init(self, pid);
                 self->comm = malloc(32);
                 if (self->comm)
                         snprintf(self->comm, 32, ":%d", self->pid);
-                self->maps = RB_ROOT;
-                INIT_LIST_HEAD(&self->removed_maps);
         }
 
         return self;
@@ -30,30 +42,84 @@ 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",
+};
+
+static size_t __thread__fprintf_maps(struct thread *self,
+                                     enum map_type type, FILE *fp)
+{
+        size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
         struct rb_node *nd;
-        struct map *pos;
-        size_t ret = fprintf(fp, "Thread %d %s\nCurrent maps:\n",
-                             self->pid, self->comm);
 
-        for (nd = rb_first(&self->maps); nd; nd = rb_next(nd)) {
-                pos = rb_entry(nd, struct map, rb_node);
-                ret += map__fprintf(pos, fp);
+        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");
+                }
         }
 
-        ret = fprintf(fp, "Removed maps:\n");
+        return printed;
+}
 
-        list_for_each_entry(pos, &self->removed_maps, node)
-                ret += map__fprintf(pos, fp);
+size_t thread__fprintf_maps(struct thread *self, FILE *fp)
+{
+        size_t printed = 0, i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                printed += __thread__fprintf_maps(self, i, fp);
+        return printed;
+}
 
-        return ret;
+static size_t __thread__fprintf_removed_maps(struct thread *self,
+                                             enum map_type type, FILE *fp)
+{
+        struct map *pos;
+        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;
+}
+
+static size_t thread__fprintf_removed_maps(struct thread *self, FILE *fp)
+{
+        size_t printed = 0, i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                printed += __thread__fprintf_removed_maps(self, i, fp);
+        return printed;
 }
 
-struct thread *
-threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
+static size_t thread__fprintf(struct thread *self, FILE *fp)
 {
-        struct rb_node **p = &threads->rb_node;
+        size_t printed = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
+        printed += thread__fprintf_removed_maps(self, fp);
+        printed += fprintf(fp, "Removed maps:\n");
+        return printed + thread__fprintf_removed_maps(self, fp);
+}
+
+struct thread *threads__findnew(pid_t pid)
+{
+        struct rb_node **p = &threads.rb_node;
         struct rb_node *parent = NULL;
         struct thread *th;
 
@@ -62,15 +128,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 (last_match && last_match->pid == pid)
+                return last_match;
 
         while (*p != NULL) {
                 parent = *p;
                 th = rb_entry(parent, struct thread, rb_node);
 
                 if (th->pid == pid) {
-                        *last_match = th;
+                        last_match = th;
                         return th;
                 }
 
@@ -83,17 +149,16 @@ 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, &threads);
+                last_match = th;
         }
 
         return th;
 }
 
-struct thread *
-register_idle_thread(struct rb_root *threads, struct thread **last_match)
+struct thread *register_idle_thread(void)
 {
-        struct thread *thread = threads__findnew(0, threads, last_match);
+        struct thread *thread = threads__findnew(0);
 
         if (!thread || thread__set_comm(thread, "swapper")) {
                 fprintf(stderr, "problem inserting idle task.\n");
@@ -105,7 +170,8 @@ register_idle_thread(struct rb_root *threads, struct thread **last_match)
 
 static void thread__remove_overlappings(struct thread *self, struct map *map)
 {
-        struct rb_node *next = rb_first(&self->maps);
+        struct rb_root *root = &self->maps[map->type];
+        struct rb_node *next = rb_first(root);
 
         while (next) {
                 struct map *pos = rb_entry(next, struct map, rb_node);
@@ -115,18 +181,18 @@ static void thread__remove_overlappings(struct thread *self, struct map *map)
                         continue;
 
                 if (verbose >= 2) {
-                        printf("overlapping maps:\n");
-                        map__fprintf(map, stdout);
-                        map__fprintf(pos, stdout);
+                        fputs("overlapping maps:\n", stderr);
+                        map__fprintf(map, stderr);
+                        map__fprintf(pos, stderr);
                 }
 
-                rb_erase(&pos->rb_node, &self->maps);
+                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);
+                list_add_tail(&pos->node, &self->removed_maps[map->type]);
         }
 }
 
@@ -173,12 +239,26 @@ struct map *maps__find(struct rb_root *maps, u64 ip)
 void thread__insert_map(struct thread *self, struct map *map)
 {
         thread__remove_overlappings(self, map);
-        maps__insert(&self->maps, map);
+        maps__insert(&self->maps[map->type], map);
 }
 
-int thread__fork(struct thread *self, struct thread *parent)
+static int thread__clone_maps(struct thread *self, struct thread *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 == NULL)
+                        return -ENOMEM;
+                thread__insert_map(self, new);
+        }
+        return 0;
+}
+
+int thread__fork(struct thread *self, struct thread *parent)
+{
+        int i;
 
         if (self->comm)
                 free(self->comm);
@@ -186,23 +266,18 @@ int thread__fork(struct thread *self, struct thread *parent)
         if (!self->comm)
                 return -ENOMEM;
 
-        for (nd = rb_first(&parent->maps); nd; nd = rb_next(nd)) {
-                struct map *map = rb_entry(nd, struct map, rb_node);
-                struct map *new = map__clone(map);
-                if (!new)
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                if (thread__clone_maps(self, parent, i) < 0)
                         return -ENOMEM;
-                thread__insert_map(self, new);
-        }
-
         return 0;
 }
 
-size_t threads__fprintf(FILE *fp, struct rb_root *threads)
+size_t threads__fprintf(FILE *fp)
 {
         size_t ret = 0;
         struct rb_node *nd;
 
-        for (nd = rb_first(threads); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&threads); nd; nd = rb_next(nd)) {
                 struct thread *pos = rb_entry(nd, struct thread, rb_node);
 
                 ret += thread__fprintf(pos, fp);
@@ -210,3 +285,15 @@ size_t threads__fprintf(FILE *fp, struct rb_root *threads)
 
         return ret;
 }
+
+struct symbol *thread__find_symbol(struct thread *self,
+                                   enum map_type type, u64 addr,
+                                   symbol_filter_t filter)
+{
+        struct map *map = thread__find_map(self, type, addr);
+
+        if (map != NULL)
+                return map__find_symbol(map, map->map_ip(map, addr), filter);
+
+        return NULL;
+}
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 845d9b62f96f..686d6e914d9e 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -7,31 +7,50 @@
 
 struct thread {
         struct rb_node          rb_node;
-        struct rb_root          maps;
-        struct list_head        removed_maps;
+        struct rb_root          maps[MAP__NR_TYPES];
+        struct list_head        removed_maps[MAP__NR_TYPES];
         pid_t                   pid;
+        bool                    use_modules;
         char                    shortname[3];
         char                    *comm;
+        int                     comm_len;
 };
 
+void thread__init(struct thread *self, pid_t pid);
 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 *threads__findnew(pid_t pid);
+struct thread *register_idle_thread(void);
 void thread__insert_map(struct thread *self, struct map *map);
 int thread__fork(struct thread *self, struct thread *parent);
-size_t threads__fprintf(FILE *fp, struct rb_root *threads);
+size_t thread__fprintf_maps(struct thread *self, FILE *fp);
+size_t threads__fprintf(FILE *fp);
 
 void maps__insert(struct rb_root *maps, struct map *map);
-struct map *maps__find(struct rb_root *maps, u64 ip);
+struct map *maps__find(struct rb_root *maps, u64 addr);
 
-struct symbol *kernel_maps__find_symbol(const u64 ip, struct map **mapp);
-struct map *kernel_maps__find_by_dso_name(const char *name);
+static inline struct map *thread__find_map(struct thread *self,
+                                           enum map_type type, u64 addr)
+{
+        return self ? maps__find(&self->maps[type], addr) : NULL;
+}
 
-static inline struct map *thread__find_map(struct thread *self, u64 ip)
+static inline void __thread__insert_map(struct thread *self, struct map *map)
 {
-        return self ? maps__find(&self->maps, ip) : NULL;
+         maps__insert(&self->maps[map->type], map);
 }
 
+void thread__find_addr_location(struct thread *self, u8 cpumode,
+                                enum map_type type, u64 addr,
+                                struct addr_location *al,
+                                symbol_filter_t filter);
+struct symbol *thread__find_symbol(struct thread *self,
+                                   enum map_type type, u64 addr,
+                                   symbol_filter_t filter);
+
+static inline struct symbol *
+thread__find_function(struct thread *self, u64 addr, symbol_filter_t filter)
+{
+        return thread__find_symbol(self, MAP__FUNCTION, addr, filter);
+}
 #endif  /* __PERF_THREAD_H */
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 831052d4b4fb..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,23 +483,31 @@ 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(int fd, 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 = fd;
 
@@ -528,11 +536,11 @@ void read_tracing_data(int fd, 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 eef60df7a5bf..0302405aa2ca 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)
 {
@@ -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)
@@ -756,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);
 
@@ -771,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)
@@ -889,14 +900,14 @@ static int event_read_fields(struct event *event, struct format_field **fields)
                                 field->flags |= FIELD_IS_DYNAMIC;
                 }
 
-                if (test_type_token(type, token,  EVENT_OP, (char *)";"))
+                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))
@@ -904,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))
@@ -918,26 +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_expected(EVENT_ITEM, (char *)"signed") < 0)
-                        goto fail_expect;
+                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;
 
-                if (read_expected(EVENT_OP, (char *)":") < 0)
-                        goto fail_expect;
+                        free_token(token);
 
-                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_expected(EVENT_OP, (char *)";") < 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;
+                }
 
-                if (read_expect_type(EVENT_NEWLINE, &token) < 0)
-                        goto fail;
                 free_token(token);
 
                 *fields = field;
@@ -960,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))
@@ -1023,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;
@@ -1043,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]) {
@@ -1167,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) {
 
@@ -1183,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;
 
@@ -1217,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)
@@ -1227,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;
 
@@ -1377,14 +1466,14 @@ 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));
@@ -1395,7 +1484,7 @@ process_fields(struct event *event, struct print_flag_sym **list, char **tok)
 
                 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);
@@ -1430,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;
@@ -1447,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);
@@ -1473,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);
@@ -1502,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);
@@ -1510,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;
         }
@@ -1555,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);
@@ -1579,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)
@@ -1589,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);
@@ -1617,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);
@@ -1676,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));
 
@@ -1722,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;
 
@@ -1743,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);
@@ -1752,7 +1842,7 @@ static int event_read_print(struct event *event)
         if (ret < 0)
                 return -1;
 
-        return 0;
+        return ret;
 
  fail:
         free_token(token);
@@ -1798,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:
@@ -1861,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);
 }
 
-static int parse_common_pid(void *data)
+int trace_parse_common_type(void *data)
+{
+        static int type_offset;
+        static int type_size;
+
+        return __parse_common(data, &type_size, &type_offset,
+                              "common_type");
+}
+
+int trace_parse_common_pid(void *data)
 {
         static int pid_offset;
         static int pid_size;
+
+        return __parse_common(data, &pid_size, &pid_offset,
+                              "common_pid");
+}
+
+int parse_common_pc(void *data)
+{
+        static int pc_offset;
+        static int pc_size;
+
+        return __parse_common(data, &pc_size, &pc_offset,
+                              "common_preempt_count");
+}
+
+int parse_common_flags(void *data)
+{
+        static int flags_offset;
+        static int flags_size;
+
+        return __parse_common(data, &flags_size, &flags_offset,
+                              "common_flags");
+}
+
+int parse_common_lock_depth(void *data)
+{
+        static int ld_offset;
+        static int ld_size;
         int ret;
 
-        if (!pid_size) {
-                ret = get_common_info("common_pid",
-                                      &pid_offset,
-                                      &pid_size);
-                if (ret < 0)
-                        return ret;
-        }
+        ret = __parse_common(data, &ld_size, &ld_offset,
+                             "common_lock_depth");
+        if (ret < 0)
+                return -1;
 
-        return read_size(data + pid_offset, pid_size);
+        return ret;
 }
 
 struct event *trace_find_event(int id)
@@ -1905,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:
@@ -1936,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]) {
@@ -1986,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);
                 }
@@ -2017,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;
 
@@ -2184,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:
@@ -2309,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:
@@ -2416,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)
 {
@@ -2491,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");
@@ -2659,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");
@@ -2702,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");
@@ -2763,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");
@@ -2846,55 +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_expected(EVENT_ITEM, (char *)"signed") < 0)
-                return;
-        if (read_expected(EVENT_OP, (char *)":") < 0)
-                return;
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                return;
-        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);
 }
 
@@ -2902,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;
@@ -2957,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.
@@ -2994,12 +3245,16 @@ int parse_event_file(char *buf, unsigned long size, char *sys)
                 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);
 
@@ -3009,6 +3264,12 @@ int parse_event_file(char *buf, unsigned long size, char *sys)
 
         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..51e833fd58c3
--- /dev/null
+++ b/tools/perf/util/trace-event-perl.c
@@ -0,0 +1,598 @@
+/*
+ * 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 boot_Perf__Trace__Context(pTHX_ CV *cv);
+void boot_DynaLoader(pTHX_ CV *cv);
+
+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 __attribute((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)
+{
+        const char *command_line[2] = { "", NULL };
+
+        command_line[1] = script;
+
+        my_perl = perl_alloc();
+        perl_construct(my_perl);
+
+        if (perl_parse(my_perl, xs_init, 2, (char **)command_line,
+                       (char **)NULL))
+                return -1;
+
+        perl_run(my_perl);
+        if (SvTRUE(ERRSV))
+                return -1;
+
+        run_start_sub();
+
+        fprintf(stderr, "perf trace started with Perl script %s\n\n", script);
+
+        return 0;
+}
+
+/*
+ * 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,
+};
+
+#ifdef NO_LIBPERL
+void setup_perl_scripting(void)
+{
+        fprintf(stderr, "Perl scripting not supported."
+                "  Install libperl and rebuild perf to enable it.  e.g. "
+                "apt-get install libperl-dev (ubuntu), yum install "
+                "perl-ExtUtils-Embed (Fedora), etc.\n");
+}
+#else
+void setup_perl_scripting(void)
+{
+        int err;
+        err = script_spec_register("Perl", &perl_scripting_ops);
+        if (err)
+                die("error registering Perl script extension");
+
+        err = script_spec_register("pl", &perl_scripting_ops);
+        if (err)
+                die("error registering pl script extension");
+
+        scripting_context = malloc(sizeof(struct scripting_context));
+}
+#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..8fe0d866fe1a
--- /dev/null
+++ b/tools/perf/util/trace-event-perl.h
@@ -0,0 +1,51 @@
+#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) {}
+#else
+#include <EXTERN.h>
+#include <perl.h>
+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 44292e06cca4..342dfdd43f87 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -471,11 +471,11 @@ void trace_report(int 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 da77e073c867..81698d5e6503 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -29,6 +29,8 @@ enum format_flags {
         FIELD_IS_SIGNED         = 4,
         FIELD_IS_STRING         = 8,
         FIELD_IS_DYNAMIC        = 16,
+        FIELD_IS_FLAG           = 32,
+        FIELD_IS_SYMBOLIC       = 64,
 };
 
 struct format_field {
@@ -139,12 +141,14 @@ struct event {
 };
 
 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 {
@@ -237,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 *);
+        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(int fd, struct perf_event_attr *pattrs, int nb_events);
+extern struct scripting_ops perl_scripting_ops;
+void setup_perl_scripting(void);
 
 #endif /* __PERF_TRACE_EVENTS_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/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;
-}