Merge branch 'next' into for-linus

84 files changed, 18846 insertions, 0 deletions

diff --git a/tools/perf/.gitignore b/tools/perf/.gitignore
new file mode 100644
index 000000000000..d69a759a1046
--- /dev/null
+++ b/tools/perf/.gitignore
@@ -0,0 +1,16 @@
+PERF-BUILD-OPTIONS
+PERF-CFLAGS
+PERF-GUI-VARS
+PERF-VERSION-FILE
+perf
+perf-help
+perf-record
+perf-report
+perf-stat
+perf-top
+perf*.1
+perf*.xml
+common-cmds.h
+tags
+TAGS
+cscope*
diff --git a/tools/perf/CREDITS b/tools/perf/CREDITS
new file mode 100644
index 000000000000..c2ddcb3acbd0
--- /dev/null
+++ b/tools/perf/CREDITS
@@ -0,0 +1,30 @@
+Most of the infrastructure that 'perf' uses here has been reused
+from the Git project, as of version:
+
+    66996ec: Sync with 1.6.2.4
+
+Here is an (incomplete!) list of main contributors to those files
+in util/* and elsewhere:
+
+ Alex Riesen
+ Christian Couder
+ Dmitry Potapov
+ Jeff King
+ Johannes Schindelin
+ Johannes Sixt
+ Junio C Hamano
+ Linus Torvalds
+ Matthias Kestenholz
+ Michal Ostrowski
+ Miklos Vajna
+ Petr Baudis
+ Pierre Habouzit
+ René Scharfe
+ Samuel Tardieu
+ Shawn O. Pearce
+ Steffen Prohaska
+ Steve Haslam
+
+Thanks guys!
+
+The full history of the files can be found in the upstream Git commits.
diff --git a/tools/perf/Documentation/Makefile b/tools/perf/Documentation/Makefile
new file mode 100644
index 000000000000..bdd3b7ecad0a
--- /dev/null
+++ b/tools/perf/Documentation/Makefile
@@ -0,0 +1,300 @@
+MAN1_TXT= \
+        $(filter-out $(addsuffix .txt, $(ARTICLES) $(SP_ARTICLES)), \
+                $(wildcard perf-*.txt)) \
+        perf.txt
+MAN5_TXT=
+MAN7_TXT=
+
+MAN_TXT = $(MAN1_TXT) $(MAN5_TXT) $(MAN7_TXT)
+MAN_XML=$(patsubst %.txt,%.xml,$(MAN_TXT))
+MAN_HTML=$(patsubst %.txt,%.html,$(MAN_TXT))
+
+DOC_HTML=$(MAN_HTML)
+
+ARTICLES =
+# with their own formatting rules.
+SP_ARTICLES =
+API_DOCS = $(patsubst %.txt,%,$(filter-out technical/api-index-skel.txt technical/api-index.txt, $(wildcard technical/api-*.txt)))
+SP_ARTICLES += $(API_DOCS)
+SP_ARTICLES += technical/api-index
+
+DOC_HTML += $(patsubst %,%.html,$(ARTICLES) $(SP_ARTICLES))
+
+DOC_MAN1=$(patsubst %.txt,%.1,$(MAN1_TXT))
+DOC_MAN5=$(patsubst %.txt,%.5,$(MAN5_TXT))
+DOC_MAN7=$(patsubst %.txt,%.7,$(MAN7_TXT))
+
+prefix?=$(HOME)
+bindir?=$(prefix)/bin
+htmldir?=$(prefix)/share/doc/perf-doc
+pdfdir?=$(prefix)/share/doc/perf-doc
+mandir?=$(prefix)/share/man
+man1dir=$(mandir)/man1
+man5dir=$(mandir)/man5
+man7dir=$(mandir)/man7
+# DESTDIR=
+
+ASCIIDOC=asciidoc
+ASCIIDOC_EXTRA = --unsafe
+MANPAGE_XSL = manpage-normal.xsl
+XMLTO_EXTRA =
+INSTALL?=install
+RM ?= rm -f
+DOC_REF = origin/man
+HTML_REF = origin/html
+
+infodir?=$(prefix)/share/info
+MAKEINFO=makeinfo
+INSTALL_INFO=install-info
+DOCBOOK2X_TEXI=docbook2x-texi
+DBLATEX=dblatex
+ifndef PERL_PATH
+        PERL_PATH = /usr/bin/perl
+endif
+
+-include ../config.mak.autogen
+-include ../config.mak
+
+#
+# For asciidoc ...
+#       -7.1.2, no extra settings are needed.
+#       8.0-,   set ASCIIDOC8.
+#
+
+#
+# For docbook-xsl ...
+#       -1.68.1,        set ASCIIDOC_NO_ROFF? (based on changelog from 1.73.0)
+#       1.69.0,         no extra settings are needed?
+#       1.69.1-1.71.0,  set DOCBOOK_SUPPRESS_SP?
+#       1.71.1,         no extra settings are needed?
+#       1.72.0,         set DOCBOOK_XSL_172.
+#       1.73.0-,        set ASCIIDOC_NO_ROFF
+#
+
+#
+# If you had been using DOCBOOK_XSL_172 in an attempt to get rid
+# of 'the ".ft C" problem' in your generated manpages, and you
+# instead ended up with weird characters around callouts, try
+# using ASCIIDOC_NO_ROFF instead (it works fine with ASCIIDOC8).
+#
+
+ifdef ASCIIDOC8
+ASCIIDOC_EXTRA += -a asciidoc7compatible
+endif
+ifdef DOCBOOK_XSL_172
+ASCIIDOC_EXTRA += -a perf-asciidoc-no-roff
+MANPAGE_XSL = manpage-1.72.xsl
+else
+        ifdef ASCIIDOC_NO_ROFF
+        # docbook-xsl after 1.72 needs the regular XSL, but will not
+        # pass-thru raw roff codes from asciidoc.conf, so turn them off.
+        ASCIIDOC_EXTRA += -a perf-asciidoc-no-roff
+        endif
+endif
+ifdef MAN_BOLD_LITERAL
+XMLTO_EXTRA += -m manpage-bold-literal.xsl
+endif
+ifdef DOCBOOK_SUPPRESS_SP
+XMLTO_EXTRA += -m manpage-suppress-sp.xsl
+endif
+
+SHELL_PATH ?= $(SHELL)
+# Shell quote;
+SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))
+
+#
+# Please note that there is a minor bug in asciidoc.
+# The version after 6.0.3 _will_ include the patch found here:
+#   http://marc.theaimsgroup.com/?l=perf&m=111558757202243&w=2
+#
+# Until that version is released you may have to apply the patch
+# yourself - yes, all 6 characters of it!
+#
+
+QUIET_SUBDIR0  = +$(MAKE) -C # space to separate -C and subdir
+QUIET_SUBDIR1  =
+
+ifneq ($(findstring $(MAKEFLAGS),w),w)
+PRINT_DIR = --no-print-directory
+else # "make -w"
+NO_SUBDIR = :
+endif
+
+ifneq ($(findstring $(MAKEFLAGS),s),s)
+ifndef V
+        QUIET_ASCIIDOC  = @echo '   ' ASCIIDOC $@;
+        QUIET_XMLTO     = @echo '   ' XMLTO $@;
+        QUIET_DB2TEXI   = @echo '   ' DB2TEXI $@;
+        QUIET_MAKEINFO  = @echo '   ' MAKEINFO $@;
+        QUIET_DBLATEX   = @echo '   ' DBLATEX $@;
+        QUIET_XSLTPROC  = @echo '   ' XSLTPROC $@;
+        QUIET_GEN       = @echo '   ' GEN $@;
+        QUIET_STDERR    = 2> /dev/null
+        QUIET_SUBDIR0   = +@subdir=
+        QUIET_SUBDIR1   = ;$(NO_SUBDIR) echo '   ' SUBDIR $$subdir; \
+                          $(MAKE) $(PRINT_DIR) -C $$subdir
+        export V
+endif
+endif
+
+all: html man
+
+html: $(DOC_HTML)
+
+$(DOC_HTML) $(DOC_MAN1) $(DOC_MAN5) $(DOC_MAN7): asciidoc.conf
+
+man: man1 man5 man7
+man1: $(DOC_MAN1)
+man5: $(DOC_MAN5)
+man7: $(DOC_MAN7)
+
+info: perf.info perfman.info
+
+pdf: user-manual.pdf
+
+install: install-man
+
+install-man: man
+        $(INSTALL) -d -m 755 $(DESTDIR)$(man1dir)
+#       $(INSTALL) -d -m 755 $(DESTDIR)$(man5dir)
+#       $(INSTALL) -d -m 755 $(DESTDIR)$(man7dir)
+        $(INSTALL) -m 644 $(DOC_MAN1) $(DESTDIR)$(man1dir)
+#       $(INSTALL) -m 644 $(DOC_MAN5) $(DESTDIR)$(man5dir)
+#       $(INSTALL) -m 644 $(DOC_MAN7) $(DESTDIR)$(man7dir)
+
+install-info: info
+        $(INSTALL) -d -m 755 $(DESTDIR)$(infodir)
+        $(INSTALL) -m 644 perf.info perfman.info $(DESTDIR)$(infodir)
+        if test -r $(DESTDIR)$(infodir)/dir; then \
+          $(INSTALL_INFO) --info-dir=$(DESTDIR)$(infodir) perf.info ;\
+          $(INSTALL_INFO) --info-dir=$(DESTDIR)$(infodir) perfman.info ;\
+        else \
+          echo "No directory found in $(DESTDIR)$(infodir)" >&2 ; \
+        fi
+
+install-pdf: pdf
+        $(INSTALL) -d -m 755 $(DESTDIR)$(pdfdir)
+        $(INSTALL) -m 644 user-manual.pdf $(DESTDIR)$(pdfdir)
+
+install-html: html
+        '$(SHELL_PATH_SQ)' ./install-webdoc.sh $(DESTDIR)$(htmldir)
+
+../PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
+        $(QUIET_SUBDIR0)../ $(QUIET_SUBDIR1) PERF-VERSION-FILE
+
+-include ../PERF-VERSION-FILE
+
+#
+# Determine "include::" file references in asciidoc files.
+#
+doc.dep : $(wildcard *.txt) build-docdep.perl
+        $(QUIET_GEN)$(RM) $@+ $@ && \
+        $(PERL_PATH) ./build-docdep.perl >$@+ $(QUIET_STDERR) && \
+        mv $@+ $@
+
+-include doc.dep
+
+cmds_txt = cmds-ancillaryinterrogators.txt \
+        cmds-ancillarymanipulators.txt \
+        cmds-mainporcelain.txt \
+        cmds-plumbinginterrogators.txt \
+        cmds-plumbingmanipulators.txt \
+        cmds-synchingrepositories.txt \
+        cmds-synchelpers.txt \
+        cmds-purehelpers.txt \
+        cmds-foreignscminterface.txt
+
+$(cmds_txt): cmd-list.made
+
+cmd-list.made: cmd-list.perl ../command-list.txt $(MAN1_TXT)
+        $(QUIET_GEN)$(RM) $@ && \
+        $(PERL_PATH) ./cmd-list.perl ../command-list.txt $(QUIET_STDERR) && \
+        date >$@
+
+clean:
+        $(RM) *.xml *.xml+ *.html *.html+ *.1 *.5 *.7
+        $(RM) *.texi *.texi+ *.texi++ perf.info perfman.info
+        $(RM) howto-index.txt howto/*.html doc.dep
+        $(RM) technical/api-*.html technical/api-index.txt
+        $(RM) $(cmds_txt) *.made
+
+$(MAN_HTML): %.html : %.txt
+        $(QUIET_ASCIIDOC)$(RM) $@+ $@ && \
+        $(ASCIIDOC) -b xhtml11 -d manpage -f asciidoc.conf \
+                $(ASCIIDOC_EXTRA) -aperf_version=$(PERF_VERSION) -o $@+ $< && \
+        mv $@+ $@
+
+%.1 %.5 %.7 : %.xml
+        $(QUIET_XMLTO)$(RM) $@ && \
+        xmlto -m $(MANPAGE_XSL) $(XMLTO_EXTRA) man $<
+
+%.xml : %.txt
+        $(QUIET_ASCIIDOC)$(RM) $@+ $@ && \
+        $(ASCIIDOC) -b docbook -d manpage -f asciidoc.conf \
+                $(ASCIIDOC_EXTRA) -aperf_version=$(PERF_VERSION) -o $@+ $< && \
+        mv $@+ $@
+
+XSLT = docbook.xsl
+XSLTOPTS = --xinclude --stringparam html.stylesheet docbook-xsl.css
+
+user-manual.html: user-manual.xml
+        $(QUIET_XSLTPROC)xsltproc $(XSLTOPTS) -o $@ $(XSLT) $<
+
+perf.info: user-manual.texi
+        $(QUIET_MAKEINFO)$(MAKEINFO) --no-split -o $@ user-manual.texi
+
+user-manual.texi: user-manual.xml
+        $(QUIET_DB2TEXI)$(RM) $@+ $@ && \
+        $(DOCBOOK2X_TEXI) user-manual.xml --encoding=UTF-8 --to-stdout >$@++ && \
+        $(PERL_PATH) fix-texi.perl <$@++ >$@+ && \
+        rm $@++ && \
+        mv $@+ $@
+
+user-manual.pdf: user-manual.xml
+        $(QUIET_DBLATEX)$(RM) $@+ $@ && \
+        $(DBLATEX) -o $@+ -p /etc/asciidoc/dblatex/asciidoc-dblatex.xsl -s /etc/asciidoc/dblatex/asciidoc-dblatex.sty $< && \
+        mv $@+ $@
+
+perfman.texi: $(MAN_XML) cat-texi.perl
+        $(QUIET_DB2TEXI)$(RM) $@+ $@ && \
+        ($(foreach xml,$(MAN_XML),$(DOCBOOK2X_TEXI) --encoding=UTF-8 \
+                --to-stdout $(xml) &&) true) > $@++ && \
+        $(PERL_PATH) cat-texi.perl $@ <$@++ >$@+ && \
+        rm $@++ && \
+        mv $@+ $@
+
+perfman.info: perfman.texi
+        $(QUIET_MAKEINFO)$(MAKEINFO) --no-split --no-validate $*.texi
+
+$(patsubst %.txt,%.texi,$(MAN_TXT)): %.texi : %.xml
+        $(QUIET_DB2TEXI)$(RM) $@+ $@ && \
+        $(DOCBOOK2X_TEXI) --to-stdout $*.xml >$@+ && \
+        mv $@+ $@
+
+howto-index.txt: howto-index.sh $(wildcard howto/*.txt)
+        $(QUIET_GEN)$(RM) $@+ $@ && \
+        '$(SHELL_PATH_SQ)' ./howto-index.sh $(wildcard howto/*.txt) >$@+ && \
+        mv $@+ $@
+
+$(patsubst %,%.html,$(ARTICLES)) : %.html : %.txt
+        $(QUIET_ASCIIDOC)$(ASCIIDOC) -b xhtml11 $*.txt
+
+WEBDOC_DEST = /pub/software/tools/perf/docs
+
+$(patsubst %.txt,%.html,$(wildcard howto/*.txt)): %.html : %.txt
+        $(QUIET_ASCIIDOC)$(RM) $@+ $@ && \
+        sed -e '1,/^$$/d' $< | $(ASCIIDOC) -b xhtml11 - >$@+ && \
+        mv $@+ $@
+
+install-webdoc : html
+        '$(SHELL_PATH_SQ)' ./install-webdoc.sh $(WEBDOC_DEST)
+
+quick-install: quick-install-man
+
+quick-install-man:
+        '$(SHELL_PATH_SQ)' ./install-doc-quick.sh $(DOC_REF) $(DESTDIR)$(mandir)
+
+quick-install-html:
+        '$(SHELL_PATH_SQ)' ./install-doc-quick.sh $(HTML_REF) $(DESTDIR)$(htmldir)
+
+.PHONY: .FORCE-PERF-VERSION-FILE
diff --git a/tools/perf/Documentation/asciidoc.conf b/tools/perf/Documentation/asciidoc.conf
new file mode 100644
index 000000000000..356b23a40339
--- /dev/null
+++ b/tools/perf/Documentation/asciidoc.conf
@@ -0,0 +1,91 @@
+## linkperf: macro
+#
+# Usage: linkperf:command[manpage-section]
+#
+# Note, {0} is the manpage section, while {target} is the command.
+#
+# Show PERF link as: <command>(<section>); if section is defined, else just show
+# the command.
+
+[macros]
+(?su)[\\]?(?P<name>linkperf):(?P<target>\S*?)\[(?P<attrlist>.*?)\]=
+
+[attributes]
+asterisk=&#42;
+plus=&#43;
+caret=&#94;
+startsb=&#91;
+endsb=&#93;
+tilde=&#126;
+
+ifdef::backend-docbook[]
+[linkperf-inlinemacro]
+{0%{target}}
+{0#<citerefentry>}
+{0#<refentrytitle>{target}</refentrytitle><manvolnum>{0}</manvolnum>}
+{0#</citerefentry>}
+endif::backend-docbook[]
+
+ifdef::backend-docbook[]
+ifndef::perf-asciidoc-no-roff[]
+# "unbreak" docbook-xsl v1.68 for manpages. v1.69 works with or without this.
+# v1.72 breaks with this because it replaces dots not in roff requests.
+[listingblock]
+<example><title>{title}</title>
+<literallayout>
+ifdef::doctype-manpage[]
+&#10;.ft C&#10;
+endif::doctype-manpage[]
+|
+ifdef::doctype-manpage[]
+&#10;.ft&#10;
+endif::doctype-manpage[]
+</literallayout>
+{title#}</example>
+endif::perf-asciidoc-no-roff[]
+
+ifdef::perf-asciidoc-no-roff[]
+ifdef::doctype-manpage[]
+# The following two small workarounds insert a simple paragraph after screen
+[listingblock]
+<example><title>{title}</title>
+<literallayout>
+|
+</literallayout><simpara></simpara>
+{title#}</example>
+
+[verseblock]
+<formalpara{id? id="{id}"}><title>{title}</title><para>
+{title%}<literallayout{id? id="{id}"}>
+{title#}<literallayout>
+|
+</literallayout>
+{title#}</para></formalpara>
+{title%}<simpara></simpara>
+endif::doctype-manpage[]
+endif::perf-asciidoc-no-roff[]
+endif::backend-docbook[]
+
+ifdef::doctype-manpage[]
+ifdef::backend-docbook[]
+[header]
+template::[header-declarations]
+<refentry>
+<refmeta>
+<refentrytitle>{mantitle}</refentrytitle>
+<manvolnum>{manvolnum}</manvolnum>
+<refmiscinfo class="source">perf</refmiscinfo>
+<refmiscinfo class="version">{perf_version}</refmiscinfo>
+<refmiscinfo class="manual">perf Manual</refmiscinfo>
+</refmeta>
+<refnamediv>
+  <refname>{manname}</refname>
+  <refpurpose>{manpurpose}</refpurpose>
+</refnamediv>
+endif::backend-docbook[]
+endif::doctype-manpage[]
+
+ifdef::backend-xhtml11[]
+[linkperf-inlinemacro]
+<a href="{target}.html">{target}{0?({0})}</a>
+endif::backend-xhtml11[]
diff --git a/tools/perf/Documentation/examples.txt b/tools/perf/Documentation/examples.txt
new file mode 100644
index 000000000000..8eb6c489fb15
--- /dev/null
+++ b/tools/perf/Documentation/examples.txt
@@ -0,0 +1,225 @@
+
+                ------------------------------
+                ****** perf by examples ******
+                ------------------------------
+
+[ From an e-mail by Ingo Molnar, http://lkml.org/lkml/2009/8/4/346 ]
+
+
+First, discovery/enumeration of available counters can be done via
+'perf list':
+
+titan:~> perf list
+  [...]
+  kmem:kmalloc                             [Tracepoint event]
+  kmem:kmem_cache_alloc                    [Tracepoint event]
+  kmem:kmalloc_node                        [Tracepoint event]
+  kmem:kmem_cache_alloc_node               [Tracepoint event]
+  kmem:kfree                               [Tracepoint event]
+  kmem:kmem_cache_free                     [Tracepoint event]
+  kmem:mm_page_free_direct                 [Tracepoint event]
+  kmem:mm_pagevec_free                     [Tracepoint event]
+  kmem:mm_page_alloc                       [Tracepoint event]
+  kmem:mm_page_alloc_zone_locked           [Tracepoint event]
+  kmem:mm_page_pcpu_drain                  [Tracepoint event]
+  kmem:mm_page_alloc_extfrag               [Tracepoint event]
+
+Then any (or all) of the above event sources can be activated and
+measured. For example the page alloc/free properties of a 'hackbench
+run' are:
+
+ titan:~> perf stat -e kmem:mm_page_pcpu_drain -e kmem:mm_page_alloc
+ -e kmem:mm_pagevec_free -e kmem:mm_page_free_direct ./hackbench 10
+ Time: 0.575
+
+ Performance counter stats for './hackbench 10':
+
+          13857  kmem:mm_page_pcpu_drain
+          27576  kmem:mm_page_alloc
+           6025  kmem:mm_pagevec_free
+          20934  kmem:mm_page_free_direct
+
+    0.613972165  seconds time elapsed
+
+You can observe the statistical properties as well, by using the
+'repeat the workload N times' feature of perf stat:
+
+ titan:~> perf stat --repeat 5 -e kmem:mm_page_pcpu_drain -e
+   kmem:mm_page_alloc -e kmem:mm_pagevec_free -e
+   kmem:mm_page_free_direct ./hackbench 10
+ Time: 0.627
+ Time: 0.644
+ Time: 0.564
+ Time: 0.559
+ Time: 0.626
+
+ Performance counter stats for './hackbench 10' (5 runs):
+
+          12920  kmem:mm_page_pcpu_drain    ( +-   3.359% )
+          25035  kmem:mm_page_alloc         ( +-   3.783% )
+           6104  kmem:mm_pagevec_free       ( +-   0.934% )
+          18376  kmem:mm_page_free_direct   ( +-   4.941% )
+
+    0.643954516  seconds time elapsed   ( +-   2.363% )
+
+Furthermore, these tracepoints can be used to sample the workload as
+well. For example the page allocations done by a 'git gc' can be
+captured the following way:
+
+ titan:~/git> perf record -f -e kmem:mm_page_alloc -c 1 ./git gc
+ Counting objects: 1148, done.
+ Delta compression using up to 2 threads.
+ Compressing objects: 100% (450/450), done.
+ Writing objects: 100% (1148/1148), done.
+ Total 1148 (delta 690), reused 1148 (delta 690)
+ [ perf record: Captured and wrote 0.267 MB perf.data (~11679 samples) ]
+
+To check which functions generated page allocations:
+
+ titan:~/git> perf report
+ # Samples: 10646
+ #
+ # Overhead          Command               Shared Object
+ # ........  ...............  ..........................
+ #
+    23.57%       git-repack  /lib64/libc-2.5.so
+    21.81%              git  /lib64/libc-2.5.so
+    14.59%              git  ./git
+    11.79%       git-repack  ./git
+     7.12%              git  /lib64/ld-2.5.so
+     3.16%       git-repack  /lib64/libpthread-2.5.so
+     2.09%       git-repack  /bin/bash
+     1.97%               rm  /lib64/libc-2.5.so
+     1.39%               mv  /lib64/ld-2.5.so
+     1.37%               mv  /lib64/libc-2.5.so
+     1.12%       git-repack  /lib64/ld-2.5.so
+     0.95%               rm  /lib64/ld-2.5.so
+     0.90%  git-update-serv  /lib64/libc-2.5.so
+     0.73%  git-update-serv  /lib64/ld-2.5.so
+     0.68%             perf  /lib64/libpthread-2.5.so
+     0.64%       git-repack  /usr/lib64/libz.so.1.2.3
+
+Or to see it on a more finegrained level:
+
+titan:~/git> perf report --sort comm,dso,symbol
+# Samples: 10646
+#
+# Overhead          Command               Shared Object  Symbol
+# ........  ...............  ..........................  ......
+#
+     9.35%       git-repack  ./git                       [.] insert_obj_hash
+     9.12%              git  ./git                       [.] insert_obj_hash
+     7.31%              git  /lib64/libc-2.5.so          [.] memcpy
+     6.34%       git-repack  /lib64/libc-2.5.so          [.] _int_malloc
+     6.24%       git-repack  /lib64/libc-2.5.so          [.] memcpy
+     5.82%       git-repack  /lib64/libc-2.5.so          [.] __GI___fork
+     5.47%              git  /lib64/libc-2.5.so          [.] _int_malloc
+     2.99%              git  /lib64/libc-2.5.so          [.] memset
+
+Furthermore, call-graph sampling can be done too, of page
+allocations - to see precisely what kind of page allocations there
+are:
+
+ titan:~/git> perf record -f -g -e kmem:mm_page_alloc -c 1 ./git gc
+ Counting objects: 1148, done.
+ Delta compression using up to 2 threads.
+ Compressing objects: 100% (450/450), done.
+ Writing objects: 100% (1148/1148), done.
+ Total 1148 (delta 690), reused 1148 (delta 690)
+ [ perf record: Captured and wrote 0.963 MB perf.data (~42069 samples) ]
+
+ titan:~/git> perf report -g
+ # Samples: 10686
+ #
+ # Overhead          Command               Shared Object
+ # ........  ...............  ..........................
+ #
+    23.25%       git-repack  /lib64/libc-2.5.so
+                |
+                |--50.00%-- _int_free
+                |
+                |--37.50%-- __GI___fork
+                |          make_child
+                |
+                |--12.50%-- ptmalloc_unlock_all2
+                |          make_child
+                |
+                 --6.25%-- __GI_strcpy
+    21.61%              git  /lib64/libc-2.5.so
+                |
+                |--30.00%-- __GI_read
+                |          |
+                |           --83.33%-- git_config_from_file
+                |                     git_config
+                |                     |
+   [...]
+
+Or you can observe the whole system's page allocations for 10
+seconds:
+
+titan:~/git> perf stat -a -e kmem:mm_page_pcpu_drain -e
+kmem:mm_page_alloc -e kmem:mm_pagevec_free -e
+kmem:mm_page_free_direct sleep 10
+
+ Performance counter stats for 'sleep 10':
+
+         171585  kmem:mm_page_pcpu_drain
+         322114  kmem:mm_page_alloc
+          73623  kmem:mm_pagevec_free
+         254115  kmem:mm_page_free_direct
+
+   10.000591410  seconds time elapsed
+
+Or observe how fluctuating the page allocations are, via statistical
+analysis done over ten 1-second intervals:
+
+ titan:~/git> perf stat --repeat 10 -a -e kmem:mm_page_pcpu_drain -e
+   kmem:mm_page_alloc -e kmem:mm_pagevec_free -e
+   kmem:mm_page_free_direct sleep 1
+
+ Performance counter stats for 'sleep 1' (10 runs):
+
+          17254  kmem:mm_page_pcpu_drain    ( +-   3.709% )
+          34394  kmem:mm_page_alloc         ( +-   4.617% )
+           7509  kmem:mm_pagevec_free       ( +-   4.820% )
+          25653  kmem:mm_page_free_direct   ( +-   3.672% )
+
+    1.058135029  seconds time elapsed   ( +-   3.089% )
+
+Or you can annotate the recorded 'git gc' run on a per symbol basis
+and check which instructions/source-code generated page allocations:
+
+ titan:~/git> perf annotate __GI___fork
+ ------------------------------------------------
+  Percent |      Source code & Disassembly of libc-2.5.so
+ ------------------------------------------------
+          :
+          :
+          :      Disassembly of section .plt:
+          :      Disassembly of section .text:
+          :
+          :      00000031a2e95560 <__fork>:
+ [...]
+     0.00 :        31a2e95602:   b8 38 00 00 00          mov    $0x38,%eax
+     0.00 :        31a2e95607:   0f 05                   syscall
+    83.42 :        31a2e95609:   48 3d 00 f0 ff ff       cmp    $0xfffffffffffff000,%rax
+     0.00 :        31a2e9560f:   0f 87 4d 01 00 00       ja     31a2e95762 <__fork+0x202>
+     0.00 :        31a2e95615:   85 c0                   test   %eax,%eax
+
+( this shows that 83.42% of __GI___fork's page allocations come from
+  the 0x38 system call it performs. )
+
+etc. etc. - a lot more is possible. I could list a dozen of
+other different usecases straight away - neither of which is
+possible via /proc/vmstat.
+
+/proc/vmstat is not in the same league really, in terms of
+expressive power of system analysis and performance
+analysis.
+
+All that the above results needed were those new tracepoints
+in include/tracing/events/kmem.h.
+
+        Ingo
+
+
diff --git a/tools/perf/Documentation/manpage-1.72.xsl b/tools/perf/Documentation/manpage-1.72.xsl
new file mode 100644
index 000000000000..b4d315cb8c47
--- /dev/null
+++ b/tools/perf/Documentation/manpage-1.72.xsl
@@ -0,0 +1,14 @@
+<!-- manpage-1.72.xsl:
+     special settings for manpages rendered from asciidoc+docbook
+     handles peculiarities in docbook-xsl 1.72.0 -->
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                version="1.0">
+
+<xsl:import href="manpage-base.xsl"/>
+
+<!-- these are the special values for the roff control characters
+     needed for docbook-xsl 1.72.0 -->
+<xsl:param name="git.docbook.backslash">&#x2593;</xsl:param>
+<xsl:param name="git.docbook.dot"      >&#x2302;</xsl:param>
+
+</xsl:stylesheet>
diff --git a/tools/perf/Documentation/manpage-base.xsl b/tools/perf/Documentation/manpage-base.xsl
new file mode 100644
index 000000000000..a264fa616093
--- /dev/null
+++ b/tools/perf/Documentation/manpage-base.xsl
@@ -0,0 +1,35 @@
+<!-- manpage-base.xsl:
+     special formatting for manpages rendered from asciidoc+docbook -->
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                version="1.0">
+
+<!-- these params silence some output from xmlto -->
+<xsl:param name="man.output.quietly" select="1"/>
+<xsl:param name="refentry.meta.get.quietly" select="1"/>
+
+<!-- convert asciidoc callouts to man page format;
+     git.docbook.backslash and git.docbook.dot params
+     must be supplied by another XSL file or other means -->
+<xsl:template match="co">
+        <xsl:value-of select="concat(
+                              $git.docbook.backslash,'fB(',
+                              substring-after(@id,'-'),')',
+                              $git.docbook.backslash,'fR')"/>
+</xsl:template>
+<xsl:template match="calloutlist">
+        <xsl:value-of select="$git.docbook.dot"/>
+        <xsl:text>sp&#10;</xsl:text>
+        <xsl:apply-templates/>
+        <xsl:text>&#10;</xsl:text>
+</xsl:template>
+<xsl:template match="callout">
+        <xsl:value-of select="concat(
+                              $git.docbook.backslash,'fB',
+                              substring-after(@arearefs,'-'),
+                              '. ',$git.docbook.backslash,'fR')"/>
+        <xsl:apply-templates/>
+        <xsl:value-of select="$git.docbook.dot"/>
+        <xsl:text>br&#10;</xsl:text>
+</xsl:template>
+
+</xsl:stylesheet>
diff --git a/tools/perf/Documentation/manpage-bold-literal.xsl b/tools/perf/Documentation/manpage-bold-literal.xsl
new file mode 100644
index 000000000000..608eb5df6281
--- /dev/null
+++ b/tools/perf/Documentation/manpage-bold-literal.xsl
@@ -0,0 +1,17 @@
+<!-- manpage-bold-literal.xsl:
+     special formatting for manpages rendered from asciidoc+docbook -->
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                version="1.0">
+
+<!-- render literal text as bold (instead of plain or monospace);
+     this makes literal text easier to distinguish in manpages
+     viewed on a tty -->
+<xsl:template match="literal">
+        <xsl:value-of select="$git.docbook.backslash"/>
+        <xsl:text>fB</xsl:text>
+        <xsl:apply-templates/>
+        <xsl:value-of select="$git.docbook.backslash"/>
+        <xsl:text>fR</xsl:text>
+</xsl:template>
+
+</xsl:stylesheet>
diff --git a/tools/perf/Documentation/manpage-normal.xsl b/tools/perf/Documentation/manpage-normal.xsl
new file mode 100644
index 000000000000..a48f5b11f3dc
--- /dev/null
+++ b/tools/perf/Documentation/manpage-normal.xsl
@@ -0,0 +1,13 @@
+<!-- manpage-normal.xsl:
+     special settings for manpages rendered from asciidoc+docbook
+     handles anything we want to keep away from docbook-xsl 1.72.0 -->
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                version="1.0">
+
+<xsl:import href="manpage-base.xsl"/>
+
+<!-- these are the normal values for the roff control characters -->
+<xsl:param name="git.docbook.backslash">\</xsl:param>
+<xsl:param name="git.docbook.dot"       >.</xsl:param>
+
+</xsl:stylesheet>
diff --git a/tools/perf/Documentation/manpage-suppress-sp.xsl b/tools/perf/Documentation/manpage-suppress-sp.xsl
new file mode 100644
index 000000000000..a63c7632a87d
--- /dev/null
+++ b/tools/perf/Documentation/manpage-suppress-sp.xsl
@@ -0,0 +1,21 @@
+<!-- manpage-suppress-sp.xsl:
+     special settings for manpages rendered from asciidoc+docbook
+     handles erroneous, inline .sp in manpage output of some
+     versions of docbook-xsl -->
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                version="1.0">
+
+<!-- attempt to work around spurious .sp at the tail of the line
+     that some versions of docbook stylesheets seem to add -->
+<xsl:template match="simpara">
+  <xsl:variable name="content">
+    <xsl:apply-templates/>
+  </xsl:variable>
+  <xsl:value-of select="normalize-space($content)"/>
+  <xsl:if test="not(ancestor::authorblurb) and
+                not(ancestor::personblurb)">
+    <xsl:text>&#10;&#10;</xsl:text>
+  </xsl:if>
+</xsl:template>
+
+</xsl:stylesheet>
diff --git a/tools/perf/Documentation/perf-annotate.txt b/tools/perf/Documentation/perf-annotate.txt
new file mode 100644
index 000000000000..c9dcade06831
--- /dev/null
+++ b/tools/perf/Documentation/perf-annotate.txt
@@ -0,0 +1,29 @@
+perf-annotate(1)
+==============
+
+NAME
+----
+perf-annotate - Read perf.data (created by perf record) and display annotated code
+
+SYNOPSIS
+--------
+[verse]
+'perf annotate' [-i <file> | --input=file] symbol_name
+
+DESCRIPTION
+-----------
+This command reads the input file and displays an annotated version of the
+code. If the object file has debug symbols then the source code will be
+displayed alongside assembly code.
+
+If there is no debug info in the object, then annotated assembly is displayed.
+
+OPTIONS
+-------
+-i::
+--input=::
+        Input file name. (default: perf.data)
+
+SEE ALSO
+--------
+linkperf:perf-record[1]
diff --git a/tools/perf/Documentation/perf-help.txt b/tools/perf/Documentation/perf-help.txt
new file mode 100644
index 000000000000..514391818d1f
--- /dev/null
+++ b/tools/perf/Documentation/perf-help.txt
@@ -0,0 +1,38 @@
+perf-help(1)
+============
+
+NAME
+----
+perf-help - display help information about perf
+
+SYNOPSIS
+--------
+'perf help' [-a|--all] [COMMAND]
+
+DESCRIPTION
+-----------
+
+With no options and no COMMAND given, the synopsis of the 'perf'
+command and a list of the most commonly used perf commands are printed
+on the standard output.
+
+If the option '--all' or '-a' is given, then all available commands are
+printed on the standard output.
+
+If a perf command is named, a manual page for that command is brought
+up. The 'man' program is used by default for this purpose, but this
+can be overridden by other options or configuration variables.
+
+Note that `perf --help ...` is identical to `perf help ...` because the
+former is internally converted into the latter.
+
+OPTIONS
+-------
+-a::
+--all::
+        Prints all the available commands on the standard output. This
+        option supersedes any other option.
+
+PERF
+----
+Part of the linkperf:perf[1] suite
diff --git a/tools/perf/Documentation/perf-list.txt b/tools/perf/Documentation/perf-list.txt
new file mode 100644
index 000000000000..8290b9422668
--- /dev/null
+++ b/tools/perf/Documentation/perf-list.txt
@@ -0,0 +1,25 @@
+perf-list(1)
+============
+
+NAME
+----
+perf-list - List all symbolic event types
+
+SYNOPSIS
+--------
+[verse]
+'perf list'
+
+DESCRIPTION
+-----------
+This command displays the symbolic event types which can be selected in the
+various perf commands with the -e option.
+
+OPTIONS
+-------
+None
+
+SEE ALSO
+--------
+linkperf:perf-stat[1], linkperf:perf-top[1],
+linkperf:perf-record[1]
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
new file mode 100644
index 000000000000..6be696b0a2bb
--- /dev/null
+++ b/tools/perf/Documentation/perf-record.txt
@@ -0,0 +1,96 @@
+perf-record(1)
+==============
+
+NAME
+----
+perf-record - Run a command and record its profile into perf.data
+
+SYNOPSIS
+--------
+[verse]
+'perf record' [-e <EVENT> | --event=EVENT] [-l] [-a] <command>
+'perf record' [-e <EVENT> | --event=EVENT] [-l] [-a] -- <command> [<options>]
+
+DESCRIPTION
+-----------
+This command runs a command and gathers a performance counter profile
+from it, into perf.data - without displaying anything.
+
+This file can then be inspected later on, using 'perf report'.
+
+
+OPTIONS
+-------
+<command>...::
+        Any command you can specify in a shell.
+
+-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.
+
+-a::
+        System-wide collection.
+
+-l::
+        Scale counter values.
+
+-p::
+--pid=::
+        Record events on existing pid.
+
+-r::
+--realtime=::
+        Collect data with this RT SCHED_FIFO priority.
+-A::
+--append::
+        Append to the output file to do incremental profiling.
+
+-f::
+--force::
+        Overwrite existing data file.
+
+-c::
+--count=::
+        Event period to sample.
+
+-o::
+--output=::
+        Output file name.
+
+-i::
+--inherit::
+        Child tasks inherit counters.
+-F::
+--freq=::
+        Profile at this frequency.
+
+-m::
+--mmap-pages=::
+        Number of mmap data pages.
+
+-g::
+--call-graph::
+        Do call-graph (stack chain/backtrace) recording.
+
+-v::
+--verbose::
+        Be more verbose (show counter open errors, etc).
+
+-s::
+--stat::
+        Per thread counts.
+
+-d::
+--data::
+        Sample addresses.
+
+-n::
+--no-samples::
+        Don't sample.
+
+SEE ALSO
+--------
+linkperf:perf-stat[1], linkperf:perf-list[1]
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
new file mode 100644
index 000000000000..e72e93110782
--- /dev/null
+++ b/tools/perf/Documentation/perf-report.txt
@@ -0,0 +1,53 @@
+perf-report(1)
+==============
+
+NAME
+----
+perf-report - Read perf.data (created by perf record) and display the profile
+
+SYNOPSIS
+--------
+[verse]
+'perf report' [-i <file> | --input=file]
+
+DESCRIPTION
+-----------
+This command displays the performance counter profile information recorded
+via perf record.
+
+OPTIONS
+-------
+-i::
+--input=::
+        Input file name. (default: perf.data)
+-d::
+--dsos=::
+        Only consider symbols in these dsos. CSV that understands
+        file://filename entries.
+-n
+--show-nr-samples
+        Show the number of samples for each symbol
+-C::
+--comms=::
+        Only consider symbols in these comms. CSV that understands
+        file://filename entries.
+-S::
+--symbols=::
+        Only consider these symbols. CSV that understands
+        file://filename entries.
+
+-w::
+--field-width=::
+        Force each column width to the provided list, for large terminal
+        readability.
+
+-t::
+--field-separator=::
+
+        Use a special separator character and don't pad with spaces, replacing
+        all occurances of this separator in symbol names (and other output)
+        with a '.' character, that thus it's the only non valid separator.
+
+SEE ALSO
+--------
+linkperf:perf-stat[1]
diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
new file mode 100644
index 000000000000..484080dd5b6f
--- /dev/null
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -0,0 +1,66 @@
+perf-stat(1)
+============
+
+NAME
+----
+perf-stat - Run a command and gather performance counter statistics
+
+SYNOPSIS
+--------
+[verse]
+'perf stat' [-e <EVENT> | --event=EVENT] [-S] [-a] <command>
+'perf stat' [-e <EVENT> | --event=EVENT] [-S] [-a] -- <command> [<options>]
+
+DESCRIPTION
+-----------
+This command runs a command and gathers performance counter statistics
+from it.
+
+
+OPTIONS
+-------
+<command>...::
+        Any command you can specify in a shell.
+
+
+-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.
+
+-i::
+--inherit::
+        child tasks inherit counters
+-p::
+--pid=<pid>::
+        stat events on existing pid
+
+-a::
+        system-wide collection
+
+-c::
+        scale counter values
+
+EXAMPLES
+--------
+
+$ perf stat -- make -j
+
+ Performance counter stats for 'make -j':
+
+    8117.370256  task clock ticks     #      11.281 CPU utilization factor
+            678  context switches     #       0.000 M/sec
+            133  CPU migrations       #       0.000 M/sec
+         235724  pagefaults           #       0.029 M/sec
+    24821162526  CPU cycles           #    3057.784 M/sec
+    18687303457  instructions         #    2302.138 M/sec
+      172158895  cache references     #      21.209 M/sec
+       27075259  cache misses         #       3.335 M/sec
+
+ Wall-clock time elapsed:   719.554352 msecs
+
+SEE ALSO
+--------
+linkperf:perf-top[1], linkperf:perf-list[1]
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
new file mode 100644
index 000000000000..4a7d558dc309
--- /dev/null
+++ b/tools/perf/Documentation/perf-top.txt
@@ -0,0 +1,125 @@
+perf-top(1)
+===========
+
+NAME
+----
+perf-top - System profiling tool.
+
+SYNOPSIS
+--------
+[verse]
+'perf top' [-e <EVENT> | --event=EVENT] [<options>]
+
+DESCRIPTION
+-----------
+This command generates and displays a performance counter profile in realtime.
+
+
+OPTIONS
+-------
+-a::
+--all-cpus::
+        System-wide collection.  (default)
+
+-c <count>::
+--count=<count>::
+        Event period to sample.
+
+-C <cpu>::
+--CPU=<cpu>::
+        CPU to profile.
+
+-d <seconds>::
+--delay=<seconds>::
+        Number of seconds to delay between refreshes.
+
+-e <event>::
+--event=<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.
+
+-E <entries>::
+--entries=<entries>::
+        Display this many functions.
+
+-f <count>::
+--count-filter=<count>::
+        Only display functions with more events than this.
+
+-F <freq>::
+--freq=<freq>::
+        Profile at this frequency.
+
+-i::
+--inherit::
+        Child tasks inherit counters, only makes sens with -p option.
+
+-k <path>::
+--vmlinux=<path>::
+        Path to vmlinux.  Required for annotation functionality.
+
+-m <pages>::
+--mmap-pages=<pages>::
+        Number of mmapped data pages.
+
+-p <pid>::
+--pid=<pid>::
+        Profile events on existing pid.
+
+-r <priority>::
+--realtime=<priority>::
+        Collect data with this RT SCHED_FIFO priority.
+
+-s <symbol>::
+--sym-annotate=<symbol>::
+        Annotate this symbol.  Requires -k option.
+
+-v::
+--verbose::
+        Be more verbose (show counter open errors, etc).
+
+-z::
+--zero::
+        Zero history across display updates.
+
+INTERACTIVE PROMPTING KEYS
+--------------------------
+
+[d]::
+        Display refresh delay.
+
+[e]::
+        Number of entries to display.
+
+[E]::
+        Event to display when multiple counters are active.
+
+[f]::
+        Profile display filter (>= hit count).
+
+[F]::
+        Annotation display filter (>= % of total).
+
+[s]::
+        Annotate symbol.
+
+[S]::
+        Stop annotation, return to full profile display.
+
+[w]::
+        Toggle between weighted sum and individual count[E]r profile.
+
+[z]::
+        Toggle event count zeroing across display updates.
+
+[qQ]::
+        Quit.
+
+Pressing any unmapped key displays a menu, and prompts for input.
+
+
+SEE ALSO
+--------
+linkperf:perf-stat[1], linkperf:perf-list[1]
diff --git a/tools/perf/Documentation/perf.txt b/tools/perf/Documentation/perf.txt
new file mode 100644
index 000000000000..69c832557199
--- /dev/null
+++ b/tools/perf/Documentation/perf.txt
@@ -0,0 +1,24 @@
+perf(1)
+=======
+
+NAME
+----
+perf - Performance analysis tools for Linux
+
+SYNOPSIS
+--------
+[verse]
+'perf' [--version] [--help] COMMAND [ARGS]
+
+DESCRIPTION
+-----------
+Performance counters for Linux are are a new kernel-based subsystem
+that provide a framework for all things performance analysis. It
+covers hardware level (CPU/PMU, Performance Monitoring Unit) features
+and software features (software counters, tracepoints) as well.
+
+SEE ALSO
+--------
+linkperf:perf-stat[1], linkperf:perf-top[1],
+linkperf:perf-record[1], linkperf:perf-report[1],
+linkperf:perf-list[1]
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
new file mode 100644
index 000000000000..c045b4271e57
--- /dev/null
+++ b/tools/perf/Makefile
@@ -0,0 +1,973 @@
+# The default target of this Makefile is...
+all::
+
+# Define V=1 to have a 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
+# have been written to the final string if enough space had been available.
+#
+# Define FREAD_READS_DIRECTORIES if your are on a system which succeeds
+# when attempting to read from an fopen'ed directory.
+#
+# Define NO_OPENSSL environment variable if you do not have OpenSSL.
+# This also implies MOZILLA_SHA1.
+#
+# Define CURLDIR=/foo/bar if your curl header and library files are in
+# /foo/bar/include and /foo/bar/lib directories.
+#
+# Define EXPATDIR=/foo/bar if your expat header and library files are in
+# /foo/bar/include and /foo/bar/lib directories.
+#
+# Define NO_D_INO_IN_DIRENT if you don't have d_ino in your struct dirent.
+#
+# Define NO_D_TYPE_IN_DIRENT if your platform defines DT_UNKNOWN but lacks
+# d_type in struct dirent (latest Cygwin -- will be fixed soonish).
+#
+# Define NO_C99_FORMAT if your formatted IO functions (printf/scanf et.al.)
+# do not support the 'size specifiers' introduced by C99, namely ll, hh,
+# j, z, t. (representing long long int, char, intmax_t, size_t, ptrdiff_t).
+# some C compilers supported these specifiers prior to C99 as an extension.
+#
+# Define NO_STRCASESTR if you don't have strcasestr.
+#
+# Define NO_MEMMEM if you don't have memmem.
+#
+# Define NO_STRTOUMAX if you don't have strtoumax in the C library.
+# If your compiler also does not support long long or does not have
+# strtoull, define NO_STRTOULL.
+#
+# Define NO_SETENV if you don't have setenv in the C library.
+#
+# Define NO_UNSETENV if you don't have unsetenv in the C library.
+#
+# Define NO_MKDTEMP if you don't have mkdtemp in the C library.
+#
+# Define NO_SYS_SELECT_H if you don't have sys/select.h.
+#
+# Define NO_SYMLINK_HEAD if you never want .perf/HEAD to be a symbolic link.
+# Enable it on Windows.  By default, symrefs are still used.
+#
+# Define NO_SVN_TESTS if you want to skip time-consuming SVN interoperability
+# tests.  These tests take up a significant amount of the total test time
+# but are not needed unless you plan to talk to SVN repos.
+#
+# Define NO_FINK if you are building on Darwin/Mac OS X, have Fink
+# installed in /sw, but don't want PERF to link against any libraries
+# installed there.  If defined you may specify your own (or Fink's)
+# include directories and library directories by defining CFLAGS
+# and LDFLAGS appropriately.
+#
+# Define NO_DARWIN_PORTS if you are building on Darwin/Mac OS X,
+# have DarwinPorts installed in /opt/local, but don't want PERF to
+# link against any libraries installed there.  If defined you may
+# specify your own (or DarwinPort's) include directories and
+# library directories by defining CFLAGS and LDFLAGS appropriately.
+#
+# Define PPC_SHA1 environment variable when running make to make use of
+# a bundled SHA1 routine optimized for PowerPC.
+#
+# Define ARM_SHA1 environment variable when running make to make use of
+# a bundled SHA1 routine optimized for ARM.
+#
+# Define MOZILLA_SHA1 environment variable when running make to make use of
+# a bundled SHA1 routine coming from Mozilla. It is GPL'd and should be fast
+# on non-x86 architectures (e.g. PowerPC), while the OpenSSL version (default
+# choice) has very fast version optimized for i586.
+#
+# Define NEEDS_SSL_WITH_CRYPTO if you need -lcrypto with -lssl (Darwin).
+#
+# Define NEEDS_LIBICONV if linking with libc is not enough (Darwin).
+#
+# Define NEEDS_SOCKET if linking with libc is not enough (SunOS,
+# Patrick Mauritz).
+#
+# Define NO_MMAP if you want to avoid mmap.
+#
+# Define NO_PTHREADS if you do not have or do not want to use Pthreads.
+#
+# Define NO_PREAD if you have a problem with pread() system call (e.g.
+# cygwin.dll before v1.5.22).
+#
+# Define NO_FAST_WORKING_DIRECTORY if accessing objects in pack files is
+# generally faster on your platform than accessing the working directory.
+#
+# Define NO_TRUSTABLE_FILEMODE if your filesystem may claim to support
+# the executable mode bit, but doesn't really do so.
+#
+# Define NO_IPV6 if you lack IPv6 support and getaddrinfo().
+#
+# Define NO_SOCKADDR_STORAGE if your platform does not have struct
+# sockaddr_storage.
+#
+# Define NO_ICONV if your libc does not properly support iconv.
+#
+# Define OLD_ICONV if your library has an old iconv(), where the second
+# (input buffer pointer) parameter is declared with type (const char **).
+#
+# Define NO_DEFLATE_BOUND if your zlib does not have deflateBound.
+#
+# Define NO_R_TO_GCC_LINKER if your gcc does not like "-R/path/lib"
+# that tells runtime paths to dynamic libraries;
+# "-Wl,-rpath=/path/lib" is used instead.
+#
+# Define USE_NSEC below if you want perf to care about sub-second file mtimes
+# and ctimes. Note that you need recent glibc (at least 2.2.4) for this, and
+# it will BREAK YOUR LOCAL DIFFS! show-diff and anything using it will likely
+# randomly break unless your underlying filesystem supports those sub-second
+# times (my ext3 doesn't).
+#
+# Define USE_ST_TIMESPEC if your "struct stat" uses "st_ctimespec" instead of
+# "st_ctim"
+#
+# Define NO_NSEC if your "struct stat" does not have "st_ctim.tv_nsec"
+# available.  This automatically turns USE_NSEC off.
+#
+# Define USE_STDEV below if you want perf to care about the underlying device
+# change being considered an inode change from the update-index perspective.
+#
+# Define NO_ST_BLOCKS_IN_STRUCT_STAT if your platform does not have st_blocks
+# field that counts the on-disk footprint in 512-byte blocks.
+#
+# Define ASCIIDOC8 if you want to format documentation with AsciiDoc 8
+#
+# Define DOCBOOK_XSL_172 if you want to format man pages with DocBook XSL v1.72.
+#
+# Define NO_PERL_MAKEMAKER if you cannot use Makefiles generated by perl's
+# MakeMaker (e.g. using ActiveState under Cygwin).
+#
+# Define NO_PERL if you do not want Perl scripts or libraries at all.
+#
+# Define INTERNAL_QSORT to use Git's implementation of qsort(), which
+# is a simplified version of the merge sort used in glibc. This is
+# recommended if Git triggers O(n^2) behavior in your platform's qsort().
+#
+# 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).
+
+PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
+        @$(SHELL_PATH) util/PERF-VERSION-GEN
+-include PERF-VERSION-FILE
+
+uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
+uname_M := $(shell sh -c 'uname -m 2>/dev/null || echo not')
+uname_O := $(shell sh -c 'uname -o 2>/dev/null || echo not')
+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')
+
+# If we're on a 64-bit kernel, use -m64
+ifndef NO_64BIT
+        ifneq ($(patsubst %64,%,$(uname_M)),$(uname_M))
+          M64 := -m64
+        endif
+endif
+
+# CFLAGS and LDFLAGS are for the users to override from the command line.
+
+CFLAGS = $(M64) -ggdb3 -Wall -Wextra -Wstrict-prototypes -Wmissing-declarations -Wmissing-prototypes -std=gnu99 -Wdeclaration-after-statement -Werror -O6
+LDFLAGS = -lpthread -lrt -lelf -lm
+ALL_CFLAGS = $(CFLAGS)
+ALL_LDFLAGS = $(LDFLAGS)
+STRIP ?= strip
+
+# Among the variables below, these:
+#   perfexecdir
+#   template_dir
+#   mandir
+#   infodir
+#   htmldir
+#   ETC_PERFCONFIG (but not sysconfdir)
+# can be specified as a relative path some/where/else;
+# this is interpreted as relative to $(prefix) and "perf" at
+# runtime figures out where they are based on the path to the executable.
+# This can help installing the suite in a relocatable way.
+
+prefix = $(HOME)
+bindir_relative = bin
+bindir = $(prefix)/$(bindir_relative)
+mandir = share/man
+infodir = share/info
+perfexecdir = libexec/perf-core
+sharedir = $(prefix)/share
+template_dir = share/perf-core/templates
+htmldir = share/doc/perf-doc
+ifeq ($(prefix),/usr)
+sysconfdir = /etc
+ETC_PERFCONFIG = $(sysconfdir)/perfconfig
+else
+sysconfdir = $(prefix)/etc
+ETC_PERFCONFIG = etc/perfconfig
+endif
+lib = lib
+# DESTDIR=
+
+export prefix bindir sharedir sysconfdir
+
+CC = gcc
+AR = ar
+RM = rm -f
+TAR = tar
+FIND = find
+INSTALL = install
+RPMBUILD = rpmbuild
+PTHREAD_LIBS = -lpthread
+
+# sparse is architecture-neutral, which means that we need to tell it
+# explicitly what architecture to check for. Fix this up for yours..
+SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
+
+
+
+### --- END CONFIGURATION SECTION ---
+
+# Those must not be GNU-specific; they are shared with perl/ which may
+# be built by a different compiler. (Note that this is an artifact now
+# but it still might be nice to keep that distinction.)
+BASIC_CFLAGS = -Iutil/include
+BASIC_LDFLAGS =
+
+# Guard against environment variables
+BUILTIN_OBJS =
+BUILT_INS =
+COMPAT_CFLAGS =
+COMPAT_OBJS =
+LIB_H =
+LIB_OBJS =
+SCRIPT_PERL =
+SCRIPT_SH =
+TEST_PROGRAMS =
+
+#
+# No scripts right now:
+#
+
+# SCRIPT_SH += perf-am.sh
+
+#
+# No Perl scripts right now:
+#
+
+# SCRIPT_PERL += perf-add--interactive.perl
+
+SCRIPTS = $(patsubst %.sh,%,$(SCRIPT_SH)) \
+          $(patsubst %.perl,%,$(SCRIPT_PERL))
+
+# Empty...
+EXTRA_PROGRAMS =
+
+# ... and all the rest that could be moved out of bindir to perfexecdir
+PROGRAMS += $(EXTRA_PROGRAMS)
+
+#
+# Single 'perf' binary right now:
+#
+PROGRAMS += perf
+
+# List built-in command $C whose implementation cmd_$C() is not in
+# builtin-$C.o but is linked in as part of some other command.
+#
+# None right now:
+#
+# BUILT_INS += perf-init $X
+
+# what 'all' will build and 'install' will install, in perfexecdir
+ALL_PROGRAMS = $(PROGRAMS) $(SCRIPTS)
+
+# what 'all' will build but not install in perfexecdir
+OTHER_PROGRAMS = perf$X
+
+# Set paths to tools early so that they can be used for version tests.
+ifndef SHELL_PATH
+        SHELL_PATH = /bin/sh
+endif
+ifndef PERL_PATH
+        PERL_PATH = /usr/bin/perl
+endif
+
+export PERL_PATH
+
+LIB_FILE=libperf.a
+
+LIB_H += ../../include/linux/perf_counter.h
+LIB_H += ../../include/linux/rbtree.h
+LIB_H += ../../include/linux/list.h
+LIB_H += util/include/linux/list.h
+LIB_H += perf.h
+LIB_H += util/types.h
+LIB_H += util/levenshtein.h
+LIB_H += util/parse-options.h
+LIB_H += util/parse-events.h
+LIB_H += util/quote.h
+LIB_H += util/util.h
+LIB_H += util/help.h
+LIB_H += util/strbuf.h
+LIB_H += util/string.h
+LIB_H += util/strlist.h
+LIB_H += util/run-command.h
+LIB_H += util/sigchain.h
+LIB_H += util/symbol.h
+LIB_H += util/module.h
+LIB_H += util/color.h
+
+LIB_OBJS += util/abspath.o
+LIB_OBJS += util/alias.o
+LIB_OBJS += util/config.o
+LIB_OBJS += util/ctype.o
+LIB_OBJS += util/environment.o
+LIB_OBJS += util/exec_cmd.o
+LIB_OBJS += util/help.o
+LIB_OBJS += util/levenshtein.o
+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/run-command.o
+LIB_OBJS += util/quote.o
+LIB_OBJS += util/strbuf.o
+LIB_OBJS += util/string.o
+LIB_OBJS += util/strlist.o
+LIB_OBJS += util/usage.o
+LIB_OBJS += util/wrapper.o
+LIB_OBJS += util/sigchain.o
+LIB_OBJS += util/symbol.o
+LIB_OBJS += util/module.o
+LIB_OBJS += util/color.o
+LIB_OBJS += util/pager.o
+LIB_OBJS += util/header.o
+LIB_OBJS += util/callchain.o
+
+BUILTIN_OBJS += builtin-annotate.o
+BUILTIN_OBJS += builtin-help.o
+BUILTIN_OBJS += builtin-list.o
+BUILTIN_OBJS += builtin-record.o
+BUILTIN_OBJS += builtin-report.o
+BUILTIN_OBJS += builtin-stat.o
+BUILTIN_OBJS += builtin-top.o
+
+PERFLIBS = $(LIB_FILE)
+
+#
+# Platform specific tweaks
+#
+
+# We choose to avoid "if .. else if .. else .. endif endif"
+# because maintaining the nesting to match is a pain.  If
+# we had "elif" things would have been much nicer...
+
+-include config.mak.autogen
+-include config.mak
+
+ifeq ($(uname_S),Darwin)
+        ifndef NO_FINK
+                ifeq ($(shell test -d /sw/lib && echo y),y)
+                        BASIC_CFLAGS += -I/sw/include
+                        BASIC_LDFLAGS += -L/sw/lib
+                endif
+        endif
+        ifndef NO_DARWIN_PORTS
+                ifeq ($(shell test -d /opt/local/lib && echo y),y)
+                        BASIC_CFLAGS += -I/opt/local/include
+                        BASIC_LDFLAGS += -L/opt/local/lib
+                endif
+        endif
+        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)
+        msg := $(error No libelf.h/libelf found, please install libelf-dev/elfutils-libelf-devel);
+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")
+
+        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")
+                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")
+                        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")
+                                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)
+                                        BASIC_CFLAGS += -DNO_DEMANGLE
+                                endif
+                        endif
+                endif
+        endif
+endif
+
+ifndef CC_LD_DYNPATH
+        ifdef NO_R_TO_GCC_LINKER
+                # Some gcc does not accept and pass -R to the linker to specify
+                # the runtime dynamic library path.
+                CC_LD_DYNPATH = -Wl,-rpath,
+        else
+                CC_LD_DYNPATH = -R
+        endif
+endif
+
+ifdef NEEDS_SOCKET
+        EXTLIBS += -lsocket
+endif
+ifdef NEEDS_NSL
+        EXTLIBS += -lnsl
+endif
+ifdef NO_D_TYPE_IN_DIRENT
+        BASIC_CFLAGS += -DNO_D_TYPE_IN_DIRENT
+endif
+ifdef NO_D_INO_IN_DIRENT
+        BASIC_CFLAGS += -DNO_D_INO_IN_DIRENT
+endif
+ifdef NO_ST_BLOCKS_IN_STRUCT_STAT
+        BASIC_CFLAGS += -DNO_ST_BLOCKS_IN_STRUCT_STAT
+endif
+ifdef USE_NSEC
+        BASIC_CFLAGS += -DUSE_NSEC
+endif
+ifdef USE_ST_TIMESPEC
+        BASIC_CFLAGS += -DUSE_ST_TIMESPEC
+endif
+ifdef NO_NSEC
+        BASIC_CFLAGS += -DNO_NSEC
+endif
+ifdef NO_C99_FORMAT
+        BASIC_CFLAGS += -DNO_C99_FORMAT
+endif
+ifdef SNPRINTF_RETURNS_BOGUS
+        COMPAT_CFLAGS += -DSNPRINTF_RETURNS_BOGUS
+        COMPAT_OBJS += compat/snprintf.o
+endif
+ifdef FREAD_READS_DIRECTORIES
+        COMPAT_CFLAGS += -DFREAD_READS_DIRECTORIES
+        COMPAT_OBJS += compat/fopen.o
+endif
+ifdef NO_SYMLINK_HEAD
+        BASIC_CFLAGS += -DNO_SYMLINK_HEAD
+endif
+ifdef NO_STRCASESTR
+        COMPAT_CFLAGS += -DNO_STRCASESTR
+        COMPAT_OBJS += compat/strcasestr.o
+endif
+ifdef NO_STRTOUMAX
+        COMPAT_CFLAGS += -DNO_STRTOUMAX
+        COMPAT_OBJS += compat/strtoumax.o
+endif
+ifdef NO_STRTOULL
+        COMPAT_CFLAGS += -DNO_STRTOULL
+endif
+ifdef NO_SETENV
+        COMPAT_CFLAGS += -DNO_SETENV
+        COMPAT_OBJS += compat/setenv.o
+endif
+ifdef NO_MKDTEMP
+        COMPAT_CFLAGS += -DNO_MKDTEMP
+        COMPAT_OBJS += compat/mkdtemp.o
+endif
+ifdef NO_UNSETENV
+        COMPAT_CFLAGS += -DNO_UNSETENV
+        COMPAT_OBJS += compat/unsetenv.o
+endif
+ifdef NO_SYS_SELECT_H
+        BASIC_CFLAGS += -DNO_SYS_SELECT_H
+endif
+ifdef NO_MMAP
+        COMPAT_CFLAGS += -DNO_MMAP
+        COMPAT_OBJS += compat/mmap.o
+else
+        ifdef USE_WIN32_MMAP
+                COMPAT_CFLAGS += -DUSE_WIN32_MMAP
+                COMPAT_OBJS += compat/win32mmap.o
+        endif
+endif
+ifdef NO_PREAD
+        COMPAT_CFLAGS += -DNO_PREAD
+        COMPAT_OBJS += compat/pread.o
+endif
+ifdef NO_FAST_WORKING_DIRECTORY
+        BASIC_CFLAGS += -DNO_FAST_WORKING_DIRECTORY
+endif
+ifdef NO_TRUSTABLE_FILEMODE
+        BASIC_CFLAGS += -DNO_TRUSTABLE_FILEMODE
+endif
+ifdef NO_IPV6
+        BASIC_CFLAGS += -DNO_IPV6
+endif
+ifdef NO_UINTMAX_T
+        BASIC_CFLAGS += -Duintmax_t=uint32_t
+endif
+ifdef NO_SOCKADDR_STORAGE
+ifdef NO_IPV6
+        BASIC_CFLAGS += -Dsockaddr_storage=sockaddr_in
+else
+        BASIC_CFLAGS += -Dsockaddr_storage=sockaddr_in6
+endif
+endif
+ifdef NO_INET_NTOP
+        LIB_OBJS += compat/inet_ntop.o
+endif
+ifdef NO_INET_PTON
+        LIB_OBJS += compat/inet_pton.o
+endif
+
+ifdef NO_ICONV
+        BASIC_CFLAGS += -DNO_ICONV
+endif
+
+ifdef OLD_ICONV
+        BASIC_CFLAGS += -DOLD_ICONV
+endif
+
+ifdef NO_DEFLATE_BOUND
+        BASIC_CFLAGS += -DNO_DEFLATE_BOUND
+endif
+
+ifdef PPC_SHA1
+        SHA1_HEADER = "ppc/sha1.h"
+        LIB_OBJS += ppc/sha1.o ppc/sha1ppc.o
+else
+ifdef ARM_SHA1
+        SHA1_HEADER = "arm/sha1.h"
+        LIB_OBJS += arm/sha1.o arm/sha1_arm.o
+else
+ifdef MOZILLA_SHA1
+        SHA1_HEADER = "mozilla-sha1/sha1.h"
+        LIB_OBJS += mozilla-sha1/sha1.o
+else
+        SHA1_HEADER = <openssl/sha.h>
+        EXTLIBS += $(LIB_4_CRYPTO)
+endif
+endif
+endif
+ifdef NO_PERL_MAKEMAKER
+        export NO_PERL_MAKEMAKER
+endif
+ifdef NO_HSTRERROR
+        COMPAT_CFLAGS += -DNO_HSTRERROR
+        COMPAT_OBJS += compat/hstrerror.o
+endif
+ifdef NO_MEMMEM
+        COMPAT_CFLAGS += -DNO_MEMMEM
+        COMPAT_OBJS += compat/memmem.o
+endif
+ifdef INTERNAL_QSORT
+        COMPAT_CFLAGS += -DINTERNAL_QSORT
+        COMPAT_OBJS += compat/qsort.o
+endif
+ifdef RUNTIME_PREFIX
+        COMPAT_CFLAGS += -DRUNTIME_PREFIX
+endif
+
+ifdef DIR_HAS_BSD_GROUP_SEMANTICS
+        COMPAT_CFLAGS += -DDIR_HAS_BSD_GROUP_SEMANTICS
+endif
+ifdef NO_EXTERNAL_GREP
+        BASIC_CFLAGS += -DNO_EXTERNAL_GREP
+endif
+
+ifeq ($(PERL_PATH),)
+NO_PERL=NoThanks
+endif
+
+QUIET_SUBDIR0  = +$(MAKE) -C # space to separate -C and subdir
+QUIET_SUBDIR1  =
+
+ifneq ($(findstring $(MAKEFLAGS),w),w)
+PRINT_DIR = --no-print-directory
+else # "make -w"
+NO_SUBDIR = :
+endif
+
+ifneq ($(findstring $(MAKEFLAGS),s),s)
+ifndef V
+        QUIET_CC       = @echo '   ' CC $@;
+        QUIET_AR       = @echo '   ' AR $@;
+        QUIET_LINK     = @echo '   ' LINK $@;
+        QUIET_BUILT_IN = @echo '   ' BUILTIN $@;
+        QUIET_GEN      = @echo '   ' GEN $@;
+        QUIET_SUBDIR0  = +@subdir=
+        QUIET_SUBDIR1  = ;$(NO_SUBDIR) echo '   ' SUBDIR $$subdir; \
+                         $(MAKE) $(PRINT_DIR) -C $$subdir
+        export V
+        export QUIET_GEN
+        export QUIET_BUILT_IN
+endif
+endif
+
+ifdef ASCIIDOC8
+        export ASCIIDOC8
+endif
+
+# Shell quote (do not use $(call) to accommodate ancient setups);
+
+SHA1_HEADER_SQ = $(subst ','\'',$(SHA1_HEADER))
+ETC_PERFCONFIG_SQ = $(subst ','\'',$(ETC_PERFCONFIG))
+
+DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
+bindir_SQ = $(subst ','\'',$(bindir))
+bindir_relative_SQ = $(subst ','\'',$(bindir_relative))
+mandir_SQ = $(subst ','\'',$(mandir))
+infodir_SQ = $(subst ','\'',$(infodir))
+perfexecdir_SQ = $(subst ','\'',$(perfexecdir))
+template_dir_SQ = $(subst ','\'',$(template_dir))
+htmldir_SQ = $(subst ','\'',$(htmldir))
+prefix_SQ = $(subst ','\'',$(prefix))
+
+SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))
+PERL_PATH_SQ = $(subst ','\'',$(PERL_PATH))
+
+LIBS = $(PERFLIBS) $(EXTLIBS)
+
+BASIC_CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER_SQ)' \
+        $(COMPAT_CFLAGS)
+LIB_OBJS += $(COMPAT_OBJS)
+
+ALL_CFLAGS += $(BASIC_CFLAGS)
+ALL_LDFLAGS += $(BASIC_LDFLAGS)
+
+export TAR INSTALL DESTDIR SHELL_PATH
+
+
+### Build rules
+
+SHELL = $(SHELL_PATH)
+
+all:: shell_compatibility_test $(ALL_PROGRAMS) $(BUILT_INS) $(OTHER_PROGRAMS) PERF-BUILD-OPTIONS
+ifneq (,$X)
+        $(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) perf$X)), test '$p' -ef '$p$X' || $(RM) '$p';)
+endif
+
+all::
+
+please_set_SHELL_PATH_to_a_more_modern_shell:
+        @$$(:)
+
+shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell
+
+strip: $(PROGRAMS) perf$X
+        $(STRIP) $(STRIP_OPTS) $(PROGRAMS) perf$X
+
+perf.o: perf.c common-cmds.h PERF-CFLAGS
+        $(QUIET_CC)$(CC) -DPERF_VERSION='"$(PERF_VERSION)"' \
+                '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
+                $(ALL_CFLAGS) -c $(filter %.c,$^)
+
+perf$X: perf.o $(BUILTIN_OBJS) $(PERFLIBS)
+        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ perf.o \
+                $(BUILTIN_OBJS) $(ALL_LDFLAGS) $(LIBS)
+
+builtin-help.o: builtin-help.c common-cmds.h PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) \
+                '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
+                '-DPERF_MAN_PATH="$(mandir_SQ)"' \
+                '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
+
+$(BUILT_INS): perf$X
+        $(QUIET_BUILT_IN)$(RM) $@ && \
+        ln perf$X $@ 2>/dev/null || \
+        ln -s perf$X $@ 2>/dev/null || \
+        cp perf$X $@
+
+common-cmds.h: util/generate-cmdlist.sh command-list.txt
+
+common-cmds.h: $(wildcard Documentation/perf-*.txt)
+        $(QUIET_GEN)util/generate-cmdlist.sh > $@+ && mv $@+ $@
+
+$(patsubst %.sh,%,$(SCRIPT_SH)) : % : %.sh
+        $(QUIET_GEN)$(RM) $@ $@+ && \
+        sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
+            -e 's|@SHELL_PATH@|$(SHELL_PATH_SQ)|' \
+            -e 's|@@PERL@@|$(PERL_PATH_SQ)|g' \
+            -e 's/@@PERF_VERSION@@/$(PERF_VERSION)/g' \
+            -e 's/@@NO_CURL@@/$(NO_CURL)/g' \
+            $@.sh >$@+ && \
+        chmod +x $@+ && \
+        mv $@+ $@
+
+configure: configure.ac
+        $(QUIET_GEN)$(RM) $@ $<+ && \
+        sed -e 's/@@PERF_VERSION@@/$(PERF_VERSION)/g' \
+            $< > $<+ && \
+        autoconf -o $@ $<+ && \
+        $(RM) $<+
+
+# These can record PERF_VERSION
+perf.o perf.spec \
+        $(patsubst %.sh,%,$(SCRIPT_SH)) \
+        $(patsubst %.perl,%,$(SCRIPT_PERL)) \
+        : PERF-VERSION-FILE
+
+%.o: %.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) $<
+%.s: %.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -S $(ALL_CFLAGS) $<
+%.o: %.S
+        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) $<
+
+util/exec_cmd.o: util/exec_cmd.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) \
+                '-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
+                '-DBINDIR="$(bindir_relative_SQ)"' \
+                '-DPREFIX="$(prefix_SQ)"' \
+                $<
+
+builtin-init-db.o: builtin-init-db.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DDEFAULT_PERF_TEMPLATE_DIR='"$(template_dir_SQ)"' $<
+
+util/config.o: util/config.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+
+util/rbtree.o: ../../lib/rbtree.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o util/rbtree.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+
+perf-%$X: %.o $(PERFLIBS)
+        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)
+
+$(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
+$(patsubst perf-%$X,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.h)
+builtin-revert.o wt-status.o: wt-status.h
+
+$(LIB_FILE): $(LIB_OBJS)
+        $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS)
+
+doc:
+        $(MAKE) -C Documentation all
+
+man:
+        $(MAKE) -C Documentation man
+
+html:
+        $(MAKE) -C Documentation html
+
+info:
+        $(MAKE) -C Documentation info
+
+pdf:
+        $(MAKE) -C Documentation pdf
+
+TAGS:
+        $(RM) TAGS
+        $(FIND) . -name '*.[hcS]' -print | xargs etags -a
+
+tags:
+        $(RM) tags
+        $(FIND) . -name '*.[hcS]' -print | xargs ctags -a
+
+cscope:
+        $(RM) cscope*
+        $(FIND) . -name '*.[hcS]' -print | xargs cscope -b
+
+### Detect prefix changes
+TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\
+             $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ)
+
+PERF-CFLAGS: .FORCE-PERF-CFLAGS
+        @FLAGS='$(TRACK_CFLAGS)'; \
+            if test x"$$FLAGS" != x"`cat PERF-CFLAGS 2>/dev/null`" ; then \
+                echo 1>&2 "    * new build flags or prefix"; \
+                echo "$$FLAGS" >PERF-CFLAGS; \
+            fi
+
+# We need to apply sq twice, once to protect from the shell
+# that runs PERF-BUILD-OPTIONS, and then again to protect it
+# and the first level quoting from the shell that runs "echo".
+PERF-BUILD-OPTIONS: .FORCE-PERF-BUILD-OPTIONS
+        @echo SHELL_PATH=\''$(subst ','\'',$(SHELL_PATH_SQ))'\' >$@
+        @echo TAR=\''$(subst ','\'',$(subst ','\'',$(TAR)))'\' >>$@
+        @echo NO_CURL=\''$(subst ','\'',$(subst ','\'',$(NO_CURL)))'\' >>$@
+        @echo NO_PERL=\''$(subst ','\'',$(subst ','\'',$(NO_PERL)))'\' >>$@
+
+### Testing rules
+
+#
+# None right now:
+#
+# TEST_PROGRAMS += test-something$X
+
+all:: $(TEST_PROGRAMS)
+
+# GNU make supports exporting all variables by "export" without parameters.
+# However, the environment gets quite big, and some programs have problems
+# with that.
+
+export NO_SVN_TESTS
+
+check: common-cmds.h
+        if sparse; \
+        then \
+                for i in *.c */*.c; \
+                do \
+                        sparse $(ALL_CFLAGS) $(SPARSE_FLAGS) $$i || exit; \
+                done; \
+        else \
+                echo 2>&1 "Did you mean 'make test'?"; \
+                exit 1; \
+        fi
+
+remove-dashes:
+        ./fixup-builtins $(BUILT_INS) $(PROGRAMS) $(SCRIPTS)
+
+### Installation rules
+
+ifneq ($(filter /%,$(firstword $(template_dir))),)
+template_instdir = $(template_dir)
+else
+template_instdir = $(prefix)/$(template_dir)
+endif
+export template_instdir
+
+ifneq ($(filter /%,$(firstword $(perfexecdir))),)
+perfexec_instdir = $(perfexecdir)
+else
+perfexec_instdir = $(prefix)/$(perfexecdir)
+endif
+perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))
+export perfexec_instdir
+
+install: all
+        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'
+        $(INSTALL) perf$X '$(DESTDIR_SQ)$(bindir_SQ)'
+ifdef BUILT_INS
+        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
+        $(INSTALL) $(BUILT_INS) '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
+ifneq (,$X)
+        $(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) perf$X)), $(RM) '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/$p';)
+endif
+endif
+
+install-doc:
+        $(MAKE) -C Documentation install
+
+install-man:
+        $(MAKE) -C Documentation install-man
+
+install-html:
+        $(MAKE) -C Documentation install-html
+
+install-info:
+        $(MAKE) -C Documentation install-info
+
+install-pdf:
+        $(MAKE) -C Documentation install-pdf
+
+quick-install-doc:
+        $(MAKE) -C Documentation quick-install
+
+quick-install-man:
+        $(MAKE) -C Documentation quick-install-man
+
+quick-install-html:
+        $(MAKE) -C Documentation quick-install-html
+
+
+### Maintainer's dist rules
+#
+# None right now
+#
+#
+# perf.spec: perf.spec.in
+#       sed -e 's/@@VERSION@@/$(PERF_VERSION)/g' < $< > $@+
+#       mv $@+ $@
+#
+# PERF_TARNAME=perf-$(PERF_VERSION)
+# dist: perf.spec perf-archive$(X) configure
+#       ./perf-archive --format=tar \
+#               --prefix=$(PERF_TARNAME)/ HEAD^{tree} > $(PERF_TARNAME).tar
+#       @mkdir -p $(PERF_TARNAME)
+#       @cp perf.spec configure $(PERF_TARNAME)
+#       @echo $(PERF_VERSION) > $(PERF_TARNAME)/version
+#       $(TAR) rf $(PERF_TARNAME).tar \
+#               $(PERF_TARNAME)/perf.spec \
+#               $(PERF_TARNAME)/configure \
+#               $(PERF_TARNAME)/version
+#       @$(RM) -r $(PERF_TARNAME)
+#       gzip -f -9 $(PERF_TARNAME).tar
+#
+# htmldocs = perf-htmldocs-$(PERF_VERSION)
+# manpages = perf-manpages-$(PERF_VERSION)
+# dist-doc:
+#       $(RM) -r .doc-tmp-dir
+#       mkdir .doc-tmp-dir
+#       $(MAKE) -C Documentation WEBDOC_DEST=../.doc-tmp-dir install-webdoc
+#       cd .doc-tmp-dir && $(TAR) cf ../$(htmldocs).tar .
+#       gzip -n -9 -f $(htmldocs).tar
+#       :
+#       $(RM) -r .doc-tmp-dir
+#       mkdir -p .doc-tmp-dir/man1 .doc-tmp-dir/man5 .doc-tmp-dir/man7
+#       $(MAKE) -C Documentation DESTDIR=./ \
+#               man1dir=../.doc-tmp-dir/man1 \
+#               man5dir=../.doc-tmp-dir/man5 \
+#               man7dir=../.doc-tmp-dir/man7 \
+#               install
+#       cd .doc-tmp-dir && $(TAR) cf ../$(manpages).tar .
+#       gzip -n -9 -f $(manpages).tar
+#       $(RM) -r .doc-tmp-dir
+#
+# rpm: dist
+#       $(RPMBUILD) -ta $(PERF_TARNAME).tar.gz
+
+### Cleaning rules
+
+distclean: clean
+#       $(RM) configure
+
+clean:
+        $(RM) *.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*
+        $(RM) -r autom4te.cache
+        $(RM) config.log config.mak.autogen config.mak.append config.status config.cache
+        $(RM) -r $(PERF_TARNAME) .doc-tmp-dir
+        $(RM) $(PERF_TARNAME).tar.gz perf-core_$(PERF_VERSION)-*.tar.gz
+        $(RM) $(htmldocs).tar.gz $(manpages).tar.gz
+        $(MAKE) -C Documentation/ clean
+        $(RM) PERF-VERSION-FILE PERF-CFLAGS PERF-BUILD-OPTIONS
+
+.PHONY: all install clean strip
+.PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
+.PHONY: .FORCE-PERF-VERSION-FILE TAGS tags cscope .FORCE-PERF-CFLAGS
+.PHONY: .FORCE-PERF-BUILD-OPTIONS
+
+### Make sure built-ins do not have dups and listed in perf.c
+#
+check-builtins::
+        ./check-builtins.sh
+
+### Test suite coverage testing
+#
+# None right now
+#
+# .PHONY: coverage coverage-clean coverage-build coverage-report
+#
+# coverage:
+#       $(MAKE) coverage-build
+#       $(MAKE) coverage-report
+#
+# coverage-clean:
+#       rm -f *.gcda *.gcno
+#
+# COVERAGE_CFLAGS = $(CFLAGS) -O0 -ftest-coverage -fprofile-arcs
+# COVERAGE_LDFLAGS = $(CFLAGS)  -O0 -lgcov
+#
+# coverage-build: coverage-clean
+#       $(MAKE) CFLAGS="$(COVERAGE_CFLAGS)" LDFLAGS="$(COVERAGE_LDFLAGS)" all
+#       $(MAKE) CFLAGS="$(COVERAGE_CFLAGS)" LDFLAGS="$(COVERAGE_LDFLAGS)" \
+#               -j1 test
+#
+# coverage-report:
+#       gcov -b *.c */*.c
+#       grep '^function.*called 0 ' *.c.gcov */*.c.gcov \
+#               | sed -e 's/\([^:]*\)\.gcov: *function \([^ ]*\) called.*/\1: \2/' \
+#               | tee coverage-untested-functions
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
new file mode 100644
index 000000000000..5e17de984dc8
--- /dev/null
+++ b/tools/perf/builtin-annotate.c
@@ -0,0 +1,1505 @@
+/*
+ * builtin-annotate.c
+ *
+ * Builtin annotate command: Analyze the perf.data input file,
+ * look up and read DSOs and symbol information and display
+ * a histogram of results, along various sorting keys.
+ */
+#include "builtin.h"
+
+#include "util/util.h"
+
+#include "util/color.h"
+#include <linux/list.h>
+#include "util/cache.h"
+#include <linux/rbtree.h>
+#include "util/symbol.h"
+#include "util/string.h"
+
+#include "perf.h"
+
+#include "util/parse-options.h"
+#include "util/parse-events.h"
+
+#define SHOW_KERNEL     1
+#define SHOW_USER       2
+#define SHOW_HV         4
+
+static char             const *input_name = "perf.data";
+static char             *vmlinux = "vmlinux";
+
+static char             default_sort_order[] = "comm,symbol";
+static char             *sort_order = default_sort_order;
+
+static int              force;
+static int              input;
+static int              show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
+
+static int              dump_trace = 0;
+#define dprintf(x...)   do { if (dump_trace) printf(x); } while (0)
+
+static int              verbose;
+
+static int              modules;
+
+static int              full_paths;
+
+static int              print_line;
+
+static unsigned long    page_size;
+static unsigned long    mmap_window = 32;
+
+struct ip_event {
+        struct perf_event_header header;
+        u64 ip;
+        u32 pid, tid;
+};
+
+struct mmap_event {
+        struct perf_event_header header;
+        u32 pid, tid;
+        u64 start;
+        u64 len;
+        u64 pgoff;
+        char filename[PATH_MAX];
+};
+
+struct comm_event {
+        struct perf_event_header header;
+        u32 pid, tid;
+        char comm[16];
+};
+
+struct fork_event {
+        struct perf_event_header header;
+        u32 pid, ppid;
+};
+
+typedef union event_union {
+        struct perf_event_header        header;
+        struct ip_event                 ip;
+        struct mmap_event               mmap;
+        struct comm_event               comm;
+        struct fork_event               fork;
+} event_t;
+
+
+struct sym_ext {
+        struct rb_node  node;
+        double          percent;
+        char            *path;
+};
+
+static LIST_HEAD(dsos);
+static struct dso *kernel_dso;
+static struct dso *vdso;
+
+
+static void dsos__add(struct dso *dso)
+{
+        list_add_tail(&dso->node, &dsos);
+}
+
+static struct dso *dsos__find(const char *name)
+{
+        struct dso *pos;
+
+        list_for_each_entry(pos, &dsos, node)
+                if (strcmp(pos->name, name) == 0)
+                        return pos;
+        return NULL;
+}
+
+static struct dso *dsos__findnew(const char *name)
+{
+        struct dso *dso = dsos__find(name);
+        int nr;
+
+        if (dso)
+                return dso;
+
+        dso = dso__new(name, 0);
+        if (!dso)
+                goto out_delete_dso;
+
+        nr = dso__load(dso, NULL, verbose);
+        if (nr < 0) {
+                if (verbose)
+                        fprintf(stderr, "Failed to open: %s\n", name);
+                goto out_delete_dso;
+        }
+        if (!nr && verbose) {
+                fprintf(stderr,
+                "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(FILE *fp)
+{
+        struct dso *pos;
+
+        list_for_each_entry(pos, &dsos, node)
+                dso__fprintf(pos, fp);
+}
+
+static struct symbol *vdso__find_symbol(struct dso *dso, u64 ip)
+{
+        return dso__find_symbol(dso, ip);
+}
+
+static int load_kernel(void)
+{
+        int err;
+
+        kernel_dso = dso__new("[kernel]", 0);
+        if (!kernel_dso)
+                return -1;
+
+        err = dso__load_kernel(kernel_dso, vmlinux, NULL, verbose, modules);
+        if (err <= 0) {
+                dso__delete(kernel_dso);
+                kernel_dso = NULL;
+        } else
+                dsos__add(kernel_dso);
+
+        vdso = dso__new("[vdso]", 0);
+        if (!vdso)
+                return -1;
+
+        vdso->find_symbol = vdso__find_symbol;
+
+        dsos__add(vdso);
+
+        return err;
+}
+
+struct map {
+        struct list_head node;
+        u64      start;
+        u64      end;
+        u64      pgoff;
+        u64      (*map_ip)(struct map *, u64);
+        struct dso       *dso;
+};
+
+static u64 map__map_ip(struct map *map, u64 ip)
+{
+        return ip - map->start + map->pgoff;
+}
+
+static u64 vdso__map_ip(struct map *map __used, u64 ip)
+{
+        return ip;
+}
+
+static struct map *map__new(struct mmap_event *event)
+{
+        struct map *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                const char *filename = event->filename;
+
+                self->start = event->start;
+                self->end   = event->start + event->len;
+                self->pgoff = event->pgoff;
+
+                self->dso = dsos__findnew(filename);
+                if (self->dso == NULL)
+                        goto out_delete;
+
+                if (self->dso == vdso)
+                        self->map_ip = vdso__map_ip;
+                else
+                        self->map_ip = map__map_ip;
+        }
+        return self;
+out_delete:
+        free(self);
+        return NULL;
+}
+
+static struct map *map__clone(struct map *self)
+{
+        struct map *map = malloc(sizeof(*self));
+
+        if (!map)
+                return NULL;
+
+        memcpy(map, self, sizeof(*self));
+
+        return map;
+}
+
+static int map__overlap(struct map *l, struct map *r)
+{
+        if (l->start > r->start) {
+                struct map *t = l;
+                l = r;
+                r = t;
+        }
+
+        if (l->end > r->start)
+                return 1;
+
+        return 0;
+}
+
+static size_t map__fprintf(struct map *self, FILE *fp)
+{
+        return fprintf(fp, " %Lx-%Lx %Lx %s\n",
+                       self->start, self->end, self->pgoff, self->dso->name);
+}
+
+
+struct thread {
+        struct rb_node   rb_node;
+        struct list_head maps;
+        pid_t            pid;
+        char             *comm;
+};
+
+static struct thread *thread__new(pid_t pid)
+{
+        struct thread *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                self->pid = pid;
+                self->comm = malloc(32);
+                if (self->comm)
+                        snprintf(self->comm, 32, ":%d", self->pid);
+                INIT_LIST_HEAD(&self->maps);
+        }
+
+        return self;
+}
+
+static int thread__set_comm(struct thread *self, const char *comm)
+{
+        if (self->comm)
+                free(self->comm);
+        self->comm = strdup(comm);
+        return self->comm ? 0 : -ENOMEM;
+}
+
+static size_t thread__fprintf(struct thread *self, FILE *fp)
+{
+        struct map *pos;
+        size_t ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
+
+        list_for_each_entry(pos, &self->maps, node)
+                ret += map__fprintf(pos, fp);
+
+        return ret;
+}
+
+
+static struct rb_root threads;
+static struct thread *last_match;
+
+static struct thread *threads__findnew(pid_t pid)
+{
+        struct rb_node **p = &threads.rb_node;
+        struct rb_node *parent = NULL;
+        struct thread *th;
+
+        /*
+         * Font-end cache - PID lookups come in blocks,
+         * so most of the time we dont have to look up
+         * the full rbtree:
+         */
+        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;
+                        return th;
+                }
+
+                if (pid < th->pid)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        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;
+        }
+
+        return th;
+}
+
+static void thread__insert_map(struct thread *self, struct map *map)
+{
+        struct map *pos, *tmp;
+
+        list_for_each_entry_safe(pos, tmp, &self->maps, node) {
+                if (map__overlap(pos, map)) {
+                        list_del_init(&pos->node);
+                        /* XXX leaks dsos */
+                        free(pos);
+                }
+        }
+
+        list_add_tail(&map->node, &self->maps);
+}
+
+static int thread__fork(struct thread *self, struct thread *parent)
+{
+        struct map *map;
+
+        if (self->comm)
+                free(self->comm);
+        self->comm = strdup(parent->comm);
+        if (!self->comm)
+                return -ENOMEM;
+
+        list_for_each_entry(map, &parent->maps, node) {
+                struct map *new = map__clone(map);
+                if (!new)
+                        return -ENOMEM;
+                thread__insert_map(self, new);
+        }
+
+        return 0;
+}
+
+static struct map *thread__find_map(struct thread *self, u64 ip)
+{
+        struct map *pos;
+
+        if (self == NULL)
+                return NULL;
+
+        list_for_each_entry(pos, &self->maps, node)
+                if (ip >= pos->start && ip <= pos->end)
+                        return pos;
+
+        return NULL;
+}
+
+static size_t threads__fprintf(FILE *fp)
+{
+        size_t ret = 0;
+        struct rb_node *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);
+        }
+
+        return ret;
+}
+
+/*
+ * histogram, sorted on item, collects counts
+ */
+
+static struct rb_root hist;
+
+struct hist_entry {
+        struct rb_node   rb_node;
+
+        struct thread    *thread;
+        struct map       *map;
+        struct dso       *dso;
+        struct symbol    *sym;
+        u64      ip;
+        char             level;
+
+        uint32_t         count;
+};
+
+/*
+ * configurable sorting bits
+ */
+
+struct sort_entry {
+        struct list_head list;
+
+        char *header;
+
+        int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
+        int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
+        size_t  (*print)(FILE *fp, struct hist_entry *);
+};
+
+/* --sort pid */
+
+static int64_t
+sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return right->thread->pid - left->thread->pid;
+}
+
+static size_t
+sort__thread_print(FILE *fp, struct hist_entry *self)
+{
+        return fprintf(fp, "%16s:%5d", self->thread->comm ?: "", self->thread->pid);
+}
+
+static struct sort_entry sort_thread = {
+        .header = "         Command:  Pid",
+        .cmp    = sort__thread_cmp,
+        .print  = sort__thread_print,
+};
+
+/* --sort comm */
+
+static int64_t
+sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return right->thread->pid - left->thread->pid;
+}
+
+static int64_t
+sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
+{
+        char *comm_l = left->thread->comm;
+        char *comm_r = right->thread->comm;
+
+        if (!comm_l || !comm_r) {
+                if (!comm_l && !comm_r)
+                        return 0;
+                else if (!comm_l)
+                        return -1;
+                else
+                        return 1;
+        }
+
+        return strcmp(comm_l, comm_r);
+}
+
+static size_t
+sort__comm_print(FILE *fp, struct hist_entry *self)
+{
+        return fprintf(fp, "%16s", self->thread->comm);
+}
+
+static struct sort_entry sort_comm = {
+        .header         = "         Command",
+        .cmp            = sort__comm_cmp,
+        .collapse       = sort__comm_collapse,
+        .print          = sort__comm_print,
+};
+
+/* --sort dso */
+
+static int64_t
+sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct dso *dso_l = left->dso;
+        struct dso *dso_r = right->dso;
+
+        if (!dso_l || !dso_r) {
+                if (!dso_l && !dso_r)
+                        return 0;
+                else if (!dso_l)
+                        return -1;
+                else
+                        return 1;
+        }
+
+        return strcmp(dso_l->name, dso_r->name);
+}
+
+static size_t
+sort__dso_print(FILE *fp, struct hist_entry *self)
+{
+        if (self->dso)
+                return fprintf(fp, "%-25s", self->dso->name);
+
+        return fprintf(fp, "%016llx         ", (u64)self->ip);
+}
+
+static struct sort_entry sort_dso = {
+        .header = "Shared Object            ",
+        .cmp    = sort__dso_cmp,
+        .print  = sort__dso_print,
+};
+
+/* --sort symbol */
+
+static int64_t
+sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        u64 ip_l, ip_r;
+
+        if (left->sym == right->sym)
+                return 0;
+
+        ip_l = left->sym ? left->sym->start : left->ip;
+        ip_r = right->sym ? right->sym->start : right->ip;
+
+        return (int64_t)(ip_r - ip_l);
+}
+
+static size_t
+sort__sym_print(FILE *fp, struct hist_entry *self)
+{
+        size_t ret = 0;
+
+        if (verbose)
+                ret += fprintf(fp, "%#018llx  ", (u64)self->ip);
+
+        if (self->sym) {
+                ret += fprintf(fp, "[%c] %s",
+                        self->dso == kernel_dso ? 'k' : '.', self->sym->name);
+        } else {
+                ret += fprintf(fp, "%#016llx", (u64)self->ip);
+        }
+
+        return ret;
+}
+
+static struct sort_entry sort_sym = {
+        .header = "Symbol",
+        .cmp    = sort__sym_cmp,
+        .print  = sort__sym_print,
+};
+
+static int sort__need_collapse = 0;
+
+struct sort_dimension {
+        char                    *name;
+        struct sort_entry       *entry;
+        int                     taken;
+};
+
+static struct sort_dimension sort_dimensions[] = {
+        { .name = "pid",        .entry = &sort_thread,  },
+        { .name = "comm",       .entry = &sort_comm,    },
+        { .name = "dso",        .entry = &sort_dso,     },
+        { .name = "symbol",     .entry = &sort_sym,     },
+};
+
+static LIST_HEAD(hist_entry__sort_list);
+
+static int sort_dimension__add(char *tok)
+{
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
+                struct sort_dimension *sd = &sort_dimensions[i];
+
+                if (sd->taken)
+                        continue;
+
+                if (strncasecmp(tok, sd->name, strlen(tok)))
+                        continue;
+
+                if (sd->entry->collapse)
+                        sort__need_collapse = 1;
+
+                list_add_tail(&sd->entry->list, &hist_entry__sort_list);
+                sd->taken = 1;
+
+                return 0;
+        }
+
+        return -ESRCH;
+}
+
+static int64_t
+hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct sort_entry *se;
+        int64_t cmp = 0;
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                cmp = se->cmp(left, right);
+                if (cmp)
+                        break;
+        }
+
+        return cmp;
+}
+
+static int64_t
+hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
+{
+        struct sort_entry *se;
+        int64_t cmp = 0;
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                int64_t (*f)(struct hist_entry *, struct hist_entry *);
+
+                f = se->collapse ?: se->cmp;
+
+                cmp = f(left, right);
+                if (cmp)
+                        break;
+        }
+
+        return cmp;
+}
+
+/*
+ * collect histogram counts
+ */
+static void hist_hit(struct hist_entry *he, u64 ip)
+{
+        unsigned int sym_size, offset;
+        struct symbol *sym = he->sym;
+
+        he->count++;
+
+        if (!sym || !sym->hist)
+                return;
+
+        sym_size = sym->end - sym->start;
+        offset = ip - sym->start;
+
+        if (offset >= sym_size)
+                return;
+
+        sym->hist_sum++;
+        sym->hist[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]);
+}
+
+static int
+hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
+                struct symbol *sym, u64 ip, char level)
+{
+        struct rb_node **p = &hist.rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *he;
+        struct hist_entry entry = {
+                .thread = thread,
+                .map    = map,
+                .dso    = dso,
+                .sym    = sym,
+                .ip     = ip,
+                .level  = level,
+                .count  = 1,
+        };
+        int cmp;
+
+        while (*p != NULL) {
+                parent = *p;
+                he = rb_entry(parent, struct hist_entry, rb_node);
+
+                cmp = hist_entry__cmp(&entry, he);
+
+                if (!cmp) {
+                        hist_hit(he, ip);
+
+                        return 0;
+                }
+
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        he = malloc(sizeof(*he));
+        if (!he)
+                return -ENOMEM;
+        *he = entry;
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, &hist);
+
+        return 0;
+}
+
+static void hist_entry__free(struct hist_entry *he)
+{
+        free(he);
+}
+
+/*
+ * collapse the histogram
+ */
+
+static struct rb_root collapse_hists;
+
+static void collapse__insert_entry(struct hist_entry *he)
+{
+        struct rb_node **p = &collapse_hists.rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *iter;
+        int64_t cmp;
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct hist_entry, rb_node);
+
+                cmp = hist_entry__collapse(iter, he);
+
+                if (!cmp) {
+                        iter->count += he->count;
+                        hist_entry__free(he);
+                        return;
+                }
+
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, &collapse_hists);
+}
+
+static void collapse__resort(void)
+{
+        struct rb_node *next;
+        struct hist_entry *n;
+
+        if (!sort__need_collapse)
+                return;
+
+        next = rb_first(&hist);
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                next = rb_next(&n->rb_node);
+
+                rb_erase(&n->rb_node, &hist);
+                collapse__insert_entry(n);
+        }
+}
+
+/*
+ * reverse the map, sort on count.
+ */
+
+static struct rb_root output_hists;
+
+static void output__insert_entry(struct hist_entry *he)
+{
+        struct rb_node **p = &output_hists.rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *iter;
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct hist_entry, rb_node);
+
+                if (he->count > iter->count)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, &output_hists);
+}
+
+static void output__resort(void)
+{
+        struct rb_node *next;
+        struct hist_entry *n;
+        struct rb_root *tree = &hist;
+
+        if (sort__need_collapse)
+                tree = &collapse_hists;
+
+        next = rb_first(tree);
+
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                next = rb_next(&n->rb_node);
+
+                rb_erase(&n->rb_node, tree);
+                output__insert_entry(n);
+        }
+}
+
+static void register_idle_thread(void)
+{
+        struct thread *thread = threads__findnew(0);
+
+        if (thread == NULL ||
+                        thread__set_comm(thread, "[idle]")) {
+                fprintf(stderr, "problem inserting idle task.\n");
+                exit(-1);
+        }
+}
+
+static unsigned long total = 0,
+                     total_mmap = 0,
+                     total_comm = 0,
+                     total_fork = 0,
+                     total_unknown = 0;
+
+static int
+process_sample_event(event_t *event, unsigned long offset, unsigned long head)
+{
+        char level;
+        int show = 0;
+        struct dso *dso = NULL;
+        struct thread *thread = threads__findnew(event->ip.pid);
+        u64 ip = event->ip.ip;
+        struct map *map = NULL;
+
+        dprintf("%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);
+
+        dprintf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
+        if (thread == NULL) {
+                fprintf(stderr, "problem processing %d event, skipping it.\n",
+                        event->header.type);
+                return -1;
+        }
+
+        if (event->header.misc & PERF_EVENT_MISC_KERNEL) {
+                show = SHOW_KERNEL;
+                level = 'k';
+
+                dso = kernel_dso;
+
+                dprintf(" ...... dso: %s\n", dso->name);
+
+        } else if (event->header.misc & PERF_EVENT_MISC_USER) {
+
+                show = SHOW_USER;
+                level = '.';
+
+                map = thread__find_map(thread, ip);
+                if (map != NULL) {
+                        ip = map->map_ip(map, ip);
+                        dso = map->dso;
+                } else {
+                        /*
+                         * If this is outside of all known maps,
+                         * and is a negative address, try to look it
+                         * up in the kernel dso, as it might be a
+                         * vsyscall (which executes in user-mode):
+                         */
+                        if ((long long)ip < 0)
+                                dso = kernel_dso;
+                }
+                dprintf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
+
+        } else {
+                show = SHOW_HV;
+                level = 'H';
+                dprintf(" ...... dso: [hypervisor]\n");
+        }
+
+        if (show & show_mask) {
+                struct symbol *sym = NULL;
+
+                if (dso)
+                        sym = dso->find_symbol(dso, ip);
+
+                if (hist_entry__add(thread, map, dso, sym, ip, level)) {
+                        fprintf(stderr,
+                "problem incrementing symbol count, skipping event\n");
+                        return -1;
+                }
+        }
+        total++;
+
+        return 0;
+}
+
+static int
+process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
+{
+        struct thread *thread = threads__findnew(event->mmap.pid);
+        struct map *map = map__new(&event->mmap);
+
+        dprintf("%p [%p]: PERF_EVENT_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) {
+                dprintf("problem processing PERF_EVENT_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 = threads__findnew(event->comm.pid);
+
+        dprintf("%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)) {
+                dprintf("problem processing PERF_EVENT_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 = threads__findnew(event->fork.pid);
+        struct thread *parent = threads__findnew(event->fork.ppid);
+
+        dprintf("%p [%p]: PERF_EVENT_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)) {
+                dprintf("problem processing PERF_EVENT_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_EVENT_SAMPLE:
+                return process_sample_event(event, offset, head);
+
+        case PERF_EVENT_MMAP:
+                return process_mmap_event(event, offset, head);
+
+        case PERF_EVENT_COMM:
+                return process_comm_event(event, offset, head);
+
+        case PERF_EVENT_FORK:
+                return process_fork_event(event, offset, head);
+        /*
+         * We dont process them right now but they are fine:
+         */
+
+        case PERF_EVENT_THROTTLE:
+        case PERF_EVENT_UNTHROTTLE:
+                return 0;
+
+        default:
+                return -1;
+        }
+
+        return 0;
+}
+
+static int
+parse_line(FILE *file, struct symbol *sym, u64 start, u64 len)
+{
+        char *line = NULL, *tmp, *tmp2;
+        static const char *prev_line;
+        static const char *prev_color;
+        unsigned int offset;
+        size_t line_len;
+        s64 line_ip;
+        int ret;
+        char *c;
+
+        if (getline(&line, &line_len, file) < 0)
+                return -1;
+        if (!line)
+                return -1;
+
+        c = strchr(line, '\n');
+        if (c)
+                *c = 0;
+
+        line_ip = -1;
+        offset = 0;
+        ret = -2;
+
+        /*
+         * Strip leading spaces:
+         */
+        tmp = line;
+        while (*tmp) {
+                if (*tmp != ' ')
+                        break;
+                tmp++;
+        }
+
+        if (*tmp) {
+                /*
+                 * Parse hexa addresses followed by ':'
+                 */
+                line_ip = strtoull(tmp, &tmp2, 16);
+                if (*tmp2 != ':')
+                        line_ip = -1;
+        }
+
+        if (line_ip != -1) {
+                const char *path = NULL;
+                unsigned int hits = 0;
+                double percent = 0.0;
+                char *color;
+                struct sym_ext *sym_ext = sym->priv;
+
+                offset = line_ip - start;
+                if (offset < len)
+                        hits = sym->hist[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;
+
+                color = get_percent_color(percent);
+
+                /*
+                 * Also color the filename and line if needed, with
+                 * the same color than the percentage. Don't print it
+                 * twice for close colored ip with the same filename:line
+                 */
+                if (path) {
+                        if (!prev_line || strcmp(prev_line, path)
+                                       || color != prev_color) {
+                                color_fprintf(stdout, color, " %s", path);
+                                prev_line = path;
+                                prev_color = color;
+                        }
+                }
+
+                color_fprintf(stdout, color, " %7.2f", percent);
+                printf(" :      ");
+                color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", line);
+        } else {
+                if (!*line)
+                        printf("         :\n");
+                else
+                        printf("         :      %s\n", line);
+        }
+
+        return 0;
+}
+
+static struct rb_root root_sym_ext;
+
+static void insert_source_line(struct sym_ext *sym_ext)
+{
+        struct sym_ext *iter;
+        struct rb_node **p = &root_sym_ext.rb_node;
+        struct rb_node *parent = NULL;
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct sym_ext, node);
+
+                if (sym_ext->percent > iter->percent)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&sym_ext->node, parent, p);
+        rb_insert_color(&sym_ext->node, &root_sym_ext);
+}
+
+static void free_source_line(struct symbol *sym, int len)
+{
+        struct sym_ext *sym_ext = sym->priv;
+        int i;
+
+        if (!sym_ext)
+                return;
+
+        for (i = 0; i < len; i++)
+                free(sym_ext[i].path);
+        free(sym_ext);
+
+        sym->priv = NULL;
+        root_sym_ext = RB_ROOT;
+}
+
+/* Get the filename:line for the colored entries */
+static void
+get_source_line(struct symbol *sym, u64 start, int len, char *filename)
+{
+        int i;
+        char cmd[PATH_MAX * 2];
+        struct sym_ext *sym_ext;
+
+        if (!sym->hist_sum)
+                return;
+
+        sym->priv = calloc(len, sizeof(struct sym_ext));
+        if (!sym->priv)
+                return;
+
+        sym_ext = sym->priv;
+
+        for (i = 0; i < len; i++) {
+                char *path = NULL;
+                size_t line_len;
+                u64 offset;
+                FILE *fp;
+
+                sym_ext[i].percent = 100.0 * sym->hist[i] / sym->hist_sum;
+                if (sym_ext[i].percent <= 0.5)
+                        continue;
+
+                offset = start + i;
+                sprintf(cmd, "addr2line -e %s %016llx", filename, offset);
+                fp = popen(cmd, "r");
+                if (!fp)
+                        continue;
+
+                if (getline(&path, &line_len, fp) < 0 || !line_len)
+                        goto next;
+
+                sym_ext[i].path = malloc(sizeof(char) * line_len + 1);
+                if (!sym_ext[i].path)
+                        goto next;
+
+                strcpy(sym_ext[i].path, path);
+                insert_source_line(&sym_ext[i]);
+
+        next:
+                pclose(fp);
+        }
+}
+
+static void print_summary(char *filename)
+{
+        struct sym_ext *sym_ext;
+        struct rb_node *node;
+
+        printf("\nSorted summary for file %s\n", filename);
+        printf("----------------------------------------------\n\n");
+
+        if (RB_EMPTY_ROOT(&root_sym_ext)) {
+                printf(" Nothing higher than %1.1f%%\n", MIN_GREEN);
+                return;
+        }
+
+        node = rb_first(&root_sym_ext);
+        while (node) {
+                double percent;
+                char *color;
+                char *path;
+
+                sym_ext = rb_entry(node, struct sym_ext, node);
+                percent = sym_ext->percent;
+                color = get_percent_color(percent);
+                path = sym_ext->path;
+
+                color_fprintf(stdout, color, " %7.2f %s", percent, path);
+                node = rb_next(node);
+        }
+}
+
+static void annotate_sym(struct dso *dso, struct symbol *sym)
+{
+        char *filename = dso->name, *d_filename;
+        u64 start, end, len;
+        char command[PATH_MAX*2];
+        FILE *file;
+
+        if (!filename)
+                return;
+        if (sym->module)
+                filename = sym->module->path;
+        else if (dso == kernel_dso)
+                filename = vmlinux;
+
+        start = sym->obj_start;
+        if (!start)
+                start = sym->start;
+        if (full_paths)
+                d_filename = filename;
+        else
+                d_filename = basename(filename);
+
+        end = start + sym->end - sym->start + 1;
+        len = sym->end - sym->start;
+
+        if (print_line) {
+                get_source_line(sym, start, len, filename);
+                print_summary(filename);
+        }
+
+        printf("\n\n------------------------------------------------\n");
+        printf(" Percent |      Source code & Disassembly of %s\n", d_filename);
+        printf("------------------------------------------------\n");
+
+        if (verbose >= 2)
+                printf("annotating [%p] %30s : [%p] %30s\n", dso, dso->name, sym, sym->name);
+
+        sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s|grep -v %s",
+                        (u64)start, (u64)end, filename, filename);
+
+        if (verbose >= 3)
+                printf("doing: %s\n", command);
+
+        file = popen(command, "r");
+        if (!file)
+                return;
+
+        while (!feof(file)) {
+                if (parse_line(file, sym, start, len) < 0)
+                        break;
+        }
+
+        pclose(file);
+        if (print_line)
+                free_source_line(sym, len);
+}
+
+static void find_annotations(void)
+{
+        struct rb_node *nd;
+        struct dso *dso;
+        int count = 0;
+
+        list_for_each_entry(dso, &dsos, node) {
+
+                for (nd = rb_first(&dso->syms); nd; nd = rb_next(nd)) {
+                        struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
+
+                        if (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 stat;
+        event_t *event;
+        uint32_t size;
+        char *buf;
+
+        register_idle_thread();
+
+        input = open(input_name, O_RDONLY);
+        if (input < 0) {
+                perror("failed to open file");
+                exit(-1);
+        }
+
+        ret = fstat(input, &stat);
+        if (ret < 0) {
+                perror("failed to stat file");
+                exit(-1);
+        }
+
+        if (!force && (stat.st_uid != geteuid())) {
+                fprintf(stderr, "file: %s not owned by current user\n", input_name);
+                exit(-1);
+        }
+
+        if (!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 ret;
+
+                ret = munmap(buf, page_size * mmap_window);
+                assert(ret == 0);
+
+                offset += shift;
+                head -= shift;
+                goto remap;
+        }
+
+        size = event->header.size;
+
+        dprintf("%p [%p]: event: %d\n",
+                        (void *)(offset + head),
+                        (void *)(long)event->header.size,
+                        event->header.type);
+
+        if (!size || process_event(event, offset, head) < 0) {
+
+                dprintf("%p [%p]: skipping unknown header type: %d\n",
+                        (void *)(offset + head),
+                        (void *)(long)(event->header.size),
+                        event->header.type);
+
+                total_unknown++;
+
+                /*
+                 * assume we lost track of the stream, check alignment, and
+                 * increment a single u64 in the hope to catch on again 'soon'.
+                 */
+
+                if (unlikely(head & 7))
+                        head &= ~7ULL;
+
+                size = 8;
+        }
+
+        head += size;
+
+        if (offset + head < (unsigned long)stat.st_size)
+                goto more;
+
+        rc = EXIT_SUCCESS;
+        close(input);
+
+        dprintf("      IP events: %10ld\n", total);
+        dprintf("    mmap events: %10ld\n", total_mmap);
+        dprintf("    comm events: %10ld\n", total_comm);
+        dprintf("    fork events: %10ld\n", total_fork);
+        dprintf(" unknown events: %10ld\n", total_unknown);
+
+        if (dump_trace)
+                return 0;
+
+        if (verbose >= 3)
+                threads__fprintf(stdout);
+
+        if (verbose >= 2)
+                dsos__fprintf(stdout);
+
+        collapse__resort();
+        output__resort();
+
+        find_annotations();
+
+        return rc;
+}
+
+static const char * const annotate_usage[] = {
+        "perf annotate [<options>] <command>",
+        NULL
+};
+
+static const struct option options[] = {
+        OPT_STRING('i', "input", &input_name, "file",
+                    "input file name"),
+        OPT_STRING('s', "symbol", &sym_hist_filter, "symbol",
+                    "symbol to annotate"),
+        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose (show symbol address, etc)"),
+        OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
+                    "dump raw trace in ASCII"),
+        OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
+        OPT_BOOLEAN('m', "modules", &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)"),
+        OPT_BOOLEAN('P', "full-paths", &full_paths,
+                    "Don't shorten the displayed pathnames"),
+        OPT_END()
+};
+
+static void setup_sorting(void)
+{
+        char *tmp, *tok, *str = strdup(sort_order);
+
+        for (tok = strtok_r(str, ", ", &tmp);
+                        tok; tok = strtok_r(NULL, ", ", &tmp)) {
+                if (sort_dimension__add(tok) < 0) {
+                        error("Unknown --sort key: `%s'", tok);
+                        usage_with_options(annotate_usage, options);
+                }
+        }
+
+        free(str);
+}
+
+int cmd_annotate(int argc, const char **argv, const char *prefix __used)
+{
+        symbol__init();
+
+        page_size = getpagesize();
+
+        argc = parse_options(argc, argv, options, annotate_usage, 0);
+
+        setup_sorting();
+
+        if (argc) {
+                /*
+                 * Special case: if there's an argument left then assume tha
+                 * it's a symbol filter:
+                 */
+                if (argc > 1)
+                        usage_with_options(annotate_usage, options);
+
+                sym_hist_filter = argv[0];
+        }
+
+        if (!sym_hist_filter)
+                usage_with_options(annotate_usage, options);
+
+        setup_pager();
+
+        return __cmd_annotate();
+}
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
new file mode 100644
index 000000000000..2599d86a733b
--- /dev/null
+++ b/tools/perf/builtin-help.c
@@ -0,0 +1,463 @@
+/*
+ * builtin-help.c
+ *
+ * Builtin help command
+ */
+#include "perf.h"
+#include "util/cache.h"
+#include "builtin.h"
+#include "util/exec_cmd.h"
+#include "common-cmds.h"
+#include "util/parse-options.h"
+#include "util/run-command.h"
+#include "util/help.h"
+
+static struct man_viewer_list {
+        struct man_viewer_list *next;
+        char name[FLEX_ARRAY];
+} *man_viewer_list;
+
+static struct man_viewer_info_list {
+        struct man_viewer_info_list *next;
+        const char *info;
+        char name[FLEX_ARRAY];
+} *man_viewer_info_list;
+
+enum help_format {
+        HELP_FORMAT_MAN,
+        HELP_FORMAT_INFO,
+        HELP_FORMAT_WEB,
+};
+
+static int show_all = 0;
+static enum help_format help_format = HELP_FORMAT_MAN;
+static struct option builtin_help_options[] = {
+        OPT_BOOLEAN('a', "all", &show_all, "print all available commands"),
+        OPT_SET_INT('m', "man", &help_format, "show man page", HELP_FORMAT_MAN),
+        OPT_SET_INT('w', "web", &help_format, "show manual in web browser",
+                        HELP_FORMAT_WEB),
+        OPT_SET_INT('i', "info", &help_format, "show info page",
+                        HELP_FORMAT_INFO),
+        OPT_END(),
+};
+
+static const char * const builtin_help_usage[] = {
+        "perf help [--all] [--man|--web|--info] [command]",
+        NULL
+};
+
+static enum help_format parse_help_format(const char *format)
+{
+        if (!strcmp(format, "man"))
+                return HELP_FORMAT_MAN;
+        if (!strcmp(format, "info"))
+                return HELP_FORMAT_INFO;
+        if (!strcmp(format, "web") || !strcmp(format, "html"))
+                return HELP_FORMAT_WEB;
+        die("unrecognized help format '%s'", format);
+}
+
+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)
+        {
+                if (!strcasecmp(name, viewer->name))
+                        return viewer->info;
+        }
+        return NULL;
+}
+
+static int check_emacsclient_version(void)
+{
+        struct strbuf buffer = STRBUF_INIT;
+        struct child_process ec_process;
+        const char *argv_ec[] = { "emacsclient", "--version", NULL };
+        int version;
+
+        /* emacsclient prints its version number on stderr */
+        memset(&ec_process, 0, sizeof(ec_process));
+        ec_process.argv = argv_ec;
+        ec_process.err = -1;
+        ec_process.stdout_to_stderr = 1;
+        if (start_command(&ec_process)) {
+                fprintf(stderr, "Failed to start emacsclient.\n");
+                return -1;
+        }
+        strbuf_read(&buffer, ec_process.err, 20);
+        close(ec_process.err);
+
+        /*
+         * Don't bother checking return value, because "emacsclient --version"
+         * seems to always exits with code 1.
+         */
+        finish_command(&ec_process);
+
+        if (prefixcmp(buffer.buf, "emacsclient")) {
+                fprintf(stderr, "Failed to parse emacsclient version.\n");
+                strbuf_release(&buffer);
+                return -1;
+        }
+
+        strbuf_remove(&buffer, 0, strlen("emacsclient"));
+        version = atoi(buffer.buf);
+
+        if (version < 22) {
+                fprintf(stderr,
+                        "emacsclient version '%d' too old (< 22).\n",
+                        version);
+                strbuf_release(&buffer);
+                return -1;
+        }
+
+        strbuf_release(&buffer);
+        return 0;
+}
+
+static void exec_woman_emacs(const char* path, const char *page)
+{
+        if (!check_emacsclient_version()) {
+                /* This works only with emacsclient version >= 22. */
+                struct strbuf man_page = STRBUF_INIT;
+
+                if (!path)
+                        path = "emacsclient";
+                strbuf_addf(&man_page, "(woman \"%s\")", page);
+                execlp(path, "emacsclient", "-e", man_page.buf, NULL);
+                warning("failed to exec '%s': %s", path, strerror(errno));
+        }
+}
+
+static void exec_man_konqueror(const char* path, const char *page)
+{
+        const char *display = getenv("DISPLAY");
+        if (display && *display) {
+                struct strbuf man_page = STRBUF_INIT;
+                const char *filename = "kfmclient";
+
+                /* It's simpler to launch konqueror using kfmclient. */
+                if (path) {
+                        const char *file = strrchr(path, '/');
+                        if (file && !strcmp(file + 1, "konqueror")) {
+                                char *new = strdup(path);
+                                char *dest = strrchr(new, '/');
+
+                                /* strlen("konqueror") == strlen("kfmclient") */
+                                strcpy(dest + 1, "kfmclient");
+                                path = new;
+                        }
+                        if (file)
+                                filename = file;
+                } else
+                        path = "kfmclient";
+                strbuf_addf(&man_page, "man:%s(1)", page);
+                execlp(path, filename, "newTab", man_page.buf, NULL);
+                warning("failed to exec '%s': %s", path, strerror(errno));
+        }
+}
+
+static void exec_man_man(const char* path, const char *page)
+{
+        if (!path)
+                path = "man";
+        execlp(path, "man", page, NULL);
+        warning("failed to exec '%s': %s", path, strerror(errno));
+}
+
+static void exec_man_cmd(const char *cmd, const char *page)
+{
+        struct strbuf shell_cmd = STRBUF_INIT;
+        strbuf_addf(&shell_cmd, "%s %s", cmd, page);
+        execl("/bin/sh", "sh", "-c", shell_cmd.buf, NULL);
+        warning("failed to exec '%s': %s", cmd, strerror(errno));
+}
+
+static void add_man_viewer(const char *name)
+{
+        struct man_viewer_list **p = &man_viewer_list;
+        size_t len = strlen(name);
+
+        while (*p)
+                p = &((*p)->next);
+        *p = calloc(1, (sizeof(**p) + len + 1));
+        strncpy((*p)->name, name, len);
+}
+
+static int supported_man_viewer(const char *name, size_t len)
+{
+        return (!strncasecmp("man", name, len) ||
+                !strncasecmp("woman", name, len) ||
+                !strncasecmp("konqueror", name, len));
+}
+
+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);
+
+        strncpy(new->name, name, len);
+        new->info = strdup(value);
+        new->next = man_viewer_info_list;
+        man_viewer_info_list = new;
+}
+
+static int add_man_viewer_path(const char *name,
+                               size_t len,
+                               const char *value)
+{
+        if (supported_man_viewer(name, len))
+                do_add_man_viewer_info(name, len, value);
+        else
+                warning("'%s': path for unsupported man viewer.\n"
+                        "Please consider using 'man.<tool>.cmd' instead.",
+                        name);
+
+        return 0;
+}
+
+static int add_man_viewer_cmd(const char *name,
+                              size_t len,
+                              const char *value)
+{
+        if (supported_man_viewer(name, len))
+                warning("'%s': cmd for supported man viewer.\n"
+                        "Please consider using 'man.<tool>.path' instead.",
+                        name);
+        else
+                do_add_man_viewer_info(name, len, value);
+
+        return 0;
+}
+
+static int add_man_viewer_info(const char *var, const char *value)
+{
+        const char *name = var + 4;
+        const char *subkey = strrchr(name, '.');
+
+        if (!subkey)
+                return error("Config with no key for man viewer: %s", name);
+
+        if (!strcmp(subkey, ".path")) {
+                if (!value)
+                        return config_error_nonbool(var);
+                return add_man_viewer_path(name, subkey - name, value);
+        }
+        if (!strcmp(subkey, ".cmd")) {
+                if (!value)
+                        return config_error_nonbool(var);
+                return add_man_viewer_cmd(name, subkey - name, value);
+        }
+
+        warning("'%s': unsupported man viewer sub key.", subkey);
+        return 0;
+}
+
+static int perf_help_config(const char *var, const char *value, void *cb)
+{
+        if (!strcmp(var, "help.format")) {
+                if (!value)
+                        return config_error_nonbool(var);
+                help_format = parse_help_format(value);
+                return 0;
+        }
+        if (!strcmp(var, "man.viewer")) {
+                if (!value)
+                        return config_error_nonbool(var);
+                add_man_viewer(value);
+                return 0;
+        }
+        if (!prefixcmp(var, "man."))
+                return add_man_viewer_info(var, value);
+
+        return perf_default_config(var, value, cb);
+}
+
+static struct cmdnames main_cmds, other_cmds;
+
+void list_common_cmds_help(void)
+{
+        unsigned int i, longest = 0;
+
+        for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
+                if (longest < strlen(common_cmds[i].name))
+                        longest = strlen(common_cmds[i].name);
+        }
+
+        puts(" The most commonly used perf commands are:");
+        for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
+                printf("   %s   ", common_cmds[i].name);
+                mput_char(' ', longest - strlen(common_cmds[i].name));
+                puts(common_cmds[i].help);
+        }
+}
+
+static int is_perf_command(const char *s)
+{
+        return is_in_cmdlist(&main_cmds, s) ||
+                is_in_cmdlist(&other_cmds, s);
+}
+
+static const char *prepend(const char *prefix, const char *cmd)
+{
+        size_t pre_len = strlen(prefix);
+        size_t cmd_len = strlen(cmd);
+        char *p = malloc(pre_len + cmd_len + 1);
+        memcpy(p, prefix, pre_len);
+        strcpy(p + pre_len, cmd);
+        return p;
+}
+
+static const char *cmd_to_page(const char *perf_cmd)
+{
+        if (!perf_cmd)
+                return "perf";
+        else if (!prefixcmp(perf_cmd, "perf"))
+                return perf_cmd;
+        else if (is_perf_command(perf_cmd))
+                return prepend("perf-", perf_cmd);
+        else
+                return prepend("perf-", perf_cmd);
+}
+
+static void setup_man_path(void)
+{
+        struct strbuf new_path = STRBUF_INIT;
+        const char *old_path = getenv("MANPATH");
+
+        /* We should always put ':' after our path. If there is no
+         * old_path, the ':' at the end will let 'man' to try
+         * system-wide paths after ours to find the manual page. If
+         * there is old_path, we need ':' as delimiter. */
+        strbuf_addstr(&new_path, system_path(PERF_MAN_PATH));
+        strbuf_addch(&new_path, ':');
+        if (old_path)
+                strbuf_addstr(&new_path, old_path);
+
+        setenv("MANPATH", new_path.buf, 1);
+
+        strbuf_release(&new_path);
+}
+
+static void exec_viewer(const char *name, const char *page)
+{
+        const char *info = get_man_viewer_info(name);
+
+        if (!strcasecmp(name, "man"))
+                exec_man_man(info, page);
+        else if (!strcasecmp(name, "woman"))
+                exec_woman_emacs(info, page);
+        else if (!strcasecmp(name, "konqueror"))
+                exec_man_konqueror(info, page);
+        else if (info)
+                exec_man_cmd(info, page);
+        else
+                warning("'%s': unknown man viewer.", name);
+}
+
+static void show_man_page(const char *perf_cmd)
+{
+        struct man_viewer_list *viewer;
+        const char *page = cmd_to_page(perf_cmd);
+        const char *fallback = getenv("PERF_MAN_VIEWER");
+
+        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);
+        die("no man viewer handled the request");
+}
+
+static void show_info_page(const char *perf_cmd)
+{
+        const char *page = cmd_to_page(perf_cmd);
+        setenv("INFOPATH", system_path(PERF_INFO_PATH), 1);
+        execlp("info", "info", "perfman", page, NULL);
+}
+
+static void get_html_page_path(struct strbuf *page_path, const char *page)
+{
+        struct stat st;
+        const char *html_path = system_path(PERF_HTML_PATH);
+
+        /* Check that we have a perf documentation directory. */
+        if (stat(mkpath("%s/perf.html", html_path), &st)
+            || !S_ISREG(st.st_mode))
+                die("'%s': not a documentation directory.", html_path);
+
+        strbuf_init(page_path, 0);
+        strbuf_addf(page_path, "%s/%s.html", html_path, page);
+}
+
+/*
+ * If open_html is not defined in a platform-specific way (see for
+ * example compat/mingw.h), we use the script web--browse to display
+ * HTML.
+ */
+#ifndef open_html
+static void open_html(const char *path)
+{
+        execl_perf_cmd("web--browse", "-c", "help.browser", path, NULL);
+}
+#endif
+
+static void show_html_page(const char *perf_cmd)
+{
+        const char *page = cmd_to_page(perf_cmd);
+        struct strbuf page_path; /* it leaks but we exec bellow */
+
+        get_html_page_path(&page_path, page);
+
+        open_html(page_path.buf);
+}
+
+int cmd_help(int argc, const char **argv, const char *prefix __used)
+{
+        const char *alias;
+
+        load_command_list("perf-", &main_cmds, &other_cmds);
+
+        perf_config(perf_help_config, NULL);
+
+        argc = parse_options(argc, argv, builtin_help_options,
+                        builtin_help_usage, 0);
+
+        if (show_all) {
+                printf("\n usage: %s\n\n", perf_usage_string);
+                list_commands("perf commands", &main_cmds, &other_cmds);
+                printf(" %s\n\n", perf_more_info_string);
+                return 0;
+        }
+
+        if (!argv[0]) {
+                printf("\n usage: %s\n\n", perf_usage_string);
+                list_common_cmds_help();
+                printf("\n %s\n\n", perf_more_info_string);
+                return 0;
+        }
+
+        alias = alias_lookup(argv[0]);
+        if (alias && !is_perf_command(argv[0])) {
+                printf("`perf %s' is aliased to `%s'\n", argv[0], alias);
+                return 0;
+        }
+
+        switch (help_format) {
+        case HELP_FORMAT_MAN:
+                show_man_page(argv[0]);
+                break;
+        case HELP_FORMAT_INFO:
+                show_info_page(argv[0]);
+                break;
+        case HELP_FORMAT_WEB:
+                show_html_page(argv[0]);
+                break;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/builtin-list.c b/tools/perf/builtin-list.c
new file mode 100644
index 000000000000..d88c6961274c
--- /dev/null
+++ b/tools/perf/builtin-list.c
@@ -0,0 +1,21 @@
+/*
+ * builtin-list.c
+ *
+ * Builtin list command: list all event types
+ *
+ * Copyright (C) 2009, Thomas Gleixner <tglx@linutronix.de>
+ * Copyright (C) 2008-2009, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
+ */
+#include "builtin.h"
+
+#include "perf.h"
+
+#include "util/parse-events.h"
+#include "util/cache.h"
+
+int cmd_list(int argc __used, const char **argv __used, const char *prefix __used)
+{
+        setup_pager();
+        print_events();
+        return 0;
+}
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
new file mode 100644
index 000000000000..89a5ddcd1ded
--- /dev/null
+++ b/tools/perf/builtin-record.c
@@ -0,0 +1,712 @@
+/*
+ * builtin-record.c
+ *
+ * Builtin record command: Record the profile of a workload
+ * (or a CPU, or a PID) into the perf.data output file - for
+ * later analysis via perf report.
+ */
+#include "builtin.h"
+
+#include "perf.h"
+
+#include "util/util.h"
+#include "util/parse-options.h"
+#include "util/parse-events.h"
+#include "util/string.h"
+
+#include "util/header.h"
+
+#include <unistd.h>
+#include <sched.h>
+
+#define ALIGN(x, a)             __ALIGN_MASK(x, (typeof(x))(a)-1)
+#define __ALIGN_MASK(x, mask)   (((x)+(mask))&~(mask))
+
+static int                      fd[MAX_NR_CPUS][MAX_COUNTERS];
+
+static long                     default_interval                = 100000;
+
+static int                      nr_cpus                         = 0;
+static unsigned int             page_size;
+static unsigned int             mmap_pages                      = 128;
+static int                      freq                            = 0;
+static int                      output;
+static const char               *output_name                    = "perf.data";
+static int                      group                           = 0;
+static unsigned int             realtime_prio                   = 0;
+static int                      raw_samples                     = 0;
+static int                      system_wide                     = 0;
+static int                      profile_cpu                     = -1;
+static pid_t                    target_pid                      = -1;
+static int                      inherit                         = 1;
+static int                      force                           = 0;
+static int                      append_file                     = 0;
+static int                      call_graph                      = 0;
+static int                      verbose                         = 0;
+static int                      inherit_stat                    = 0;
+static int                      no_samples                      = 0;
+static int                      sample_address                  = 0;
+
+static long                     samples;
+static struct timeval           last_read;
+static struct timeval           this_read;
+
+static u64                      bytes_written;
+
+static struct pollfd            event_array[MAX_NR_CPUS * MAX_COUNTERS];
+
+static int                      nr_poll;
+static int                      nr_cpu;
+
+static int                      file_new = 1;
+
+struct perf_header              *header;
+
+struct mmap_event {
+        struct perf_event_header        header;
+        u32                             pid;
+        u32                             tid;
+        u64                             start;
+        u64                             len;
+        u64                             pgoff;
+        char                            filename[PATH_MAX];
+};
+
+struct comm_event {
+        struct perf_event_header        header;
+        u32                             pid;
+        u32                             tid;
+        char                            comm[16];
+};
+
+
+struct mmap_data {
+        int                     counter;
+        void                    *base;
+        unsigned int            mask;
+        unsigned int            prev;
+};
+
+static struct mmap_data         mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
+
+static unsigned long mmap_read_head(struct mmap_data *md)
+{
+        struct perf_counter_mmap_page *pc = md->base;
+        long head;
+
+        head = pc->data_head;
+        rmb();
+
+        return head;
+}
+
+static void mmap_write_tail(struct mmap_data *md, unsigned long tail)
+{
+        struct perf_counter_mmap_page *pc = md->base;
+
+        /*
+         * ensure all reads are done before we write the tail out.
+         */
+        /* mb(); */
+        pc->data_tail = tail;
+}
+
+static void write_output(void *buf, size_t size)
+{
+        while (size) {
+                int ret = write(output, buf, size);
+
+                if (ret < 0)
+                        die("failed to write");
+
+                size -= ret;
+                buf += ret;
+
+                bytes_written += ret;
+        }
+}
+
+static void mmap_read(struct mmap_data *md)
+{
+        unsigned int head = mmap_read_head(md);
+        unsigned int old = md->prev;
+        unsigned char *data = md->base + page_size;
+        unsigned long size;
+        void *buf;
+        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.
+         *
+         * If we somehow ended up ahead of the head, we got messed up.
+         *
+         * In either case, truncate and restart at head.
+         */
+        diff = head - old;
+        if (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);
+
+                /*
+                 * head points to a known good entry, start there.
+                 */
+                old = head;
+        }
+
+        last_read = this_read;
+
+        if (old != head)
+                samples++;
+
+        size = head - old;
+
+        if ((old & md->mask) + size != (head & md->mask)) {
+                buf = &data[old & md->mask];
+                size = md->mask + 1 - (old & md->mask);
+                old += size;
+
+                write_output(buf, size);
+        }
+
+        buf = &data[old & md->mask];
+        size = head - old;
+        old += size;
+
+        write_output(buf, size);
+
+        md->prev = old;
+        mmap_write_tail(md, old);
+}
+
+static volatile int done = 0;
+static volatile int signr = -1;
+
+static void sig_handler(int sig)
+{
+        done = 1;
+        signr = sig;
+}
+
+static void sig_atexit(void)
+{
+        if (signr == -1)
+                return;
+
+        signal(signr, SIG_DFL);
+        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_EVENT_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_EVENT_MMAP },
+                };
+                int n;
+                size_t size;
+                if (fgets(bf, sizeof(bf), fp) == NULL)
+                        break;
+
+                /* 00400000-0040c000 r-xp 00000000 fd:01 41038  /bin/cat */
+                n = hex2u64(pbf, &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_counter_attr *a, int nr)
+{
+        struct perf_header_attr *h_attr;
+
+        if (nr < header->attrs) {
+                h_attr = header->attr[nr];
+        } else {
+                h_attr = perf_header_attr__new(a);
+                perf_header__add_attr(header, h_attr);
+        }
+
+        return h_attr;
+}
+
+static void create_counter(int counter, int cpu, pid_t pid)
+{
+        struct perf_counter_attr *attr = attrs + counter;
+        struct perf_header_attr *h_attr;
+        int track = !counter; /* only the first counter needs these */
+        struct {
+                u64 count;
+                u64 time_enabled;
+                u64 time_running;
+                u64 id;
+        } read_data;
+
+        attr->read_format       = PERF_FORMAT_TOTAL_TIME_ENABLED |
+                                  PERF_FORMAT_TOTAL_TIME_RUNNING |
+                                  PERF_FORMAT_ID;
+
+        attr->sample_type       |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
+
+        if (freq) {
+                attr->sample_type       |= PERF_SAMPLE_PERIOD;
+                attr->freq              = 1;
+                attr->sample_freq       = freq;
+        }
+
+        if (no_samples)
+                attr->sample_freq = 0;
+
+        if (inherit_stat)
+                attr->inherit_stat = 1;
+
+        if (sample_address)
+                attr->sample_type       |= PERF_SAMPLE_ADDR;
+
+        if (call_graph)
+                attr->sample_type       |= PERF_SAMPLE_CALLCHAIN;
+
+        if (raw_samples)
+                attr->sample_type       |= PERF_SAMPLE_RAW;
+
+        attr->mmap              = track;
+        attr->comm              = track;
+        attr->inherit           = (cpu < 0) && inherit;
+        attr->disabled          = 1;
+
+try_again:
+        fd[nr_cpu][counter] = sys_perf_counter_open(attr, pid, cpu, group_fd, 0);
+
+        if (fd[nr_cpu][counter] < 0) {
+                int err = errno;
+
+                if (err == EPERM)
+                        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");
+
+                /*
+                 * If it's cycles then fall back to hrtimer
+                 * based cpu-clock-tick sw counter, which
+                 * is always available even if no PMU support:
+                 */
+                if (attr->type == PERF_TYPE_HARDWARE
+                        && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
+
+                        if (verbose)
+                                warning(" ... trying to fall back to cpu-clock-ticks\n");
+                        attr->type = PERF_TYPE_SOFTWARE;
+                        attr->config = PERF_COUNT_SW_CPU_CLOCK;
+                        goto try_again;
+                }
+                printf("\n");
+                error("perfcounter syscall returned with %d (%s)\n",
+                        fd[nr_cpu][counter], strerror(err));
+                die("No CONFIG_PERF_COUNTERS=y kernel support configured?\n");
+                exit(-1);
+        }
+
+        h_attr = get_header_attr(attr, counter);
+
+        if (!file_new) {
+                if (memcmp(&h_attr->attr, attr, sizeof(*attr))) {
+                        fprintf(stderr, "incompatible append\n");
+                        exit(-1);
+                }
+        }
+
+        if (read(fd[nr_cpu][counter], &read_data, sizeof(read_data)) == -1) {
+                perror("Unable to read perf file descriptor\n");
+                exit(-1);
+        }
+
+        perf_header_attr__add_id(h_attr, read_data.id);
+
+        assert(fd[nr_cpu][counter] >= 0);
+        fcntl(fd[nr_cpu][counter], F_SETFL, O_NONBLOCK);
+
+        /*
+         * First counter acts as the group leader:
+         */
+        if (group && group_fd == -1)
+                group_fd = fd[nr_cpu][counter];
+
+        event_array[nr_poll].fd = fd[nr_cpu][counter];
+        event_array[nr_poll].events = POLLIN;
+        nr_poll++;
+
+        mmap_array[nr_cpu][counter].counter = counter;
+        mmap_array[nr_cpu][counter].prev = 0;
+        mmap_array[nr_cpu][counter].mask = mmap_pages*page_size - 1;
+        mmap_array[nr_cpu][counter].base = mmap(NULL, (mmap_pages+1)*page_size,
+                        PROT_READ|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter], 0);
+        if (mmap_array[nr_cpu][counter].base == MAP_FAILED) {
+                error("failed to mmap with %d (%s)\n", errno, strerror(errno));
+                exit(-1);
+        }
+
+        ioctl(fd[nr_cpu][counter], PERF_COUNTER_IOC_ENABLE);
+}
+
+static void open_counters(int cpu, pid_t pid)
+{
+        int counter;
+
+        group_fd = -1;
+        for (counter = 0; counter < nr_counters; counter++)
+                create_counter(counter, cpu, pid);
+
+        nr_cpu++;
+}
+
+static void atexit_header(void)
+{
+        header->data_size += bytes_written;
+
+        perf_header__write(header, output);
+}
+
+static int __cmd_record(int argc, const char **argv)
+{
+        int i, counter;
+        struct stat st;
+        pid_t pid = 0;
+        int flags;
+        int ret;
+
+        page_size = sysconf(_SC_PAGE_SIZE);
+        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+        assert(nr_cpus <= MAX_NR_CPUS);
+        assert(nr_cpus >= 0);
+
+        atexit(sig_atexit);
+        signal(SIGCHLD, sig_handler);
+        signal(SIGINT, sig_handler);
+
+        if (!stat(output_name, &st) && st.st_size) {
+                if (!force && !append_file) {
+                        fprintf(stderr, "Error, output file %s exists, use -A to append or -f to overwrite.\n",
+                                        output_name);
+                        exit(-1);
+                }
+        } else {
+                append_file = 0;
+        }
+
+        flags = O_CREAT|O_RDWR;
+        if (append_file)
+                file_new = 0;
+        else
+                flags |= O_TRUNC;
+
+        output = open(output_name, flags, S_IRUSR|S_IWUSR);
+        if (output < 0) {
+                perror("failed to create output file");
+                exit(-1);
+        }
+
+        if (!file_new)
+                header = perf_header__read(output);
+        else
+                header = perf_header__new();
+
+        atexit(atexit_header);
+
+        if (!system_wide) {
+                pid = target_pid;
+                if (pid == -1)
+                        pid = getpid();
+
+                open_counters(profile_cpu, pid);
+        } else {
+                if (profile_cpu != -1) {
+                        open_counters(profile_cpu, target_pid);
+                } else {
+                        for (i = 0; i < nr_cpus; i++)
+                                open_counters(i, target_pid);
+                }
+        }
+
+        if (file_new)
+                perf_header__write(header, output);
+
+        if (!system_wide) {
+                pid_t tgid = pid_synthesize_comm_event(pid, 0);
+                pid_synthesize_mmap_samples(pid, tgid);
+        } else
+                synthesize_all();
+
+        if (target_pid == -1 && argc) {
+                pid = fork();
+                if (pid < 0)
+                        perror("failed to fork");
+
+                if (!pid) {
+                        if (execvp(argv[0], (char **)argv)) {
+                                perror(argv[0]);
+                                exit(-1);
+                        }
+                }
+        }
+
+        if (realtime_prio) {
+                struct sched_param param;
+
+                param.sched_priority = realtime_prio;
+                if (sched_setscheduler(0, SCHED_FIFO, &param)) {
+                        printf("Could not set realtime priority.\n");
+                        exit(-1);
+                }
+        }
+
+        for (;;) {
+                int hits = samples;
+
+                for (i = 0; i < nr_cpu; i++) {
+                        for (counter = 0; counter < nr_counters; counter++)
+                                mmap_read(&mmap_array[i][counter]);
+                }
+
+                if (hits == samples) {
+                        if (done)
+                                break;
+                        ret = poll(event_array, nr_poll, 100);
+                }
+        }
+
+        /*
+         * Approximate RIP event size: 24 bytes.
+         */
+        fprintf(stderr,
+                "[ perf record: Captured and wrote %.3f MB %s (~%lld samples) ]\n",
+                (double)bytes_written / 1024.0 / 1024.0,
+                output_name,
+                bytes_written / 24);
+
+        return 0;
+}
+
+static const char * const record_usage[] = {
+        "perf record [<options>] [<command>]",
+        "perf record [<options>] -- <command> [<options>]",
+        NULL
+};
+
+static const struct option options[] = {
+        OPT_CALLBACK('e', "event", NULL, "event",
+                     "event selector. use 'perf list' to list available events",
+                     parse_events),
+        OPT_INTEGER('p', "pid", &target_pid,
+                    "record events on existing pid"),
+        OPT_INTEGER('r', "realtime", &realtime_prio,
+                    "collect data with this RT SCHED_FIFO priority"),
+        OPT_BOOLEAN('R', "raw-samples", &raw_samples,
+                    "collect raw sample records from all opened counters"),
+        OPT_BOOLEAN('a', "all-cpus", &system_wide,
+                            "system-wide collection from all CPUs"),
+        OPT_BOOLEAN('A', "append", &append_file,
+                            "append to the output file to do incremental profiling"),
+        OPT_INTEGER('C', "profile_cpu", &profile_cpu,
+                            "CPU to profile on"),
+        OPT_BOOLEAN('f', "force", &force,
+                        "overwrite existing data file"),
+        OPT_LONG('c', "count", &default_interval,
+                    "event period to sample"),
+        OPT_STRING('o', "output", &output_name, "file",
+                    "output file name"),
+        OPT_BOOLEAN('i', "inherit", &inherit,
+                    "child tasks inherit counters"),
+        OPT_INTEGER('F', "freq", &freq,
+                    "profile at this frequency"),
+        OPT_INTEGER('m', "mmap-pages", &mmap_pages,
+                    "number of mmap data pages"),
+        OPT_BOOLEAN('g', "call-graph", &call_graph,
+                    "do call-graph (stack chain/backtrace) recording"),
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose (show counter open errors, etc)"),
+        OPT_BOOLEAN('s', "stat", &inherit_stat,
+                    "per thread counts"),
+        OPT_BOOLEAN('d', "data", &sample_address,
+                    "Sample addresses"),
+        OPT_BOOLEAN('n', "no-samples", &no_samples,
+                    "don't sample"),
+        OPT_END()
+};
+
+int cmd_record(int argc, const char **argv, const char *prefix __used)
+{
+        int counter;
+
+        argc = parse_options(argc, argv, options, record_usage,
+                PARSE_OPT_STOP_AT_NON_OPTION);
+        if (!argc && target_pid == -1 && !system_wide)
+                usage_with_options(record_usage, options);
+
+        if (!nr_counters) {
+                nr_counters     = 1;
+                attrs[0].type   = PERF_TYPE_HARDWARE;
+                attrs[0].config = PERF_COUNT_HW_CPU_CYCLES;
+        }
+
+        for (counter = 0; counter < nr_counters; counter++) {
+                if (attrs[counter].sample_period)
+                        continue;
+
+                attrs[counter].sample_period = default_interval;
+        }
+
+        return __cmd_record(argc, argv);
+}
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
new file mode 100644
index 000000000000..8b2ec882e6e0
--- /dev/null
+++ b/tools/perf/builtin-report.c
@@ -0,0 +1,2173 @@
+/*
+ * builtin-report.c
+ *
+ * Builtin report command: Analyze the perf.data input file,
+ * look up and read DSOs and symbol information and display
+ * a histogram of results, along various sorting keys.
+ */
+#include "builtin.h"
+
+#include "util/util.h"
+
+#include "util/color.h"
+#include <linux/list.h>
+#include "util/cache.h"
+#include <linux/rbtree.h>
+#include "util/symbol.h"
+#include "util/string.h"
+#include "util/callchain.h"
+#include "util/strlist.h"
+
+#include "perf.h"
+#include "util/header.h"
+
+#include "util/parse-options.h"
+#include "util/parse-events.h"
+
+#define SHOW_KERNEL     1
+#define SHOW_USER       2
+#define SHOW_HV         4
+
+static char             const *input_name = "perf.data";
+static char             *vmlinux = NULL;
+
+static char             default_sort_order[] = "comm,dso,symbol";
+static char             *sort_order = default_sort_order;
+static char             *dso_list_str, *comm_list_str, *sym_list_str,
+                        *col_width_list_str;
+static struct strlist   *dso_list, *comm_list, *sym_list;
+static char             *field_sep;
+
+static int              force;
+static int              input;
+static int              show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
+
+static int              dump_trace = 0;
+#define dprintf(x...)   do { if (dump_trace) printf(x); } while (0)
+#define cdprintf(x...)  do { if (dump_trace) color_fprintf(stdout, color, x); } while (0)
+
+static int              verbose;
+#define eprintf(x...)   do { if (verbose) fprintf(stderr, x); } while (0)
+
+static int              modules;
+
+static int              full_paths;
+static int              show_nr_samples;
+
+static unsigned long    page_size;
+static unsigned long    mmap_window = 32;
+
+static char             default_parent_pattern[] = "^sys_|^do_page_fault";
+static char             *parent_pattern = default_parent_pattern;
+static regex_t          parent_regex;
+
+static int              exclude_other = 1;
+
+static char             callchain_default_opt[] = "fractal,0.5";
+
+static int              callchain;
+
+static
+struct callchain_param  callchain_param = {
+        .mode   = CHAIN_GRAPH_REL,
+        .min_percent = 0.5
+};
+
+static u64              sample_type;
+
+struct ip_event {
+        struct perf_event_header header;
+        u64 ip;
+        u32 pid, tid;
+        unsigned char __more_data[];
+};
+
+struct mmap_event {
+        struct perf_event_header header;
+        u32 pid, tid;
+        u64 start;
+        u64 len;
+        u64 pgoff;
+        char filename[PATH_MAX];
+};
+
+struct comm_event {
+        struct perf_event_header header;
+        u32 pid, tid;
+        char comm[16];
+};
+
+struct fork_event {
+        struct perf_event_header header;
+        u32 pid, ppid;
+        u32 tid, ptid;
+};
+
+struct lost_event {
+        struct perf_event_header header;
+        u64 id;
+        u64 lost;
+};
+
+struct read_event {
+        struct perf_event_header header;
+        u32 pid,tid;
+        u64 value;
+        u64 time_enabled;
+        u64 time_running;
+        u64 id;
+};
+
+typedef union event_union {
+        struct perf_event_header        header;
+        struct ip_event                 ip;
+        struct mmap_event               mmap;
+        struct comm_event               comm;
+        struct fork_event               fork;
+        struct lost_event               lost;
+        struct read_event               read;
+} event_t;
+
+static int repsep_fprintf(FILE *fp, const char *fmt, ...)
+{
+        int n;
+        va_list ap;
+
+        va_start(ap, fmt);
+        if (!field_sep)
+                n = vfprintf(fp, fmt, ap);
+        else {
+                char *bf = NULL;
+                n = vasprintf(&bf, fmt, ap);
+                if (n > 0) {
+                        char *sep = bf;
+                        while (1) {
+                                sep = strchr(sep, *field_sep);
+                                if (sep == NULL)
+                                        break;
+                                *sep = '.';
+                        }
+                }
+                fputs(bf, fp);
+                free(bf);
+        }
+        va_end(ap);
+        return n;
+}
+
+static LIST_HEAD(dsos);
+static struct dso *kernel_dso;
+static struct dso *vdso;
+static struct dso *hypervisor_dso;
+
+static void dsos__add(struct dso *dso)
+{
+        list_add_tail(&dso->node, &dsos);
+}
+
+static struct dso *dsos__find(const char *name)
+{
+        struct dso *pos;
+
+        list_for_each_entry(pos, &dsos, node)
+                if (strcmp(pos->name, name) == 0)
+                        return pos;
+        return NULL;
+}
+
+static struct dso *dsos__findnew(const char *name)
+{
+        struct dso *dso = dsos__find(name);
+        int nr;
+
+        if (dso)
+                return dso;
+
+        dso = dso__new(name, 0);
+        if (!dso)
+                goto out_delete_dso;
+
+        nr = dso__load(dso, NULL, verbose);
+        if (nr < 0) {
+                eprintf("Failed to open: %s\n", name);
+                goto out_delete_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(FILE *fp)
+{
+        struct dso *pos;
+
+        list_for_each_entry(pos, &dsos, node)
+                dso__fprintf(pos, fp);
+}
+
+static struct symbol *vdso__find_symbol(struct dso *dso, u64 ip)
+{
+        return dso__find_symbol(dso, ip);
+}
+
+static int load_kernel(void)
+{
+        int err;
+
+        kernel_dso = dso__new("[kernel]", 0);
+        if (!kernel_dso)
+                return -1;
+
+        err = dso__load_kernel(kernel_dso, vmlinux, NULL, verbose, modules);
+        if (err <= 0) {
+                dso__delete(kernel_dso);
+                kernel_dso = NULL;
+        } else
+                dsos__add(kernel_dso);
+
+        vdso = dso__new("[vdso]", 0);
+        if (!vdso)
+                return -1;
+
+        vdso->find_symbol = vdso__find_symbol;
+
+        dsos__add(vdso);
+
+        hypervisor_dso = dso__new("[hypervisor]", 0);
+        if (!hypervisor_dso)
+                return -1;
+        dsos__add(hypervisor_dso);
+
+        return err;
+}
+
+static char __cwd[PATH_MAX];
+static char *cwd = __cwd;
+static int cwdlen;
+
+static int strcommon(const char *pathname)
+{
+        int n = 0;
+
+        while (n < cwdlen && pathname[n] == cwd[n])
+                ++n;
+
+        return n;
+}
+
+struct map {
+        struct list_head node;
+        u64      start;
+        u64      end;
+        u64      pgoff;
+        u64      (*map_ip)(struct map *, u64);
+        struct dso       *dso;
+};
+
+static u64 map__map_ip(struct map *map, u64 ip)
+{
+        return ip - map->start + map->pgoff;
+}
+
+static u64 vdso__map_ip(struct map *map __used, u64 ip)
+{
+        return ip;
+}
+
+static inline int is_anon_memory(const char *filename)
+{
+        return strcmp(filename, "//anon") == 0;
+}
+
+static struct map *map__new(struct mmap_event *event)
+{
+        struct map *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                const char *filename = event->filename;
+                char newfilename[PATH_MAX];
+                int anon;
+
+                if (cwd) {
+                        int n = strcommon(filename);
+
+                        if (n == cwdlen) {
+                                snprintf(newfilename, sizeof(newfilename),
+                                         ".%s", filename + n);
+                                filename = newfilename;
+                        }
+                }
+
+                anon = is_anon_memory(filename);
+
+                if (anon) {
+                        snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", event->pid);
+                        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)
+                        goto out_delete;
+
+                if (self->dso == vdso || anon)
+                        self->map_ip = vdso__map_ip;
+                else
+                        self->map_ip = map__map_ip;
+        }
+        return self;
+out_delete:
+        free(self);
+        return NULL;
+}
+
+static struct map *map__clone(struct map *self)
+{
+        struct map *map = malloc(sizeof(*self));
+
+        if (!map)
+                return NULL;
+
+        memcpy(map, self, sizeof(*self));
+
+        return map;
+}
+
+static int map__overlap(struct map *l, struct map *r)
+{
+        if (l->start > r->start) {
+                struct map *t = l;
+                l = r;
+                r = t;
+        }
+
+        if (l->end > r->start)
+                return 1;
+
+        return 0;
+}
+
+static size_t map__fprintf(struct map *self, FILE *fp)
+{
+        return fprintf(fp, " %Lx-%Lx %Lx %s\n",
+                       self->start, self->end, self->pgoff, self->dso->name);
+}
+
+
+struct thread {
+        struct rb_node   rb_node;
+        struct list_head maps;
+        pid_t            pid;
+        char             *comm;
+};
+
+static struct thread *thread__new(pid_t pid)
+{
+        struct thread *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                self->pid = pid;
+                self->comm = malloc(32);
+                if (self->comm)
+                        snprintf(self->comm, 32, ":%d", self->pid);
+                INIT_LIST_HEAD(&self->maps);
+        }
+
+        return self;
+}
+
+static unsigned int dsos__col_width,
+                    comms__col_width,
+                    threads__col_width;
+
+static int thread__set_comm(struct thread *self, const char *comm)
+{
+        if (self->comm)
+                free(self->comm);
+        self->comm = strdup(comm);
+        if (!self->comm)
+                return -ENOMEM;
+
+        if (!col_width_list_str && !field_sep &&
+            (!comm_list || strlist__has_entry(comm_list, comm))) {
+                unsigned int slen = strlen(comm);
+                if (slen > comms__col_width) {
+                        comms__col_width = slen;
+                        threads__col_width = slen + 6;
+                }
+        }
+
+        return 0;
+}
+
+static size_t thread__fprintf(struct thread *self, FILE *fp)
+{
+        struct map *pos;
+        size_t ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
+
+        list_for_each_entry(pos, &self->maps, node)
+                ret += map__fprintf(pos, fp);
+
+        return ret;
+}
+
+
+static struct rb_root threads;
+static struct thread *last_match;
+
+static struct thread *threads__findnew(pid_t pid)
+{
+        struct rb_node **p = &threads.rb_node;
+        struct rb_node *parent = NULL;
+        struct thread *th;
+
+        /*
+         * Font-end cache - PID lookups come in blocks,
+         * so most of the time we dont have to look up
+         * the full rbtree:
+         */
+        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;
+                        return th;
+                }
+
+                if (pid < th->pid)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        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;
+        }
+
+        return th;
+}
+
+static void thread__insert_map(struct thread *self, struct map *map)
+{
+        struct map *pos, *tmp;
+
+        list_for_each_entry_safe(pos, tmp, &self->maps, node) {
+                if (map__overlap(pos, map)) {
+                        if (verbose >= 2) {
+                                printf("overlapping maps:\n");
+                                map__fprintf(map, stdout);
+                                map__fprintf(pos, stdout);
+                        }
+
+                        if (map->start <= pos->start && map->end > pos->start)
+                                pos->start = map->end;
+
+                        if (map->end >= pos->end && map->start < pos->end)
+                                pos->end = map->start;
+
+                        if (verbose >= 2) {
+                                printf("after collision:\n");
+                                map__fprintf(pos, stdout);
+                        }
+
+                        if (pos->start >= pos->end) {
+                                list_del_init(&pos->node);
+                                free(pos);
+                        }
+                }
+        }
+
+        list_add_tail(&map->node, &self->maps);
+}
+
+static int thread__fork(struct thread *self, struct thread *parent)
+{
+        struct map *map;
+
+        if (self->comm)
+                free(self->comm);
+        self->comm = strdup(parent->comm);
+        if (!self->comm)
+                return -ENOMEM;
+
+        list_for_each_entry(map, &parent->maps, node) {
+                struct map *new = map__clone(map);
+                if (!new)
+                        return -ENOMEM;
+                thread__insert_map(self, new);
+        }
+
+        return 0;
+}
+
+static struct map *thread__find_map(struct thread *self, u64 ip)
+{
+        struct map *pos;
+
+        if (self == NULL)
+                return NULL;
+
+        list_for_each_entry(pos, &self->maps, node)
+                if (ip >= pos->start && ip <= pos->end)
+                        return pos;
+
+        return NULL;
+}
+
+static size_t threads__fprintf(FILE *fp)
+{
+        size_t ret = 0;
+        struct rb_node *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);
+        }
+
+        return ret;
+}
+
+/*
+ * histogram, sorted on item, collects counts
+ */
+
+static struct rb_root hist;
+
+struct hist_entry {
+        struct rb_node          rb_node;
+
+        struct thread           *thread;
+        struct map              *map;
+        struct dso              *dso;
+        struct symbol           *sym;
+        struct symbol           *parent;
+        u64                     ip;
+        char                    level;
+        struct callchain_node   callchain;
+        struct rb_root          sorted_chain;
+
+        u64                     count;
+};
+
+/*
+ * configurable sorting bits
+ */
+
+struct sort_entry {
+        struct list_head list;
+
+        char *header;
+
+        int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
+        int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
+        size_t  (*print)(FILE *fp, struct hist_entry *, unsigned int width);
+        unsigned int *width;
+        bool    elide;
+};
+
+static int64_t cmp_null(void *l, void *r)
+{
+        if (!l && !r)
+                return 0;
+        else if (!l)
+                return -1;
+        else
+                return 1;
+}
+
+/* --sort pid */
+
+static int64_t
+sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return right->thread->pid - left->thread->pid;
+}
+
+static size_t
+sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        return repsep_fprintf(fp, "%*s:%5d", width - 6,
+                              self->thread->comm ?: "", self->thread->pid);
+}
+
+static struct sort_entry sort_thread = {
+        .header = "Command:  Pid",
+        .cmp    = sort__thread_cmp,
+        .print  = sort__thread_print,
+        .width  = &threads__col_width,
+};
+
+/* --sort comm */
+
+static int64_t
+sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return right->thread->pid - left->thread->pid;
+}
+
+static int64_t
+sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
+{
+        char *comm_l = left->thread->comm;
+        char *comm_r = right->thread->comm;
+
+        if (!comm_l || !comm_r)
+                return cmp_null(comm_l, comm_r);
+
+        return strcmp(comm_l, comm_r);
+}
+
+static size_t
+sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        return repsep_fprintf(fp, "%*s", width, self->thread->comm);
+}
+
+static struct sort_entry sort_comm = {
+        .header         = "Command",
+        .cmp            = sort__comm_cmp,
+        .collapse       = sort__comm_collapse,
+        .print          = sort__comm_print,
+        .width          = &comms__col_width,
+};
+
+/* --sort dso */
+
+static int64_t
+sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct dso *dso_l = left->dso;
+        struct dso *dso_r = right->dso;
+
+        if (!dso_l || !dso_r)
+                return cmp_null(dso_l, dso_r);
+
+        return strcmp(dso_l->name, dso_r->name);
+}
+
+static size_t
+sort__dso_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        if (self->dso)
+                return repsep_fprintf(fp, "%-*s", width, self->dso->name);
+
+        return repsep_fprintf(fp, "%*llx", width, (u64)self->ip);
+}
+
+static struct sort_entry sort_dso = {
+        .header = "Shared Object",
+        .cmp    = sort__dso_cmp,
+        .print  = sort__dso_print,
+        .width  = &dsos__col_width,
+};
+
+/* --sort symbol */
+
+static int64_t
+sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        u64 ip_l, ip_r;
+
+        if (left->sym == right->sym)
+                return 0;
+
+        ip_l = left->sym ? left->sym->start : left->ip;
+        ip_r = right->sym ? right->sym->start : right->ip;
+
+        return (int64_t)(ip_r - ip_l);
+}
+
+static size_t
+sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
+{
+        size_t ret = 0;
+
+        if (verbose)
+                ret += repsep_fprintf(fp, "%#018llx %c ", (u64)self->ip,
+                                      dso__symtab_origin(self->dso));
+
+        ret += repsep_fprintf(fp, "[%c] ", self->level);
+        if (self->sym) {
+                ret += repsep_fprintf(fp, "%s", self->sym->name);
+
+                if (self->sym->module)
+                        ret += repsep_fprintf(fp, "\t[%s]",
+                                             self->sym->module->name);
+        } else {
+                ret += repsep_fprintf(fp, "%#016llx", (u64)self->ip);
+        }
+
+        return ret;
+}
+
+static struct sort_entry sort_sym = {
+        .header = "Symbol",
+        .cmp    = sort__sym_cmp,
+        .print  = sort__sym_print,
+};
+
+/* --sort parent */
+
+static int64_t
+sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct symbol *sym_l = left->parent;
+        struct symbol *sym_r = right->parent;
+
+        if (!sym_l || !sym_r)
+                return cmp_null(sym_l, sym_r);
+
+        return strcmp(sym_l->name, sym_r->name);
+}
+
+static size_t
+sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width)
+{
+        return repsep_fprintf(fp, "%-*s", width,
+                              self->parent ? self->parent->name : "[other]");
+}
+
+static unsigned int parent_symbol__col_width;
+
+static struct sort_entry sort_parent = {
+        .header = "Parent symbol",
+        .cmp    = sort__parent_cmp,
+        .print  = sort__parent_print,
+        .width  = &parent_symbol__col_width,
+};
+
+static int sort__need_collapse = 0;
+static int sort__has_parent = 0;
+
+struct sort_dimension {
+        char                    *name;
+        struct sort_entry       *entry;
+        int                     taken;
+};
+
+static struct sort_dimension sort_dimensions[] = {
+        { .name = "pid",        .entry = &sort_thread,  },
+        { .name = "comm",       .entry = &sort_comm,    },
+        { .name = "dso",        .entry = &sort_dso,     },
+        { .name = "symbol",     .entry = &sort_sym,     },
+        { .name = "parent",     .entry = &sort_parent,  },
+};
+
+static LIST_HEAD(hist_entry__sort_list);
+
+static int sort_dimension__add(char *tok)
+{
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
+                struct sort_dimension *sd = &sort_dimensions[i];
+
+                if (sd->taken)
+                        continue;
+
+                if (strncasecmp(tok, sd->name, strlen(tok)))
+                        continue;
+
+                if (sd->entry->collapse)
+                        sort__need_collapse = 1;
+
+                if (sd->entry == &sort_parent) {
+                        int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
+                        if (ret) {
+                                char err[BUFSIZ];
+
+                                regerror(ret, &parent_regex, err, sizeof(err));
+                                fprintf(stderr, "Invalid regex: %s\n%s",
+                                        parent_pattern, err);
+                                exit(-1);
+                        }
+                        sort__has_parent = 1;
+                }
+
+                list_add_tail(&sd->entry->list, &hist_entry__sort_list);
+                sd->taken = 1;
+
+                return 0;
+        }
+
+        return -ESRCH;
+}
+
+static int64_t
+hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct sort_entry *se;
+        int64_t cmp = 0;
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                cmp = se->cmp(left, right);
+                if (cmp)
+                        break;
+        }
+
+        return cmp;
+}
+
+static int64_t
+hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
+{
+        struct sort_entry *se;
+        int64_t cmp = 0;
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                int64_t (*f)(struct hist_entry *, struct hist_entry *);
+
+                f = se->collapse ?: se->cmp;
+
+                cmp = f(left, right);
+                if (cmp)
+                        break;
+        }
+
+        return cmp;
+}
+
+static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask)
+{
+        int i;
+        size_t ret = 0;
+
+        ret += fprintf(fp, "%s", "                ");
+
+        for (i = 0; i < depth; i++)
+                if (depth_mask & (1 << i))
+                        ret += fprintf(fp, "|          ");
+                else
+                        ret += fprintf(fp, "           ");
+
+        ret += fprintf(fp, "\n");
+
+        return ret;
+}
+static size_t
+ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain, int depth,
+                       int depth_mask, int count, u64 total_samples,
+                       int hits)
+{
+        int i;
+        size_t ret = 0;
+
+        ret += fprintf(fp, "%s", "                ");
+        for (i = 0; i < depth; i++) {
+                if (depth_mask & (1 << i))
+                        ret += fprintf(fp, "|");
+                else
+                        ret += fprintf(fp, " ");
+                if (!count && i == depth - 1) {
+                        double percent;
+
+                        percent = hits * 100.0 / total_samples;
+                        ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
+                } else
+                        ret += fprintf(fp, "%s", "          ");
+        }
+        if (chain->sym)
+                ret += fprintf(fp, "%s\n", chain->sym->name);
+        else
+                ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
+
+        return ret;
+}
+
+static struct symbol *rem_sq_bracket;
+static struct callchain_list rem_hits;
+
+static void init_rem_hits(void)
+{
+        rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
+        if (!rem_sq_bracket) {
+                fprintf(stderr, "Not enough memory to display remaining hits\n");
+                return;
+        }
+
+        strcpy(rem_sq_bracket->name, "[...]");
+        rem_hits.sym = rem_sq_bracket;
+}
+
+static size_t
+callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
+                        u64 total_samples, int depth, int depth_mask)
+{
+        struct rb_node *node, *next;
+        struct callchain_node *child;
+        struct callchain_list *chain;
+        int new_depth_mask = depth_mask;
+        u64 new_total;
+        u64 remaining;
+        size_t ret = 0;
+        int i;
+
+        if (callchain_param.mode == CHAIN_GRAPH_REL)
+                new_total = self->children_hit;
+        else
+                new_total = total_samples;
+
+        remaining = new_total;
+
+        node = rb_first(&self->rb_root);
+        while (node) {
+                u64 cumul;
+
+                child = rb_entry(node, struct callchain_node, rb_node);
+                cumul = cumul_hits(child);
+                remaining -= cumul;
+
+                /*
+                 * The depth mask manages the output of pipes that show
+                 * the depth. We don't want to keep the pipes of the current
+                 * level for the last child of this depth.
+                 * Except if we have remaining filtered hits. They will
+                 * supersede the last child
+                 */
+                next = rb_next(node);
+                if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
+                        new_depth_mask &= ~(1 << (depth - 1));
+
+                /*
+                 * But we keep the older depth mask for the line seperator
+                 * to keep the level link until we reach the last child
+                 */
+                ret += ipchain__fprintf_graph_line(fp, depth, depth_mask);
+                i = 0;
+                list_for_each_entry(chain, &child->val, list) {
+                        if (chain->ip >= PERF_CONTEXT_MAX)
+                                continue;
+                        ret += ipchain__fprintf_graph(fp, chain, depth,
+                                                      new_depth_mask, i++,
+                                                      new_total,
+                                                      cumul);
+                }
+                ret += callchain__fprintf_graph(fp, child, new_total,
+                                                depth + 1,
+                                                new_depth_mask | (1 << depth));
+                node = next;
+        }
+
+        if (callchain_param.mode == CHAIN_GRAPH_REL &&
+                remaining && remaining != new_total) {
+
+                if (!rem_sq_bracket)
+                        return ret;
+
+                new_depth_mask &= ~(1 << (depth - 1));
+
+                ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
+                                              new_depth_mask, 0, new_total,
+                                              remaining);
+        }
+
+        return ret;
+}
+
+static size_t
+callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
+                        u64 total_samples)
+{
+        struct callchain_list *chain;
+        size_t ret = 0;
+
+        if (!self)
+                return 0;
+
+        ret += callchain__fprintf_flat(fp, self->parent, total_samples);
+
+
+        list_for_each_entry(chain, &self->val, list) {
+                if (chain->ip >= PERF_CONTEXT_MAX)
+                        continue;
+                if (chain->sym)
+                        ret += fprintf(fp, "                %s\n", chain->sym->name);
+                else
+                        ret += fprintf(fp, "                %p\n",
+                                        (void *)(long)chain->ip);
+        }
+
+        return ret;
+}
+
+static size_t
+hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
+                              u64 total_samples)
+{
+        struct rb_node *rb_node;
+        struct callchain_node *chain;
+        size_t ret = 0;
+
+        rb_node = rb_first(&self->sorted_chain);
+        while (rb_node) {
+                double percent;
+
+                chain = rb_entry(rb_node, struct callchain_node, rb_node);
+                percent = chain->hit * 100.0 / total_samples;
+                switch (callchain_param.mode) {
+                case CHAIN_FLAT:
+                        ret += percent_color_fprintf(fp, "           %6.2f%%\n",
+                                                     percent);
+                        ret += callchain__fprintf_flat(fp, chain, total_samples);
+                        break;
+                case CHAIN_GRAPH_ABS: /* Falldown */
+                case CHAIN_GRAPH_REL:
+                        ret += callchain__fprintf_graph(fp, chain,
+                                                        total_samples, 1, 1);
+                default:
+                        break;
+                }
+                ret += fprintf(fp, "\n");
+                rb_node = rb_next(rb_node);
+        }
+
+        return ret;
+}
+
+
+static size_t
+hist_entry__fprintf(FILE *fp, struct hist_entry *self, u64 total_samples)
+{
+        struct sort_entry *se;
+        size_t ret;
+
+        if (exclude_other && !self->parent)
+                return 0;
+
+        if (total_samples)
+                ret = percent_color_fprintf(fp,
+                                            field_sep ? "%.2f" : "   %6.2f%%",
+                                        (self->count * 100.0) / total_samples);
+        else
+                ret = fprintf(fp, field_sep ? "%lld" : "%12lld ", self->count);
+
+        if (show_nr_samples) {
+                if (field_sep)
+                        fprintf(fp, "%c%lld", *field_sep, self->count);
+                else
+                        fprintf(fp, "%11lld", self->count);
+        }
+
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                if (se->elide)
+                        continue;
+
+                fprintf(fp, "%s", field_sep ?: "  ");
+                ret += se->print(fp, self, se->width ? *se->width : 0);
+        }
+
+        ret += fprintf(fp, "\n");
+
+        if (callchain)
+                hist_entry_callchain__fprintf(fp, self, total_samples);
+
+        return ret;
+}
+
+/*
+ *
+ */
+
+static void dso__calc_col_width(struct dso *self)
+{
+        if (!col_width_list_str && !field_sep &&
+            (!dso_list || strlist__has_entry(dso_list, self->name))) {
+                unsigned int slen = strlen(self->name);
+                if (slen > dsos__col_width)
+                        dsos__col_width = slen;
+        }
+
+        self->slen_calculated = 1;
+}
+
+static struct symbol *
+resolve_symbol(struct thread *thread, struct map **mapp,
+               struct dso **dsop, u64 *ipp)
+{
+        struct dso *dso = dsop ? *dsop : NULL;
+        struct map *map = mapp ? *mapp : NULL;
+        u64 ip = *ipp;
+
+        if (!thread)
+                return NULL;
+
+        if (dso)
+                goto got_dso;
+
+        if (map)
+                goto got_map;
+
+        map = thread__find_map(thread, ip);
+        if (map != NULL) {
+                /*
+                 * We have to do this here as we may have a dso
+                 * with no symbol hit that has a name longer than
+                 * the ones with symbols sampled.
+                 */
+                if (!sort_dso.elide && !map->dso->slen_calculated)
+                        dso__calc_col_width(map->dso);
+
+                if (mapp)
+                        *mapp = map;
+got_map:
+                ip = map->map_ip(map, ip);
+
+                dso = map->dso;
+        } else {
+                /*
+                 * If this is outside of all known maps,
+                 * and is a negative address, try to look it
+                 * up in the kernel dso, as it might be a
+                 * vsyscall (which executes in user-mode):
+                 */
+                if ((long long)ip < 0)
+                dso = kernel_dso;
+        }
+        dprintf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
+        dprintf(" ...... map: %Lx -> %Lx\n", *ipp, ip);
+        *ipp  = ip;
+
+        if (dsop)
+                *dsop = dso;
+
+        if (!dso)
+                return NULL;
+got_dso:
+        return dso->find_symbol(dso, ip);
+}
+
+static int call__match(struct symbol *sym)
+{
+        if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
+                return 1;
+
+        return 0;
+}
+
+static struct symbol **
+resolve_callchain(struct thread *thread, struct map *map __used,
+                    struct ip_callchain *chain, struct hist_entry *entry)
+{
+        u64 context = PERF_CONTEXT_MAX;
+        struct symbol **syms = NULL;
+        unsigned int i;
+
+        if (callchain) {
+                syms = calloc(chain->nr, sizeof(*syms));
+                if (!syms) {
+                        fprintf(stderr, "Can't allocate memory for symbols\n");
+                        exit(-1);
+                }
+        }
+
+        for (i = 0; i < chain->nr; i++) {
+                u64 ip = chain->ips[i];
+                struct dso *dso = NULL;
+                struct symbol *sym;
+
+                if (ip >= PERF_CONTEXT_MAX) {
+                        context = ip;
+                        continue;
+                }
+
+                switch (context) {
+                case PERF_CONTEXT_HV:
+                        dso = hypervisor_dso;
+                        break;
+                case PERF_CONTEXT_KERNEL:
+                        dso = kernel_dso;
+                        break;
+                default:
+                        break;
+                }
+
+                sym = resolve_symbol(thread, NULL, &dso, &ip);
+
+                if (sym) {
+                        if (sort__has_parent && call__match(sym) &&
+                            !entry->parent)
+                                entry->parent = sym;
+                        if (!callchain)
+                                break;
+                        syms[i] = sym;
+                }
+        }
+
+        return syms;
+}
+
+/*
+ * collect histogram counts
+ */
+
+static int
+hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
+                struct symbol *sym, u64 ip, struct ip_callchain *chain,
+                char level, u64 count)
+{
+        struct rb_node **p = &hist.rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *he;
+        struct symbol **syms = NULL;
+        struct hist_entry entry = {
+                .thread = thread,
+                .map    = map,
+                .dso    = dso,
+                .sym    = sym,
+                .ip     = ip,
+                .level  = level,
+                .count  = count,
+                .parent = NULL,
+                .sorted_chain = RB_ROOT
+        };
+        int cmp;
+
+        if ((sort__has_parent || callchain) && chain)
+                syms = resolve_callchain(thread, map, chain, &entry);
+
+        while (*p != NULL) {
+                parent = *p;
+                he = rb_entry(parent, struct hist_entry, rb_node);
+
+                cmp = hist_entry__cmp(&entry, he);
+
+                if (!cmp) {
+                        he->count += count;
+                        if (callchain) {
+                                append_chain(&he->callchain, chain, syms);
+                                free(syms);
+                        }
+                        return 0;
+                }
+
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        he = malloc(sizeof(*he));
+        if (!he)
+                return -ENOMEM;
+        *he = entry;
+        if (callchain) {
+                callchain_init(&he->callchain);
+                append_chain(&he->callchain, chain, syms);
+                free(syms);
+        }
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, &hist);
+
+        return 0;
+}
+
+static void hist_entry__free(struct hist_entry *he)
+{
+        free(he);
+}
+
+/*
+ * collapse the histogram
+ */
+
+static struct rb_root collapse_hists;
+
+static void collapse__insert_entry(struct hist_entry *he)
+{
+        struct rb_node **p = &collapse_hists.rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *iter;
+        int64_t cmp;
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct hist_entry, rb_node);
+
+                cmp = hist_entry__collapse(iter, he);
+
+                if (!cmp) {
+                        iter->count += he->count;
+                        hist_entry__free(he);
+                        return;
+                }
+
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, &collapse_hists);
+}
+
+static void collapse__resort(void)
+{
+        struct rb_node *next;
+        struct hist_entry *n;
+
+        if (!sort__need_collapse)
+                return;
+
+        next = rb_first(&hist);
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                next = rb_next(&n->rb_node);
+
+                rb_erase(&n->rb_node, &hist);
+                collapse__insert_entry(n);
+        }
+}
+
+/*
+ * reverse the map, sort on count.
+ */
+
+static struct rb_root output_hists;
+
+static void output__insert_entry(struct hist_entry *he, u64 min_callchain_hits)
+{
+        struct rb_node **p = &output_hists.rb_node;
+        struct rb_node *parent = NULL;
+        struct hist_entry *iter;
+
+        if (callchain)
+                callchain_param.sort(&he->sorted_chain, &he->callchain,
+                                      min_callchain_hits, &callchain_param);
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct hist_entry, rb_node);
+
+                if (he->count > iter->count)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&he->rb_node, parent, p);
+        rb_insert_color(&he->rb_node, &output_hists);
+}
+
+static void output__resort(u64 total_samples)
+{
+        struct rb_node *next;
+        struct hist_entry *n;
+        struct rb_root *tree = &hist;
+        u64 min_callchain_hits;
+
+        min_callchain_hits = total_samples * (callchain_param.min_percent / 100);
+
+        if (sort__need_collapse)
+                tree = &collapse_hists;
+
+        next = rb_first(tree);
+
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                next = rb_next(&n->rb_node);
+
+                rb_erase(&n->rb_node, tree);
+                output__insert_entry(n, min_callchain_hits);
+        }
+}
+
+static size_t output__fprintf(FILE *fp, u64 total_samples)
+{
+        struct hist_entry *pos;
+        struct sort_entry *se;
+        struct rb_node *nd;
+        size_t ret = 0;
+        unsigned int width;
+        char *col_width = col_width_list_str;
+
+        init_rem_hits();
+
+        fprintf(fp, "# Samples: %Ld\n", (u64)total_samples);
+        fprintf(fp, "#\n");
+
+        fprintf(fp, "# Overhead");
+        if (show_nr_samples) {
+                if (field_sep)
+                        fprintf(fp, "%cSamples", *field_sep);
+                else
+                        fputs("  Samples  ", fp);
+        }
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                if (se->elide)
+                        continue;
+                if (field_sep) {
+                        fprintf(fp, "%c%s", *field_sep, se->header);
+                        continue;
+                }
+                width = strlen(se->header);
+                if (se->width) {
+                        if (col_width_list_str) {
+                                if (col_width) {
+                                        *se->width = atoi(col_width);
+                                        col_width = strchr(col_width, ',');
+                                        if (col_width)
+                                                ++col_width;
+                                }
+                        }
+                        width = *se->width = max(*se->width, width);
+                }
+                fprintf(fp, "  %*s", width, se->header);
+        }
+        fprintf(fp, "\n");
+
+        if (field_sep)
+                goto print_entries;
+
+        fprintf(fp, "# ........");
+        if (show_nr_samples)
+                fprintf(fp, " ..........");
+        list_for_each_entry(se, &hist_entry__sort_list, list) {
+                unsigned int i;
+
+                if (se->elide)
+                        continue;
+
+                fprintf(fp, "  ");
+                if (se->width)
+                        width = *se->width;
+                else
+                        width = strlen(se->header);
+                for (i = 0; i < width; i++)
+                        fprintf(fp, ".");
+        }
+        fprintf(fp, "\n");
+
+        fprintf(fp, "#\n");
+
+print_entries:
+        for (nd = rb_first(&output_hists); nd; nd = rb_next(nd)) {
+                pos = rb_entry(nd, struct hist_entry, rb_node);
+                ret += hist_entry__fprintf(fp, pos, total_samples);
+        }
+
+        if (sort_order == default_sort_order &&
+                        parent_pattern == default_parent_pattern) {
+                fprintf(fp, "#\n");
+                fprintf(fp, "# (For a higher level overview, try: perf report --sort comm,dso)\n");
+                fprintf(fp, "#\n");
+        }
+        fprintf(fp, "\n");
+
+        free(rem_sq_bracket);
+
+        return ret;
+}
+
+static void register_idle_thread(void)
+{
+        struct thread *thread = threads__findnew(0);
+
+        if (thread == NULL ||
+                        thread__set_comm(thread, "[idle]")) {
+                fprintf(stderr, "problem inserting idle task.\n");
+                exit(-1);
+        }
+}
+
+static unsigned long total = 0,
+                     total_mmap = 0,
+                     total_comm = 0,
+                     total_fork = 0,
+                     total_unknown = 0,
+                     total_lost = 0;
+
+static int validate_chain(struct ip_callchain *chain, event_t *event)
+{
+        unsigned int chain_size;
+
+        chain_size = event->header.size;
+        chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
+
+        if (chain->nr*sizeof(u64) > chain_size)
+                return -1;
+
+        return 0;
+}
+
+static int
+process_sample_event(event_t *event, unsigned long offset, unsigned long head)
+{
+        char level;
+        int show = 0;
+        struct dso *dso = NULL;
+        struct thread *thread = threads__findnew(event->ip.pid);
+        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;
+
+        if (sample_type & PERF_SAMPLE_PERIOD) {
+                period = *(u64 *)more_data;
+                more_data += sizeof(u64);
+        }
+
+        dprintf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d/%d: %p period: %Ld\n",
+                (void *)(offset + head),
+                (void *)(long)(event->header.size),
+                event->header.misc,
+                event->ip.pid, event->ip.tid,
+                (void *)(long)ip,
+                (long long)period);
+
+        if (sample_type & PERF_SAMPLE_CALLCHAIN) {
+                unsigned int i;
+
+                chain = (void *)more_data;
+
+                dprintf("... chain: nr:%Lu\n", chain->nr);
+
+                if (validate_chain(chain, event) < 0) {
+                        eprintf("call-chain problem with event, skipping it.\n");
+                        return 0;
+                }
+
+                if (dump_trace) {
+                        for (i = 0; i < chain->nr; i++)
+                                dprintf("..... %2d: %016Lx\n", i, chain->ips[i]);
+                }
+        }
+
+        dprintf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
+        if (thread == NULL) {
+                eprintf("problem processing %d event, skipping it.\n",
+                        event->header.type);
+                return -1;
+        }
+
+        if (comm_list && !strlist__has_entry(comm_list, thread->comm))
+                return 0;
+
+        cpumode = event->header.misc & PERF_EVENT_MISC_CPUMODE_MASK;
+
+        if (cpumode == PERF_EVENT_MISC_KERNEL) {
+                show = SHOW_KERNEL;
+                level = 'k';
+
+                dso = kernel_dso;
+
+                dprintf(" ...... dso: %s\n", dso->name);
+
+        } else if (cpumode == PERF_EVENT_MISC_USER) {
+
+                show = SHOW_USER;
+                level = '.';
+
+        } else {
+                show = SHOW_HV;
+                level = 'H';
+
+                dso = hypervisor_dso;
+
+                dprintf(" ...... dso: [hypervisor]\n");
+        }
+
+        if (show & show_mask) {
+                struct symbol *sym = resolve_symbol(thread, &map, &dso, &ip);
+
+                if (dso_list && (!dso || !dso->name ||
+                                 !strlist__has_entry(dso_list, dso->name)))
+                        return 0;
+
+                if (sym_list && (!sym || !strlist__has_entry(sym_list, sym->name)))
+                        return 0;
+
+                if (hist_entry__add(thread, map, dso, sym, ip, chain, level, period)) {
+                        eprintf("problem incrementing symbol count, skipping event\n");
+                        return -1;
+                }
+        }
+        total += period;
+
+        return 0;
+}
+
+static int
+process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
+{
+        struct thread *thread = threads__findnew(event->mmap.pid);
+        struct map *map = map__new(&event->mmap);
+
+        dprintf("%p [%p]: PERF_EVENT_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) {
+                dprintf("problem processing PERF_EVENT_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 = threads__findnew(event->comm.pid);
+
+        dprintf("%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)) {
+                dprintf("problem processing PERF_EVENT_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 = threads__findnew(event->fork.pid);
+        struct thread *parent = threads__findnew(event->fork.ppid);
+
+        dprintf("%p [%p]: PERF_EVENT_%s: (%d:%d):(%d:%d)\n",
+                (void *)(offset + head),
+                (void *)(long)(event->header.size),
+                event->header.type == PERF_EVENT_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_EVENT_EXIT)
+                return 0;
+
+        if (!thread || !parent || thread__fork(thread, parent)) {
+                dprintf("problem processing PERF_EVENT_FORK, skipping event.\n");
+                return -1;
+        }
+        total_fork++;
+
+        return 0;
+}
+
+static int
+process_lost_event(event_t *event, unsigned long offset, unsigned long head)
+{
+        dprintf("%p [%p]: PERF_EVENT_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 void trace_event(event_t *event)
+{
+        unsigned char *raw_event = (void *)event;
+        char *color = PERF_COLOR_BLUE;
+        int i, j;
+
+        if (!dump_trace)
+                return;
+
+        dprintf(".");
+        cdprintf("\n. ... raw event: size %d bytes\n", event->header.size);
+
+        for (i = 0; i < event->header.size; i++) {
+                if ((i & 15) == 0) {
+                        dprintf(".");
+                        cdprintf("  %04x: ", i);
+                }
+
+                cdprintf(" %02x", raw_event[i]);
+
+                if (((i & 15) == 15) || i == event->header.size-1) {
+                        cdprintf("  ");
+                        for (j = 0; j < 15-(i & 15); j++)
+                                cdprintf("   ");
+                        for (j = 0; j < (i & 15); j++) {
+                                if (isprint(raw_event[i-15+j]))
+                                        cdprintf("%c", raw_event[i-15+j]);
+                                else
+                                        cdprintf(".");
+                        }
+                        cdprintf("\n");
+                }
+        }
+        dprintf(".\n");
+}
+
+static struct perf_header       *header;
+
+static struct perf_counter_attr *perf_header__find_attr(u64 id)
+{
+        int i;
+
+        for (i = 0; i < header->attrs; i++) {
+                struct perf_header_attr *attr = header->attr[i];
+                int j;
+
+                for (j = 0; j < attr->ids; j++) {
+                        if (attr->id[j] == id)
+                                return &attr->attr;
+                }
+        }
+
+        return NULL;
+}
+
+static int
+process_read_event(event_t *event, unsigned long offset, unsigned long head)
+{
+        struct perf_counter_attr *attr = perf_header__find_attr(event->read.id);
+
+        dprintf("%p [%p]: PERF_EVENT_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);
+
+        return 0;
+}
+
+static int
+process_event(event_t *event, unsigned long offset, unsigned long head)
+{
+        trace_event(event);
+
+        switch (event->header.type) {
+        case PERF_EVENT_SAMPLE:
+                return process_sample_event(event, offset, head);
+
+        case PERF_EVENT_MMAP:
+                return process_mmap_event(event, offset, head);
+
+        case PERF_EVENT_COMM:
+                return process_comm_event(event, offset, head);
+
+        case PERF_EVENT_FORK:
+        case PERF_EVENT_EXIT:
+                return process_task_event(event, offset, head);
+
+        case PERF_EVENT_LOST:
+                return process_lost_event(event, offset, head);
+
+        case PERF_EVENT_READ:
+                return process_read_event(event, offset, head);
+
+        /*
+         * We dont process them right now but they are fine:
+         */
+
+        case PERF_EVENT_THROTTLE:
+        case PERF_EVENT_UNTHROTTLE:
+                return 0;
+
+        default:
+                return -1;
+        }
+
+        return 0;
+}
+
+static u64 perf_header__sample_type(void)
+{
+        u64 sample_type = 0;
+        int i;
+
+        for (i = 0; i < header->attrs; i++) {
+                struct perf_header_attr *attr = header->attr[i];
+
+                if (!sample_type)
+                        sample_type = attr->attr.sample_type;
+                else if (sample_type != attr->attr.sample_type)
+                        die("non matching sample_type");
+        }
+
+        return sample_type;
+}
+
+static int __cmd_report(void)
+{
+        int ret, rc = EXIT_FAILURE;
+        unsigned long offset = 0;
+        unsigned long head, shift;
+        struct stat stat;
+        event_t *event;
+        uint32_t size;
+        char *buf;
+
+        register_idle_thread();
+
+        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, &stat);
+        if (ret < 0) {
+                perror("failed to stat file");
+                exit(-1);
+        }
+
+        if (!force && (stat.st_uid != geteuid())) {
+                fprintf(stderr, "file: %s not owned by current user\n", input_name);
+                exit(-1);
+        }
+
+        if (!stat.st_size) {
+                fprintf(stderr, "zero-sized file, nothing to do!\n");
+                exit(0);
+        }
+
+        header = perf_header__read(input);
+        head = header->data_offset;
+
+        sample_type = perf_header__sample_type();
+
+        if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {
+                if (sort__has_parent) {
+                        fprintf(stderr, "selected --sort parent, but no"
+                                        " callchain data. Did you call"
+                                        " perf record without -g?\n");
+                        exit(-1);
+                }
+                if (callchain) {
+                        fprintf(stderr, "selected -c but no callchain data."
+                                        " Did you call perf record without"
+                                        " -g?\n");
+                        exit(-1);
+                }
+        } else if (callchain_param.mode != CHAIN_NONE && !callchain) {
+                        callchain = 1;
+                        if (register_callchain_param(&callchain_param) < 0) {
+                                fprintf(stderr, "Can't register callchain"
+                                                " params\n");
+                                exit(-1);
+                        }
+        }
+
+        if (load_kernel() < 0) {
+                perror("failed to load kernel symbols");
+                return EXIT_FAILURE;
+        }
+
+        if (!full_paths) {
+                if (getcwd(__cwd, sizeof(__cwd)) == NULL) {
+                        perror("failed to get the current directory");
+                        return EXIT_FAILURE;
+                }
+                cwdlen = strlen(cwd);
+        } else {
+                cwd = NULL;
+                cwdlen = 0;
+        }
+
+        shift = page_size * (head / page_size);
+        offset += shift;
+        head -= shift;
+
+remap:
+        buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
+                           MAP_SHARED, input, offset);
+        if (buf == MAP_FAILED) {
+                perror("failed to mmap file");
+                exit(-1);
+        }
+
+more:
+        event = (event_t *)(buf + head);
+
+        size = event->header.size;
+        if (!size)
+                size = 8;
+
+        if (head + event->header.size >= page_size * mmap_window) {
+                int ret;
+
+                shift = page_size * (head / page_size);
+
+                ret = munmap(buf, page_size * mmap_window);
+                assert(ret == 0);
+
+                offset += shift;
+                head -= shift;
+                goto remap;
+        }
+
+        size = event->header.size;
+
+        dprintf("\n%p [%p]: event: %d\n",
+                        (void *)(offset + head),
+                        (void *)(long)event->header.size,
+                        event->header.type);
+
+        if (!size || process_event(event, offset, head) < 0) {
+
+                dprintf("%p [%p]: skipping unknown header type: %d\n",
+                        (void *)(offset + head),
+                        (void *)(long)(event->header.size),
+                        event->header.type);
+
+                total_unknown++;
+
+                /*
+                 * assume we lost track of the stream, check alignment, and
+                 * increment a single u64 in the hope to catch on again 'soon'.
+                 */
+
+                if (unlikely(head & 7))
+                        head &= ~7ULL;
+
+                size = 8;
+        }
+
+        head += size;
+
+        if (offset + head >= header->data_offset + header->data_size)
+                goto done;
+
+        if (offset + head < (unsigned long)stat.st_size)
+                goto more;
+
+done:
+        rc = EXIT_SUCCESS;
+        close(input);
+
+        dprintf("      IP events: %10ld\n", total);
+        dprintf("    mmap events: %10ld\n", total_mmap);
+        dprintf("    comm events: %10ld\n", total_comm);
+        dprintf("    fork events: %10ld\n", total_fork);
+        dprintf("    lost events: %10ld\n", total_lost);
+        dprintf(" unknown events: %10ld\n", total_unknown);
+
+        if (dump_trace)
+                return 0;
+
+        if (verbose >= 3)
+                threads__fprintf(stdout);
+
+        if (verbose >= 2)
+                dsos__fprintf(stdout);
+
+        collapse__resort();
+        output__resort(total);
+        output__fprintf(stdout, total);
+
+        return rc;
+}
+
+static int
+parse_callchain_opt(const struct option *opt __used, const char *arg,
+                    int unset __used)
+{
+        char *tok;
+        char *endptr;
+
+        callchain = 1;
+
+        if (!arg)
+                return 0;
+
+        tok = strtok((char *)arg, ",");
+        if (!tok)
+                return -1;
+
+        /* get the output mode */
+        if (!strncmp(tok, "graph", strlen(arg)))
+                callchain_param.mode = CHAIN_GRAPH_ABS;
+
+        else if (!strncmp(tok, "flat", strlen(arg)))
+                callchain_param.mode = CHAIN_FLAT;
+
+        else if (!strncmp(tok, "fractal", strlen(arg)))
+                callchain_param.mode = CHAIN_GRAPH_REL;
+
+        else if (!strncmp(tok, "none", strlen(arg))) {
+                callchain_param.mode = CHAIN_NONE;
+                callchain = 0;
+
+                return 0;
+        }
+
+        else
+                return -1;
+
+        /* get the min percentage */
+        tok = strtok(NULL, ",");
+        if (!tok)
+                goto setup;
+
+        callchain_param.min_percent = strtod(tok, &endptr);
+        if (tok == endptr)
+                return -1;
+
+setup:
+        if (register_callchain_param(&callchain_param) < 0) {
+                fprintf(stderr, "Can't register callchain params\n");
+                return -1;
+        }
+        return 0;
+}
+
+static const char * const report_usage[] = {
+        "perf report [<options>] <command>",
+        NULL
+};
+
+static const struct option options[] = {
+        OPT_STRING('i', "input", &input_name, "file",
+                    "input file name"),
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose (show symbol address, etc)"),
+        OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
+                    "dump raw trace in ASCII"),
+        OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
+        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
+        OPT_BOOLEAN('m', "modules", &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"),
+        OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
+                   "sort by key(s): pid, comm, dso, symbol, parent"),
+        OPT_BOOLEAN('P', "full-paths", &full_paths,
+                    "Don't shorten the pathnames taking into account the cwd"),
+        OPT_STRING('p', "parent", &parent_pattern, "regex",
+                   "regex filter to identify parent, see: '--sort parent'"),
+        OPT_BOOLEAN('x', "exclude-other", &exclude_other,
+                    "Only display entries with parent-match"),
+        OPT_CALLBACK_DEFAULT('g', "call-graph", NULL, "output_type,min_percent",
+                     "Display callchains using output_type and min percent threshold. "
+                     "Default: fractal,0.5", &parse_callchain_opt, callchain_default_opt),
+        OPT_STRING('d', "dsos", &dso_list_str, "dso[,dso...]",
+                   "only consider symbols in these dsos"),
+        OPT_STRING('C', "comms", &comm_list_str, "comm[,comm...]",
+                   "only consider symbols in these comms"),
+        OPT_STRING('S', "symbols", &sym_list_str, "symbol[,symbol...]",
+                   "only consider these symbols"),
+        OPT_STRING('w', "column-widths", &col_width_list_str,
+                   "width[,width...]",
+                   "don't try to adjust column width, use these fixed values"),
+        OPT_STRING('t', "field-separator", &field_sep, "separator",
+                   "separator for columns, no spaces will be added between "
+                   "columns '.' is reserved."),
+        OPT_END()
+};
+
+static void setup_sorting(void)
+{
+        char *tmp, *tok, *str = strdup(sort_order);
+
+        for (tok = strtok_r(str, ", ", &tmp);
+                        tok; tok = strtok_r(NULL, ", ", &tmp)) {
+                if (sort_dimension__add(tok) < 0) {
+                        error("Unknown --sort key: `%s'", tok);
+                        usage_with_options(report_usage, options);
+                }
+        }
+
+        free(str);
+}
+
+static void setup_list(struct strlist **list, const char *list_str,
+                       struct sort_entry *se, const char *list_name,
+                       FILE *fp)
+{
+        if (list_str) {
+                *list = strlist__new(true, list_str);
+                if (!*list) {
+                        fprintf(stderr, "problems parsing %s list\n",
+                                list_name);
+                        exit(129);
+                }
+                if (strlist__nr_entries(*list) == 1) {
+                        fprintf(fp, "# %s: %s\n", list_name,
+                                strlist__entry(*list, 0)->s);
+                        se->elide = true;
+                }
+        }
+}
+
+int cmd_report(int argc, const char **argv, const char *prefix __used)
+{
+        symbol__init();
+
+        page_size = getpagesize();
+
+        argc = parse_options(argc, argv, options, report_usage, 0);
+
+        setup_sorting();
+
+        if (parent_pattern != default_parent_pattern) {
+                sort_dimension__add("parent");
+                sort_parent.elide = 1;
+        } else
+                exclude_other = 0;
+
+        /*
+         * Any (unrecognized) arguments left?
+         */
+        if (argc)
+                usage_with_options(report_usage, options);
+
+        setup_pager();
+
+        setup_list(&dso_list, dso_list_str, &sort_dso, "dso", stdout);
+        setup_list(&comm_list, comm_list_str, &sort_comm, "comm", stdout);
+        setup_list(&sym_list, sym_list_str, &sort_sym, "symbol", stdout);
+
+        if (field_sep && *field_sep == '.') {
+                fputs("'.' is the only non valid --field-separator argument\n",
+                      stderr);
+                exit(129);
+        }
+
+        return __cmd_report();
+}
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
new file mode 100644
index 000000000000..b4b06c7903e1
--- /dev/null
+++ b/tools/perf/builtin-stat.c
@@ -0,0 +1,552 @@
+/*
+ * builtin-stat.c
+ *
+ * Builtin stat command: Give a precise performance counters summary
+ * overview about any workload, CPU or specific PID.
+ *
+ * Sample output:
+
+   $ perf stat ~/hackbench 10
+   Time: 0.104
+
+    Performance counter stats for '/home/mingo/hackbench':
+
+       1255.538611  task clock ticks     #      10.143 CPU utilization factor
+             54011  context switches     #       0.043 M/sec
+               385  CPU migrations       #       0.000 M/sec
+             17755  pagefaults           #       0.014 M/sec
+        3808323185  CPU cycles           #    3033.219 M/sec
+        1575111190  instructions         #    1254.530 M/sec
+          17367895  cache references     #      13.833 M/sec
+           7674421  cache misses         #       6.112 M/sec
+
+    Wall-clock time elapsed:   123.786620 msecs
+
+ *
+ * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
+ *
+ * Improvements and fixes by:
+ *
+ *   Arjan van de Ven <arjan@linux.intel.com>
+ *   Yanmin Zhang <yanmin.zhang@intel.com>
+ *   Wu Fengguang <fengguang.wu@intel.com>
+ *   Mike Galbraith <efault@gmx.de>
+ *   Paul Mackerras <paulus@samba.org>
+ *   Jaswinder Singh Rajput <jaswinder@kernel.org>
+ *
+ * Released under the GPL v2. (and only v2, not any later version)
+ */
+
+#include "perf.h"
+#include "builtin.h"
+#include "util/util.h"
+#include "util/parse-options.h"
+#include "util/parse-events.h"
+
+#include <sys/prctl.h>
+#include <math.h>
+
+static struct perf_counter_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    },
+
+};
+
+#define MAX_RUN                 100
+
+static int                      system_wide                     =  0;
+static int                      verbose                         =  0;
+static unsigned int             nr_cpus                         =  0;
+static int                      run_idx                         =  0;
+
+static int                      run_count                       =  1;
+static int                      inherit                         =  1;
+static int                      scale                           =  1;
+static int                      target_pid                      = -1;
+static int                      null_run                        =  0;
+
+static int                      fd[MAX_NR_CPUS][MAX_COUNTERS];
+
+static u64                      runtime_nsecs[MAX_RUN];
+static u64                      walltime_nsecs[MAX_RUN];
+static u64                      runtime_cycles[MAX_RUN];
+
+static u64                      event_res[MAX_RUN][MAX_COUNTERS][3];
+static u64                      event_scaled[MAX_RUN][MAX_COUNTERS];
+
+static u64                      event_res_avg[MAX_COUNTERS][3];
+static u64                      event_res_noise[MAX_COUNTERS][3];
+
+static u64                      event_scaled_avg[MAX_COUNTERS];
+
+static u64                      runtime_nsecs_avg;
+static u64                      runtime_nsecs_noise;
+
+static u64                      walltime_nsecs_avg;
+static u64                      walltime_nsecs_noise;
+
+static u64                      runtime_cycles_avg;
+static u64                      runtime_cycles_noise;
+
+#define MATCH_EVENT(t, c, counter)                      \
+        (attrs[counter].type == PERF_TYPE_##t &&        \
+         attrs[counter].config == PERF_COUNT_##c)
+
+#define ERR_PERF_OPEN \
+"Error: counter %d, sys_perf_counter_open() syscall returned with %d (%s)\n"
+
+static void create_perf_stat_counter(int counter, int pid)
+{
+        struct perf_counter_attr *attr = attrs + counter;
+
+        if (scale)
+                attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
+                                    PERF_FORMAT_TOTAL_TIME_RUNNING;
+
+        if (system_wide) {
+                unsigned int cpu;
+
+                for (cpu = 0; cpu < nr_cpus; cpu++) {
+                        fd[cpu][counter] = sys_perf_counter_open(attr, -1, cpu, -1, 0);
+                        if (fd[cpu][counter] < 0 && verbose)
+                                fprintf(stderr, ERR_PERF_OPEN, counter,
+                                        fd[cpu][counter], strerror(errno));
+                }
+        } else {
+                attr->inherit        = inherit;
+                attr->disabled       = 1;
+                attr->enable_on_exec = 1;
+
+                fd[0][counter] = sys_perf_counter_open(attr, pid, -1, -1, 0);
+                if (fd[0][counter] < 0 && verbose)
+                        fprintf(stderr, ERR_PERF_OPEN, counter,
+                                fd[0][counter], strerror(errno));
+        }
+}
+
+/*
+ * Does the counter have nsecs as a unit?
+ */
+static inline int nsec_counter(int counter)
+{
+        if (MATCH_EVENT(SOFTWARE, SW_CPU_CLOCK, counter) ||
+            MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
+                return 1;
+
+        return 0;
+}
+
+/*
+ * Read out the results of a single counter:
+ */
+static void read_counter(int counter)
+{
+        u64 *count, single_count[3];
+        unsigned int cpu;
+        size_t res, nv;
+        int scaled;
+
+        count = event_res[run_idx][counter];
+
+        count[0] = count[1] = count[2] = 0;
+
+        nv = scale ? 3 : 1;
+        for (cpu = 0; cpu < nr_cpus; cpu++) {
+                if (fd[cpu][counter] < 0)
+                        continue;
+
+                res = read(fd[cpu][counter], single_count, nv * sizeof(u64));
+                assert(res == nv * sizeof(u64));
+
+                close(fd[cpu][counter]);
+                fd[cpu][counter] = -1;
+
+                count[0] += single_count[0];
+                if (scale) {
+                        count[1] += single_count[1];
+                        count[2] += single_count[2];
+                }
+        }
+
+        scaled = 0;
+        if (scale) {
+                if (count[2] == 0) {
+                        event_scaled[run_idx][counter] = -1;
+                        count[0] = 0;
+                        return;
+                }
+
+                if (count[2] < count[1]) {
+                        event_scaled[run_idx][counter] = 1;
+                        count[0] = (unsigned long long)
+                                ((double)count[0] * count[1] / count[2] + 0.5);
+                }
+        }
+        /*
+         * Save the full runtime - to allow normalization during printout:
+         */
+        if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
+                runtime_nsecs[run_idx] = count[0];
+        if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
+                runtime_cycles[run_idx] = count[0];
+}
+
+static int run_perf_stat(int argc __used, const char **argv)
+{
+        unsigned long long t0, t1;
+        int status = 0;
+        int counter;
+        int pid;
+        int child_ready_pipe[2], go_pipe[2];
+        char buf;
+
+        if (!system_wide)
+                nr_cpus = 1;
+
+        if (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0) {
+                perror("failed to create pipes");
+                exit(1);
+        }
+
+        if ((pid = fork()) < 0)
+                perror("failed to fork");
+
+        if (!pid) {
+                close(child_ready_pipe[0]);
+                close(go_pipe[1]);
+                fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
+
+                /*
+                 * Do a dummy execvp to get the PLT entry resolved,
+                 * so we avoid the resolver overhead on the real
+                 * execvp call.
+                 */
+                execvp("", (char **)argv);
+
+                /*
+                 * Tell the parent we're ready to go
+                 */
+                close(child_ready_pipe[1]);
+
+                /*
+                 * Wait until the parent tells us to go.
+                 */
+                if (read(go_pipe[0], &buf, 1) == -1)
+                        perror("unable to read pipe");
+
+                execvp(argv[0], (char **)argv);
+
+                perror(argv[0]);
+                exit(-1);
+        }
+
+        /*
+         * Wait for the child to be ready to exec.
+         */
+        close(child_ready_pipe[1]);
+        close(go_pipe[0]);
+        if (read(child_ready_pipe[0], &buf, 1) == -1)
+                perror("unable to read pipe");
+        close(child_ready_pipe[0]);
+
+        for (counter = 0; counter < nr_counters; counter++)
+                create_perf_stat_counter(counter, pid);
+
+        /*
+         * Enable counters and exec the command:
+         */
+        t0 = rdclock();
+
+        close(go_pipe[1]);
+        wait(&status);
+
+        t1 = rdclock();
+
+        walltime_nsecs[run_idx] = t1 - t0;
+
+        for (counter = 0; counter < nr_counters; counter++)
+                read_counter(counter);
+
+        return WEXITSTATUS(status);
+}
+
+static void print_noise(u64 *count, u64 *noise)
+{
+        if (run_count > 1)
+                fprintf(stderr, "   ( +- %7.3f%% )",
+                        (double)noise[0]/(count[0]+1)*100.0);
+}
+
+static void nsec_printout(int counter, u64 *count, u64 *noise)
+{
+        double msecs = (double)count[0] / 1000000;
+
+        fprintf(stderr, " %14.6f  %-24s", msecs, event_name(counter));
+
+        if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) {
+                if (walltime_nsecs_avg)
+                        fprintf(stderr, " # %10.3f CPUs ",
+                                (double)count[0] / (double)walltime_nsecs_avg);
+        }
+        print_noise(count, noise);
+}
+
+static void abs_printout(int counter, u64 *count, u64 *noise)
+{
+        fprintf(stderr, " %14Ld  %-24s", count[0], event_name(counter));
+
+        if (runtime_cycles_avg &&
+            MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
+                fprintf(stderr, " # %10.3f IPC  ",
+                        (double)count[0] / (double)runtime_cycles_avg);
+        } else {
+                if (runtime_nsecs_avg) {
+                        fprintf(stderr, " # %10.3f M/sec",
+                                (double)count[0]/runtime_nsecs_avg*1000.0);
+                }
+        }
+        print_noise(count, noise);
+}
+
+/*
+ * Print out the results of a single counter:
+ */
+static void print_counter(int counter)
+{
+        u64 *count, *noise;
+        int scaled;
+
+        count = event_res_avg[counter];
+        noise = event_res_noise[counter];
+        scaled = event_scaled_avg[counter];
+
+        if (scaled == -1) {
+                fprintf(stderr, " %14s  %-24s\n",
+                        "<not counted>", event_name(counter));
+                return;
+        }
+
+        if (nsec_counter(counter))
+                nsec_printout(counter, count, noise);
+        else
+                abs_printout(counter, count, noise);
+
+        if (scaled)
+                fprintf(stderr, "  (scaled from %.2f%%)",
+                        (double) count[2] / count[1] * 100);
+
+        fprintf(stderr, "\n");
+}
+
+/*
+ * normalize_noise noise values down to stddev:
+ */
+static void normalize_noise(u64 *val)
+{
+        double res;
+
+        res = (double)*val / (run_count * sqrt((double)run_count));
+
+        *val = (u64)res;
+}
+
+static void update_avg(const char *name, int idx, u64 *avg, u64 *val)
+{
+        *avg += *val;
+
+        if (verbose > 1)
+                fprintf(stderr, "debug: %20s[%d]: %Ld\n", name, idx, *val);
+}
+/*
+ * Calculate the averages and noises:
+ */
+static void calc_avg(void)
+{
+        int i, j;
+
+        if (verbose > 1)
+                fprintf(stderr, "\n");
+
+        for (i = 0; i < run_count; i++) {
+                update_avg("runtime", 0, &runtime_nsecs_avg, runtime_nsecs + i);
+                update_avg("walltime", 0, &walltime_nsecs_avg, walltime_nsecs + i);
+                update_avg("runtime_cycles", 0, &runtime_cycles_avg, runtime_cycles + i);
+
+                for (j = 0; j < nr_counters; j++) {
+                        update_avg("counter/0", j,
+                                event_res_avg[j]+0, event_res[i][j]+0);
+                        update_avg("counter/1", j,
+                                event_res_avg[j]+1, event_res[i][j]+1);
+                        update_avg("counter/2", j,
+                                event_res_avg[j]+2, event_res[i][j]+2);
+                        if (event_scaled[i][j] != (u64)-1)
+                                update_avg("scaled", j,
+                                        event_scaled_avg + j, event_scaled[i]+j);
+                        else
+                                event_scaled_avg[j] = -1;
+                }
+        }
+        runtime_nsecs_avg /= run_count;
+        walltime_nsecs_avg /= run_count;
+        runtime_cycles_avg /= run_count;
+
+        for (j = 0; j < nr_counters; j++) {
+                event_res_avg[j][0] /= run_count;
+                event_res_avg[j][1] /= run_count;
+                event_res_avg[j][2] /= run_count;
+        }
+
+        for (i = 0; i < run_count; i++) {
+                runtime_nsecs_noise +=
+                        abs((s64)(runtime_nsecs[i] - runtime_nsecs_avg));
+                walltime_nsecs_noise +=
+                        abs((s64)(walltime_nsecs[i] - walltime_nsecs_avg));
+                runtime_cycles_noise +=
+                        abs((s64)(runtime_cycles[i] - runtime_cycles_avg));
+
+                for (j = 0; j < nr_counters; j++) {
+                        event_res_noise[j][0] +=
+                                abs((s64)(event_res[i][j][0] - event_res_avg[j][0]));
+                        event_res_noise[j][1] +=
+                                abs((s64)(event_res[i][j][1] - event_res_avg[j][1]));
+                        event_res_noise[j][2] +=
+                                abs((s64)(event_res[i][j][2] - event_res_avg[j][2]));
+                }
+        }
+
+        normalize_noise(&runtime_nsecs_noise);
+        normalize_noise(&walltime_nsecs_noise);
+        normalize_noise(&runtime_cycles_noise);
+
+        for (j = 0; j < nr_counters; j++) {
+                normalize_noise(&event_res_noise[j][0]);
+                normalize_noise(&event_res_noise[j][1]);
+                normalize_noise(&event_res_noise[j][2]);
+        }
+}
+
+static void print_stat(int argc, const char **argv)
+{
+        int i, counter;
+
+        calc_avg();
+
+        fflush(stdout);
+
+        fprintf(stderr, "\n");
+        fprintf(stderr, " Performance counter stats for \'%s", argv[0]);
+
+        for (i = 1; i < argc; i++)
+                fprintf(stderr, " %s", argv[i]);
+
+        fprintf(stderr, "\'");
+        if (run_count > 1)
+                fprintf(stderr, " (%d runs)", run_count);
+        fprintf(stderr, ":\n\n");
+
+        for (counter = 0; counter < nr_counters; counter++)
+                print_counter(counter);
+
+        fprintf(stderr, "\n");
+        fprintf(stderr, " %14.9f  seconds time elapsed",
+                        (double)walltime_nsecs_avg/1e9);
+        if (run_count > 1) {
+                fprintf(stderr, "   ( +- %7.3f%% )",
+                        100.0*(double)walltime_nsecs_noise/(double)walltime_nsecs_avg);
+        }
+        fprintf(stderr, "\n\n");
+}
+
+static volatile int signr = -1;
+
+static void skip_signal(int signo)
+{
+        signr = signo;
+}
+
+static void sig_atexit(void)
+{
+        if (signr == -1)
+                return;
+
+        signal(signr, SIG_DFL);
+        kill(getpid(), signr);
+}
+
+static const char * const stat_usage[] = {
+        "perf stat [<options>] <command>",
+        NULL
+};
+
+static const struct option options[] = {
+        OPT_CALLBACK('e', "event", NULL, "event",
+                     "event selector. use 'perf list' to list available events",
+                     parse_events),
+        OPT_BOOLEAN('i', "inherit", &inherit,
+                    "child tasks inherit counters"),
+        OPT_INTEGER('p', "pid", &target_pid,
+                    "stat events on existing pid"),
+        OPT_BOOLEAN('a', "all-cpus", &system_wide,
+                    "system-wide collection from all CPUs"),
+        OPT_BOOLEAN('c', "scale", &scale,
+                    "scale/normalize counters"),
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose (show counter open errors, etc)"),
+        OPT_INTEGER('r', "repeat", &run_count,
+                    "repeat command and print average + stddev (max: 100)"),
+        OPT_BOOLEAN('n', "null", &null_run,
+                    "null run - dont start any counters"),
+        OPT_END()
+};
+
+int cmd_stat(int argc, const char **argv, const char *prefix __used)
+{
+        int status;
+
+        argc = parse_options(argc, argv, options, stat_usage,
+                PARSE_OPT_STOP_AT_NON_OPTION);
+        if (!argc)
+                usage_with_options(stat_usage, options);
+        if (run_count <= 0 || run_count > MAX_RUN)
+                usage_with_options(stat_usage, options);
+
+        /* Set attrs and nr_counters if no event is selected and !null_run */
+        if (!null_run && !nr_counters) {
+                memcpy(attrs, default_attrs, sizeof(default_attrs));
+                nr_counters = ARRAY_SIZE(default_attrs);
+        }
+
+        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+        assert(nr_cpus <= MAX_NR_CPUS);
+        assert((int)nr_cpus >= 0);
+
+        /*
+         * We dont want to block the signals - that would cause
+         * child tasks to inherit that and Ctrl-C would not work.
+         * What we want is for Ctrl-C to work in the exec()-ed
+         * task, but being ignored by perf stat itself:
+         */
+        atexit(sig_atexit);
+        signal(SIGINT,  skip_signal);
+        signal(SIGALRM, skip_signal);
+        signal(SIGABRT, skip_signal);
+
+        status = 0;
+        for (run_idx = 0; run_idx < run_count; run_idx++) {
+                if (run_count != 1 && verbose)
+                        fprintf(stderr, "[ perf stat: executing run #%d ... ]\n", run_idx + 1);
+                status = run_perf_stat(argc, argv);
+        }
+
+        print_stat(argc, argv);
+
+        return status;
+}
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
new file mode 100644
index 000000000000..7de28ce9ca26
--- /dev/null
+++ b/tools/perf/builtin-top.c
@@ -0,0 +1,1220 @@
+/*
+ * builtin-top.c
+ *
+ * Builtin top command: Display a continuously updated profile of
+ * any workload, CPU or specific PID.
+ *
+ * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
+ *
+ * Improvements and fixes by:
+ *
+ *   Arjan van de Ven <arjan@linux.intel.com>
+ *   Yanmin Zhang <yanmin.zhang@intel.com>
+ *   Wu Fengguang <fengguang.wu@intel.com>
+ *   Mike Galbraith <efault@gmx.de>
+ *   Paul Mackerras <paulus@samba.org>
+ *
+ * Released under the GPL v2. (and only v2, not any later version)
+ */
+#include "builtin.h"
+
+#include "perf.h"
+
+#include "util/symbol.h"
+#include "util/color.h"
+#include "util/util.h"
+#include <linux/rbtree.h>
+#include "util/parse-options.h"
+#include "util/parse-events.h"
+
+#include <assert.h>
+#include <fcntl.h>
+
+#include <stdio.h>
+#include <termios.h>
+#include <unistd.h>
+
+#include <errno.h>
+#include <time.h>
+#include <sched.h>
+#include <pthread.h>
+
+#include <sys/syscall.h>
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <sys/prctl.h>
+#include <sys/wait.h>
+#include <sys/uio.h>
+#include <sys/mman.h>
+
+#include <linux/unistd.h>
+#include <linux/types.h>
+
+static int                      fd[MAX_NR_CPUS][MAX_COUNTERS];
+
+static int                      system_wide                     =  0;
+
+static int                      default_interval                = 100000;
+
+static int                      count_filter                    =  5;
+static int                      print_entries                   = 15;
+
+static int                      target_pid                      = -1;
+static int                      inherit                         =  0;
+static int                      profile_cpu                     = -1;
+static int                      nr_cpus                         =  0;
+static unsigned int             realtime_prio                   =  0;
+static int                      group                           =  0;
+static unsigned int             page_size;
+static unsigned int             mmap_pages                      = 16;
+static int                      freq                            =  0;
+static int                      verbose                         =  0;
+static char                     *vmlinux                        =  NULL;
+
+static int                      delay_secs                      =  2;
+static int                      zero;
+static int                      dump_symtab;
+
+/*
+ * Source
+ */
+
+struct source_line {
+        u64                     eip;
+        unsigned long           count[MAX_COUNTERS];
+        char                    *line;
+        struct source_line      *next;
+};
+
+static char                     *sym_filter                     =  NULL;
+struct sym_entry                *sym_filter_entry               =  NULL;
+static int                      sym_pcnt_filter                 =  5;
+static int                      sym_counter                     =  0;
+static int                      display_weighted                = -1;
+
+/*
+ * Symbols
+ */
+
+static u64                      min_ip;
+static u64                      max_ip = -1ll;
+
+struct sym_entry {
+        struct rb_node          rb_node;
+        struct list_head        node;
+        unsigned long           count[MAX_COUNTERS];
+        unsigned long           snap_count;
+        double                  weight;
+        int                     skip;
+        struct source_line      *source;
+        struct source_line      *lines;
+        struct source_line      **lines_tail;
+        pthread_mutex_t         source_lock;
+};
+
+/*
+ * Source functions
+ */
+
+static void parse_source(struct sym_entry *syme)
+{
+        struct symbol *sym;
+        struct module *module;
+        struct section *section = NULL;
+        FILE *file;
+        char command[PATH_MAX*2], *path = vmlinux;
+        u64 start, end, len;
+
+        if (!syme)
+                return;
+
+        if (syme->lines) {
+                pthread_mutex_lock(&syme->source_lock);
+                goto out_assign;
+        }
+
+        sym = (struct symbol *)(syme + 1);
+        module = sym->module;
+
+        if (module)
+                path = module->path;
+        if (!path)
+                return;
+
+        start = sym->obj_start;
+        if (!start)
+                start = sym->start;
+
+        if (module) {
+                section = module->sections->find_section(module->sections, ".text");
+                if (section)
+                        start -= section->vma;
+        }
+
+        end = start + sym->end - sym->start + 1;
+        len = sym->end - sym->start;
+
+        sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s", start, end, path);
+
+        file = popen(command, "r");
+        if (!file)
+                return;
+
+        pthread_mutex_lock(&syme->source_lock);
+        syme->lines_tail = &syme->lines;
+        while (!feof(file)) {
+                struct source_line *src;
+                size_t dummy = 0;
+                char *c;
+
+                src = malloc(sizeof(struct source_line));
+                assert(src != NULL);
+                memset(src, 0, sizeof(struct source_line));
+
+                if (getline(&src->line, &dummy, file) < 0)
+                        break;
+                if (!src->line)
+                        break;
+
+                c = strchr(src->line, '\n');
+                if (c)
+                        *c = 0;
+
+                src->next = NULL;
+                *syme->lines_tail = src;
+                syme->lines_tail = &src->next;
+
+                if (strlen(src->line)>8 && src->line[8] == ':') {
+                        src->eip = strtoull(src->line, NULL, 16);
+                        if (section)
+                                src->eip += section->vma;
+                }
+                if (strlen(src->line)>8 && src->line[16] == ':') {
+                        src->eip = strtoull(src->line, NULL, 16);
+                        if (section)
+                                src->eip += section->vma;
+                }
+        }
+        pclose(file);
+out_assign:
+        sym_filter_entry = syme;
+        pthread_mutex_unlock(&syme->source_lock);
+}
+
+static void __zero_source_counters(struct sym_entry *syme)
+{
+        int i;
+        struct source_line *line;
+
+        line = syme->lines;
+        while (line) {
+                for (i = 0; i < nr_counters; i++)
+                        line->count[i] = 0;
+                line = line->next;
+        }
+}
+
+static void record_precise_ip(struct sym_entry *syme, int counter, u64 ip)
+{
+        struct source_line *line;
+
+        if (syme != sym_filter_entry)
+                return;
+
+        if (pthread_mutex_trylock(&syme->source_lock))
+                return;
+
+        if (!syme->source)
+                goto out_unlock;
+
+        for (line = syme->lines; line; line = line->next) {
+                if (line->eip == ip) {
+                        line->count[counter]++;
+                        break;
+                }
+                if (line->eip > ip)
+                        break;
+        }
+out_unlock:
+        pthread_mutex_unlock(&syme->source_lock);
+}
+
+static void lookup_sym_source(struct sym_entry *syme)
+{
+        struct symbol *symbol = (struct symbol *)(syme + 1);
+        struct source_line *line;
+        char pattern[PATH_MAX];
+        char *idx;
+
+        sprintf(pattern, "<%s>:", symbol->name);
+
+        if (symbol->module) {
+                idx = strstr(pattern, "\t");
+                if (idx)
+                        *idx = 0;
+        }
+
+        pthread_mutex_lock(&syme->source_lock);
+        for (line = syme->lines; line; line = line->next) {
+                if (strstr(line->line, pattern)) {
+                        syme->source = line;
+                        break;
+                }
+        }
+        pthread_mutex_unlock(&syme->source_lock);
+}
+
+static void show_lines(struct source_line *queue, int count, int total)
+{
+        int i;
+        struct source_line *line;
+
+        line = queue;
+        for (i = 0; i < count; i++) {
+                float pcnt = 100.0*(float)line->count[sym_counter]/(float)total;
+
+                printf("%8li %4.1f%%\t%s\n", line->count[sym_counter], pcnt, line->line);
+                line = line->next;
+        }
+}
+
+#define TRACE_COUNT     3
+
+static void show_details(struct sym_entry *syme)
+{
+        struct symbol *symbol;
+        struct source_line *line;
+        struct source_line *line_queue = NULL;
+        int displayed = 0;
+        int line_queue_count = 0, total = 0, more = 0;
+
+        if (!syme)
+                return;
+
+        if (!syme->source)
+                lookup_sym_source(syme);
+
+        if (!syme->source)
+                return;
+
+        symbol = (struct symbol *)(syme + 1);
+        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;
+        while (line) {
+                total += line->count[sym_counter];
+                line = line->next;
+        }
+
+        line = syme->source;
+        while (line) {
+                float pcnt = 0.0;
+
+                if (!line_queue_count)
+                        line_queue = line;
+                line_queue_count++;
+
+                if (line->count[sym_counter])
+                        pcnt = 100.0 * line->count[sym_counter] / (float)total;
+                if (pcnt >= (float)sym_pcnt_filter) {
+                        if (displayed <= print_entries)
+                                show_lines(line_queue, line_queue_count, total);
+                        else more++;
+                        displayed += line_queue_count;
+                        line_queue_count = 0;
+                        line_queue = NULL;
+                } else if (line_queue_count > TRACE_COUNT) {
+                        line_queue = line_queue->next;
+                        line_queue_count--;
+                }
+
+                line->count[sym_counter] = zero ? 0 : line->count[sym_counter] * 7 / 8;
+                line = line->next;
+        }
+        pthread_mutex_unlock(&syme->source_lock);
+        if (more)
+                printf("%d lines not displayed, maybe increase display entries [e]\n", more);
+}
+
+struct dso                      *kernel_dso;
+
+/*
+ * Symbols will be added here in record_ip and will get out
+ * after decayed.
+ */
+static LIST_HEAD(active_symbols);
+static pthread_mutex_t active_symbols_lock = PTHREAD_MUTEX_INITIALIZER;
+
+/*
+ * Ordering weight: count-1 * count-2 * ... / count-n
+ */
+static double sym_weight(const struct sym_entry *sym)
+{
+        double weight = sym->snap_count;
+        int counter;
+
+        if (!display_weighted)
+                return weight;
+
+        for (counter = 1; counter < nr_counters-1; counter++)
+                weight *= sym->count[counter];
+
+        weight /= (sym->count[counter] + 1);
+
+        return weight;
+}
+
+static long                     samples;
+static long                     userspace_samples;
+static const char               CONSOLE_CLEAR[] = "";
+
+static void __list_insert_active_sym(struct sym_entry *syme)
+{
+        list_add(&syme->node, &active_symbols);
+}
+
+static void list_remove_active_sym(struct sym_entry *syme)
+{
+        pthread_mutex_lock(&active_symbols_lock);
+        list_del_init(&syme->node);
+        pthread_mutex_unlock(&active_symbols_lock);
+}
+
+static void rb_insert_active_sym(struct rb_root *tree, struct sym_entry *se)
+{
+        struct rb_node **p = &tree->rb_node;
+        struct rb_node *parent = NULL;
+        struct sym_entry *iter;
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct sym_entry, rb_node);
+
+                if (se->weight > iter->weight)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&se->rb_node, parent, p);
+        rb_insert_color(&se->rb_node, tree);
+}
+
+static void print_sym_table(void)
+{
+        int printed = 0, j;
+        int counter, snap = !display_weighted ? sym_counter : 0;
+        float samples_per_sec = samples/delay_secs;
+        float ksamples_per_sec = (samples-userspace_samples)/delay_secs;
+        float sum_ksamples = 0.0;
+        struct sym_entry *syme, *n;
+        struct rb_root tmp = RB_ROOT;
+        struct rb_node *nd;
+
+        samples = userspace_samples = 0;
+
+        /* Sort the active symbols */
+        pthread_mutex_lock(&active_symbols_lock);
+        syme = list_entry(active_symbols.next, struct sym_entry, node);
+        pthread_mutex_unlock(&active_symbols_lock);
+
+        list_for_each_entry_safe_from(syme, n, &active_symbols, node) {
+                syme->snap_count = syme->count[snap];
+                if (syme->snap_count != 0) {
+                        syme->weight = sym_weight(syme);
+                        rb_insert_active_sym(&tmp, syme);
+                        sum_ksamples += syme->snap_count;
+
+                        for (j = 0; j < nr_counters; j++)
+                                syme->count[j] = zero ? 0 : syme->count[j] * 7 / 8;
+                } else
+                        list_remove_active_sym(syme);
+        }
+
+        puts(CONSOLE_CLEAR);
+
+        printf(
+"------------------------------------------------------------------------------\n");
+        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)));
+
+        if (nr_counters == 1 || !display_weighted) {
+                printf("%Ld", (u64)attrs[0].sample_period);
+                if (freq)
+                        printf("Hz ");
+                else
+                        printf(" ");
+        }
+
+        if (!display_weighted)
+                printf("%s", event_name(sym_counter));
+        else for (counter = 0; counter < nr_counters; counter++) {
+                if (counter)
+                        printf("/");
+
+                printf("%s", event_name(counter));
+        }
+
+        printf( "], ");
+
+        if (target_pid != -1)
+                printf(" (target_pid: %d", target_pid);
+        else
+                printf(" (all");
+
+        if (profile_cpu != -1)
+                printf(", cpu: %d)\n", profile_cpu);
+        else {
+                if (target_pid != -1)
+                        printf(")\n");
+                else
+                        printf(", %d CPUs)\n", nr_cpus);
+        }
+
+        printf("------------------------------------------------------------------------------\n\n");
+
+        if (sym_filter_entry) {
+                show_details(sym_filter_entry);
+                return;
+        }
+
+        if (nr_counters == 1)
+                printf("             samples    pcnt");
+        else
+                printf("  weight     samples    pcnt");
+
+        printf("         RIP          kernel function\n"
+                       "  ______     _______   _____   ________________   _______________\n\n"
+        );
+
+        for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) {
+                struct sym_entry *syme = rb_entry(nd, struct sym_entry, rb_node);
+                struct symbol *sym = (struct symbol *)(syme + 1);
+                double pcnt;
+
+                if (++printed > print_entries || (int)syme->snap_count < count_filter)
+                        continue;
+
+                pcnt = 100.0 - (100.0 * ((sum_ksamples - syme->snap_count) /
+                                         sum_ksamples));
+
+                if (nr_counters == 1 || !display_weighted)
+                        printf("%20.2f - ", syme->weight);
+                else
+                        printf("%9.1f %10ld - ", syme->weight, syme->snap_count);
+
+                percent_color_fprintf(stdout, "%4.1f%%", pcnt);
+                printf(" - %016llx : %s", sym->start, sym->name);
+                if (sym->module)
+                        printf("\t[%s]", sym->module->name);
+                printf("\n");
+        }
+}
+
+static void prompt_integer(int *target, const char *msg)
+{
+        char *buf = malloc(0), *p;
+        size_t dummy = 0;
+        int tmp;
+
+        fprintf(stdout, "\n%s: ", msg);
+        if (getline(&buf, &dummy, stdin) < 0)
+                return;
+
+        p = strchr(buf, '\n');
+        if (p)
+                *p = 0;
+
+        p = buf;
+        while(*p) {
+                if (!isdigit(*p))
+                        goto out_free;
+                p++;
+        }
+        tmp = strtoul(buf, NULL, 10);
+        *target = tmp;
+out_free:
+        free(buf);
+}
+
+static void prompt_percent(int *target, const char *msg)
+{
+        int tmp = 0;
+
+        prompt_integer(&tmp, msg);
+        if (tmp >= 0 && tmp <= 100)
+                *target = tmp;
+}
+
+static void prompt_symbol(struct sym_entry **target, const char *msg)
+{
+        char *buf = malloc(0), *p;
+        struct sym_entry *syme = *target, *n, *found = NULL;
+        size_t dummy = 0;
+
+        /* zero counters of active symbol */
+        if (syme) {
+                pthread_mutex_lock(&syme->source_lock);
+                __zero_source_counters(syme);
+                *target = NULL;
+                pthread_mutex_unlock(&syme->source_lock);
+        }
+
+        fprintf(stdout, "\n%s: ", msg);
+        if (getline(&buf, &dummy, stdin) < 0)
+                goto out_free;
+
+        p = strchr(buf, '\n');
+        if (p)
+                *p = 0;
+
+        pthread_mutex_lock(&active_symbols_lock);
+        syme = list_entry(active_symbols.next, struct sym_entry, node);
+        pthread_mutex_unlock(&active_symbols_lock);
+
+        list_for_each_entry_safe_from(syme, n, &active_symbols, node) {
+                struct symbol *sym = (struct symbol *)(syme + 1);
+
+                if (!strcmp(buf, sym->name)) {
+                        found = syme;
+                        break;
+                }
+        }
+
+        if (!found) {
+                fprintf(stderr, "Sorry, %s is not active.\n", sym_filter);
+                sleep(1);
+                return;
+        } else
+                parse_source(found);
+
+out_free:
+        free(buf);
+}
+
+static void print_mapped_keys(void)
+{
+        char *name = NULL;
+
+        if (sym_filter_entry) {
+                struct symbol *sym = (struct symbol *)(sym_filter_entry+1);
+                name = sym->name;
+        }
+
+        fprintf(stdout, "\nMapped keys:\n");
+        fprintf(stdout, "\t[d]     display refresh delay.             \t(%d)\n", delay_secs);
+        fprintf(stdout, "\t[e]     display entries (lines).           \t(%d)\n", print_entries);
+
+        if (nr_counters > 1)
+                fprintf(stdout, "\t[E]     active event counter.              \t(%s)\n", event_name(sym_counter));
+
+        fprintf(stdout, "\t[f]     profile display filter (count).    \t(%d)\n", count_filter);
+
+        if (vmlinux) {
+                fprintf(stdout, "\t[F]     annotate display filter (percent). \t(%d%%)\n", sym_pcnt_filter);
+                fprintf(stdout, "\t[s]     annotate symbol.                   \t(%s)\n", name?: "NULL");
+                fprintf(stdout, "\t[S]     stop annotation.\n");
+        }
+
+        if (nr_counters > 1)
+                fprintf(stdout, "\t[w]     toggle display weighted/count[E]r. \t(%d)\n", display_weighted ? 1 : 0);
+
+        fprintf(stdout, "\t[z]     toggle sample zeroing.             \t(%d)\n", zero ? 1 : 0);
+        fprintf(stdout, "\t[qQ]    quit.\n");
+}
+
+static int key_mapped(int c)
+{
+        switch (c) {
+                case 'd':
+                case 'e':
+                case 'f':
+                case 'z':
+                case 'q':
+                case 'Q':
+                        return 1;
+                case 'E':
+                case 'w':
+                        return nr_counters > 1 ? 1 : 0;
+                case 'F':
+                case 's':
+                case 'S':
+                        return vmlinux ? 1 : 0;
+        }
+
+        return 0;
+}
+
+static void handle_keypress(int c)
+{
+        if (!key_mapped(c)) {
+                struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
+                struct termios tc, save;
+
+                print_mapped_keys();
+                fprintf(stdout, "\nEnter selection, or unmapped key to continue: ");
+                fflush(stdout);
+
+                tcgetattr(0, &save);
+                tc = save;
+                tc.c_lflag &= ~(ICANON | ECHO);
+                tc.c_cc[VMIN] = 0;
+                tc.c_cc[VTIME] = 0;
+                tcsetattr(0, TCSANOW, &tc);
+
+                poll(&stdin_poll, 1, -1);
+                c = getc(stdin);
+
+                tcsetattr(0, TCSAFLUSH, &save);
+                if (!key_mapped(c))
+                        return;
+        }
+
+        switch (c) {
+                case 'd':
+                        prompt_integer(&delay_secs, "Enter display delay");
+                        break;
+                case 'e':
+                        prompt_integer(&print_entries, "Enter display entries (lines)");
+                        break;
+                case 'E':
+                        if (nr_counters > 1) {
+                                int i;
+
+                                fprintf(stderr, "\nAvailable events:");
+                                for (i = 0; i < nr_counters; i++)
+                                        fprintf(stderr, "\n\t%d %s", i, event_name(i));
+
+                                prompt_integer(&sym_counter, "Enter details event counter");
+
+                                if (sym_counter >= nr_counters) {
+                                        fprintf(stderr, "Sorry, no such event, using %s.\n", event_name(0));
+                                        sym_counter = 0;
+                                        sleep(1);
+                                }
+                        } else sym_counter = 0;
+                        break;
+                case 'f':
+                        prompt_integer(&count_filter, "Enter display event count filter");
+                        break;
+                case 'F':
+                        prompt_percent(&sym_pcnt_filter, "Enter details display event filter (percent)");
+                        break;
+                case 'q':
+                case 'Q':
+                        printf("exiting.\n");
+                        exit(0);
+                case 's':
+                        prompt_symbol(&sym_filter_entry, "Enter details symbol");
+                        break;
+                case 'S':
+                        if (!sym_filter_entry)
+                                break;
+                        else {
+                                struct sym_entry *syme = sym_filter_entry;
+
+                                pthread_mutex_lock(&syme->source_lock);
+                                sym_filter_entry = NULL;
+                                __zero_source_counters(syme);
+                                pthread_mutex_unlock(&syme->source_lock);
+                        }
+                        break;
+                case 'w':
+                        display_weighted = ~display_weighted;
+                        break;
+                case 'z':
+                        zero = ~zero;
+                        break;
+        }
+}
+
+static void *display_thread(void *arg __used)
+{
+        struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
+        struct termios tc, save;
+        int delay_msecs, c;
+
+        tcgetattr(0, &save);
+        tc = save;
+        tc.c_lflag &= ~(ICANON | ECHO);
+        tc.c_cc[VMIN] = 0;
+        tc.c_cc[VTIME] = 0;
+
+repeat:
+        delay_msecs = delay_secs * 1000;
+        tcsetattr(0, TCSANOW, &tc);
+        /* trash return*/
+        getc(stdin);
+
+        do {
+                print_sym_table();
+        } while (!poll(&stdin_poll, 1, delay_msecs) == 1);
+
+        c = getc(stdin);
+        tcsetattr(0, TCSAFLUSH, &save);
+
+        handle_keypress(c);
+        goto repeat;
+
+        return NULL;
+}
+
+/* Tag samples to be skipped. */
+static const char *skip_symbols[] = {
+        "default_idle",
+        "cpu_idle",
+        "enter_idle",
+        "exit_idle",
+        "mwait_idle",
+        "mwait_idle_with_hints",
+        "ppc64_runlatch_off",
+        "pseries_dedicated_idle_sleep",
+        NULL
+};
+
+static int symbol_filter(struct dso *self, struct symbol *sym)
+{
+        struct sym_entry *syme;
+        const char *name = sym->name;
+        int i;
+
+        /*
+         * ppc64 uses function descriptors and appends a '.' to the
+         * start of every instruction address. Remove it.
+         */
+        if (name[0] == '.')
+                name++;
+
+        if (!strcmp(name, "_text") ||
+            !strcmp(name, "_etext") ||
+            !strcmp(name, "_sinittext") ||
+            !strncmp("init_module", name, 11) ||
+            !strncmp("cleanup_module", name, 14) ||
+            strstr(name, "_text_start") ||
+            strstr(name, "_text_end"))
+                return 1;
+
+        syme = dso__sym_priv(self, sym);
+        pthread_mutex_init(&syme->source_lock, NULL);
+        if (!sym_filter_entry && sym_filter && !strcmp(name, sym_filter))
+                sym_filter_entry = syme;
+
+        for (i = 0; skip_symbols[i]; i++) {
+                if (!strcmp(skip_symbols[i], name)) {
+                        syme->skip = 1;
+                        break;
+                }
+        }
+
+        return 0;
+}
+
+static int parse_symbols(void)
+{
+        struct rb_node *node;
+        struct symbol  *sym;
+        int modules = vmlinux ? 1 : 0;
+
+        kernel_dso = dso__new("[kernel]", sizeof(struct sym_entry));
+        if (kernel_dso == NULL)
+                return -1;
+
+        if (dso__load_kernel(kernel_dso, vmlinux, symbol_filter, verbose, modules) <= 0)
+                goto out_delete_dso;
+
+        node = rb_first(&kernel_dso->syms);
+        sym = rb_entry(node, struct symbol, rb_node);
+        min_ip = sym->start;
+
+        node = rb_last(&kernel_dso->syms);
+        sym = rb_entry(node, struct symbol, rb_node);
+        max_ip = sym->end;
+
+        if (dump_symtab)
+                dso__fprintf(kernel_dso, stderr);
+
+        return 0;
+
+out_delete_dso:
+        dso__delete(kernel_dso);
+        kernel_dso = NULL;
+        return -1;
+}
+
+/*
+ * Binary search in the histogram table and record the hit:
+ */
+static void record_ip(u64 ip, int counter)
+{
+        struct symbol *sym = dso__find_symbol(kernel_dso, ip);
+
+        if (sym != NULL) {
+                struct sym_entry *syme = dso__sym_priv(kernel_dso, sym);
+
+                if (!syme->skip) {
+                        syme->count[counter]++;
+                        record_precise_ip(syme, counter, ip);
+                        pthread_mutex_lock(&active_symbols_lock);
+                        if (list_empty(&syme->node) || !syme->node.next)
+                                __list_insert_active_sym(syme);
+                        pthread_mutex_unlock(&active_symbols_lock);
+                        return;
+                }
+        }
+
+        samples--;
+}
+
+static void process_event(u64 ip, int counter, int user)
+{
+        samples++;
+
+        if (user) {
+                userspace_samples++;
+                return;
+        }
+
+        record_ip(ip, counter);
+}
+
+struct mmap_data {
+        int                     counter;
+        void                    *base;
+        int                     mask;
+        unsigned int            prev;
+};
+
+static unsigned int mmap_read_head(struct mmap_data *md)
+{
+        struct perf_counter_mmap_page *pc = md->base;
+        int head;
+
+        head = pc->data_head;
+        rmb();
+
+        return head;
+}
+
+struct timeval last_read, this_read;
+
+static void mmap_read_counter(struct mmap_data *md)
+{
+        unsigned int head = mmap_read_head(md);
+        unsigned int old = md->prev;
+        unsigned char *data = md->base + page_size;
+        int diff;
+
+        gettimeofday(&this_read, NULL);
+
+        /*
+         * If we're further behind than half the buffer, there's a chance
+         * the writer will bite our tail and mess up the samples under us.
+         *
+         * If we somehow ended up ahead of the head, we got messed up.
+         *
+         * In either case, truncate and restart at head.
+         */
+        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);
+
+                /*
+                 * head points to a known good entry, start there.
+                 */
+                old = head;
+        }
+
+        last_read = this_read;
+
+        for (; old != head;) {
+                struct ip_event {
+                        struct perf_event_header header;
+                        u64 ip;
+                        u32 pid, target_pid;
+                };
+                struct mmap_event {
+                        struct perf_event_header header;
+                        u32 pid, target_pid;
+                        u64 start;
+                        u64 len;
+                        u64 pgoff;
+                        char filename[PATH_MAX];
+                };
+
+                typedef union event_union {
+                        struct perf_event_header header;
+                        struct ip_event ip;
+                        struct mmap_event mmap;
+                } event_t;
+
+                event_t *event = (event_t *)&data[old & md->mask];
+
+                event_t event_copy;
+
+                size_t size = event->header.size;
+
+                /*
+                 * Event straddles the mmap boundary -- header should always
+                 * be inside due to u64 alignment of output.
+                 */
+                if ((old & md->mask) + size != ((old + size) & md->mask)) {
+                        unsigned int offset = old;
+                        unsigned int len = min(sizeof(*event), size), cpy;
+                        void *dst = &event_copy;
+
+                        do {
+                                cpy = min(md->mask + 1 - (offset & md->mask), len);
+                                memcpy(dst, &data[offset & md->mask], cpy);
+                                offset += cpy;
+                                dst += cpy;
+                                len -= cpy;
+                        } while (len);
+
+                        event = &event_copy;
+                }
+
+                old += size;
+
+                if (event->header.type == PERF_EVENT_SAMPLE) {
+                        int user =
+        (event->header.misc & PERF_EVENT_MISC_CPUMODE_MASK) == PERF_EVENT_MISC_USER;
+                        process_event(event->ip.ip, md->counter, user);
+                }
+        }
+
+        md->prev = old;
+}
+
+static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
+static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
+
+static void mmap_read(void)
+{
+        int i, counter;
+
+        for (i = 0; i < nr_cpus; i++) {
+                for (counter = 0; counter < nr_counters; counter++)
+                        mmap_read_counter(&mmap_array[i][counter]);
+        }
+}
+
+int nr_poll;
+int group_fd;
+
+static void start_counter(int i, int counter)
+{
+        struct perf_counter_attr *attr;
+        int cpu;
+
+        cpu = profile_cpu;
+        if (target_pid == -1 && profile_cpu == -1)
+                cpu = i;
+
+        attr = attrs + counter;
+
+        attr->sample_type       = PERF_SAMPLE_IP | PERF_SAMPLE_TID;
+        attr->freq              = freq;
+        attr->inherit           = (cpu < 0) && inherit;
+
+try_again:
+        fd[i][counter] = sys_perf_counter_open(attr, target_pid, cpu, group_fd, 0);
+
+        if (fd[i][counter] < 0) {
+                int err = errno;
+
+                if (err == EPERM)
+                        die("No permission - are you root?\n");
+                /*
+                 * If it's cycles then fall back to hrtimer
+                 * based cpu-clock-tick sw counter, which
+                 * is always available even if no PMU support:
+                 */
+                if (attr->type == PERF_TYPE_HARDWARE
+                        && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
+
+                        if (verbose)
+                                warning(" ... trying to fall back to cpu-clock-ticks\n");
+
+                        attr->type = PERF_TYPE_SOFTWARE;
+                        attr->config = PERF_COUNT_SW_CPU_CLOCK;
+                        goto try_again;
+                }
+                printf("\n");
+                error("perfcounter syscall returned with %d (%s)\n",
+                        fd[i][counter], strerror(err));
+                die("No CONFIG_PERF_COUNTERS=y kernel support configured?\n");
+                exit(-1);
+        }
+        assert(fd[i][counter] >= 0);
+        fcntl(fd[i][counter], F_SETFL, O_NONBLOCK);
+
+        /*
+         * First counter acts as the group leader:
+         */
+        if (group && group_fd == -1)
+                group_fd = fd[i][counter];
+
+        event_array[nr_poll].fd = fd[i][counter];
+        event_array[nr_poll].events = POLLIN;
+        nr_poll++;
+
+        mmap_array[i][counter].counter = counter;
+        mmap_array[i][counter].prev = 0;
+        mmap_array[i][counter].mask = mmap_pages*page_size - 1;
+        mmap_array[i][counter].base = mmap(NULL, (mmap_pages+1)*page_size,
+                        PROT_READ, MAP_SHARED, fd[i][counter], 0);
+        if (mmap_array[i][counter].base == MAP_FAILED)
+                die("failed to mmap with %d (%s)\n", errno, strerror(errno));
+}
+
+static int __cmd_top(void)
+{
+        pthread_t thread;
+        int i, counter;
+        int ret;
+
+        for (i = 0; i < nr_cpus; i++) {
+                group_fd = -1;
+                for (counter = 0; counter < nr_counters; counter++)
+                        start_counter(i, counter);
+        }
+
+        /* Wait for a minimal set of events before starting the snapshot */
+        poll(event_array, nr_poll, 100);
+
+        mmap_read();
+
+        if (pthread_create(&thread, NULL, display_thread, NULL)) {
+                printf("Could not create display thread.\n");
+                exit(-1);
+        }
+
+        if (realtime_prio) {
+                struct sched_param param;
+
+                param.sched_priority = realtime_prio;
+                if (sched_setscheduler(0, SCHED_FIFO, &param)) {
+                        printf("Could not set realtime priority.\n");
+                        exit(-1);
+                }
+        }
+
+        while (1) {
+                int hits = samples;
+
+                mmap_read();
+
+                if (hits == samples)
+                        ret = poll(event_array, nr_poll, 100);
+        }
+
+        return 0;
+}
+
+static const char * const top_usage[] = {
+        "perf top [<options>]",
+        NULL
+};
+
+static const struct option options[] = {
+        OPT_CALLBACK('e', "event", NULL, "event",
+                     "event selector. use 'perf list' to list available events",
+                     parse_events),
+        OPT_INTEGER('c', "count", &default_interval,
+                    "event period to sample"),
+        OPT_INTEGER('p', "pid", &target_pid,
+                    "profile events on existing pid"),
+        OPT_BOOLEAN('a', "all-cpus", &system_wide,
+                            "system-wide collection from all CPUs"),
+        OPT_INTEGER('C', "CPU", &profile_cpu,
+                    "CPU to profile on"),
+        OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
+        OPT_INTEGER('m', "mmap-pages", &mmap_pages,
+                    "number of mmap data pages"),
+        OPT_INTEGER('r', "realtime", &realtime_prio,
+                    "collect data with this RT SCHED_FIFO priority"),
+        OPT_INTEGER('d', "delay", &delay_secs,
+                    "number of seconds to delay between refreshes"),
+        OPT_BOOLEAN('D', "dump-symtab", &dump_symtab,
+                            "dump the symbol table used for profiling"),
+        OPT_INTEGER('f', "count-filter", &count_filter,
+                    "only display functions with more events than this"),
+        OPT_BOOLEAN('g', "group", &group,
+                            "put the counters into a counter group"),
+        OPT_BOOLEAN('i', "inherit", &inherit,
+                    "child tasks inherit counters"),
+        OPT_STRING('s', "sym-annotate", &sym_filter, "symbol name",
+                    "symbol to annotate - requires -k option"),
+        OPT_BOOLEAN('z', "zero", &zero,
+                    "zero history across updates"),
+        OPT_INTEGER('F', "freq", &freq,
+                    "profile at this frequency"),
+        OPT_INTEGER('E', "entries", &print_entries,
+                    "display this many functions"),
+        OPT_BOOLEAN('v', "verbose", &verbose,
+                    "be more verbose (show counter open errors, etc)"),
+        OPT_END()
+};
+
+int cmd_top(int argc, const char **argv, const char *prefix __used)
+{
+        int counter;
+
+        symbol__init();
+
+        page_size = sysconf(_SC_PAGE_SIZE);
+
+        argc = parse_options(argc, argv, options, top_usage, 0);
+        if (argc)
+                usage_with_options(top_usage, options);
+
+        if (freq) {
+                default_interval = freq;
+                freq = 1;
+        }
+
+        /* CPU and PID are mutually exclusive */
+        if (target_pid != -1 && profile_cpu != -1) {
+                printf("WARNING: PID switch overriding CPU\n");
+                sleep(1);
+                profile_cpu = -1;
+        }
+
+        if (!nr_counters)
+                nr_counters = 1;
+
+        if (delay_secs < 1)
+                delay_secs = 1;
+
+        parse_symbols();
+        parse_source(sym_filter_entry);
+
+        /*
+         * Fill in the ones not specifically initialized via -c:
+         */
+        for (counter = 0; counter < nr_counters; counter++) {
+                if (attrs[counter].sample_period)
+                        continue;
+
+                attrs[counter].sample_period = default_interval;
+        }
+
+        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+        assert(nr_cpus <= MAX_NR_CPUS);
+        assert(nr_cpus >= 0);
+
+        if (target_pid != -1 || profile_cpu != -1)
+                nr_cpus = 1;
+
+        return __cmd_top();
+}
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
new file mode 100644
index 000000000000..51d168230ee7
--- /dev/null
+++ b/tools/perf/builtin.h
@@ -0,0 +1,26 @@
+#ifndef BUILTIN_H
+#define BUILTIN_H
+
+#include "util/util.h"
+#include "util/strbuf.h"
+
+extern const char perf_version_string[];
+extern const char perf_usage_string[];
+extern const char perf_more_info_string[];
+
+extern void list_common_cmds_help(void);
+extern const char *help_unknown_cmd(const char *cmd);
+extern void prune_packed_objects(int);
+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_help(int argc, const char **argv, const char *prefix);
+extern int cmd_record(int argc, const char **argv, const char *prefix);
+extern int cmd_report(int argc, const char **argv, const char *prefix);
+extern int cmd_stat(int argc, const char **argv, const char *prefix);
+extern int cmd_top(int argc, const char **argv, const char *prefix);
+extern int cmd_version(int argc, const char **argv, const char *prefix);
+extern int cmd_list(int argc, const char **argv, const char *prefix);
+
+#endif
diff --git a/tools/perf/command-list.txt b/tools/perf/command-list.txt
new file mode 100644
index 000000000000..eebce30afbc0
--- /dev/null
+++ b/tools/perf/command-list.txt
@@ -0,0 +1,10 @@
+#
+# List of known perf commands.
+# command name                  category [deprecated] [common]
+#
+perf-annotate                   mainporcelain common
+perf-list                       mainporcelain common
+perf-record                     mainporcelain common
+perf-report                     mainporcelain common
+perf-stat                       mainporcelain common
+perf-top                        mainporcelain common
diff --git a/tools/perf/design.txt b/tools/perf/design.txt
new file mode 100644
index 000000000000..f71e0d245cba
--- /dev/null
+++ b/tools/perf/design.txt
@@ -0,0 +1,457 @@
+
+Performance Counters for Linux
+------------------------------
+
+Performance counters are special hardware registers available on most modern
+CPUs. These registers count the number of certain types of hw events: such
+as instructions executed, cachemisses suffered, or branches mis-predicted -
+without slowing down the kernel or applications. These registers can also
+trigger interrupts when a threshold number of events have passed - and can
+thus be used to profile the code that runs on that CPU.
+
+The Linux Performance Counter subsystem provides an abstraction of these
+hardware capabilities. It provides per task and per CPU counters, counter
+groups, and it provides event capabilities on top of those.  It
+provides "virtual" 64-bit counters, regardless of the width of the
+underlying hardware counters.
+
+Performance counters are accessed via special file descriptors.
+There's one file descriptor per virtual counter used.
+
+The special file descriptor is opened via the perf_counter_open()
+system call:
+
+   int sys_perf_counter_open(struct perf_counter_hw_event *hw_event_uptr,
+                             pid_t pid, int cpu, int group_fd,
+                             unsigned long flags);
+
+The syscall returns the new fd. The fd can be used via the normal
+VFS system calls: read() can be used to read the counter, fcntl()
+can be used to set the blocking mode, etc.
+
+Multiple counters can be kept open at a time, and the counters
+can be poll()ed.
+
+When creating a new counter fd, 'perf_counter_hw_event' is:
+
+struct perf_counter_hw_event {
+        /*
+         * The MSB of the config word signifies if the rest contains cpu
+         * specific (raw) counter configuration data, if unset, the next
+         * 7 bits are an event type and the rest of the bits are the event
+         * identifier.
+         */
+        __u64                   config;
+
+        __u64                   irq_period;
+        __u32                   record_type;
+        __u32                   read_format;
+
+        __u64                   disabled       :  1, /* off by default        */
+                                inherit        :  1, /* children inherit it   */
+                                pinned         :  1, /* must always be on PMU */
+                                exclusive      :  1, /* only group on PMU     */
+                                exclude_user   :  1, /* don't count user      */
+                                exclude_kernel :  1, /* ditto kernel          */
+                                exclude_hv     :  1, /* ditto hypervisor      */
+                                exclude_idle   :  1, /* don't count when idle */
+                                mmap           :  1, /* include mmap data     */
+                                munmap         :  1, /* include munmap data   */
+                                comm           :  1, /* include comm data     */
+
+                                __reserved_1   : 52;
+
+        __u32                   extra_config_len;
+        __u32                   wakeup_events;  /* wakeup every n events */
+
+        __u64                   __reserved_2;
+        __u64                   __reserved_3;
+};
+
+The 'config' field specifies what the counter should count.  It
+is divided into 3 bit-fields:
+
+raw_type: 1 bit   (most significant bit)        0x8000_0000_0000_0000
+type:     7 bits  (next most significant)       0x7f00_0000_0000_0000
+event_id: 56 bits (least significant)           0x00ff_ffff_ffff_ffff
+
+If 'raw_type' is 1, then the counter will count a hardware event
+specified by the remaining 63 bits of event_config.  The encoding is
+machine-specific.
+
+If 'raw_type' is 0, then the 'type' field says what kind of counter
+this is, with the following encoding:
+
+enum perf_event_types {
+        PERF_TYPE_HARDWARE              = 0,
+        PERF_TYPE_SOFTWARE              = 1,
+        PERF_TYPE_TRACEPOINT            = 2,
+};
+
+A counter of PERF_TYPE_HARDWARE will count the hardware event
+specified by 'event_id':
+
+/*
+ * Generalized performance counter event types, used by the hw_event.event_id
+ * parameter of the sys_perf_counter_open() syscall:
+ */
+enum hw_event_ids {
+        /*
+         * Common hardware events, generalized by the kernel:
+         */
+        PERF_COUNT_HW_CPU_CYCLES                = 0,
+        PERF_COUNT_HW_INSTRUCTIONS              = 1,
+        PERF_COUNT_HW_CACHE_REFERENCES  = 2,
+        PERF_COUNT_HW_CACHE_MISSES              = 3,
+        PERF_COUNT_HW_BRANCH_INSTRUCTIONS       = 4,
+        PERF_COUNT_HW_BRANCH_MISSES     = 5,
+        PERF_COUNT_HW_BUS_CYCLES                = 6,
+};
+
+These are standardized types of events that work relatively uniformly
+on all CPUs that implement Performance Counters support under Linux,
+although there may be variations (e.g., different CPUs might count
+cache references and misses at different levels of the cache hierarchy).
+If a CPU is not able to count the selected event, then the system call
+will return -EINVAL.
+
+More hw_event_types are supported as well, but they are CPU-specific
+and accessed as raw events.  For example, to count "External bus
+cycles while bus lock signal asserted" events on Intel Core CPUs, pass
+in a 0x4064 event_id value and set hw_event.raw_type to 1.
+
+A counter of type PERF_TYPE_SOFTWARE will count one of the available
+software events, selected by 'event_id':
+
+/*
+ * Special "software" counters provided by the kernel, even if the hardware
+ * does not support performance counters. These counters measure various
+ * physical and sw events of the kernel (and allow the profiling of them as
+ * well):
+ */
+enum sw_event_ids {
+        PERF_COUNT_SW_CPU_CLOCK         = 0,
+        PERF_COUNT_SW_TASK_CLOCK                = 1,
+        PERF_COUNT_SW_PAGE_FAULTS               = 2,
+        PERF_COUNT_SW_CONTEXT_SWITCHES  = 3,
+        PERF_COUNT_SW_CPU_MIGRATIONS    = 4,
+        PERF_COUNT_SW_PAGE_FAULTS_MIN   = 5,
+        PERF_COUNT_SW_PAGE_FAULTS_MAJ   = 6,
+};
+
+Counters of the type PERF_TYPE_TRACEPOINT are available when the ftrace event
+tracer is available, and event_id values can be obtained from
+/debug/tracing/events/*/*/id
+
+
+Counters come in two flavours: counting counters and sampling
+counters.  A "counting" counter is one that is used for counting the
+number of events that occur, and is characterised by having
+irq_period = 0.
+
+
+A read() on a counter returns the current value of the counter and possible
+additional values as specified by 'read_format', each value is a u64 (8 bytes)
+in size.
+
+/*
+ * Bits that can be set in hw_event.read_format to request that
+ * reads on the counter should return the indicated quantities,
+ * in increasing order of bit value, after the counter value.
+ */
+enum perf_counter_read_format {
+        PERF_FORMAT_TOTAL_TIME_ENABLED  =  1,
+        PERF_FORMAT_TOTAL_TIME_RUNNING  =  2,
+};
+
+Using these additional values one can establish the overcommit ratio for a
+particular counter allowing one to take the round-robin scheduling effect
+into account.
+
+
+A "sampling" counter is one that is set up to generate an interrupt
+every N events, where N is given by 'irq_period'.  A sampling counter
+has irq_period > 0. The record_type controls what data is recorded on each
+interrupt:
+
+/*
+ * Bits that can be set in hw_event.record_type to request information
+ * in the overflow packets.
+ */
+enum perf_counter_record_format {
+        PERF_RECORD_IP          = 1U << 0,
+        PERF_RECORD_TID         = 1U << 1,
+        PERF_RECORD_TIME        = 1U << 2,
+        PERF_RECORD_ADDR        = 1U << 3,
+        PERF_RECORD_GROUP       = 1U << 4,
+        PERF_RECORD_CALLCHAIN   = 1U << 5,
+};
+
+Such (and other) events will be recorded in a ring-buffer, which is
+available to user-space using mmap() (see below).
+
+The 'disabled' bit specifies whether the counter starts out disabled
+or enabled.  If it is initially disabled, it can be enabled by ioctl
+or prctl (see below).
+
+The 'inherit' bit, if set, specifies that this counter should count
+events on descendant tasks as well as the task specified.  This only
+applies to new descendents, not to any existing descendents at the
+time the counter is created (nor to any new descendents of existing
+descendents).
+
+The 'pinned' bit, if set, specifies that the counter should always be
+on the CPU if at all possible.  It only applies to hardware counters
+and only to group leaders.  If a pinned counter cannot be put onto the
+CPU (e.g. because there are not enough hardware counters or because of
+a conflict with some other event), then the counter goes into an
+'error' state, where reads return end-of-file (i.e. read() returns 0)
+until the counter is subsequently enabled or disabled.
+
+The 'exclusive' bit, if set, specifies that when this counter's group
+is on the CPU, it should be the only group using the CPU's counters.
+In future, this will allow sophisticated monitoring programs to supply
+extra configuration information via 'extra_config_len' to exploit
+advanced features of the CPU's Performance Monitor Unit (PMU) that are
+not otherwise accessible and that might disrupt other hardware
+counters.
+
+The 'exclude_user', 'exclude_kernel' and 'exclude_hv' bits provide a
+way to request that counting of events be restricted to times when the
+CPU is in user, kernel and/or hypervisor mode.
+
+The 'mmap' and 'munmap' bits allow recording of PROT_EXEC mmap/munmap
+operations, these can be used to relate userspace IP addresses to actual
+code, even after the mapping (or even the whole process) is gone,
+these events are recorded in the ring-buffer (see below).
+
+The 'comm' bit allows tracking of process comm data on process creation.
+This too is recorded in the ring-buffer (see below).
+
+The 'pid' parameter to the perf_counter_open() system call allows the
+counter to be specific to a task:
+
+ pid == 0: if the pid parameter is zero, the counter is attached to the
+ current task.
+
+ pid > 0: the counter is attached to a specific task (if the current task
+ has sufficient privilege to do so)
+
+ pid < 0: all tasks are counted (per cpu counters)
+
+The 'cpu' parameter allows a counter to be made specific to a CPU:
+
+ cpu >= 0: the counter is restricted to a specific CPU
+ cpu == -1: the counter counts on all CPUs
+
+(Note: the combination of 'pid == -1' and 'cpu == -1' is not valid.)
+
+A 'pid > 0' and 'cpu == -1' counter is a per task counter that counts
+events of that task and 'follows' that task to whatever CPU the task
+gets schedule to. Per task counters can be created by any user, for
+their own tasks.
+
+A 'pid == -1' and 'cpu == x' counter is a per CPU counter that counts
+all events on CPU-x. Per CPU counters need CAP_SYS_ADMIN privilege.
+
+The 'flags' parameter is currently unused and must be zero.
+
+The 'group_fd' parameter allows counter "groups" to be set up.  A
+counter group has one counter which is the group "leader".  The leader
+is created first, with group_fd = -1 in the perf_counter_open call
+that creates it.  The rest of the group members are created
+subsequently, with group_fd giving the fd of the group leader.
+(A single counter on its own is created with group_fd = -1 and is
+considered to be a group with only 1 member.)
+
+A counter group is scheduled onto the CPU as a unit, that is, it will
+only be put onto the CPU if all of the counters in the group can be
+put onto the CPU.  This means that the values of the member counters
+can be meaningfully compared, added, divided (to get ratios), etc.,
+with each other, since they have counted events for the same set of
+executed instructions.
+
+
+Like stated, asynchronous events, like counter overflow or PROT_EXEC mmap
+tracking are logged into a ring-buffer. This ring-buffer is created and
+accessed through mmap().
+
+The mmap size should be 1+2^n pages, where the first page is a meta-data page
+(struct perf_counter_mmap_page) that contains various bits of information such
+as where the ring-buffer head is.
+
+/*
+ * Structure of the page that can be mapped via mmap
+ */
+struct perf_counter_mmap_page {
+        __u32   version;                /* version number of this structure */
+        __u32   compat_version;         /* lowest version this is compat with */
+
+        /*
+         * Bits needed to read the hw counters in user-space.
+         *
+         *   u32 seq;
+         *   s64 count;
+         *
+         *   do {
+         *     seq = pc->lock;
+         *
+         *     barrier()
+         *     if (pc->index) {
+         *       count = pmc_read(pc->index - 1);
+         *       count += pc->offset;
+         *     } else
+         *       goto regular_read;
+         *
+         *     barrier();
+         *   } while (pc->lock != seq);
+         *
+         * NOTE: for obvious reason this only works on self-monitoring
+         *       processes.
+         */
+        __u32   lock;                   /* seqlock for synchronization */
+        __u32   index;                  /* hardware counter identifier */
+        __s64   offset;                 /* add to hardware counter value */
+
+        /*
+         * Control data for the mmap() data buffer.
+         *
+         * User-space reading this value should issue an rmb(), on SMP capable
+         * platforms, after reading this value -- see perf_counter_wakeup().
+         */
+        __u32   data_head;              /* head in the data section */
+};
+
+NOTE: the hw-counter userspace bits are arch specific and are currently only
+      implemented on powerpc.
+
+The following 2^n pages are the ring-buffer which contains events of the form:
+
+#define PERF_EVENT_MISC_KERNEL          (1 << 0)
+#define PERF_EVENT_MISC_USER            (1 << 1)
+#define PERF_EVENT_MISC_OVERFLOW        (1 << 2)
+
+struct perf_event_header {
+        __u32   type;
+        __u16   misc;
+        __u16   size;
+};
+
+enum perf_event_type {
+
+        /*
+         * The MMAP events record the PROT_EXEC mappings so that we can
+         * correlate userspace IPs to code. They have the following structure:
+         *
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      u32                             pid, tid;
+         *      u64                             addr;
+         *      u64                             len;
+         *      u64                             pgoff;
+         *      char                            filename[];
+         * };
+         */
+        PERF_EVENT_MMAP                 = 1,
+        PERF_EVENT_MUNMAP               = 2,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      u32                             pid, tid;
+         *      char                            comm[];
+         * };
+         */
+        PERF_EVENT_COMM                 = 3,
+
+        /*
+         * When header.misc & PERF_EVENT_MISC_OVERFLOW the event_type field
+         * will be PERF_RECORD_*
+         *
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      { u64                   ip;       } && PERF_RECORD_IP
+         *      { u32                   pid, tid; } && PERF_RECORD_TID
+         *      { u64                   time;     } && PERF_RECORD_TIME
+         *      { u64                   addr;     } && PERF_RECORD_ADDR
+         *
+         *      { u64                   nr;
+         *        { u64 event, val; }   cnt[nr];  } && PERF_RECORD_GROUP
+         *
+         *      { u16                   nr,
+         *                              hv,
+         *                              kernel,
+         *                              user;
+         *        u64                   ips[nr];  } && PERF_RECORD_CALLCHAIN
+         * };
+         */
+};
+
+NOTE: PERF_RECORD_CALLCHAIN is arch specific and currently only implemented
+      on x86.
+
+Notification of new events is possible through poll()/select()/epoll() and
+fcntl() managing signals.
+
+Normally a notification is generated for every page filled, however one can
+additionally set perf_counter_hw_event.wakeup_events to generate one every
+so many counter overflow events.
+
+Future work will include a splice() interface to the ring-buffer.
+
+
+Counters can be enabled and disabled in two ways: via ioctl and via
+prctl.  When a counter is disabled, it doesn't count or generate
+events but does continue to exist and maintain its count value.
+
+An individual counter or counter group can be enabled with
+
+        ioctl(fd, PERF_COUNTER_IOC_ENABLE);
+
+or disabled with
+
+        ioctl(fd, PERF_COUNTER_IOC_DISABLE);
+
+Enabling or disabling the leader of a group enables or disables the
+whole group; that is, while the group leader is disabled, none of the
+counters in the group will count.  Enabling or disabling a member of a
+group other than the leader only affects that counter - disabling an
+non-leader stops that counter from counting but doesn't affect any
+other counter.
+
+Additionally, non-inherited overflow counters can use
+
+        ioctl(fd, PERF_COUNTER_IOC_REFRESH, nr);
+
+to enable a counter for 'nr' events, after which it gets disabled again.
+
+A process can enable or disable all the counter groups that are
+attached to it, using prctl:
+
+        prctl(PR_TASK_PERF_COUNTERS_ENABLE);
+
+        prctl(PR_TASK_PERF_COUNTERS_DISABLE);
+
+This applies to all counters on the current process, whether created
+by this process or by another, and doesn't affect any counters that
+this process has created on other processes.  It only enables or
+disables the group leaders, not any other members in the groups.
+
+
+Arch requirements
+-----------------
+
+If your architecture does not have hardware performance metrics, you can
+still use the generic software counters based on hrtimers for sampling.
+
+So to start with, in order to add HAVE_PERF_COUNTERS to your Kconfig, you
+will need at least this:
+        - asm/perf_counter.h - a basic stub will suffice at first
+        - support for atomic64 types (and associated helper functions)
+        - set_perf_counter_pending() implemented
+
+If your architecture does have hardware capabilities, you can override the
+weak stub hw_perf_counter_init() to register hardware counters.
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
new file mode 100644
index 000000000000..31982ad064b4
--- /dev/null
+++ b/tools/perf/perf.c
@@ -0,0 +1,500 @@
+/*
+ * perf.c
+ *
+ * Performance analysis utility.
+ *
+ * This is the main hub from which the sub-commands (perf stat,
+ * perf top, perf record, perf report, etc.) are started.
+ */
+#include "builtin.h"
+
+#include "util/exec_cmd.h"
+#include "util/cache.h"
+#include "util/quote.h"
+#include "util/run-command.h"
+#include "util/parse-events.h"
+#include "util/string.h"
+
+const char perf_usage_string[] =
+        "perf [--version] [--help] COMMAND [ARGS]";
+
+const char perf_more_info_string[] =
+        "See 'perf help COMMAND' for more information on a specific command.";
+
+static int use_pager = -1;
+struct pager_config {
+        const char *cmd;
+        int val;
+};
+
+static char debugfs_mntpt[MAXPATHLEN];
+
+static int pager_command_config(const char *var, const char *value, void *data)
+{
+        struct pager_config *c = data;
+        if (!prefixcmp(var, "pager.") && !strcmp(var + 6, c->cmd))
+                c->val = perf_config_bool(var, value);
+        return 0;
+}
+
+/* returns 0 for "no pager", 1 for "use pager", and -1 for "not specified" */
+int check_pager_config(const char *cmd)
+{
+        struct pager_config c;
+        c.cmd = cmd;
+        c.val = -1;
+        perf_config(pager_command_config, &c);
+        return c.val;
+}
+
+static void commit_pager_choice(void) {
+        switch (use_pager) {
+        case 0:
+                setenv("PERF_PAGER", "cat", 1);
+                break;
+        case 1:
+                /* setup_pager(); */
+                break;
+        default:
+                break;
+        }
+}
+
+static void set_debugfs_path(void)
+{
+        char *path;
+
+        path = getenv(PERF_DEBUGFS_ENVIRONMENT);
+        snprintf(debugfs_path, MAXPATHLEN, "%s/%s", path ?: debugfs_mntpt,
+                 "tracing/events");
+}
+
+static int handle_options(const char*** argv, int* argc, int* envchanged)
+{
+        int handled = 0;
+
+        while (*argc > 0) {
+                const char *cmd = (*argv)[0];
+                if (cmd[0] != '-')
+                        break;
+
+                /*
+                 * For legacy reasons, the "version" and "help"
+                 * commands can be written with "--" prepended
+                 * to make them look like flags.
+                 */
+                if (!strcmp(cmd, "--help") || !strcmp(cmd, "--version"))
+                        break;
+
+                /*
+                 * Check remaining flags.
+                 */
+                if (!prefixcmp(cmd, "--exec-path")) {
+                        cmd += 11;
+                        if (*cmd == '=')
+                                perf_set_argv_exec_path(cmd + 1);
+                        else {
+                                puts(perf_exec_path());
+                                exit(0);
+                        }
+                } else if (!strcmp(cmd, "--html-path")) {
+                        puts(system_path(PERF_HTML_PATH));
+                        exit(0);
+                } else if (!strcmp(cmd, "-p") || !strcmp(cmd, "--paginate")) {
+                        use_pager = 1;
+                } else if (!strcmp(cmd, "--no-pager")) {
+                        use_pager = 0;
+                        if (envchanged)
+                                *envchanged = 1;
+                } else if (!strcmp(cmd, "--perf-dir")) {
+                        if (*argc < 2) {
+                                fprintf(stderr, "No directory given for --perf-dir.\n" );
+                                usage(perf_usage_string);
+                        }
+                        setenv(PERF_DIR_ENVIRONMENT, (*argv)[1], 1);
+                        if (envchanged)
+                                *envchanged = 1;
+                        (*argv)++;
+                        (*argc)--;
+                        handled++;
+                } else if (!prefixcmp(cmd, "--perf-dir=")) {
+                        setenv(PERF_DIR_ENVIRONMENT, cmd + 10, 1);
+                        if (envchanged)
+                                *envchanged = 1;
+                } else if (!strcmp(cmd, "--work-tree")) {
+                        if (*argc < 2) {
+                                fprintf(stderr, "No directory given for --work-tree.\n" );
+                                usage(perf_usage_string);
+                        }
+                        setenv(PERF_WORK_TREE_ENVIRONMENT, (*argv)[1], 1);
+                        if (envchanged)
+                                *envchanged = 1;
+                        (*argv)++;
+                        (*argc)--;
+                } else if (!prefixcmp(cmd, "--work-tree=")) {
+                        setenv(PERF_WORK_TREE_ENVIRONMENT, cmd + 12, 1);
+                        if (envchanged)
+                                *envchanged = 1;
+                } else if (!strcmp(cmd, "--debugfs-dir")) {
+                        if (*argc < 2) {
+                                fprintf(stderr, "No directory given for --debugfs-dir.\n");
+                                usage(perf_usage_string);
+                        }
+                        strncpy(debugfs_mntpt, (*argv)[1], MAXPATHLEN);
+                        debugfs_mntpt[MAXPATHLEN - 1] = '\0';
+                        if (envchanged)
+                                *envchanged = 1;
+                        (*argv)++;
+                        (*argc)--;
+                } else if (!prefixcmp(cmd, "--debugfs-dir=")) {
+                        strncpy(debugfs_mntpt, cmd + 14, MAXPATHLEN);
+                        debugfs_mntpt[MAXPATHLEN - 1] = '\0';
+                        if (envchanged)
+                                *envchanged = 1;
+                } else {
+                        fprintf(stderr, "Unknown option: %s\n", cmd);
+                        usage(perf_usage_string);
+                }
+
+                (*argv)++;
+                (*argc)--;
+                handled++;
+        }
+        return handled;
+}
+
+static int handle_alias(int *argcp, const char ***argv)
+{
+        int envchanged = 0, ret = 0, saved_errno = errno;
+        int count, option_count;
+        const char** new_argv;
+        const char *alias_command;
+        char *alias_string;
+
+        alias_command = (*argv)[0];
+        alias_string = alias_lookup(alias_command);
+        if (alias_string) {
+                if (alias_string[0] == '!') {
+                        if (*argcp > 1) {
+                                struct strbuf buf;
+
+                                strbuf_init(&buf, PATH_MAX);
+                                strbuf_addstr(&buf, alias_string);
+                                sq_quote_argv(&buf, (*argv) + 1, PATH_MAX);
+                                free(alias_string);
+                                alias_string = buf.buf;
+                        }
+                        ret = system(alias_string + 1);
+                        if (ret >= 0 && WIFEXITED(ret) &&
+                            WEXITSTATUS(ret) != 127)
+                                exit(WEXITSTATUS(ret));
+                        die("Failed to run '%s' when expanding alias '%s'",
+                            alias_string + 1, alias_command);
+                }
+                count = split_cmdline(alias_string, &new_argv);
+                if (count < 0)
+                        die("Bad alias.%s string", alias_command);
+                option_count = handle_options(&new_argv, &count, &envchanged);
+                if (envchanged)
+                        die("alias '%s' changes environment variables\n"
+                                 "You can use '!perf' in the alias to do this.",
+                                 alias_command);
+                memmove(new_argv - option_count, new_argv,
+                                count * sizeof(char *));
+                new_argv -= option_count;
+
+                if (count < 1)
+                        die("empty alias for %s", alias_command);
+
+                if (!strcmp(alias_command, new_argv[0]))
+                        die("recursive alias: %s", alias_command);
+
+                new_argv = realloc(new_argv, sizeof(char*) *
+                                    (count + *argcp + 1));
+                /* insert after command name */
+                memcpy(new_argv + count, *argv + 1, sizeof(char*) * *argcp);
+                new_argv[count+*argcp] = NULL;
+
+                *argv = new_argv;
+                *argcp += count - 1;
+
+                ret = 1;
+        }
+
+        errno = saved_errno;
+
+        return ret;
+}
+
+const char perf_version_string[] = PERF_VERSION;
+
+#define RUN_SETUP       (1<<0)
+#define USE_PAGER       (1<<1)
+/*
+ * require working tree to be present -- anything uses this needs
+ * RUN_SETUP for reading from the configuration file.
+ */
+#define NEED_WORK_TREE  (1<<2)
+
+struct cmd_struct {
+        const char *cmd;
+        int (*fn)(int, const char **, const char *);
+        int option;
+};
+
+static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
+{
+        int status;
+        struct stat st;
+        const char *prefix;
+
+        prefix = NULL;
+        if (p->option & RUN_SETUP)
+                prefix = NULL; /* setup_perf_directory(); */
+
+        if (use_pager == -1 && p->option & RUN_SETUP)
+                use_pager = check_pager_config(p->cmd);
+        if (use_pager == -1 && p->option & USE_PAGER)
+                use_pager = 1;
+        commit_pager_choice();
+        set_debugfs_path();
+
+        status = p->fn(argc, argv, prefix);
+        if (status)
+                return status & 0xff;
+
+        /* Somebody closed stdout? */
+        if (fstat(fileno(stdout), &st))
+                return 0;
+        /* Ignore write errors for pipes and sockets.. */
+        if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode))
+                return 0;
+
+        /* Check for ENOSPC and EIO errors.. */
+        if (fflush(stdout))
+                die("write failure on standard output: %s", strerror(errno));
+        if (ferror(stdout))
+                die("unknown write failure on standard output");
+        if (fclose(stdout))
+                die("close failed on standard output: %s", strerror(errno));
+        return 0;
+}
+
+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 },
+                { "top", cmd_top, 0 },
+                { "annotate", cmd_annotate, 0 },
+                { "version", cmd_version, 0 },
+        };
+        unsigned int i;
+        static const char ext[] = STRIP_EXTENSION;
+
+        if (sizeof(ext) > 1) {
+                i = strlen(argv[0]) - strlen(ext);
+                if (i > 0 && !strcmp(argv[0] + i, ext)) {
+                        char *argv0 = strdup(argv[0]);
+                        argv[0] = cmd = argv0;
+                        argv0[i] = '\0';
+                }
+        }
+
+        /* Turn "perf cmd --help" into "perf help cmd" */
+        if (argc > 1 && !strcmp(argv[1], "--help")) {
+                argv[1] = argv[0];
+                argv[0] = cmd = "help";
+        }
+
+        for (i = 0; i < ARRAY_SIZE(commands); i++) {
+                struct cmd_struct *p = commands+i;
+                if (strcmp(p->cmd, cmd))
+                        continue;
+                exit(run_builtin(p, argc, argv));
+        }
+}
+
+static void execv_dashed_external(const char **argv)
+{
+        struct strbuf cmd = STRBUF_INIT;
+        const char *tmp;
+        int status;
+
+        strbuf_addf(&cmd, "perf-%s", argv[0]);
+
+        /*
+         * argv[0] must be the perf command, but the argv array
+         * belongs to the caller, and may be reused in
+         * subsequent loop iterations. Save argv[0] and
+         * restore it on error.
+         */
+        tmp = argv[0];
+        argv[0] = cmd.buf;
+
+        /*
+         * if we fail because the command is not found, it is
+         * OK to return. Otherwise, we just pass along the status code.
+         */
+        status = run_command_v_opt(argv, 0);
+        if (status != -ERR_RUN_COMMAND_EXEC) {
+                if (IS_RUN_COMMAND_ERR(status))
+                        die("unable to run '%s'", argv[0]);
+                exit(-status);
+        }
+        errno = ENOENT; /* as if we called execvp */
+
+        argv[0] = tmp;
+
+        strbuf_release(&cmd);
+}
+
+static int run_argv(int *argcp, const char ***argv)
+{
+        int done_alias = 0;
+
+        while (1) {
+                /* See if it's an internal command */
+                handle_internal_command(*argcp, *argv);
+
+                /* .. then try the external ones */
+                execv_dashed_external(*argv);
+
+                /* It could be an alias -- this works around the insanity
+                 * of overriding "perf log" with "perf show" by having
+                 * alias.log = show
+                 */
+                if (done_alias || !handle_alias(argcp, argv))
+                        break;
+                done_alias = 1;
+        }
+
+        return done_alias;
+}
+
+/* mini /proc/mounts parser: searching for "^blah /mount/point debugfs" */
+static void get_debugfs_mntpt(void)
+{
+        FILE *file;
+        char fs_type[100];
+        char debugfs[MAXPATHLEN];
+
+        /*
+         * try the standard location
+         */
+        if (valid_debugfs_mount("/sys/kernel/debug/") == 0) {
+                strcpy(debugfs_mntpt, "/sys/kernel/debug/");
+                return;
+        }
+
+        /*
+         * try the sane location
+         */
+        if (valid_debugfs_mount("/debug/") == 0) {
+                strcpy(debugfs_mntpt, "/debug/");
+                return;
+        }
+
+        /*
+         * 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';
+        }
+}
+
+int main(int argc, const char **argv)
+{
+        const char *cmd;
+
+        cmd = perf_extract_argv0_path(argv[0]);
+        if (!cmd)
+                cmd = "perf-help";
+        /* get debugfs mount point from /proc/mounts */
+        get_debugfs_mntpt();
+        /*
+         * "perf-xxxx" is the same as "perf xxxx", but we obviously:
+         *
+         *  - cannot take flags in between the "perf" and the "xxxx".
+         *  - cannot execute it externally (since it would just do
+         *    the same thing over again)
+         *
+         * So we just directly call the internal command handler, and
+         * die if that one cannot handle it.
+         */
+        if (!prefixcmp(cmd, "perf-")) {
+                cmd += 5;
+                argv[0] = cmd;
+                handle_internal_command(argc, argv);
+                die("cannot handle %s internally", cmd);
+        }
+
+        /* Look for flags.. */
+        argv++;
+        argc--;
+        handle_options(&argv, &argc, NULL);
+        commit_pager_choice();
+        set_debugfs_path();
+        if (argc > 0) {
+                if (!prefixcmp(argv[0], "--"))
+                        argv[0] += 2;
+        } else {
+                /* The user didn't specify a command; give them help */
+                printf("\n usage: %s\n\n", perf_usage_string);
+                list_common_cmds_help();
+                printf("\n %s\n\n", perf_more_info_string);
+                exit(1);
+        }
+        cmd = argv[0];
+
+        /*
+         * We use PATH to find perf commands, but we prepend some higher
+         * precidence paths: the "--exec-path" option, the PERF_EXEC_PATH
+         * environment, and the $(perfexecdir) from the Makefile at build
+         * time.
+         */
+        setup_path();
+
+        while (1) {
+                static int done_help = 0;
+                static int was_alias = 0;
+
+                was_alias = run_argv(&argc, &argv);
+                if (errno != ENOENT)
+                        break;
+
+                if (was_alias) {
+                        fprintf(stderr, "Expansion of alias '%s' failed; "
+                                "'%s' is not a perf-command\n",
+                                cmd, argv[0]);
+                        exit(1);
+                }
+                if (!done_help) {
+                        cmd = argv[0] = help_unknown_cmd(cmd);
+                        done_help = 1;
+                } else
+                        break;
+        }
+
+        fprintf(stderr, "Failed to run command '%s': %s\n",
+                cmd, strerror(errno));
+
+        return 1;
+}
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
new file mode 100644
index 000000000000..e5148e2b6134
--- /dev/null
+++ b/tools/perf/perf.h
@@ -0,0 +1,104 @@
+#ifndef _PERF_PERF_H
+#define _PERF_PERF_H
+
+#if defined(__i386__)
+#include "../../arch/x86/include/asm/unistd.h"
+#define rmb()           asm volatile("lock; addl $0,0(%%esp)" ::: "memory")
+#define cpu_relax()     asm volatile("rep; nop" ::: "memory");
+#endif
+
+#if defined(__x86_64__)
+#include "../../arch/x86/include/asm/unistd.h"
+#define rmb()           asm volatile("lfence" ::: "memory")
+#define cpu_relax()     asm volatile("rep; nop" ::: "memory");
+#endif
+
+#ifdef __powerpc__
+#include "../../arch/powerpc/include/asm/unistd.h"
+#define rmb()           asm volatile ("sync" ::: "memory")
+#define cpu_relax()     asm volatile ("" ::: "memory");
+#endif
+
+#ifdef __s390__
+#include "../../arch/s390/include/asm/unistd.h"
+#define rmb()           asm volatile("bcr 15,0" ::: "memory")
+#define cpu_relax()     asm volatile("" ::: "memory");
+#endif
+
+#ifdef __sh__
+#include "../../arch/sh/include/asm/unistd.h"
+#if defined(__SH4A__) || defined(__SH5__)
+# define rmb()          asm volatile("synco" ::: "memory")
+#else
+# define rmb()          asm volatile("" ::: "memory")
+#endif
+#define cpu_relax()     asm volatile("" ::: "memory")
+#endif
+
+#ifdef __hppa__
+#include "../../arch/parisc/include/asm/unistd.h"
+#define rmb()           asm volatile("" ::: "memory")
+#define cpu_relax()     asm volatile("" ::: "memory");
+#endif
+
+#include <time.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/syscall.h>
+
+#include "../../include/linux/perf_counter.h"
+#include "util/types.h"
+
+/*
+ * prctl(PR_TASK_PERF_COUNTERS_DISABLE) will (cheaply) disable all
+ * counters in the current task.
+ */
+#define PR_TASK_PERF_COUNTERS_DISABLE   31
+#define PR_TASK_PERF_COUNTERS_ENABLE    32
+
+#ifndef NSEC_PER_SEC
+# define NSEC_PER_SEC                   1000000000ULL
+#endif
+
+static inline unsigned long long rdclock(void)
+{
+        struct timespec ts;
+
+        clock_gettime(CLOCK_MONOTONIC, &ts);
+        return ts.tv_sec * 1000000000ULL + ts.tv_nsec;
+}
+
+/*
+ * Pick up some kernel type conventions:
+ */
+#define __user
+#define asmlinkage
+
+#define __used          __attribute__((__unused__))
+
+#define unlikely(x)     __builtin_expect(!!(x), 0)
+#define min(x, y) ({                            \
+        typeof(x) _min1 = (x);                  \
+        typeof(y) _min2 = (y);                  \
+        (void) (&_min1 == &_min2);              \
+        _min1 < _min2 ? _min1 : _min2; })
+
+static inline int
+sys_perf_counter_open(struct perf_counter_attr *attr,
+                      pid_t pid, int cpu, int group_fd,
+                      unsigned long flags)
+{
+        attr->size = sizeof(*attr);
+        return syscall(__NR_perf_counter_open, attr, pid, cpu,
+                       group_fd, flags);
+}
+
+#define MAX_COUNTERS                    256
+#define MAX_NR_CPUS                     256
+
+struct ip_callchain {
+        u64 nr;
+        u64 ips[0];
+};
+
+#endif
diff --git a/tools/perf/util/PERF-VERSION-GEN b/tools/perf/util/PERF-VERSION-GEN
new file mode 100755
index 000000000000..c561d1538c03
--- /dev/null
+++ b/tools/perf/util/PERF-VERSION-GEN
@@ -0,0 +1,42 @@
+#!/bin/sh
+
+GVF=PERF-VERSION-FILE
+DEF_VER=v0.0.1.PERF
+
+LF='
+'
+
+# First see if there is a version file (included in release tarballs),
+# then try git-describe, then default.
+if test -f version
+then
+        VN=$(cat version) || VN="$DEF_VER"
+elif test -d .git -o -f .git &&
+        VN=$(git describe --abbrev=4 HEAD 2>/dev/null) &&
+        case "$VN" in
+        *$LF*) (exit 1) ;;
+        v[0-9]*)
+                git update-index -q --refresh
+                test -z "$(git diff-index --name-only HEAD --)" ||
+                VN="$VN-dirty" ;;
+        esac
+then
+        VN=$(echo "$VN" | sed -e 's/-/./g');
+else
+        VN="$DEF_VER"
+fi
+
+VN=$(expr "$VN" : v*'\(.*\)')
+
+if test -r $GVF
+then
+        VC=$(sed -e 's/^PERF_VERSION = //' <$GVF)
+else
+        VC=unset
+fi
+test "$VN" = "$VC" || {
+        echo >&2 "PERF_VERSION = $VN"
+        echo "PERF_VERSION = $VN" >$GVF
+}
+
+
diff --git a/tools/perf/util/abspath.c b/tools/perf/util/abspath.c
new file mode 100644
index 000000000000..61d33b81fc97
--- /dev/null
+++ b/tools/perf/util/abspath.c
@@ -0,0 +1,117 @@
+#include "cache.h"
+
+/*
+ * Do not use this for inspecting *tracked* content.  When path is a
+ * symlink to a directory, we do not want to say it is a directory when
+ * dealing with tracked content in the working tree.
+ */
+static int is_directory(const char *path)
+{
+        struct stat st;
+        return (!stat(path, &st) && S_ISDIR(st.st_mode));
+}
+
+/* We allow "recursive" symbolic links. Only within reason, though. */
+#define MAXDEPTH 5
+
+const char *make_absolute_path(const char *path)
+{
+        static char bufs[2][PATH_MAX + 1], *buf = bufs[0], *next_buf = bufs[1];
+        char cwd[1024] = "";
+        int buf_index = 1, len;
+
+        int depth = MAXDEPTH;
+        char *last_elem = NULL;
+        struct stat st;
+
+        if (strlcpy(buf, path, PATH_MAX) >= PATH_MAX)
+                die ("Too long path: %.*s", 60, path);
+
+        while (depth--) {
+                if (!is_directory(buf)) {
+                        char *last_slash = strrchr(buf, '/');
+                        if (last_slash) {
+                                *last_slash = '\0';
+                                last_elem = xstrdup(last_slash + 1);
+                        } else {
+                                last_elem = xstrdup(buf);
+                                *buf = '\0';
+                        }
+                }
+
+                if (*buf) {
+                        if (!*cwd && !getcwd(cwd, sizeof(cwd)))
+                                die ("Could not get current working directory");
+
+                        if (chdir(buf))
+                                die ("Could not switch to '%s'", buf);
+                }
+                if (!getcwd(buf, PATH_MAX))
+                        die ("Could not get current working directory");
+
+                if (last_elem) {
+                        int len = strlen(buf);
+                        if (len + strlen(last_elem) + 2 > PATH_MAX)
+                                die ("Too long path name: '%s/%s'",
+                                                buf, last_elem);
+                        buf[len] = '/';
+                        strcpy(buf + len + 1, last_elem);
+                        free(last_elem);
+                        last_elem = NULL;
+                }
+
+                if (!lstat(buf, &st) && S_ISLNK(st.st_mode)) {
+                        len = readlink(buf, next_buf, PATH_MAX);
+                        if (len < 0)
+                                die ("Invalid symlink: %s", buf);
+                        if (PATH_MAX <= len)
+                                die("symbolic link too long: %s", buf);
+                        next_buf[len] = '\0';
+                        buf = next_buf;
+                        buf_index = 1 - buf_index;
+                        next_buf = bufs[buf_index];
+                } else
+                        break;
+        }
+
+        if (*cwd && chdir(cwd))
+                die ("Could not change back to '%s'", cwd);
+
+        return buf;
+}
+
+static const char *get_pwd_cwd(void)
+{
+        static char cwd[PATH_MAX + 1];
+        char *pwd;
+        struct stat cwd_stat, pwd_stat;
+        if (getcwd(cwd, PATH_MAX) == NULL)
+                return NULL;
+        pwd = getenv("PWD");
+        if (pwd && strcmp(pwd, cwd)) {
+                stat(cwd, &cwd_stat);
+                if (!stat(pwd, &pwd_stat) &&
+                    pwd_stat.st_dev == cwd_stat.st_dev &&
+                    pwd_stat.st_ino == cwd_stat.st_ino) {
+                        strlcpy(cwd, pwd, PATH_MAX);
+                }
+        }
+        return cwd;
+}
+
+const char *make_nonrelative_path(const char *path)
+{
+        static char buf[PATH_MAX + 1];
+
+        if (is_absolute_path(path)) {
+                if (strlcpy(buf, path, PATH_MAX) >= PATH_MAX)
+                        die("Too long path: %.*s", 60, path);
+        } else {
+                const char *cwd = get_pwd_cwd();
+                if (!cwd)
+                        die("Cannot determine the current working directory");
+                if (snprintf(buf, PATH_MAX, "%s/%s", cwd, path) >= PATH_MAX)
+                        die("Too long path: %.*s", 60, path);
+        }
+        return buf;
+}
diff --git a/tools/perf/util/alias.c b/tools/perf/util/alias.c
new file mode 100644
index 000000000000..b8144e80bb1e
--- /dev/null
+++ b/tools/perf/util/alias.c
@@ -0,0 +1,77 @@
+#include "cache.h"
+
+static const char *alias_key;
+static char *alias_val;
+
+static int alias_lookup_cb(const char *k, const char *v, void *cb __used)
+{
+        if (!prefixcmp(k, "alias.") && !strcmp(k+6, alias_key)) {
+                if (!v)
+                        return config_error_nonbool(k);
+                alias_val = strdup(v);
+                return 0;
+        }
+        return 0;
+}
+
+char *alias_lookup(const char *alias)
+{
+        alias_key = alias;
+        alias_val = NULL;
+        perf_config(alias_lookup_cb, NULL);
+        return alias_val;
+}
+
+int split_cmdline(char *cmdline, const char ***argv)
+{
+        int src, dst, count = 0, size = 16;
+        char quoted = 0;
+
+        *argv = malloc(sizeof(char*) * size);
+
+        /* split alias_string */
+        (*argv)[count++] = cmdline;
+        for (src = dst = 0; cmdline[src];) {
+                char c = cmdline[src];
+                if (!quoted && isspace(c)) {
+                        cmdline[dst++] = 0;
+                        while (cmdline[++src]
+                                        && isspace(cmdline[src]))
+                                ; /* skip */
+                        if (count >= size) {
+                                size += 16;
+                                *argv = realloc(*argv, sizeof(char*) * size);
+                        }
+                        (*argv)[count++] = cmdline + dst;
+                } else if (!quoted && (c == '\'' || c == '"')) {
+                        quoted = c;
+                        src++;
+                } else if (c == quoted) {
+                        quoted = 0;
+                        src++;
+                } else {
+                        if (c == '\\' && quoted != '\'') {
+                                src++;
+                                c = cmdline[src];
+                                if (!c) {
+                                        free(*argv);
+                                        *argv = NULL;
+                                        return error("cmdline ends with \\");
+                                }
+                        }
+                        cmdline[dst++] = c;
+                        src++;
+                }
+        }
+
+        cmdline[dst] = 0;
+
+        if (quoted) {
+                free(*argv);
+                *argv = NULL;
+                return error("unclosed quote");
+        }
+
+        return count;
+}
+
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
new file mode 100644
index 000000000000..4b50c412b9c5
--- /dev/null
+++ b/tools/perf/util/cache.h
@@ -0,0 +1,121 @@
+#ifndef CACHE_H
+#define CACHE_H
+
+#include "util.h"
+#include "strbuf.h"
+#include "../perf.h"
+
+#define PERF_DIR_ENVIRONMENT "PERF_DIR"
+#define PERF_WORK_TREE_ENVIRONMENT "PERF_WORK_TREE"
+#define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
+#define DB_ENVIRONMENT "PERF_OBJECT_DIRECTORY"
+#define INDEX_ENVIRONMENT "PERF_INDEX_FILE"
+#define GRAFT_ENVIRONMENT "PERF_GRAFT_FILE"
+#define TEMPLATE_DIR_ENVIRONMENT "PERF_TEMPLATE_DIR"
+#define CONFIG_ENVIRONMENT "PERF_CONFIG"
+#define EXEC_PATH_ENVIRONMENT "PERF_EXEC_PATH"
+#define CEILING_DIRECTORIES_ENVIRONMENT "PERF_CEILING_DIRECTORIES"
+#define PERFATTRIBUTES_FILE ".perfattributes"
+#define INFOATTRIBUTES_FILE "info/attributes"
+#define ATTRIBUTE_MACRO_PREFIX "[attr]"
+#define PERF_DEBUGFS_ENVIRONMENT "PERF_DEBUGFS_DIR"
+
+typedef int (*config_fn_t)(const char *, const char *, void *);
+extern int perf_default_config(const char *, const char *, void *);
+extern int perf_config_from_file(config_fn_t fn, const char *, void *);
+extern int perf_config(config_fn_t fn, void *);
+extern int perf_parse_ulong(const char *, unsigned long *);
+extern int perf_config_int(const char *, const char *);
+extern unsigned long perf_config_ulong(const char *, const char *);
+extern int perf_config_bool_or_int(const char *, const char *, int *);
+extern int perf_config_bool(const char *, const char *);
+extern int perf_config_string(const char **, const char *, const char *);
+extern int perf_config_set(const char *, const char *);
+extern int perf_config_set_multivar(const char *, const char *, const char *, int);
+extern int perf_config_rename_section(const char *, const char *);
+extern const char *perf_etc_perfconfig(void);
+extern int check_repository_format_version(const char *var, const char *value, void *cb);
+extern int perf_config_system(void);
+extern int perf_config_global(void);
+extern int config_error_nonbool(const char *);
+extern const char *config_exclusive_filename;
+
+#define MAX_PERFNAME (1000)
+extern char perf_default_email[MAX_PERFNAME];
+extern char perf_default_name[MAX_PERFNAME];
+extern int user_ident_explicitly_given;
+
+extern const char *perf_log_output_encoding;
+extern const char *perf_mailmap_file;
+
+/* IO helper functions */
+extern void maybe_flush_or_die(FILE *, const char *);
+extern int copy_fd(int ifd, int ofd);
+extern int copy_file(const char *dst, const char *src, int mode);
+extern ssize_t read_in_full(int fd, void *buf, size_t count);
+extern ssize_t write_in_full(int fd, const void *buf, size_t count);
+extern void write_or_die(int fd, const void *buf, size_t count);
+extern int write_or_whine(int fd, const void *buf, size_t count, const char *msg);
+extern int write_or_whine_pipe(int fd, const void *buf, size_t count, const char *msg);
+extern void fsync_or_die(int fd, const char *);
+
+/* pager.c */
+extern void setup_pager(void);
+extern const char *pager_program;
+extern int pager_in_use(void);
+extern int pager_use_color;
+
+extern const char *editor_program;
+extern const char *excludes_file;
+
+char *alias_lookup(const char *alias);
+int split_cmdline(char *cmdline, const char ***argv);
+
+#define alloc_nr(x) (((x)+16)*3/2)
+
+/*
+ * Realloc the buffer pointed at by variable 'x' so that it can hold
+ * at least 'nr' entries; the number of entries currently allocated
+ * is 'alloc', using the standard growing factor alloc_nr() macro.
+ *
+ * DO NOT USE any expression with side-effect for 'x' or 'alloc'.
+ */
+#define ALLOC_GROW(x, nr, alloc) \
+        do { \
+                if ((nr) > alloc) { \
+                        if (alloc_nr(alloc) < (nr)) \
+                                alloc = (nr); \
+                        else \
+                                alloc = alloc_nr(alloc); \
+                        x = xrealloc((x), alloc * sizeof(*(x))); \
+                } \
+        } while(0)
+
+
+static inline int is_absolute_path(const char *path)
+{
+        return path[0] == '/';
+}
+
+const char *make_absolute_path(const char *path);
+const char *make_nonrelative_path(const char *path);
+const char *make_relative_path(const char *abs, const char *base);
+int normalize_path_copy(char *dst, const char *src);
+int longest_ancestor_length(const char *path, const char *prefix_list);
+char *strip_path_suffix(const char *path, const char *suffix);
+
+extern char *mkpath(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
+extern char *perf_path(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
+/* perf_mkstemp() - create tmp file honoring TMPDIR variable */
+extern int perf_mkstemp(char *path, size_t len, const char *template);
+
+extern char *mksnpath(char *buf, size_t n, const char *fmt, ...)
+        __attribute__((format (printf, 3, 4)));
+extern char *perf_snpath(char *buf, size_t n, const char *fmt, ...)
+        __attribute__((format (printf, 3, 4)));
+extern char *perf_pathdup(const char *fmt, ...)
+        __attribute__((format (printf, 1, 2)));
+
+extern size_t strlcpy(char *dest, const char *src, size_t size);
+
+#endif /* CACHE_H */
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
new file mode 100644
index 000000000000..011473411642
--- /dev/null
+++ b/tools/perf/util/callchain.c
@@ -0,0 +1,343 @@
+/*
+ * Copyright (C) 2009, Frederic Weisbecker <fweisbec@gmail.com>
+ *
+ * Handle the callchains from the stream in an ad-hoc radix tree and then
+ * sort them in an rbtree.
+ *
+ * Using a radix for code path provides a fast retrieval and factorizes
+ * memory use. Also that lets us use the paths in a hierarchical graph view.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <math.h>
+
+#include "callchain.h"
+
+#define chain_for_each_child(child, parent)     \
+        list_for_each_entry(child, &parent->children, brothers)
+
+static void
+rb_insert_callchain(struct rb_root *root, struct callchain_node *chain,
+                    enum chain_mode mode)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct callchain_node *rnode;
+        u64 chain_cumul = cumul_hits(chain);
+
+        while (*p) {
+                u64 rnode_cumul;
+
+                parent = *p;
+                rnode = rb_entry(parent, struct callchain_node, rb_node);
+                rnode_cumul = cumul_hits(rnode);
+
+                switch (mode) {
+                case CHAIN_FLAT:
+                        if (rnode->hit < chain->hit)
+                                p = &(*p)->rb_left;
+                        else
+                                p = &(*p)->rb_right;
+                        break;
+                case CHAIN_GRAPH_ABS: /* Falldown */
+                case CHAIN_GRAPH_REL:
+                        if (rnode_cumul < chain_cumul)
+                                p = &(*p)->rb_left;
+                        else
+                                p = &(*p)->rb_right;
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        rb_link_node(&chain->rb_node, parent, p);
+        rb_insert_color(&chain->rb_node, root);
+}
+
+static void
+__sort_chain_flat(struct rb_root *rb_root, struct callchain_node *node,
+                  u64 min_hit)
+{
+        struct callchain_node *child;
+
+        chain_for_each_child(child, node)
+                __sort_chain_flat(rb_root, child, min_hit);
+
+        if (node->hit && node->hit >= min_hit)
+                rb_insert_callchain(rb_root, node, CHAIN_FLAT);
+}
+
+/*
+ * Once we get every callchains from the stream, we can now
+ * sort them by hit
+ */
+static void
+sort_chain_flat(struct rb_root *rb_root, struct callchain_node *node,
+                u64 min_hit, struct callchain_param *param __used)
+{
+        __sort_chain_flat(rb_root, node, min_hit);
+}
+
+static void __sort_chain_graph_abs(struct callchain_node *node,
+                                   u64 min_hit)
+{
+        struct callchain_node *child;
+
+        node->rb_root = RB_ROOT;
+
+        chain_for_each_child(child, node) {
+                __sort_chain_graph_abs(child, min_hit);
+                if (cumul_hits(child) >= min_hit)
+                        rb_insert_callchain(&node->rb_root, child,
+                                            CHAIN_GRAPH_ABS);
+        }
+}
+
+static void
+sort_chain_graph_abs(struct rb_root *rb_root, struct callchain_node *chain_root,
+                     u64 min_hit, struct callchain_param *param __used)
+{
+        __sort_chain_graph_abs(chain_root, min_hit);
+        rb_root->rb_node = chain_root->rb_root.rb_node;
+}
+
+static void __sort_chain_graph_rel(struct callchain_node *node,
+                                   double min_percent)
+{
+        struct callchain_node *child;
+        u64 min_hit;
+
+        node->rb_root = RB_ROOT;
+        min_hit = ceil(node->children_hit * min_percent);
+
+        chain_for_each_child(child, node) {
+                __sort_chain_graph_rel(child, min_percent);
+                if (cumul_hits(child) >= min_hit)
+                        rb_insert_callchain(&node->rb_root, child,
+                                            CHAIN_GRAPH_REL);
+        }
+}
+
+static void
+sort_chain_graph_rel(struct rb_root *rb_root, struct callchain_node *chain_root,
+                     u64 min_hit __used, struct callchain_param *param)
+{
+        __sort_chain_graph_rel(chain_root, param->min_percent / 100.0);
+        rb_root->rb_node = chain_root->rb_root.rb_node;
+}
+
+int register_callchain_param(struct callchain_param *param)
+{
+        switch (param->mode) {
+        case CHAIN_GRAPH_ABS:
+                param->sort = sort_chain_graph_abs;
+                break;
+        case CHAIN_GRAPH_REL:
+                param->sort = sort_chain_graph_rel;
+                break;
+        case CHAIN_FLAT:
+                param->sort = sort_chain_flat;
+                break;
+        default:
+                return -1;
+        }
+        return 0;
+}
+
+/*
+ * Create a child for a parent. If inherit_children, then the new child
+ * will become the new parent of it's parent children
+ */
+static struct callchain_node *
+create_child(struct callchain_node *parent, bool inherit_children)
+{
+        struct callchain_node *new;
+
+        new = malloc(sizeof(*new));
+        if (!new) {
+                perror("not enough memory to create child for code path tree");
+                return NULL;
+        }
+        new->parent = parent;
+        INIT_LIST_HEAD(&new->children);
+        INIT_LIST_HEAD(&new->val);
+
+        if (inherit_children) {
+                struct callchain_node *next;
+
+                list_splice(&parent->children, &new->children);
+                INIT_LIST_HEAD(&parent->children);
+
+                chain_for_each_child(next, new)
+                        next->parent = new;
+        }
+        list_add_tail(&new->brothers, &parent->children);
+
+        return new;
+}
+
+/*
+ * Fill the node with callchain values
+ */
+static void
+fill_node(struct callchain_node *node, struct ip_callchain *chain,
+          int start, struct symbol **syms)
+{
+        unsigned int i;
+
+        for (i = start; i < chain->nr; i++) {
+                struct callchain_list *call;
+
+                call = malloc(sizeof(*call));
+                if (!call) {
+                        perror("not enough memory for the code path tree");
+                        return;
+                }
+                call->ip = chain->ips[i];
+                call->sym = syms[i];
+                list_add_tail(&call->list, &node->val);
+        }
+        node->val_nr = chain->nr - start;
+        if (!node->val_nr)
+                printf("Warning: empty node in callchain tree\n");
+}
+
+static void
+add_child(struct callchain_node *parent, struct ip_callchain *chain,
+          int start, struct symbol **syms)
+{
+        struct callchain_node *new;
+
+        new = create_child(parent, false);
+        fill_node(new, chain, start, syms);
+
+        new->children_hit = 0;
+        new->hit = 1;
+}
+
+/*
+ * Split the parent in two parts (a new child is created) and
+ * give a part of its callchain to the created child.
+ * Then create another child to host the given callchain of new branch
+ */
+static void
+split_add_child(struct callchain_node *parent, struct ip_callchain *chain,
+                struct callchain_list *to_split, int idx_parents, int idx_local,
+                struct symbol **syms)
+{
+        struct callchain_node *new;
+        struct list_head *old_tail;
+        unsigned int idx_total = idx_parents + idx_local;
+
+        /* split */
+        new = create_child(parent, true);
+
+        /* split the callchain and move a part to the new child */
+        old_tail = parent->val.prev;
+        list_del_range(&to_split->list, old_tail);
+        new->val.next = &to_split->list;
+        new->val.prev = old_tail;
+        to_split->list.prev = &new->val;
+        old_tail->next = &new->val;
+
+        /* split the hits */
+        new->hit = parent->hit;
+        new->children_hit = parent->children_hit;
+        parent->children_hit = cumul_hits(new);
+        new->val_nr = parent->val_nr - idx_local;
+        parent->val_nr = idx_local;
+
+        /* create a new child for the new branch if any */
+        if (idx_total < chain->nr) {
+                parent->hit = 0;
+                add_child(parent, chain, idx_total, syms);
+                parent->children_hit++;
+        } else {
+                parent->hit = 1;
+        }
+}
+
+static int
+__append_chain(struct callchain_node *root, struct ip_callchain *chain,
+               unsigned int start, struct symbol **syms);
+
+static void
+__append_chain_children(struct callchain_node *root, struct ip_callchain *chain,
+                        struct symbol **syms, unsigned int start)
+{
+        struct callchain_node *rnode;
+
+        /* lookup in childrens */
+        chain_for_each_child(rnode, root) {
+                unsigned int ret = __append_chain(rnode, chain, start, syms);
+
+                if (!ret)
+                        goto inc_children_hit;
+        }
+        /* nothing in children, add to the current node */
+        add_child(root, chain, start, syms);
+
+inc_children_hit:
+        root->children_hit++;
+}
+
+static int
+__append_chain(struct callchain_node *root, struct ip_callchain *chain,
+               unsigned int start, struct symbol **syms)
+{
+        struct callchain_list *cnode;
+        unsigned int i = start;
+        bool found = false;
+
+        /*
+         * Lookup in the current node
+         * If we have a symbol, then compare the start to match
+         * anywhere inside a function.
+         */
+        list_for_each_entry(cnode, &root->val, list) {
+                if (i == chain->nr)
+                        break;
+                if (cnode->sym && syms[i]) {
+                        if (cnode->sym->start != syms[i]->start)
+                                break;
+                } else if (cnode->ip != chain->ips[i])
+                        break;
+                if (!found)
+                        found = true;
+                i++;
+        }
+
+        /* matches not, relay on the parent */
+        if (!found)
+                return -1;
+
+        /* we match only a part of the node. Split it and add the new chain */
+        if (i - start < root->val_nr) {
+                split_add_child(root, chain, cnode, start, i - start, syms);
+                return 0;
+        }
+
+        /* we match 100% of the path, increment the hit */
+        if (i - start == root->val_nr && i == chain->nr) {
+                root->hit++;
+                return 0;
+        }
+
+        /* We match the node and still have a part remaining */
+        __append_chain_children(root, chain, syms, i);
+
+        return 0;
+}
+
+void append_chain(struct callchain_node *root, struct ip_callchain *chain,
+                  struct symbol **syms)
+{
+        if (!chain->nr)
+                return;
+        __append_chain_children(root, chain, syms, 0);
+}
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
new file mode 100644
index 000000000000..a926ae4f5a16
--- /dev/null
+++ b/tools/perf/util/callchain.h
@@ -0,0 +1,60 @@
+#ifndef __PERF_CALLCHAIN_H
+#define __PERF_CALLCHAIN_H
+
+#include "../perf.h"
+#include <linux/list.h>
+#include <linux/rbtree.h>
+#include "symbol.h"
+
+enum chain_mode {
+        CHAIN_NONE,
+        CHAIN_FLAT,
+        CHAIN_GRAPH_ABS,
+        CHAIN_GRAPH_REL
+};
+
+struct callchain_node {
+        struct callchain_node   *parent;
+        struct list_head        brothers;
+        struct list_head        children;
+        struct list_head        val;
+        struct rb_node          rb_node; /* to sort nodes in an rbtree */
+        struct rb_root          rb_root; /* sorted tree of children */
+        unsigned int            val_nr;
+        u64                     hit;
+        u64                     children_hit;
+};
+
+struct callchain_param;
+
+typedef void (*sort_chain_func_t)(struct rb_root *, struct callchain_node *,
+                                 u64, struct callchain_param *);
+
+struct callchain_param {
+        enum chain_mode         mode;
+        double                  min_percent;
+        sort_chain_func_t       sort;
+};
+
+struct callchain_list {
+        u64                     ip;
+        struct symbol           *sym;
+        struct list_head        list;
+};
+
+static inline void callchain_init(struct callchain_node *node)
+{
+        INIT_LIST_HEAD(&node->brothers);
+        INIT_LIST_HEAD(&node->children);
+        INIT_LIST_HEAD(&node->val);
+}
+
+static inline u64 cumul_hits(struct callchain_node *node)
+{
+        return node->hit + node->children_hit;
+}
+
+int register_callchain_param(struct callchain_param *param);
+void append_chain(struct callchain_node *root, struct ip_callchain *chain,
+                  struct symbol **syms);
+#endif
diff --git a/tools/perf/util/color.c b/tools/perf/util/color.c
new file mode 100644
index 000000000000..90a044d1fe7d
--- /dev/null
+++ b/tools/perf/util/color.c
@@ -0,0 +1,272 @@
+#include "cache.h"
+#include "color.h"
+
+int perf_use_color_default = -1;
+
+static int parse_color(const char *name, int len)
+{
+        static const char * const color_names[] = {
+                "normal", "black", "red", "green", "yellow",
+                "blue", "magenta", "cyan", "white"
+        };
+        char *end;
+        int i;
+
+        for (i = 0; i < (int)ARRAY_SIZE(color_names); i++) {
+                const char *str = color_names[i];
+                if (!strncasecmp(name, str, len) && !str[len])
+                        return i - 1;
+        }
+        i = strtol(name, &end, 10);
+        if (end - name == len && i >= -1 && i <= 255)
+                return i;
+        return -2;
+}
+
+static int parse_attr(const char *name, int len)
+{
+        static const int attr_values[] = { 1, 2, 4, 5, 7 };
+        static const char * const attr_names[] = {
+                "bold", "dim", "ul", "blink", "reverse"
+        };
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(attr_names); i++) {
+                const char *str = attr_names[i];
+                if (!strncasecmp(name, str, len) && !str[len])
+                        return attr_values[i];
+        }
+        return -1;
+}
+
+void color_parse(const char *value, const char *var, char *dst)
+{
+        color_parse_mem(value, strlen(value), var, dst);
+}
+
+void color_parse_mem(const char *value, int value_len, const char *var,
+                char *dst)
+{
+        const char *ptr = value;
+        int len = value_len;
+        int attr = -1;
+        int fg = -2;
+        int bg = -2;
+
+        if (!strncasecmp(value, "reset", len)) {
+                strcpy(dst, PERF_COLOR_RESET);
+                return;
+        }
+
+        /* [fg [bg]] [attr] */
+        while (len > 0) {
+                const char *word = ptr;
+                int val, wordlen = 0;
+
+                while (len > 0 && !isspace(word[wordlen])) {
+                        wordlen++;
+                        len--;
+                }
+
+                ptr = word + wordlen;
+                while (len > 0 && isspace(*ptr)) {
+                        ptr++;
+                        len--;
+                }
+
+                val = parse_color(word, wordlen);
+                if (val >= -1) {
+                        if (fg == -2) {
+                                fg = val;
+                                continue;
+                        }
+                        if (bg == -2) {
+                                bg = val;
+                                continue;
+                        }
+                        goto bad;
+                }
+                val = parse_attr(word, wordlen);
+                if (val < 0 || attr != -1)
+                        goto bad;
+                attr = val;
+        }
+
+        if (attr >= 0 || fg >= 0 || bg >= 0) {
+                int sep = 0;
+
+                *dst++ = '\033';
+                *dst++ = '[';
+                if (attr >= 0) {
+                        *dst++ = '0' + attr;
+                        sep++;
+                }
+                if (fg >= 0) {
+                        if (sep++)
+                                *dst++ = ';';
+                        if (fg < 8) {
+                                *dst++ = '3';
+                                *dst++ = '0' + fg;
+                        } else {
+                                dst += sprintf(dst, "38;5;%d", fg);
+                        }
+                }
+                if (bg >= 0) {
+                        if (sep++)
+                                *dst++ = ';';
+                        if (bg < 8) {
+                                *dst++ = '4';
+                                *dst++ = '0' + bg;
+                        } else {
+                                dst += sprintf(dst, "48;5;%d", bg);
+                        }
+                }
+                *dst++ = 'm';
+        }
+        *dst = 0;
+        return;
+bad:
+        die("bad color value '%.*s' for variable '%s'", value_len, value, var);
+}
+
+int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty)
+{
+        if (value) {
+                if (!strcasecmp(value, "never"))
+                        return 0;
+                if (!strcasecmp(value, "always"))
+                        return 1;
+                if (!strcasecmp(value, "auto"))
+                        goto auto_color;
+        }
+
+        /* Missing or explicit false to turn off colorization */
+        if (!perf_config_bool(var, value))
+                return 0;
+
+        /* any normal truth value defaults to 'auto' */
+ auto_color:
+        if (stdout_is_tty < 0)
+                stdout_is_tty = isatty(1);
+        if (stdout_is_tty || (pager_in_use() && pager_use_color)) {
+                char *term = getenv("TERM");
+                if (term && strcmp(term, "dumb"))
+                        return 1;
+        }
+        return 0;
+}
+
+int perf_color_default_config(const char *var, const char *value, void *cb)
+{
+        if (!strcmp(var, "color.ui")) {
+                perf_use_color_default = perf_config_colorbool(var, value, -1);
+                return 0;
+        }
+
+        return perf_default_config(var, value, cb);
+}
+
+static int color_vfprintf(FILE *fp, const char *color, const char *fmt,
+                va_list args, const char *trail)
+{
+        int r = 0;
+
+        /*
+         * Auto-detect:
+         */
+        if (perf_use_color_default < 0) {
+                if (isatty(1) || pager_in_use())
+                        perf_use_color_default = 1;
+                else
+                        perf_use_color_default = 0;
+        }
+
+        if (perf_use_color_default && *color)
+                r += fprintf(fp, "%s", color);
+        r += vfprintf(fp, fmt, args);
+        if (perf_use_color_default && *color)
+                r += fprintf(fp, "%s", PERF_COLOR_RESET);
+        if (trail)
+                r += fprintf(fp, "%s", trail);
+        return r;
+}
+
+
+
+int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
+{
+        va_list args;
+        int r;
+
+        va_start(args, fmt);
+        r = color_vfprintf(fp, color, fmt, args, NULL);
+        va_end(args);
+        return r;
+}
+
+int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...)
+{
+        va_list args;
+        int r;
+        va_start(args, fmt);
+        r = color_vfprintf(fp, color, fmt, args, "\n");
+        va_end(args);
+        return r;
+}
+
+/*
+ * This function splits the buffer by newlines and colors the lines individually.
+ *
+ * Returns 0 on success.
+ */
+int color_fwrite_lines(FILE *fp, const char *color,
+                size_t count, const char *buf)
+{
+        if (!*color)
+                return fwrite(buf, count, 1, fp) != 1;
+
+        while (count) {
+                char *p = memchr(buf, '\n', count);
+
+                if (p != buf && (fputs(color, fp) < 0 ||
+                                fwrite(buf, p ? (size_t)(p - buf) : count, 1, fp) != 1 ||
+                                fputs(PERF_COLOR_RESET, fp) < 0))
+                        return -1;
+                if (!p)
+                        return 0;
+                if (fputc('\n', fp) < 0)
+                        return -1;
+                count -= p + 1 - buf;
+                buf = p + 1;
+        }
+        return 0;
+}
+
+char *get_percent_color(double percent)
+{
+        char *color = PERF_COLOR_NORMAL;
+
+        /*
+         * We color high-overhead entries in red, mid-overhead
+         * entries in green - and keep the low overhead places
+         * normal:
+         */
+        if (percent >= MIN_RED)
+                color = PERF_COLOR_RED;
+        else {
+                if (percent > MIN_GREEN)
+                        color = PERF_COLOR_GREEN;
+        }
+        return color;
+}
+
+int percent_color_fprintf(FILE *fp, const char *fmt, double percent)
+{
+        int r;
+        char *color;
+
+        color = get_percent_color(percent);
+        r = color_fprintf(fp, color, fmt, percent);
+
+        return r;
+}
diff --git a/tools/perf/util/color.h b/tools/perf/util/color.h
new file mode 100644
index 000000000000..706cec50bd25
--- /dev/null
+++ b/tools/perf/util/color.h
@@ -0,0 +1,41 @@
+#ifndef COLOR_H
+#define COLOR_H
+
+/* "\033[1;38;5;2xx;48;5;2xxm\0" is 23 bytes */
+#define COLOR_MAXLEN 24
+
+#define PERF_COLOR_NORMAL       ""
+#define PERF_COLOR_RESET        "\033[m"
+#define PERF_COLOR_BOLD         "\033[1m"
+#define PERF_COLOR_RED          "\033[31m"
+#define PERF_COLOR_GREEN        "\033[32m"
+#define PERF_COLOR_YELLOW       "\033[33m"
+#define PERF_COLOR_BLUE         "\033[34m"
+#define PERF_COLOR_MAGENTA      "\033[35m"
+#define PERF_COLOR_CYAN         "\033[36m"
+#define PERF_COLOR_BG_RED       "\033[41m"
+
+#define MIN_GREEN       0.5
+#define MIN_RED         5.0
+
+/*
+ * This variable stores the value of color.ui
+ */
+extern int perf_use_color_default;
+
+
+/*
+ * Use this instead of perf_default_config if you need the value of color.ui.
+ */
+int perf_color_default_config(const char *var, const char *value, void *cb);
+
+int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty);
+void color_parse(const char *value, const char *var, char *dst);
+void color_parse_mem(const char *value, int len, const char *var, char *dst);
+int color_fprintf(FILE *fp, const char *color, const char *fmt, ...);
+int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...);
+int color_fwrite_lines(FILE *fp, const char *color, size_t count, const char *buf);
+int percent_color_fprintf(FILE *fp, const char *fmt, double percent);
+char *get_percent_color(double percent);
+
+#endif /* COLOR_H */
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
new file mode 100644
index 000000000000..780df541006d
--- /dev/null
+++ b/tools/perf/util/config.c
@@ -0,0 +1,875 @@
+/*
+ * GIT - The information manager from hell
+ *
+ * Copyright (C) Linus Torvalds, 2005
+ * Copyright (C) Johannes Schindelin, 2005
+ *
+ */
+#include "util.h"
+#include "cache.h"
+#include "exec_cmd.h"
+
+#define MAXNAME (256)
+
+static FILE *config_file;
+static const char *config_file_name;
+static int config_linenr;
+static int config_file_eof;
+
+const char *config_exclusive_filename = NULL;
+
+static int get_next_char(void)
+{
+        int c;
+        FILE *f;
+
+        c = '\n';
+        if ((f = config_file) != NULL) {
+                c = fgetc(f);
+                if (c == '\r') {
+                        /* DOS like systems */
+                        c = fgetc(f);
+                        if (c != '\n') {
+                                ungetc(c, f);
+                                c = '\r';
+                        }
+                }
+                if (c == '\n')
+                        config_linenr++;
+                if (c == EOF) {
+                        config_file_eof = 1;
+                        c = '\n';
+                }
+        }
+        return c;
+}
+
+static char *parse_value(void)
+{
+        static char value[1024];
+        int quote = 0, comment = 0, space = 0;
+        size_t len = 0;
+
+        for (;;) {
+                int c = get_next_char();
+
+                if (len >= sizeof(value) - 1)
+                        return NULL;
+                if (c == '\n') {
+                        if (quote)
+                                return NULL;
+                        value[len] = 0;
+                        return value;
+                }
+                if (comment)
+                        continue;
+                if (isspace(c) && !quote) {
+                        space = 1;
+                        continue;
+                }
+                if (!quote) {
+                        if (c == ';' || c == '#') {
+                                comment = 1;
+                                continue;
+                        }
+                }
+                if (space) {
+                        if (len)
+                                value[len++] = ' ';
+                        space = 0;
+                }
+                if (c == '\\') {
+                        c = get_next_char();
+                        switch (c) {
+                        case '\n':
+                                continue;
+                        case 't':
+                                c = '\t';
+                                break;
+                        case 'b':
+                                c = '\b';
+                                break;
+                        case 'n':
+                                c = '\n';
+                                break;
+                        /* Some characters escape as themselves */
+                        case '\\': case '"':
+                                break;
+                        /* Reject unknown escape sequences */
+                        default:
+                                return NULL;
+                        }
+                        value[len++] = c;
+                        continue;
+                }
+                if (c == '"') {
+                        quote = 1-quote;
+                        continue;
+                }
+                value[len++] = c;
+        }
+}
+
+static inline int iskeychar(int c)
+{
+        return isalnum(c) || c == '-';
+}
+
+static int get_value(config_fn_t fn, void *data, char *name, unsigned int len)
+{
+        int c;
+        char *value;
+
+        /* Get the full name */
+        for (;;) {
+                c = get_next_char();
+                if (config_file_eof)
+                        break;
+                if (!iskeychar(c))
+                        break;
+                name[len++] = tolower(c);
+                if (len >= MAXNAME)
+                        return -1;
+        }
+        name[len] = 0;
+        while (c == ' ' || c == '\t')
+                c = get_next_char();
+
+        value = NULL;
+        if (c != '\n') {
+                if (c != '=')
+                        return -1;
+                value = parse_value();
+                if (!value)
+                        return -1;
+        }
+        return fn(name, value, data);
+}
+
+static int get_extended_base_var(char *name, int baselen, int c)
+{
+        do {
+                if (c == '\n')
+                        return -1;
+                c = get_next_char();
+        } while (isspace(c));
+
+        /* We require the format to be '[base "extension"]' */
+        if (c != '"')
+                return -1;
+        name[baselen++] = '.';
+
+        for (;;) {
+                int c = get_next_char();
+                if (c == '\n')
+                        return -1;
+                if (c == '"')
+                        break;
+                if (c == '\\') {
+                        c = get_next_char();
+                        if (c == '\n')
+                                return -1;
+                }
+                name[baselen++] = c;
+                if (baselen > MAXNAME / 2)
+                        return -1;
+        }
+
+        /* Final ']' */
+        if (get_next_char() != ']')
+                return -1;
+        return baselen;
+}
+
+static int get_base_var(char *name)
+{
+        int baselen = 0;
+
+        for (;;) {
+                int c = get_next_char();
+                if (config_file_eof)
+                        return -1;
+                if (c == ']')
+                        return baselen;
+                if (isspace(c))
+                        return get_extended_base_var(name, baselen, c);
+                if (!iskeychar(c) && c != '.')
+                        return -1;
+                if (baselen > MAXNAME / 2)
+                        return -1;
+                name[baselen++] = tolower(c);
+        }
+}
+
+static int perf_parse_file(config_fn_t fn, void *data)
+{
+        int comment = 0;
+        int baselen = 0;
+        static char var[MAXNAME];
+
+        /* U+FEFF Byte Order Mark in UTF8 */
+        static const unsigned char *utf8_bom = (unsigned char *) "\xef\xbb\xbf";
+        const unsigned char *bomptr = utf8_bom;
+
+        for (;;) {
+                int c = get_next_char();
+                if (bomptr && *bomptr) {
+                        /* We are at the file beginning; skip UTF8-encoded BOM
+                         * if present. Sane editors won't put this in on their
+                         * own, but e.g. Windows Notepad will do it happily. */
+                        if ((unsigned char) c == *bomptr) {
+                                bomptr++;
+                                continue;
+                        } else {
+                                /* Do not tolerate partial BOM. */
+                                if (bomptr != utf8_bom)
+                                        break;
+                                /* No BOM at file beginning. Cool. */
+                                bomptr = NULL;
+                        }
+                }
+                if (c == '\n') {
+                        if (config_file_eof)
+                                return 0;
+                        comment = 0;
+                        continue;
+                }
+                if (comment || isspace(c))
+                        continue;
+                if (c == '#' || c == ';') {
+                        comment = 1;
+                        continue;
+                }
+                if (c == '[') {
+                        baselen = get_base_var(var);
+                        if (baselen <= 0)
+                                break;
+                        var[baselen++] = '.';
+                        var[baselen] = 0;
+                        continue;
+                }
+                if (!isalpha(c))
+                        break;
+                var[baselen] = tolower(c);
+                if (get_value(fn, data, var, baselen+1) < 0)
+                        break;
+        }
+        die("bad config file line %d in %s", config_linenr, config_file_name);
+}
+
+static int parse_unit_factor(const char *end, unsigned long *val)
+{
+        if (!*end)
+                return 1;
+        else if (!strcasecmp(end, "k")) {
+                *val *= 1024;
+                return 1;
+        }
+        else if (!strcasecmp(end, "m")) {
+                *val *= 1024 * 1024;
+                return 1;
+        }
+        else if (!strcasecmp(end, "g")) {
+                *val *= 1024 * 1024 * 1024;
+                return 1;
+        }
+        return 0;
+}
+
+static int perf_parse_long(const char *value, long *ret)
+{
+        if (value && *value) {
+                char *end;
+                long val = strtol(value, &end, 0);
+                unsigned long factor = 1;
+                if (!parse_unit_factor(end, &factor))
+                        return 0;
+                *ret = val * factor;
+                return 1;
+        }
+        return 0;
+}
+
+int perf_parse_ulong(const char *value, unsigned long *ret)
+{
+        if (value && *value) {
+                char *end;
+                unsigned long val = strtoul(value, &end, 0);
+                if (!parse_unit_factor(end, &val))
+                        return 0;
+                *ret = val;
+                return 1;
+        }
+        return 0;
+}
+
+static void die_bad_config(const char *name)
+{
+        if (config_file_name)
+                die("bad config value for '%s' in %s", name, config_file_name);
+        die("bad config value for '%s'", name);
+}
+
+int perf_config_int(const char *name, const char *value)
+{
+        long ret = 0;
+        if (!perf_parse_long(value, &ret))
+                die_bad_config(name);
+        return ret;
+}
+
+unsigned long perf_config_ulong(const char *name, const char *value)
+{
+        unsigned long ret;
+        if (!perf_parse_ulong(value, &ret))
+                die_bad_config(name);
+        return ret;
+}
+
+int perf_config_bool_or_int(const char *name, const char *value, int *is_bool)
+{
+        *is_bool = 1;
+        if (!value)
+                return 1;
+        if (!*value)
+                return 0;
+        if (!strcasecmp(value, "true") || !strcasecmp(value, "yes") || !strcasecmp(value, "on"))
+                return 1;
+        if (!strcasecmp(value, "false") || !strcasecmp(value, "no") || !strcasecmp(value, "off"))
+                return 0;
+        *is_bool = 0;
+        return perf_config_int(name, value);
+}
+
+int perf_config_bool(const char *name, const char *value)
+{
+        int discard;
+        return !!perf_config_bool_or_int(name, value, &discard);
+}
+
+int perf_config_string(const char **dest, const char *var, const char *value)
+{
+        if (!value)
+                return config_error_nonbool(var);
+        *dest = strdup(value);
+        return 0;
+}
+
+static int perf_default_core_config(const char *var __used, const char *value __used)
+{
+        /* Add other config variables here and to Documentation/config.txt. */
+        return 0;
+}
+
+int perf_default_config(const char *var, const char *value, void *dummy __used)
+{
+        if (!prefixcmp(var, "core."))
+                return perf_default_core_config(var, value);
+
+        /* Add other config variables here and to Documentation/config.txt. */
+        return 0;
+}
+
+int perf_config_from_file(config_fn_t fn, const char *filename, void *data)
+{
+        int ret;
+        FILE *f = fopen(filename, "r");
+
+        ret = -1;
+        if (f) {
+                config_file = f;
+                config_file_name = filename;
+                config_linenr = 1;
+                config_file_eof = 0;
+                ret = perf_parse_file(fn, data);
+                fclose(f);
+                config_file_name = NULL;
+        }
+        return ret;
+}
+
+const char *perf_etc_perfconfig(void)
+{
+        static const char *system_wide;
+        if (!system_wide)
+                system_wide = system_path(ETC_PERFCONFIG);
+        return system_wide;
+}
+
+static int perf_env_bool(const char *k, int def)
+{
+        const char *v = getenv(k);
+        return v ? perf_config_bool(k, v) : def;
+}
+
+int perf_config_system(void)
+{
+        return !perf_env_bool("PERF_CONFIG_NOSYSTEM", 0);
+}
+
+int perf_config_global(void)
+{
+        return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0);
+}
+
+int perf_config(config_fn_t fn, void *data)
+{
+        int ret = 0, found = 0;
+        char *repo_config = NULL;
+        const char *home = NULL;
+
+        /* Setting $PERF_CONFIG makes perf read _only_ the given config file. */
+        if (config_exclusive_filename)
+                return perf_config_from_file(fn, config_exclusive_filename, data);
+        if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK)) {
+                ret += perf_config_from_file(fn, perf_etc_perfconfig(),
+                                            data);
+                found += 1;
+        }
+
+        home = getenv("HOME");
+        if (perf_config_global() && home) {
+                char *user_config = strdup(mkpath("%s/.perfconfig", home));
+                if (!access(user_config, R_OK)) {
+                        ret += perf_config_from_file(fn, user_config, data);
+                        found += 1;
+                }
+                free(user_config);
+        }
+
+        repo_config = perf_pathdup("config");
+        if (!access(repo_config, R_OK)) {
+                ret += perf_config_from_file(fn, repo_config, data);
+                found += 1;
+        }
+        free(repo_config);
+        if (found == 0)
+                return -1;
+        return ret;
+}
+
+/*
+ * Find all the stuff for perf_config_set() below.
+ */
+
+#define MAX_MATCHES 512
+
+static struct {
+        int baselen;
+        char* key;
+        int do_not_match;
+        regex_t* value_regex;
+        int multi_replace;
+        size_t offset[MAX_MATCHES];
+        enum { START, SECTION_SEEN, SECTION_END_SEEN, KEY_SEEN } state;
+        int seen;
+} store;
+
+static int matches(const char* key, const char* value)
+{
+        return !strcmp(key, store.key) &&
+                (store.value_regex == NULL ||
+                 (store.do_not_match ^
+                  !regexec(store.value_regex, value, 0, NULL, 0)));
+}
+
+static int store_aux(const char* key, const char* value, void *cb __used)
+{
+        int section_len;
+        const char *ep;
+
+        switch (store.state) {
+        case KEY_SEEN:
+                if (matches(key, value)) {
+                        if (store.seen == 1 && store.multi_replace == 0) {
+                                warning("%s has multiple values", key);
+                        } else if (store.seen >= MAX_MATCHES) {
+                                error("too many matches for %s", key);
+                                return 1;
+                        }
+
+                        store.offset[store.seen] = ftell(config_file);
+                        store.seen++;
+                }
+                break;
+        case SECTION_SEEN:
+                /*
+                 * What we are looking for is in store.key (both
+                 * section and var), and its section part is baselen
+                 * long.  We found key (again, both section and var).
+                 * We would want to know if this key is in the same
+                 * section as what we are looking for.  We already
+                 * know we are in the same section as what should
+                 * hold store.key.
+                 */
+                ep = strrchr(key, '.');
+                section_len = ep - key;
+
+                if ((section_len != store.baselen) ||
+                    memcmp(key, store.key, section_len+1)) {
+                        store.state = SECTION_END_SEEN;
+                        break;
+                }
+
+                /*
+                 * Do not increment matches: this is no match, but we
+                 * just made sure we are in the desired section.
+                 */
+                store.offset[store.seen] = ftell(config_file);
+                /* fallthru */
+        case SECTION_END_SEEN:
+        case START:
+                if (matches(key, value)) {
+                        store.offset[store.seen] = ftell(config_file);
+                        store.state = KEY_SEEN;
+                        store.seen++;
+                } else {
+                        if (strrchr(key, '.') - key == store.baselen &&
+                              !strncmp(key, store.key, store.baselen)) {
+                                        store.state = SECTION_SEEN;
+                                        store.offset[store.seen] = ftell(config_file);
+                        }
+                }
+        }
+        return 0;
+}
+
+static int store_write_section(int fd, const char* key)
+{
+        const char *dot;
+        int i, success;
+        struct strbuf sb = STRBUF_INIT;
+
+        dot = memchr(key, '.', store.baselen);
+        if (dot) {
+                strbuf_addf(&sb, "[%.*s \"", (int)(dot - key), key);
+                for (i = dot - key + 1; i < store.baselen; i++) {
+                        if (key[i] == '"' || key[i] == '\\')
+                                strbuf_addch(&sb, '\\');
+                        strbuf_addch(&sb, key[i]);
+                }
+                strbuf_addstr(&sb, "\"]\n");
+        } else {
+                strbuf_addf(&sb, "[%.*s]\n", store.baselen, key);
+        }
+
+        success = (write_in_full(fd, sb.buf, sb.len) == (ssize_t)sb.len);
+        strbuf_release(&sb);
+
+        return success;
+}
+
+static int store_write_pair(int fd, const char* key, const char* value)
+{
+        int i, success;
+        int length = strlen(key + store.baselen + 1);
+        const char *quote = "";
+        struct strbuf sb = STRBUF_INIT;
+
+        /*
+         * Check to see if the value needs to be surrounded with a dq pair.
+         * Note that problematic characters are always backslash-quoted; this
+         * check is about not losing leading or trailing SP and strings that
+         * follow beginning-of-comment characters (i.e. ';' and '#') by the
+         * configuration parser.
+         */
+        if (value[0] == ' ')
+                quote = "\"";
+        for (i = 0; value[i]; i++)
+                if (value[i] == ';' || value[i] == '#')
+                        quote = "\"";
+        if (i && value[i - 1] == ' ')
+                quote = "\"";
+
+        strbuf_addf(&sb, "\t%.*s = %s",
+                    length, key + store.baselen + 1, quote);
+
+        for (i = 0; value[i]; i++)
+                switch (value[i]) {
+                case '\n':
+                        strbuf_addstr(&sb, "\\n");
+                        break;
+                case '\t':
+                        strbuf_addstr(&sb, "\\t");
+                        break;
+                case '"':
+                case '\\':
+                        strbuf_addch(&sb, '\\');
+                default:
+                        strbuf_addch(&sb, value[i]);
+                        break;
+                }
+        strbuf_addf(&sb, "%s\n", quote);
+
+        success = (write_in_full(fd, sb.buf, sb.len) == (ssize_t)sb.len);
+        strbuf_release(&sb);
+
+        return success;
+}
+
+static ssize_t find_beginning_of_line(const char* contents, size_t size,
+        size_t offset_, int* found_bracket)
+{
+        size_t equal_offset = size, bracket_offset = size;
+        ssize_t offset;
+
+contline:
+        for (offset = offset_-2; offset > 0
+                        && contents[offset] != '\n'; offset--)
+                switch (contents[offset]) {
+                        case '=': equal_offset = offset; break;
+                        case ']': bracket_offset = offset; break;
+                }
+        if (offset > 0 && contents[offset-1] == '\\') {
+                offset_ = offset;
+                goto contline;
+        }
+        if (bracket_offset < equal_offset) {
+                *found_bracket = 1;
+                offset = bracket_offset+1;
+        } else
+                offset++;
+
+        return offset;
+}
+
+int perf_config_set(const char* key, const char* value)
+{
+        return perf_config_set_multivar(key, value, NULL, 0);
+}
+
+/*
+ * If value==NULL, unset in (remove from) config,
+ * if value_regex!=NULL, disregard key/value pairs where value does not match.
+ * if multi_replace==0, nothing, or only one matching key/value is replaced,
+ *     else all matching key/values (regardless how many) are removed,
+ *     before the new pair is written.
+ *
+ * Returns 0 on success.
+ *
+ * This function does this:
+ *
+ * - it locks the config file by creating ".perf/config.lock"
+ *
+ * - it then parses the config using store_aux() as validator to find
+ *   the position on the key/value pair to replace. If it is to be unset,
+ *   it must be found exactly once.
+ *
+ * - the config file is mmap()ed and the part before the match (if any) is
+ *   written to the lock file, then the changed part and the rest.
+ *
+ * - the config file is removed and the lock file rename()d to it.
+ *
+ */
+int perf_config_set_multivar(const char* key, const char* value,
+        const char* value_regex, int multi_replace)
+{
+        int i, dot;
+        int fd = -1, in_fd;
+        int ret = 0;
+        char* config_filename;
+        const char* last_dot = strrchr(key, '.');
+
+        if (config_exclusive_filename)
+                config_filename = strdup(config_exclusive_filename);
+        else
+                config_filename = perf_pathdup("config");
+
+        /*
+         * Since "key" actually contains the section name and the real
+         * key name separated by a dot, we have to know where the dot is.
+         */
+
+        if (last_dot == NULL) {
+                error("key does not contain a section: %s", key);
+                ret = 2;
+                goto out_free;
+        }
+        store.baselen = last_dot - key;
+
+        store.multi_replace = multi_replace;
+
+        /*
+         * Validate the key and while at it, lower case it for matching.
+         */
+        store.key = malloc(strlen(key) + 1);
+        dot = 0;
+        for (i = 0; key[i]; i++) {
+                unsigned char c = key[i];
+                if (c == '.')
+                        dot = 1;
+                /* Leave the extended basename untouched.. */
+                if (!dot || i > store.baselen) {
+                        if (!iskeychar(c) || (i == store.baselen+1 && !isalpha(c))) {
+                                error("invalid key: %s", key);
+                                free(store.key);
+                                ret = 1;
+                                goto out_free;
+                        }
+                        c = tolower(c);
+                } else if (c == '\n') {
+                        error("invalid key (newline): %s", key);
+                        free(store.key);
+                        ret = 1;
+                        goto out_free;
+                }
+                store.key[i] = c;
+        }
+        store.key[i] = 0;
+
+        /*
+         * If .perf/config does not exist yet, write a minimal version.
+         */
+        in_fd = open(config_filename, O_RDONLY);
+        if ( in_fd < 0 ) {
+                free(store.key);
+
+                if ( ENOENT != errno ) {
+                        error("opening %s: %s", config_filename,
+                              strerror(errno));
+                        ret = 3; /* same as "invalid config file" */
+                        goto out_free;
+                }
+                /* if nothing to unset, error out */
+                if (value == NULL) {
+                        ret = 5;
+                        goto out_free;
+                }
+
+                store.key = (char*)key;
+                if (!store_write_section(fd, key) ||
+                    !store_write_pair(fd, key, value))
+                        goto write_err_out;
+        } else {
+                struct stat st;
+                char* contents;
+                ssize_t contents_sz, copy_begin, copy_end;
+                int i, new_line = 0;
+
+                if (value_regex == NULL)
+                        store.value_regex = NULL;
+                else {
+                        if (value_regex[0] == '!') {
+                                store.do_not_match = 1;
+                                value_regex++;
+                        } else
+                                store.do_not_match = 0;
+
+                        store.value_regex = (regex_t*)malloc(sizeof(regex_t));
+                        if (regcomp(store.value_regex, value_regex,
+                                        REG_EXTENDED)) {
+                                error("invalid pattern: %s", value_regex);
+                                free(store.value_regex);
+                                ret = 6;
+                                goto out_free;
+                        }
+                }
+
+                store.offset[0] = 0;
+                store.state = START;
+                store.seen = 0;
+
+                /*
+                 * After this, store.offset will contain the *end* offset
+                 * of the last match, or remain at 0 if no match was found.
+                 * As a side effect, we make sure to transform only a valid
+                 * existing config file.
+                 */
+                if (perf_config_from_file(store_aux, config_filename, NULL)) {
+                        error("invalid config file %s", config_filename);
+                        free(store.key);
+                        if (store.value_regex != NULL) {
+                                regfree(store.value_regex);
+                                free(store.value_regex);
+                        }
+                        ret = 3;
+                        goto out_free;
+                }
+
+                free(store.key);
+                if (store.value_regex != NULL) {
+                        regfree(store.value_regex);
+                        free(store.value_regex);
+                }
+
+                /* if nothing to unset, or too many matches, error out */
+                if ((store.seen == 0 && value == NULL) ||
+                                (store.seen > 1 && multi_replace == 0)) {
+                        ret = 5;
+                        goto out_free;
+                }
+
+                fstat(in_fd, &st);
+                contents_sz = xsize_t(st.st_size);
+                contents = mmap(NULL, contents_sz, PROT_READ,
+                        MAP_PRIVATE, in_fd, 0);
+                close(in_fd);
+
+                if (store.seen == 0)
+                        store.seen = 1;
+
+                for (i = 0, copy_begin = 0; i < store.seen; i++) {
+                        if (store.offset[i] == 0) {
+                                store.offset[i] = copy_end = contents_sz;
+                        } else if (store.state != KEY_SEEN) {
+                                copy_end = store.offset[i];
+                        } else
+                                copy_end = find_beginning_of_line(
+                                        contents, contents_sz,
+                                        store.offset[i]-2, &new_line);
+
+                        if (copy_end > 0 && contents[copy_end-1] != '\n')
+                                new_line = 1;
+
+                        /* write the first part of the config */
+                        if (copy_end > copy_begin) {
+                                if (write_in_full(fd, contents + copy_begin,
+                                                  copy_end - copy_begin) <
+                                    copy_end - copy_begin)
+                                        goto write_err_out;
+                                if (new_line &&
+                                    write_in_full(fd, "\n", 1) != 1)
+                                        goto write_err_out;
+                        }
+                        copy_begin = store.offset[i];
+                }
+
+                /* write the pair (value == NULL means unset) */
+                if (value != NULL) {
+                        if (store.state == START) {
+                                if (!store_write_section(fd, key))
+                                        goto write_err_out;
+                        }
+                        if (!store_write_pair(fd, key, value))
+                                goto write_err_out;
+                }
+
+                /* write the rest of the config */
+                if (copy_begin < contents_sz)
+                        if (write_in_full(fd, contents + copy_begin,
+                                          contents_sz - copy_begin) <
+                            contents_sz - copy_begin)
+                                goto write_err_out;
+
+                munmap(contents, contents_sz);
+        }
+
+        ret = 0;
+
+out_free:
+        free(config_filename);
+        return ret;
+
+write_err_out:
+        goto out_free;
+
+}
+
+/*
+ * Call this to report error for your variable that should not
+ * get a boolean value (i.e. "[my] var" means "true").
+ */
+int config_error_nonbool(const char *var)
+{
+        return error("Missing value for '%s'", var);
+}
diff --git a/tools/perf/util/ctype.c b/tools/perf/util/ctype.c
new file mode 100644
index 000000000000..0b791bd346bc
--- /dev/null
+++ b/tools/perf/util/ctype.c
@@ -0,0 +1,31 @@
+/*
+ * Sane locale-independent, ASCII ctype.
+ *
+ * No surprises, and works with signed and unsigned chars.
+ */
+#include "cache.h"
+
+enum {
+        S = GIT_SPACE,
+        A = GIT_ALPHA,
+        D = GIT_DIGIT,
+        G = GIT_GLOB_SPECIAL,   /* *, ?, [, \\ */
+        R = GIT_REGEX_SPECIAL,  /* $, (, ), +, ., ^, {, | * */
+        P = GIT_PRINT_EXTRA,    /* printable - alpha - digit - glob - regex */
+
+        PS = GIT_SPACE | GIT_PRINT_EXTRA,
+};
+
+unsigned char sane_ctype[256] = {
+/*      0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F                      */
+
+        0, 0, 0, 0, 0, 0, 0, 0, 0, S, S, 0, 0, S, 0, 0,         /*   0.. 15 */
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /*  16.. 31 */
+        PS,P, P, P, R, P, P, P, R, R, G, R, P, P, R, P,         /*  32.. 47 */
+        D, D, D, D, D, D, D, D, D, D, P, P, P, P, P, G,         /*  48.. 63 */
+        P, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A,         /*  64.. 79 */
+        A, A, A, A, A, A, A, A, A, A, A, G, G, P, R, P,         /*  80.. 95 */
+        P, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A,         /*  96..111 */
+        A, A, A, A, A, A, A, A, A, A, A, R, R, P, P, 0,         /* 112..127 */
+        /* Nothing in the 128.. range */
+};
diff --git a/tools/perf/util/environment.c b/tools/perf/util/environment.c
new file mode 100644
index 000000000000..275b0ee345f5
--- /dev/null
+++ b/tools/perf/util/environment.c
@@ -0,0 +1,9 @@
+/*
+ * We put all the perf config variables in this same object
+ * file, so that programs can link against the config parser
+ * without having to link against all the rest of perf.
+ */
+#include "cache.h"
+
+const char *pager_program;
+int pager_use_color = 1;
diff --git a/tools/perf/util/exec_cmd.c b/tools/perf/util/exec_cmd.c
new file mode 100644
index 000000000000..34a352867382
--- /dev/null
+++ b/tools/perf/util/exec_cmd.c
@@ -0,0 +1,168 @@
+#include "cache.h"
+#include "exec_cmd.h"
+#include "quote.h"
+
+#include <string.h>
+
+#define MAX_ARGS        32
+
+extern char **environ;
+static const char *argv_exec_path;
+static const char *argv0_path;
+
+const char *system_path(const char *path)
+{
+#ifdef RUNTIME_PREFIX
+        static const char *prefix;
+#else
+        static const char *prefix = PREFIX;
+#endif
+        struct strbuf d = STRBUF_INIT;
+
+        if (is_absolute_path(path))
+                return path;
+
+#ifdef RUNTIME_PREFIX
+        assert(argv0_path);
+        assert(is_absolute_path(argv0_path));
+
+        if (!prefix &&
+            !(prefix = strip_path_suffix(argv0_path, PERF_EXEC_PATH)) &&
+            !(prefix = strip_path_suffix(argv0_path, BINDIR)) &&
+            !(prefix = strip_path_suffix(argv0_path, "perf"))) {
+                prefix = PREFIX;
+                fprintf(stderr, "RUNTIME_PREFIX requested, "
+                                "but prefix computation failed.  "
+                                "Using static fallback '%s'.\n", prefix);
+        }
+#endif
+
+        strbuf_addf(&d, "%s/%s", prefix, path);
+        path = strbuf_detach(&d, NULL);
+        return path;
+}
+
+const char *perf_extract_argv0_path(const char *argv0)
+{
+        const char *slash;
+
+        if (!argv0 || !*argv0)
+                return NULL;
+        slash = argv0 + strlen(argv0);
+
+        while (argv0 <= slash && !is_dir_sep(*slash))
+                slash--;
+
+        if (slash >= argv0) {
+                argv0_path = xstrndup(argv0, slash - argv0);
+                return slash + 1;
+        }
+
+        return argv0;
+}
+
+void perf_set_argv_exec_path(const char *exec_path)
+{
+        argv_exec_path = exec_path;
+        /*
+         * Propagate this setting to external programs.
+         */
+        setenv(EXEC_PATH_ENVIRONMENT, exec_path, 1);
+}
+
+
+/* Returns the highest-priority, location to look for perf programs. */
+const char *perf_exec_path(void)
+{
+        const char *env;
+
+        if (argv_exec_path)
+                return argv_exec_path;
+
+        env = getenv(EXEC_PATH_ENVIRONMENT);
+        if (env && *env) {
+                return env;
+        }
+
+        return system_path(PERF_EXEC_PATH);
+}
+
+static void add_path(struct strbuf *out, const char *path)
+{
+        if (path && *path) {
+                if (is_absolute_path(path))
+                        strbuf_addstr(out, path);
+                else
+                        strbuf_addstr(out, make_nonrelative_path(path));
+
+                strbuf_addch(out, PATH_SEP);
+        }
+}
+
+void setup_path(void)
+{
+        const char *old_path = getenv("PATH");
+        struct strbuf new_path = STRBUF_INIT;
+
+        add_path(&new_path, perf_exec_path());
+        add_path(&new_path, argv0_path);
+
+        if (old_path)
+                strbuf_addstr(&new_path, old_path);
+        else
+                strbuf_addstr(&new_path, "/usr/local/bin:/usr/bin:/bin");
+
+        setenv("PATH", new_path.buf, 1);
+
+        strbuf_release(&new_path);
+}
+
+const char **prepare_perf_cmd(const char **argv)
+{
+        int argc;
+        const char **nargv;
+
+        for (argc = 0; argv[argc]; argc++)
+                ; /* just counting */
+        nargv = malloc(sizeof(*nargv) * (argc + 2));
+
+        nargv[0] = "perf";
+        for (argc = 0; argv[argc]; argc++)
+                nargv[argc + 1] = argv[argc];
+        nargv[argc + 1] = NULL;
+        return nargv;
+}
+
+int execv_perf_cmd(const char **argv) {
+        const char **nargv = prepare_perf_cmd(argv);
+
+        /* execvp() can only ever return if it fails */
+        execvp("perf", (char **)nargv);
+
+        free(nargv);
+        return -1;
+}
+
+
+int execl_perf_cmd(const char *cmd,...)
+{
+        int argc;
+        const char *argv[MAX_ARGS + 1];
+        const char *arg;
+        va_list param;
+
+        va_start(param, cmd);
+        argv[0] = cmd;
+        argc = 1;
+        while (argc < MAX_ARGS) {
+                arg = argv[argc++] = va_arg(param, char *);
+                if (!arg)
+                        break;
+        }
+        va_end(param);
+        if (MAX_ARGS <= argc)
+                return error("too many args to run %s", cmd);
+
+        argv[argc] = NULL;
+        return execv_perf_cmd(argv);
+}
diff --git a/tools/perf/util/exec_cmd.h b/tools/perf/util/exec_cmd.h
new file mode 100644
index 000000000000..effe25eb1545
--- /dev/null
+++ b/tools/perf/util/exec_cmd.h
@@ -0,0 +1,13 @@
+#ifndef PERF_EXEC_CMD_H
+#define PERF_EXEC_CMD_H
+
+extern void perf_set_argv_exec_path(const char *exec_path);
+extern const char *perf_extract_argv0_path(const char *path);
+extern const char *perf_exec_path(void);
+extern void setup_path(void);
+extern const char **prepare_perf_cmd(const char **argv);
+extern int execv_perf_cmd(const char **argv); /* NULL terminated */
+extern int execl_perf_cmd(const char *cmd, ...);
+extern const char *system_path(const char *path);
+
+#endif /* PERF_EXEC_CMD_H */
diff --git a/tools/perf/util/generate-cmdlist.sh b/tools/perf/util/generate-cmdlist.sh
new file mode 100755
index 000000000000..f06f6fd148f8
--- /dev/null
+++ b/tools/perf/util/generate-cmdlist.sh
@@ -0,0 +1,24 @@
+#!/bin/sh
+
+echo "/* Automatically generated by $0 */
+struct cmdname_help
+{
+    char name[16];
+    char help[80];
+};
+
+static struct cmdname_help common_cmds[] = {"
+
+sed -n -e 's/^perf-\([^         ]*\)[   ].* common.*/\1/p' command-list.txt |
+sort |
+while read cmd
+do
+     sed -n '
+     /^NAME/,/perf-'"$cmd"'/H
+     ${
+            x
+            s/.*perf-'"$cmd"' - \(.*\)/  {"'"$cmd"'", "\1"},/
+            p
+     }' "Documentation/perf-$cmd.txt"
+done
+echo "};"
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
new file mode 100644
index 000000000000..b92a457ca32e
--- /dev/null
+++ b/tools/perf/util/header.c
@@ -0,0 +1,245 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "util.h"
+#include "header.h"
+
+/*
+ *
+ */
+
+struct perf_header_attr *perf_header_attr__new(struct perf_counter_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");
+
+        return self;
+}
+
+void 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");
+        }
+        self->id[pos] = id;
+}
+
+/*
+ *
+ */
+
+struct perf_header *perf_header__new(void)
+{
+        struct perf_header *self = malloc(sizeof(*self));
+
+        if (!self)
+                die("nomem");
+
+        self->frozen = 0;
+
+        self->attrs = 0;
+        self->size = 1;
+        self->attr = malloc(sizeof(void *));
+
+        if (!self->attr)
+                die("nomem");
+
+        self->data_offset = 0;
+        self->data_size = 0;
+
+        return self;
+}
+
+void perf_header__add_attr(struct perf_header *self,
+                           struct perf_header_attr *attr)
+{
+        int pos = self->attrs;
+
+        if (self->frozen)
+                die("frozen");
+
+        self->attrs++;
+        if (self->attrs > self->size) {
+                self->size *= 2;
+                self->attr = realloc(self->attr, self->size * sizeof(void *));
+                if (!self->attr)
+                        die("nomem");
+        }
+        self->attr[pos] = attr;
+}
+
+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_counter_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;
+};
+
+static void do_write(int fd, void *buf, size_t size)
+{
+        while (size) {
+                int ret = write(fd, buf, size);
+
+                if (ret < 0)
+                        die("failed to write");
+
+                size -= ret;
+                buf += ret;
+        }
+}
+
+void perf_header__write(struct perf_header *self, int fd)
+{
+        struct perf_file_header f_header;
+        struct perf_file_attr   f_attr;
+        struct perf_header_attr *attr;
+        int i;
+
+        lseek(fd, sizeof(f_header), SEEK_SET);
+
+
+        for (i = 0; i < self->attrs; i++) {
+                attr = self->attr[i];
+
+                attr->id_offset = lseek(fd, 0, SEEK_CUR);
+                do_write(fd, attr->id, attr->ids * sizeof(u64));
+        }
+
+
+        self->attr_offset = lseek(fd, 0, SEEK_CUR);
+
+        for (i = 0; i < self->attrs; i++) {
+                attr = self->attr[i];
+
+                f_attr = (struct perf_file_attr){
+                        .attr = attr->attr,
+                        .ids  = {
+                                .offset = attr->id_offset,
+                                .size   = attr->ids * sizeof(u64),
+                        }
+                };
+                do_write(fd, &f_attr, sizeof(f_attr));
+        }
+
+
+        self->data_offset = lseek(fd, 0, SEEK_CUR);
+
+        f_header = (struct perf_file_header){
+                .magic     = PERF_MAGIC,
+                .size      = sizeof(f_header),
+                .attr_size = sizeof(f_attr),
+                .attrs = {
+                        .offset = self->attr_offset,
+                        .size   = self->attrs * sizeof(f_attr),
+                },
+                .data = {
+                        .offset = self->data_offset,
+                        .size   = self->data_size,
+                },
+        };
+
+        lseek(fd, 0, SEEK_SET);
+        do_write(fd, &f_header, sizeof(f_header));
+        lseek(fd, self->data_offset + self->data_size, SEEK_SET);
+
+        self->frozen = 1;
+}
+
+static void do_read(int fd, void *buf, size_t size)
+{
+        while (size) {
+                int ret = read(fd, buf, size);
+
+                if (ret < 0)
+                        die("failed to read");
+                if (ret == 0)
+                        die("failed to read: missing data");
+
+                size -= ret;
+                buf += ret;
+        }
+}
+
+struct perf_header *perf_header__read(int fd)
+{
+        struct perf_header      *self = perf_header__new();
+        struct perf_file_header f_header;
+        struct perf_file_attr   f_attr;
+        u64                     f_id;
+
+        int nr_attrs, nr_ids, i, j;
+
+        lseek(fd, 0, SEEK_SET);
+        do_read(fd, &f_header, sizeof(f_header));
+
+        if (f_header.magic      != PERF_MAGIC           ||
+            f_header.size       != sizeof(f_header)     ||
+            f_header.attr_size  != sizeof(f_attr))
+                die("incompatible file format");
+
+        nr_attrs = f_header.attrs.size / sizeof(f_attr);
+        lseek(fd, f_header.attrs.offset, SEEK_SET);
+
+        for (i = 0; i < nr_attrs; i++) {
+                struct perf_header_attr *attr;
+                off_t tmp;
+
+                do_read(fd, &f_attr, sizeof(f_attr));
+                tmp = lseek(fd, 0, SEEK_CUR);
+
+                attr = perf_header_attr__new(&f_attr.attr);
+
+                nr_ids = f_attr.ids.size / sizeof(u64);
+                lseek(fd, f_attr.ids.offset, SEEK_SET);
+
+                for (j = 0; j < nr_ids; j++) {
+                        do_read(fd, &f_id, sizeof(f_id));
+
+                        perf_header_attr__add_id(attr, f_id);
+                }
+                perf_header__add_attr(self, attr);
+                lseek(fd, tmp, SEEK_SET);
+        }
+
+        self->data_offset = f_header.data.offset;
+        self->data_size   = f_header.data.size;
+
+        lseek(fd, self->data_offset + self->data_size, SEEK_SET);
+
+        self->frozen = 1;
+
+        return self;
+}
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
new file mode 100644
index 000000000000..bf280449fcfd
--- /dev/null
+++ b/tools/perf/util/header.h
@@ -0,0 +1,37 @@
+#ifndef _PERF_HEADER_H
+#define _PERF_HEADER_H
+
+#include "../../../include/linux/perf_counter.h"
+#include <sys/types.h>
+#include "types.h"
+
+struct perf_header_attr {
+        struct perf_counter_attr attr;
+        int ids, size;
+        u64 *id;
+        off_t id_offset;
+};
+
+struct perf_header {
+        int frozen;
+        int attrs, size;
+        struct perf_header_attr **attr;
+        s64 attr_offset;
+        u64 data_offset;
+        u64 data_size;
+};
+
+struct perf_header *perf_header__read(int fd);
+void perf_header__write(struct perf_header *self, int fd);
+
+void perf_header__add_attr(struct perf_header *self,
+                           struct perf_header_attr *attr);
+
+struct perf_header_attr *
+perf_header_attr__new(struct perf_counter_attr *attr);
+void perf_header_attr__add_id(struct perf_header_attr *self, u64 id);
+
+
+struct perf_header *perf_header__new(void);
+
+#endif /* _PERF_HEADER_H */
diff --git a/tools/perf/util/help.c b/tools/perf/util/help.c
new file mode 100644
index 000000000000..fbb00978b2e2
--- /dev/null
+++ b/tools/perf/util/help.c
@@ -0,0 +1,356 @@
+#include "cache.h"
+#include "../builtin.h"
+#include "exec_cmd.h"
+#include "levenshtein.h"
+#include "help.h"
+
+/* most GUI terminals set COLUMNS (although some don't export it) */
+static int term_columns(void)
+{
+        char *col_string = getenv("COLUMNS");
+        int n_cols;
+
+        if (col_string && (n_cols = atoi(col_string)) > 0)
+                return n_cols;
+
+#ifdef TIOCGWINSZ
+        {
+                struct winsize ws;
+                if (!ioctl(1, TIOCGWINSZ, &ws)) {
+                        if (ws.ws_col)
+                                return ws.ws_col;
+                }
+        }
+#endif
+
+        return 80;
+}
+
+void add_cmdname(struct cmdnames *cmds, const char *name, size_t len)
+{
+        struct cmdname *ent = malloc(sizeof(*ent) + len + 1);
+
+        ent->len = len;
+        memcpy(ent->name, name, len);
+        ent->name[len] = 0;
+
+        ALLOC_GROW(cmds->names, cmds->cnt + 1, cmds->alloc);
+        cmds->names[cmds->cnt++] = ent;
+}
+
+static void clean_cmdnames(struct cmdnames *cmds)
+{
+        unsigned int i;
+
+        for (i = 0; i < cmds->cnt; ++i)
+                free(cmds->names[i]);
+        free(cmds->names);
+        cmds->cnt = 0;
+        cmds->alloc = 0;
+}
+
+static int cmdname_compare(const void *a_, const void *b_)
+{
+        struct cmdname *a = *(struct cmdname **)a_;
+        struct cmdname *b = *(struct cmdname **)b_;
+        return strcmp(a->name, b->name);
+}
+
+static void uniq(struct cmdnames *cmds)
+{
+        unsigned int i, j;
+
+        if (!cmds->cnt)
+                return;
+
+        for (i = j = 1; i < cmds->cnt; i++)
+                if (strcmp(cmds->names[i]->name, cmds->names[i-1]->name))
+                        cmds->names[j++] = cmds->names[i];
+
+        cmds->cnt = j;
+}
+
+void exclude_cmds(struct cmdnames *cmds, struct cmdnames *excludes)
+{
+        size_t ci, cj, ei;
+        int cmp;
+
+        ci = cj = ei = 0;
+        while (ci < cmds->cnt && ei < excludes->cnt) {
+                cmp = strcmp(cmds->names[ci]->name, excludes->names[ei]->name);
+                if (cmp < 0)
+                        cmds->names[cj++] = cmds->names[ci++];
+                else if (cmp == 0)
+                        ci++, ei++;
+                else if (cmp > 0)
+                        ei++;
+        }
+
+        while (ci < cmds->cnt)
+                cmds->names[cj++] = cmds->names[ci++];
+
+        cmds->cnt = cj;
+}
+
+static void pretty_print_string_list(struct cmdnames *cmds, int longest)
+{
+        int cols = 1, rows;
+        int space = longest + 1; /* min 1 SP between words */
+        int max_cols = term_columns() - 1; /* don't print *on* the edge */
+        int i, j;
+
+        if (space < max_cols)
+                cols = max_cols / space;
+        rows = (cmds->cnt + cols - 1) / cols;
+
+        for (i = 0; i < rows; i++) {
+                printf("  ");
+
+                for (j = 0; j < cols; j++) {
+                        unsigned int n = j * rows + i;
+                        unsigned int size = space;
+
+                        if (n >= cmds->cnt)
+                                break;
+                        if (j == cols-1 || n + rows >= cmds->cnt)
+                                size = 1;
+                        printf("%-*s", size, cmds->names[n]->name);
+                }
+                putchar('\n');
+        }
+}
+
+static int is_executable(const char *name)
+{
+        struct stat st;
+
+        if (stat(name, &st) || /* stat, not lstat */
+            !S_ISREG(st.st_mode))
+                return 0;
+
+        return st.st_mode & S_IXUSR;
+}
+
+static void list_commands_in_dir(struct cmdnames *cmds,
+                                         const char *path,
+                                         const char *prefix)
+{
+        int prefix_len;
+        DIR *dir = opendir(path);
+        struct dirent *de;
+        struct strbuf buf = STRBUF_INIT;
+        int len;
+
+        if (!dir)
+                return;
+        if (!prefix)
+                prefix = "perf-";
+        prefix_len = strlen(prefix);
+
+        strbuf_addf(&buf, "%s/", path);
+        len = buf.len;
+
+        while ((de = readdir(dir)) != NULL) {
+                int entlen;
+
+                if (prefixcmp(de->d_name, prefix))
+                        continue;
+
+                strbuf_setlen(&buf, len);
+                strbuf_addstr(&buf, de->d_name);
+                if (!is_executable(buf.buf))
+                        continue;
+
+                entlen = strlen(de->d_name) - prefix_len;
+                if (has_extension(de->d_name, ".exe"))
+                        entlen -= 4;
+
+                add_cmdname(cmds, de->d_name + prefix_len, entlen);
+        }
+        closedir(dir);
+        strbuf_release(&buf);
+}
+
+void load_command_list(const char *prefix,
+                struct cmdnames *main_cmds,
+                struct cmdnames *other_cmds)
+{
+        const char *env_path = getenv("PATH");
+        const char *exec_path = perf_exec_path();
+
+        if (exec_path) {
+                list_commands_in_dir(main_cmds, exec_path, prefix);
+                qsort(main_cmds->names, main_cmds->cnt,
+                      sizeof(*main_cmds->names), cmdname_compare);
+                uniq(main_cmds);
+        }
+
+        if (env_path) {
+                char *paths, *path, *colon;
+                path = paths = strdup(env_path);
+                while (1) {
+                        if ((colon = strchr(path, PATH_SEP)))
+                                *colon = 0;
+                        if (!exec_path || strcmp(path, exec_path))
+                                list_commands_in_dir(other_cmds, path, prefix);
+
+                        if (!colon)
+                                break;
+                        path = colon + 1;
+                }
+                free(paths);
+
+                qsort(other_cmds->names, other_cmds->cnt,
+                      sizeof(*other_cmds->names), cmdname_compare);
+                uniq(other_cmds);
+        }
+        exclude_cmds(other_cmds, main_cmds);
+}
+
+void list_commands(const char *title, struct cmdnames *main_cmds,
+                   struct cmdnames *other_cmds)
+{
+        unsigned int i, longest = 0;
+
+        for (i = 0; i < main_cmds->cnt; i++)
+                if (longest < main_cmds->names[i]->len)
+                        longest = main_cmds->names[i]->len;
+        for (i = 0; i < other_cmds->cnt; i++)
+                if (longest < other_cmds->names[i]->len)
+                        longest = other_cmds->names[i]->len;
+
+        if (main_cmds->cnt) {
+                const char *exec_path = perf_exec_path();
+                printf("available %s in '%s'\n", title, exec_path);
+                printf("----------------");
+                mput_char('-', strlen(title) + strlen(exec_path));
+                putchar('\n');
+                pretty_print_string_list(main_cmds, longest);
+                putchar('\n');
+        }
+
+        if (other_cmds->cnt) {
+                printf("%s available from elsewhere on your $PATH\n", title);
+                printf("---------------------------------------");
+                mput_char('-', strlen(title));
+                putchar('\n');
+                pretty_print_string_list(other_cmds, longest);
+                putchar('\n');
+        }
+}
+
+int is_in_cmdlist(struct cmdnames *c, const char *s)
+{
+        unsigned int i;
+
+        for (i = 0; i < c->cnt; i++)
+                if (!strcmp(s, c->names[i]->name))
+                        return 1;
+        return 0;
+}
+
+static int autocorrect;
+static struct cmdnames aliases;
+
+static int perf_unknown_cmd_config(const char *var, const char *value, void *cb)
+{
+        if (!strcmp(var, "help.autocorrect"))
+                autocorrect = perf_config_int(var,value);
+        /* Also use aliases for command lookup */
+        if (!prefixcmp(var, "alias."))
+                add_cmdname(&aliases, var + 6, strlen(var + 6));
+
+        return perf_default_config(var, value, cb);
+}
+
+static int levenshtein_compare(const void *p1, const void *p2)
+{
+        const struct cmdname *const *c1 = p1, *const *c2 = p2;
+        const char *s1 = (*c1)->name, *s2 = (*c2)->name;
+        int l1 = (*c1)->len;
+        int l2 = (*c2)->len;
+        return l1 != l2 ? l1 - l2 : strcmp(s1, s2);
+}
+
+static void add_cmd_list(struct cmdnames *cmds, struct cmdnames *old)
+{
+        unsigned int i;
+
+        ALLOC_GROW(cmds->names, cmds->cnt + old->cnt, cmds->alloc);
+
+        for (i = 0; i < old->cnt; i++)
+                cmds->names[cmds->cnt++] = old->names[i];
+        free(old->names);
+        old->cnt = 0;
+        old->names = NULL;
+}
+
+const char *help_unknown_cmd(const char *cmd)
+{
+        unsigned int i, n = 0, best_similarity = 0;
+        struct cmdnames main_cmds, other_cmds;
+
+        memset(&main_cmds, 0, sizeof(main_cmds));
+        memset(&other_cmds, 0, sizeof(main_cmds));
+        memset(&aliases, 0, sizeof(aliases));
+
+        perf_config(perf_unknown_cmd_config, NULL);
+
+        load_command_list("perf-", &main_cmds, &other_cmds);
+
+        add_cmd_list(&main_cmds, &aliases);
+        add_cmd_list(&main_cmds, &other_cmds);
+        qsort(main_cmds.names, main_cmds.cnt,
+              sizeof(main_cmds.names), cmdname_compare);
+        uniq(&main_cmds);
+
+        if (main_cmds.cnt) {
+                /* This reuses cmdname->len for similarity index */
+                for (i = 0; i < main_cmds.cnt; ++i)
+                        main_cmds.names[i]->len =
+                                levenshtein(cmd, main_cmds.names[i]->name, 0, 2, 1, 4);
+
+                qsort(main_cmds.names, main_cmds.cnt,
+                      sizeof(*main_cmds.names), levenshtein_compare);
+
+                best_similarity = main_cmds.names[0]->len;
+                n = 1;
+                while (n < main_cmds.cnt && best_similarity == main_cmds.names[n]->len)
+                        ++n;
+        }
+
+        if (autocorrect && n == 1) {
+                const char *assumed = main_cmds.names[0]->name;
+
+                main_cmds.names[0] = NULL;
+                clean_cmdnames(&main_cmds);
+                fprintf(stderr, "WARNING: You called a Git program named '%s', "
+                        "which does not exist.\n"
+                        "Continuing under the assumption that you meant '%s'\n",
+                        cmd, assumed);
+                if (autocorrect > 0) {
+                        fprintf(stderr, "in %0.1f seconds automatically...\n",
+                                (float)autocorrect/10.0);
+                        poll(NULL, 0, autocorrect * 100);
+                }
+                return assumed;
+        }
+
+        fprintf(stderr, "perf: '%s' is not a perf-command. See 'perf --help'.\n", cmd);
+
+        if (main_cmds.cnt && best_similarity < 6) {
+                fprintf(stderr, "\nDid you mean %s?\n",
+                        n < 2 ? "this": "one of these");
+
+                for (i = 0; i < n; i++)
+                        fprintf(stderr, "\t%s\n", main_cmds.names[i]->name);
+        }
+
+        exit(1);
+}
+
+int cmd_version(int argc __used, const char **argv __used, const char *prefix __used)
+{
+        printf("perf version %s\n", perf_version_string);
+        return 0;
+}
diff --git a/tools/perf/util/help.h b/tools/perf/util/help.h
new file mode 100644
index 000000000000..7128783637b4
--- /dev/null
+++ b/tools/perf/util/help.h
@@ -0,0 +1,29 @@
+#ifndef HELP_H
+#define HELP_H
+
+struct cmdnames {
+        size_t alloc;
+        size_t cnt;
+        struct cmdname {
+                size_t len; /* also used for similarity index in help.c */
+                char name[FLEX_ARRAY];
+        } **names;
+};
+
+static inline void mput_char(char c, unsigned int num)
+{
+        while(num--)
+                putchar(c);
+}
+
+void load_command_list(const char *prefix,
+                struct cmdnames *main_cmds,
+                struct cmdnames *other_cmds);
+void add_cmdname(struct cmdnames *cmds, const char *name, size_t len);
+/* Here we require that excludes is a sorted list. */
+void exclude_cmds(struct cmdnames *cmds, struct cmdnames *excludes);
+int is_in_cmdlist(struct cmdnames *c, const char *s);
+void list_commands(const char *title, struct cmdnames *main_cmds,
+                   struct cmdnames *other_cmds);
+
+#endif /* HELP_H */
diff --git a/tools/perf/util/include/asm/system.h b/tools/perf/util/include/asm/system.h
new file mode 100644
index 000000000000..710cecca972d
--- /dev/null
+++ b/tools/perf/util/include/asm/system.h
@@ -0,0 +1 @@
+/* Empty */
diff --git a/tools/perf/util/include/linux/kernel.h b/tools/perf/util/include/linux/kernel.h
new file mode 100644
index 000000000000..a6b87390cb52
--- /dev/null
+++ b/tools/perf/util/include/linux/kernel.h
@@ -0,0 +1,29 @@
+#ifndef PERF_LINUX_KERNEL_H_
+#define PERF_LINUX_KERNEL_H_
+
+#ifndef offsetof
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#endif
+
+#ifndef container_of
+/**
+ * container_of - cast a member of a structure out to the containing structure
+ * @ptr:        the pointer to the member.
+ * @type:       the type of the container struct this is embedded in.
+ * @member:     the name of the member within the struct.
+ *
+ */
+#define container_of(ptr, type, member) ({                      \
+        const typeof(((type *)0)->member) * __mptr = (ptr);     \
+        (type *)((char *)__mptr - offsetof(type, member)); })
+#endif
+
+#ifndef max
+#define max(x, y) ({                            \
+        typeof(x) _max1 = (x);                  \
+        typeof(y) _max2 = (y);                  \
+        (void) (&_max1 == &_max2);              \
+        _max1 > _max2 ? _max1 : _max2; })
+#endif
+
+#endif
diff --git a/tools/perf/util/include/linux/list.h b/tools/perf/util/include/linux/list.h
new file mode 100644
index 000000000000..dbe4b814382a
--- /dev/null
+++ b/tools/perf/util/include/linux/list.h
@@ -0,0 +1,18 @@
+#include "../../../../include/linux/list.h"
+
+#ifndef PERF_LIST_H
+#define PERF_LIST_H
+/**
+ * list_del_range - deletes range of entries from list.
+ * @begin: first element in the range to delete from the list.
+ * @end: last element in the range to delete from the list.
+ * Note: list_empty on the range of entries does not return true after this,
+ * the entries is in an undefined state.
+ */
+static inline void list_del_range(struct list_head *begin,
+                                  struct list_head *end)
+{
+        begin->prev->next = end->next;
+        end->next->prev = begin->prev;
+}
+#endif
diff --git a/tools/perf/util/include/linux/module.h b/tools/perf/util/include/linux/module.h
new file mode 100644
index 000000000000..b43e2dc21e04
--- /dev/null
+++ b/tools/perf/util/include/linux/module.h
@@ -0,0 +1,6 @@
+#ifndef PERF_LINUX_MODULE_H
+#define PERF_LINUX_MODULE_H
+
+#define EXPORT_SYMBOL(name)
+
+#endif
diff --git a/tools/perf/util/include/linux/poison.h b/tools/perf/util/include/linux/poison.h
new file mode 100644
index 000000000000..fef6dbc9ce13
--- /dev/null
+++ b/tools/perf/util/include/linux/poison.h
@@ -0,0 +1 @@
+#include "../../../../include/linux/poison.h"
diff --git a/tools/perf/util/include/linux/prefetch.h b/tools/perf/util/include/linux/prefetch.h
new file mode 100644
index 000000000000..7841e485d8c3
--- /dev/null
+++ b/tools/perf/util/include/linux/prefetch.h
@@ -0,0 +1,6 @@
+#ifndef PERF_LINUX_PREFETCH_H
+#define PERF_LINUX_PREFETCH_H
+
+static inline void prefetch(void *a __attribute__((unused))) { }
+
+#endif
diff --git a/tools/perf/util/include/linux/rbtree.h b/tools/perf/util/include/linux/rbtree.h
new file mode 100644
index 000000000000..7a243a143037
--- /dev/null
+++ b/tools/perf/util/include/linux/rbtree.h
@@ -0,0 +1 @@
+#include "../../../../include/linux/rbtree.h"
diff --git a/tools/perf/util/levenshtein.c b/tools/perf/util/levenshtein.c
new file mode 100644
index 000000000000..e521d1516df6
--- /dev/null
+++ b/tools/perf/util/levenshtein.c
@@ -0,0 +1,84 @@
+#include "cache.h"
+#include "levenshtein.h"
+
+/*
+ * This function implements the Damerau-Levenshtein algorithm to
+ * calculate a distance between strings.
+ *
+ * Basically, it says how many letters need to be swapped, substituted,
+ * deleted from, or added to string1, at least, to get string2.
+ *
+ * The idea is to build a distance matrix for the substrings of both
+ * strings.  To avoid a large space complexity, only the last three rows
+ * are kept in memory (if swaps had the same or higher cost as one deletion
+ * plus one insertion, only two rows would be needed).
+ *
+ * At any stage, "i + 1" denotes the length of the current substring of
+ * string1 that the distance is calculated for.
+ *
+ * row2 holds the current row, row1 the previous row (i.e. for the substring
+ * of string1 of length "i"), and row0 the row before that.
+ *
+ * In other words, at the start of the big loop, row2[j + 1] contains the
+ * Damerau-Levenshtein distance between the substring of string1 of length
+ * "i" and the substring of string2 of length "j + 1".
+ *
+ * All the big loop does is determine the partial minimum-cost paths.
+ *
+ * It does so by calculating the costs of the path ending in characters
+ * i (in string1) and j (in string2), respectively, given that the last
+ * operation is a substition, a swap, a deletion, or an insertion.
+ *
+ * This implementation allows the costs to be weighted:
+ *
+ * - w (as in "sWap")
+ * - s (as in "Substitution")
+ * - a (for insertion, AKA "Add")
+ * - d (as in "Deletion")
+ *
+ * Note that this algorithm calculates a distance _iff_ d == a.
+ */
+int levenshtein(const char *string1, const char *string2,
+                int w, int s, int a, int d)
+{
+        int len1 = strlen(string1), len2 = strlen(string2);
+        int *row0 = malloc(sizeof(int) * (len2 + 1));
+        int *row1 = malloc(sizeof(int) * (len2 + 1));
+        int *row2 = malloc(sizeof(int) * (len2 + 1));
+        int i, j;
+
+        for (j = 0; j <= len2; j++)
+                row1[j] = j * a;
+        for (i = 0; i < len1; i++) {
+                int *dummy;
+
+                row2[0] = (i + 1) * d;
+                for (j = 0; j < len2; j++) {
+                        /* substitution */
+                        row2[j + 1] = row1[j] + s * (string1[i] != string2[j]);
+                        /* swap */
+                        if (i > 0 && j > 0 && string1[i - 1] == string2[j] &&
+                                        string1[i] == string2[j - 1] &&
+                                        row2[j + 1] > row0[j - 1] + w)
+                                row2[j + 1] = row0[j - 1] + w;
+                        /* deletion */
+                        if (row2[j + 1] > row1[j + 1] + d)
+                                row2[j + 1] = row1[j + 1] + d;
+                        /* insertion */
+                        if (row2[j + 1] > row2[j] + a)
+                                row2[j + 1] = row2[j] + a;
+                }
+
+                dummy = row0;
+                row0 = row1;
+                row1 = row2;
+                row2 = dummy;
+        }
+
+        i = row1[len2];
+        free(row0);
+        free(row1);
+        free(row2);
+
+        return i;
+}
diff --git a/tools/perf/util/levenshtein.h b/tools/perf/util/levenshtein.h
new file mode 100644
index 000000000000..0173abeef52c
--- /dev/null
+++ b/tools/perf/util/levenshtein.h
@@ -0,0 +1,8 @@
+#ifndef LEVENSHTEIN_H
+#define LEVENSHTEIN_H
+
+int levenshtein(const char *string1, const char *string2,
+        int swap_penalty, int substition_penalty,
+        int insertion_penalty, int deletion_penalty);
+
+#endif
diff --git a/tools/perf/util/module.c b/tools/perf/util/module.c
new file mode 100644
index 000000000000..ddabe925d65d
--- /dev/null
+++ b/tools/perf/util/module.c
@@ -0,0 +1,509 @@
+#include "util.h"
+#include "../perf.h"
+#include "string.h"
+#include "module.h"
+
+#include <libelf.h>
+#include <gelf.h>
+#include <elf.h>
+#include <dirent.h>
+#include <sys/utsname.h>
+
+static unsigned int crc32(const char *p, unsigned int len)
+{
+        int i;
+        unsigned int crc = 0;
+
+        while (len--) {
+                crc ^= *p++;
+                for (i = 0; i < 8; i++)
+                        crc = (crc >> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
+        }
+        return crc;
+}
+
+/* module section methods */
+
+struct sec_dso *sec_dso__new_dso(const char *name)
+{
+        struct sec_dso *self = malloc(sizeof(*self) + strlen(name) + 1);
+
+        if (self != NULL) {
+                strcpy(self->name, name);
+                self->secs = RB_ROOT;
+                self->find_section = sec_dso__find_section;
+        }
+
+        return self;
+}
+
+static void sec_dso__delete_section(struct section *self)
+{
+        free(((void *)self));
+}
+
+void sec_dso__delete_sections(struct sec_dso *self)
+{
+        struct section *pos;
+        struct rb_node *next = rb_first(&self->secs);
+
+        while (next) {
+                pos = rb_entry(next, struct section, rb_node);
+                next = rb_next(&pos->rb_node);
+                rb_erase(&pos->rb_node, &self->secs);
+                sec_dso__delete_section(pos);
+        }
+}
+
+void sec_dso__delete_self(struct sec_dso *self)
+{
+        sec_dso__delete_sections(self);
+        free(self);
+}
+
+static void sec_dso__insert_section(struct sec_dso *self, struct section *sec)
+{
+        struct rb_node **p = &self->secs.rb_node;
+        struct rb_node *parent = NULL;
+        const u64 hash = sec->hash;
+        struct section *s;
+
+        while (*p != NULL) {
+                parent = *p;
+                s = rb_entry(parent, struct section, rb_node);
+                if (hash < s->hash)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+        rb_link_node(&sec->rb_node, parent, p);
+        rb_insert_color(&sec->rb_node, &self->secs);
+}
+
+struct section *sec_dso__find_section(struct sec_dso *self, const char *name)
+{
+        struct rb_node *n;
+        u64 hash;
+        int len;
+
+        if (self == NULL)
+                return NULL;
+
+        len = strlen(name);
+        hash = crc32(name, len);
+
+        n = self->secs.rb_node;
+
+        while (n) {
+                struct section *s = rb_entry(n, struct section, rb_node);
+
+                if (hash < s->hash)
+                        n = n->rb_left;
+                else if (hash > s->hash)
+                        n = n->rb_right;
+                else {
+                        if (!strcmp(name, s->name))
+                                return s;
+                        else
+                                n = rb_next(&s->rb_node);
+                }
+        }
+
+        return NULL;
+}
+
+static size_t sec_dso__fprintf_section(struct section *self, FILE *fp)
+{
+        return fprintf(fp, "name:%s vma:%llx path:%s\n",
+                       self->name, self->vma, self->path);
+}
+
+size_t sec_dso__fprintf(struct sec_dso *self, FILE *fp)
+{
+        size_t ret = fprintf(fp, "dso: %s\n", self->name);
+
+        struct rb_node *nd;
+        for (nd = rb_first(&self->secs); nd; nd = rb_next(nd)) {
+                struct section *pos = rb_entry(nd, struct section, rb_node);
+                ret += sec_dso__fprintf_section(pos, fp);
+        }
+
+        return ret;
+}
+
+static struct section *section__new(const char *name, const char *path)
+{
+        struct section *self = calloc(1, sizeof(*self));
+
+        if (!self)
+                goto out_failure;
+
+        self->name = calloc(1, strlen(name) + 1);
+        if (!self->name)
+                goto out_failure;
+
+        self->path = calloc(1, strlen(path) + 1);
+        if (!self->path)
+                goto out_failure;
+
+        strcpy(self->name, name);
+        strcpy(self->path, path);
+        self->hash = crc32(self->name, strlen(name));
+
+        return self;
+
+out_failure:
+        if (self) {
+                if (self->name)
+                        free(self->name);
+                if (self->path)
+                        free(self->path);
+                free(self);
+        }
+
+        return NULL;
+}
+
+/* module methods */
+
+struct mod_dso *mod_dso__new_dso(const char *name)
+{
+        struct mod_dso *self = malloc(sizeof(*self) + strlen(name) + 1);
+
+        if (self != NULL) {
+                strcpy(self->name, name);
+                self->mods = RB_ROOT;
+                self->find_module = mod_dso__find_module;
+        }
+
+        return self;
+}
+
+static void mod_dso__delete_module(struct module *self)
+{
+        free(((void *)self));
+}
+
+void mod_dso__delete_modules(struct mod_dso *self)
+{
+        struct module *pos;
+        struct rb_node *next = rb_first(&self->mods);
+
+        while (next) {
+                pos = rb_entry(next, struct module, rb_node);
+                next = rb_next(&pos->rb_node);
+                rb_erase(&pos->rb_node, &self->mods);
+                mod_dso__delete_module(pos);
+        }
+}
+
+void mod_dso__delete_self(struct mod_dso *self)
+{
+        mod_dso__delete_modules(self);
+        free(self);
+}
+
+static void mod_dso__insert_module(struct mod_dso *self, struct module *mod)
+{
+        struct rb_node **p = &self->mods.rb_node;
+        struct rb_node *parent = NULL;
+        const u64 hash = mod->hash;
+        struct module *m;
+
+        while (*p != NULL) {
+                parent = *p;
+                m = rb_entry(parent, struct module, rb_node);
+                if (hash < m->hash)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+        rb_link_node(&mod->rb_node, parent, p);
+        rb_insert_color(&mod->rb_node, &self->mods);
+}
+
+struct module *mod_dso__find_module(struct mod_dso *self, const char *name)
+{
+        struct rb_node *n;
+        u64 hash;
+        int len;
+
+        if (self == NULL)
+                return NULL;
+
+        len = strlen(name);
+        hash = crc32(name, len);
+
+        n = self->mods.rb_node;
+
+        while (n) {
+                struct module *m = rb_entry(n, struct module, rb_node);
+
+                if (hash < m->hash)
+                        n = n->rb_left;
+                else if (hash > m->hash)
+                        n = n->rb_right;
+                else {
+                        if (!strcmp(name, m->name))
+                                return m;
+                        else
+                                n = rb_next(&m->rb_node);
+                }
+        }
+
+        return NULL;
+}
+
+static size_t mod_dso__fprintf_module(struct module *self, FILE *fp)
+{
+        return fprintf(fp, "name:%s path:%s\n", self->name, self->path);
+}
+
+size_t mod_dso__fprintf(struct mod_dso *self, FILE *fp)
+{
+        struct rb_node *nd;
+        size_t ret;
+
+        ret = fprintf(fp, "dso: %s\n", self->name);
+
+        for (nd = rb_first(&self->mods); nd; nd = rb_next(nd)) {
+                struct module *pos = rb_entry(nd, struct module, rb_node);
+
+                ret += mod_dso__fprintf_module(pos, fp);
+        }
+
+        return ret;
+}
+
+static struct module *module__new(const char *name, const char *path)
+{
+        struct module *self = calloc(1, sizeof(*self));
+
+        if (!self)
+                goto out_failure;
+
+        self->name = calloc(1, strlen(name) + 1);
+        if (!self->name)
+                goto out_failure;
+
+        self->path = calloc(1, strlen(path) + 1);
+        if (!self->path)
+                goto out_failure;
+
+        strcpy(self->name, name);
+        strcpy(self->path, path);
+        self->hash = crc32(self->name, strlen(name));
+
+        return self;
+
+out_failure:
+        if (self) {
+                if (self->name)
+                        free(self->name);
+                if (self->path)
+                        free(self->path);
+                free(self);
+        }
+
+        return NULL;
+}
+
+static int mod_dso__load_sections(struct module *mod)
+{
+        int count = 0, path_len;
+        struct dirent *entry;
+        char *line = NULL;
+        char *dir_path;
+        DIR *dir;
+        size_t n;
+
+        path_len = strlen("/sys/module/");
+        path_len += strlen(mod->name);
+        path_len += strlen("/sections/");
+
+        dir_path = calloc(1, path_len + 1);
+        if (dir_path == NULL)
+                goto out_failure;
+
+        strcat(dir_path, "/sys/module/");
+        strcat(dir_path, mod->name);
+        strcat(dir_path, "/sections/");
+
+        dir = opendir(dir_path);
+        if (dir == NULL)
+                goto out_free;
+
+        while ((entry = readdir(dir))) {
+                struct section *section;
+                char *path, *vma;
+                int line_len;
+                FILE *file;
+
+                if (!strcmp(".", entry->d_name) || !strcmp("..", entry->d_name))
+                        continue;
+
+                path = calloc(1, path_len + strlen(entry->d_name) + 1);
+                if (path == NULL)
+                        break;
+                strcat(path, dir_path);
+                strcat(path, entry->d_name);
+
+                file = fopen(path, "r");
+                if (file == NULL) {
+                        free(path);
+                        break;
+                }
+
+                line_len = getline(&line, &n, file);
+                if (line_len < 0) {
+                        free(path);
+                        fclose(file);
+                        break;
+                }
+
+                if (!line) {
+                        free(path);
+                        fclose(file);
+                        break;
+                }
+
+                line[--line_len] = '\0'; /* \n */
+
+                vma = strstr(line, "0x");
+                if (!vma) {
+                        free(path);
+                        fclose(file);
+                        break;
+                }
+                vma += 2;
+
+                section = section__new(entry->d_name, path);
+                if (!section) {
+                        fprintf(stderr, "load_sections: allocation error\n");
+                        free(path);
+                        fclose(file);
+                        break;
+                }
+
+                hex2u64(vma, &section->vma);
+                sec_dso__insert_section(mod->sections, section);
+
+                free(path);
+                fclose(file);
+                count++;
+        }
+
+        closedir(dir);
+        free(line);
+        free(dir_path);
+
+        return count;
+
+out_free:
+        free(dir_path);
+
+out_failure:
+        return count;
+}
+
+static int mod_dso__load_module_paths(struct mod_dso *self)
+{
+        struct utsname uts;
+        int count = 0, len;
+        char *line = NULL;
+        FILE *file;
+        char *path;
+        size_t n;
+
+        if (uname(&uts) < 0)
+                goto out_failure;
+
+        len = strlen("/lib/modules/");
+        len += strlen(uts.release);
+        len += strlen("/modules.dep");
+
+        path = calloc(1, len);
+        if (path == NULL)
+                goto out_failure;
+
+        strcat(path, "/lib/modules/");
+        strcat(path, uts.release);
+        strcat(path, "/modules.dep");
+
+        file = fopen(path, "r");
+        free(path);
+        if (file == NULL)
+                goto out_failure;
+
+        while (!feof(file)) {
+                char *path, *name, *tmp;
+                struct module *module;
+                int line_len, len;
+
+                line_len = getline(&line, &n, file);
+                if (line_len < 0)
+                        break;
+
+                if (!line)
+                        goto out_failure;
+
+                line[--line_len] = '\0'; /* \n */
+
+                path = strtok(line, ":");
+                if (!path)
+                        goto out_failure;
+
+                name = strdup(path);
+                name = strtok(name, "/");
+
+                tmp = name;
+
+                while (tmp) {
+                        tmp = strtok(NULL, "/");
+                        if (tmp)
+                                name = tmp;
+                }
+                name = strsep(&name, ".");
+
+                /* Quirk: replace '-' with '_' in sound modules */
+                for (len = strlen(name); len; len--) {
+                        if (*(name+len) == '-')
+                                *(name+len) = '_';
+                }
+
+                module = module__new(name, path);
+                if (!module) {
+                        fprintf(stderr, "load_module_paths: allocation error\n");
+                        goto out_failure;
+                }
+                mod_dso__insert_module(self, module);
+
+                module->sections = sec_dso__new_dso("sections");
+                if (!module->sections) {
+                        fprintf(stderr, "load_module_paths: allocation error\n");
+                        goto out_failure;
+                }
+
+                module->active = mod_dso__load_sections(module);
+
+                if (module->active > 0)
+                        count++;
+        }
+
+        free(line);
+        fclose(file);
+
+        return count;
+
+out_failure:
+        return -1;
+}
+
+int mod_dso__load_modules(struct mod_dso *dso)
+{
+        int err;
+
+        err = mod_dso__load_module_paths(dso);
+
+        return err;
+}
diff --git a/tools/perf/util/module.h b/tools/perf/util/module.h
new file mode 100644
index 000000000000..8a592ef641ca
--- /dev/null
+++ b/tools/perf/util/module.h
@@ -0,0 +1,53 @@
+#ifndef _PERF_MODULE_
+#define _PERF_MODULE_ 1
+
+#include <linux/types.h>
+#include "../types.h"
+#include <linux/list.h>
+#include <linux/rbtree.h>
+
+struct section {
+        struct rb_node  rb_node;
+        u64             hash;
+        u64             vma;
+        char            *name;
+        char            *path;
+};
+
+struct sec_dso {
+        struct list_head node;
+        struct rb_root   secs;
+        struct section    *(*find_section)(struct sec_dso *, const char *name);
+        char             name[0];
+};
+
+struct module {
+        struct rb_node  rb_node;
+        u64             hash;
+        char            *name;
+        char            *path;
+        struct sec_dso  *sections;
+        int             active;
+};
+
+struct mod_dso {
+        struct list_head node;
+        struct rb_root   mods;
+        struct module    *(*find_module)(struct mod_dso *, const char *name);
+        char             name[0];
+};
+
+struct sec_dso *sec_dso__new_dso(const char *name);
+void sec_dso__delete_sections(struct sec_dso *self);
+void sec_dso__delete_self(struct sec_dso *self);
+size_t sec_dso__fprintf(struct sec_dso *self, FILE *fp);
+struct section *sec_dso__find_section(struct sec_dso *self, const char *name);
+
+struct mod_dso *mod_dso__new_dso(const char *name);
+void mod_dso__delete_modules(struct mod_dso *self);
+void mod_dso__delete_self(struct mod_dso *self);
+size_t mod_dso__fprintf(struct mod_dso *self, FILE *fp);
+struct module *mod_dso__find_module(struct mod_dso *self, const char *name);
+int mod_dso__load_modules(struct mod_dso *dso);
+
+#endif /* _PERF_MODULE_ */
diff --git a/tools/perf/util/pager.c b/tools/perf/util/pager.c
new file mode 100644
index 000000000000..1915de20dcac
--- /dev/null
+++ b/tools/perf/util/pager.c
@@ -0,0 +1,96 @@
+#include "cache.h"
+#include "run-command.h"
+#include "sigchain.h"
+
+/*
+ * This is split up from the rest of git so that we can do
+ * something different on Windows.
+ */
+
+static int spawned_pager;
+
+static void pager_preexec(void)
+{
+        /*
+         * Work around bug in "less" by not starting it until we
+         * have real input
+         */
+        fd_set in;
+
+        FD_ZERO(&in);
+        FD_SET(0, &in);
+        select(1, &in, NULL, &in, NULL);
+
+        setenv("LESS", "FRSX", 0);
+}
+
+static const char *pager_argv[] = { "sh", "-c", NULL, NULL };
+static struct child_process pager_process;
+
+static void wait_for_pager(void)
+{
+        fflush(stdout);
+        fflush(stderr);
+        /* signal EOF to pager */
+        close(1);
+        close(2);
+        finish_command(&pager_process);
+}
+
+static void wait_for_pager_signal(int signo)
+{
+        wait_for_pager();
+        sigchain_pop(signo);
+        raise(signo);
+}
+
+void setup_pager(void)
+{
+        const char *pager = getenv("PERF_PAGER");
+
+        if (!isatty(1))
+                return;
+        if (!pager) {
+                if (!pager_program)
+                        perf_config(perf_default_config, NULL);
+                pager = pager_program;
+        }
+        if (!pager)
+                pager = getenv("PAGER");
+        if (!pager)
+                pager = "less";
+        else if (!*pager || !strcmp(pager, "cat"))
+                return;
+
+        spawned_pager = 1; /* means we are emitting to terminal */
+
+        /* spawn the pager */
+        pager_argv[2] = pager;
+        pager_process.argv = pager_argv;
+        pager_process.in = -1;
+        pager_process.preexec_cb = pager_preexec;
+
+        if (start_command(&pager_process))
+                return;
+
+        /* original process continues, but writes to the pipe */
+        dup2(pager_process.in, 1);
+        if (isatty(2))
+                dup2(pager_process.in, 2);
+        close(pager_process.in);
+
+        /* this makes sure that the parent terminates after the pager */
+        sigchain_push_common(wait_for_pager_signal);
+        atexit(wait_for_pager);
+}
+
+int pager_in_use(void)
+{
+        const char *env;
+
+        if (spawned_pager)
+                return 1;
+
+        env = getenv("PERF_PAGER_IN_USE");
+        return env ? perf_config_bool("PERF_PAGER_IN_USE", env) : 0;
+}
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
new file mode 100644
index 000000000000..044178408783
--- /dev/null
+++ b/tools/perf/util/parse-events.c
@@ -0,0 +1,682 @@
+
+#include "../perf.h"
+#include "util.h"
+#include "parse-options.h"
+#include "parse-events.h"
+#include "exec_cmd.h"
+#include "string.h"
+#include "cache.h"
+
+extern char *strcasestr(const char *haystack, const char *needle);
+
+int                                     nr_counters;
+
+struct perf_counter_attr                attrs[MAX_COUNTERS];
+
+struct event_symbol {
+        u8      type;
+        u64     config;
+        char    *symbol;
+        char    *alias;
+};
+
+char debugfs_path[MAXPATHLEN];
+
+#define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
+#define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x
+
+static struct event_symbol event_symbols[] = {
+  { CHW(CPU_CYCLES),            "cpu-cycles",           "cycles"        },
+  { CHW(INSTRUCTIONS),          "instructions",         ""              },
+  { CHW(CACHE_REFERENCES),      "cache-references",     ""              },
+  { CHW(CACHE_MISSES),          "cache-misses",         ""              },
+  { CHW(BRANCH_INSTRUCTIONS),   "branch-instructions",  "branches"      },
+  { CHW(BRANCH_MISSES),         "branch-misses",        ""              },
+  { CHW(BUS_CYCLES),            "bus-cycles",           ""              },
+
+  { CSW(CPU_CLOCK),             "cpu-clock",            ""              },
+  { CSW(TASK_CLOCK),            "task-clock",           ""              },
+  { CSW(PAGE_FAULTS),           "page-faults",          "faults"        },
+  { CSW(PAGE_FAULTS_MIN),       "minor-faults",         ""              },
+  { CSW(PAGE_FAULTS_MAJ),       "major-faults",         ""              },
+  { CSW(CONTEXT_SWITCHES),      "context-switches",     "cs"            },
+  { CSW(CPU_MIGRATIONS),        "cpu-migrations",       "migrations"    },
+};
+
+#define __PERF_COUNTER_FIELD(config, name) \
+        ((config & PERF_COUNTER_##name##_MASK) >> PERF_COUNTER_##name##_SHIFT)
+
+#define PERF_COUNTER_RAW(config)        __PERF_COUNTER_FIELD(config, RAW)
+#define PERF_COUNTER_CONFIG(config)     __PERF_COUNTER_FIELD(config, CONFIG)
+#define PERF_COUNTER_TYPE(config)       __PERF_COUNTER_FIELD(config, TYPE)
+#define PERF_COUNTER_ID(config)         __PERF_COUNTER_FIELD(config, EVENT)
+
+static char *hw_event_names[] = {
+        "cycles",
+        "instructions",
+        "cache-references",
+        "cache-misses",
+        "branches",
+        "branch-misses",
+        "bus-cycles",
+};
+
+static char *sw_event_names[] = {
+        "cpu-clock-msecs",
+        "task-clock-msecs",
+        "page-faults",
+        "context-switches",
+        "CPU-migrations",
+        "minor-faults",
+        "major-faults",
+};
+
+#define MAX_ALIASES 8
+
+static char *hw_cache[][MAX_ALIASES] = {
+ { "L1-dcache", "l1-d",         "l1d",          "L1-data",              },
+ { "L1-icache", "l1-i",         "l1i",          "L1-instruction",       },
+ { "LLC",       "L2"                                                    },
+ { "dTLB",      "d-tlb",        "Data-TLB",                             },
+ { "iTLB",      "i-tlb",        "Instruction-TLB",                      },
+ { "branch",    "branches",     "bpu",          "btb",          "bpc",  },
+};
+
+static char *hw_cache_op[][MAX_ALIASES] = {
+ { "load",      "loads",        "read",                                 },
+ { "store",     "stores",       "write",                                },
+ { "prefetch",  "prefetches",   "speculative-read", "speculative-load", },
+};
+
+static char *hw_cache_result[][MAX_ALIASES] = {
+ { "refs",      "Reference",    "ops",          "access",               },
+ { "misses",    "miss",                                                 },
+};
+
+#define C(x)            PERF_COUNT_HW_CACHE_##x
+#define CACHE_READ      (1 << C(OP_READ))
+#define CACHE_WRITE     (1 << C(OP_WRITE))
+#define CACHE_PREFETCH  (1 << C(OP_PREFETCH))
+#define COP(x)          (1 << x)
+
+/*
+ * cache operartion stat
+ * L1I : Read and prefetch only
+ * ITLB and BPU : Read-only
+ */
+static unsigned long hw_cache_stat[C(MAX)] = {
+ [C(L1D)]       = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
+ [C(L1I)]       = (CACHE_READ | CACHE_PREFETCH),
+ [C(LL)]        = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
+ [C(DTLB)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
+ [C(ITLB)]      = (CACHE_READ),
+ [C(BPU)]       = (CACHE_READ),
+};
+
+#define for_each_subsystem(sys_dir, sys_dirent, sys_next, file, st)            \
+        while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next)        \
+        if (snprintf(file, MAXPATHLEN, "%s/%s", debugfs_path,                  \
+                        sys_dirent.d_name) &&                                  \
+           (!stat(file, &st)) && (S_ISDIR(st.st_mode)) &&                      \
+           (strcmp(sys_dirent.d_name, ".")) &&                                 \
+           (strcmp(sys_dirent.d_name, "..")))
+
+static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
+{
+        char evt_path[MAXPATHLEN];
+        int fd;
+
+        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
+                        sys_dir->d_name, evt_dir->d_name);
+        fd = open(evt_path, O_RDONLY);
+        if (fd < 0)
+                return -EINVAL;
+        close(fd);
+
+        return 0;
+}
+
+#define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next, file, st)    \
+        while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next)        \
+        if (snprintf(file, MAXPATHLEN, "%s/%s/%s", debugfs_path,               \
+                     sys_dirent.d_name, evt_dirent.d_name) &&                  \
+           (!stat(file, &st)) && (S_ISDIR(st.st_mode)) &&                      \
+           (strcmp(evt_dirent.d_name, ".")) &&                                 \
+           (strcmp(evt_dirent.d_name, "..")) &&                                \
+           (!tp_event_has_id(&sys_dirent, &evt_dirent)))
+
+#define MAX_EVENT_LENGTH 30
+
+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;
+}
+
+static char *tracepoint_id_to_name(u64 config)
+{
+        static char tracepoint_name[2 * MAX_EVENT_LENGTH];
+        DIR *sys_dir, *evt_dir;
+        struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
+        struct stat st;
+        char id_buf[4];
+        int fd;
+        u64 id;
+        char evt_path[MAXPATHLEN];
+
+        if (valid_debugfs_mount(debugfs_path))
+                return "unkown";
+
+        sys_dir = opendir(debugfs_path);
+        if (!sys_dir)
+                goto cleanup;
+
+        for_each_subsystem(sys_dir, sys_dirent, sys_next, evt_path, st) {
+                evt_dir = opendir(evt_path);
+                if (!evt_dir)
+                        goto cleanup;
+                for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next,
+                                                                evt_path, st) {
+                        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id",
+                                 debugfs_path, sys_dirent.d_name,
+                                 evt_dirent.d_name);
+                        fd = open(evt_path, O_RDONLY);
+                        if (fd < 0)
+                                continue;
+                        if (read(fd, id_buf, sizeof(id_buf)) < 0) {
+                                close(fd);
+                                continue;
+                        }
+                        close(fd);
+                        id = atoll(id_buf);
+                        if (id == config) {
+                                closedir(evt_dir);
+                                closedir(sys_dir);
+                                snprintf(tracepoint_name, 2 * MAX_EVENT_LENGTH,
+                                        "%s:%s", sys_dirent.d_name,
+                                        evt_dirent.d_name);
+                                return tracepoint_name;
+                        }
+                }
+                closedir(evt_dir);
+        }
+
+cleanup:
+        closedir(sys_dir);
+        return "unkown";
+}
+
+static int is_cache_op_valid(u8 cache_type, u8 cache_op)
+{
+        if (hw_cache_stat[cache_type] & COP(cache_op))
+                return 1;       /* valid */
+        else
+                return 0;       /* invalid */
+}
+
+static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
+{
+        static char name[50];
+
+        if (cache_result) {
+                sprintf(name, "%s-%s-%s", hw_cache[cache_type][0],
+                        hw_cache_op[cache_op][0],
+                        hw_cache_result[cache_result][0]);
+        } else {
+                sprintf(name, "%s-%s", hw_cache[cache_type][0],
+                        hw_cache_op[cache_op][1]);
+        }
+
+        return name;
+}
+
+char *event_name(int counter)
+{
+        u64 config = attrs[counter].config;
+        int type = attrs[counter].type;
+
+        return __event_name(type, config);
+}
+
+char *__event_name(int type, u64 config)
+{
+        static char buf[32];
+
+        if (type == PERF_TYPE_RAW) {
+                sprintf(buf, "raw 0x%llx", config);
+                return buf;
+        }
+
+        switch (type) {
+        case PERF_TYPE_HARDWARE:
+                if (config < PERF_COUNT_HW_MAX)
+                        return hw_event_names[config];
+                return "unknown-hardware";
+
+        case PERF_TYPE_HW_CACHE: {
+                u8 cache_type, cache_op, cache_result;
+
+                cache_type   = (config >>  0) & 0xff;
+                if (cache_type > PERF_COUNT_HW_CACHE_MAX)
+                        return "unknown-ext-hardware-cache-type";
+
+                cache_op     = (config >>  8) & 0xff;
+                if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX)
+                        return "unknown-ext-hardware-cache-op";
+
+                cache_result = (config >> 16) & 0xff;
+                if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
+                        return "unknown-ext-hardware-cache-result";
+
+                if (!is_cache_op_valid(cache_type, cache_op))
+                        return "invalid-cache";
+
+                return event_cache_name(cache_type, cache_op, cache_result);
+        }
+
+        case PERF_TYPE_SOFTWARE:
+                if (config < PERF_COUNT_SW_MAX)
+                        return sw_event_names[config];
+                return "unknown-software";
+
+        case PERF_TYPE_TRACEPOINT:
+                return tracepoint_id_to_name(config);
+
+        default:
+                break;
+        }
+
+        return "unknown";
+}
+
+static int parse_aliases(const char **str, char *names[][MAX_ALIASES], int size)
+{
+        int i, j;
+        int n, longest = -1;
+
+        for (i = 0; i < size; i++) {
+                for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
+                        n = strlen(names[i][j]);
+                        if (n > longest && !strncasecmp(*str, names[i][j], n))
+                                longest = n;
+                }
+                if (longest > 0) {
+                        *str += longest;
+                        return i;
+                }
+        }
+
+        return -1;
+}
+
+static int
+parse_generic_hw_event(const char **str, struct perf_counter_attr *attr)
+{
+        const char *s = *str;
+        int cache_type = -1, cache_op = -1, cache_result = -1;
+
+        cache_type = parse_aliases(&s, hw_cache, PERF_COUNT_HW_CACHE_MAX);
+        /*
+         * No fallback - if we cannot get a clear cache type
+         * then bail out:
+         */
+        if (cache_type == -1)
+                return 0;
+
+        while ((cache_op == -1 || cache_result == -1) && *s == '-') {
+                ++s;
+
+                if (cache_op == -1) {
+                        cache_op = parse_aliases(&s, hw_cache_op,
+                                                PERF_COUNT_HW_CACHE_OP_MAX);
+                        if (cache_op >= 0) {
+                                if (!is_cache_op_valid(cache_type, cache_op))
+                                        return 0;
+                                continue;
+                        }
+                }
+
+                if (cache_result == -1) {
+                        cache_result = parse_aliases(&s, hw_cache_result,
+                                                PERF_COUNT_HW_CACHE_RESULT_MAX);
+                        if (cache_result >= 0)
+                                continue;
+                }
+
+                /*
+                 * Can't parse this as a cache op or result, so back up
+                 * to the '-'.
+                 */
+                --s;
+                break;
+        }
+
+        /*
+         * Fall back to reads:
+         */
+        if (cache_op == -1)
+                cache_op = PERF_COUNT_HW_CACHE_OP_READ;
+
+        /*
+         * Fall back to accesses:
+         */
+        if (cache_result == -1)
+                cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
+
+        attr->config = cache_type | (cache_op << 8) | (cache_result << 16);
+        attr->type = PERF_TYPE_HW_CACHE;
+
+        *str = s;
+        return 1;
+}
+
+static int parse_tracepoint_event(const char **strp,
+                                    struct perf_counter_attr *attr)
+{
+        const char *evt_name;
+        char *flags;
+        char sys_name[MAX_EVENT_LENGTH];
+        char id_buf[4];
+        int fd;
+        unsigned int sys_length, evt_length;
+        u64 id;
+        char evt_path[MAXPATHLEN];
+
+        if (valid_debugfs_mount(debugfs_path))
+                return 0;
+
+        evt_name = strchr(*strp, ':');
+        if (!evt_name)
+                return 0;
+
+        sys_length = evt_name - *strp;
+        if (sys_length >= MAX_EVENT_LENGTH)
+                return 0;
+
+        strncpy(sys_name, *strp, sys_length);
+        sys_name[sys_length] = '\0';
+        evt_name = evt_name + 1;
+
+        flags = strchr(evt_name, ':');
+        if (flags) {
+                *flags = '\0';
+                flags++;
+                if (!strncmp(flags, "record", strlen(flags)))
+                        attr->sample_type |= PERF_SAMPLE_RAW;
+        }
+
+        evt_length = strlen(evt_name);
+        if (evt_length >= MAX_EVENT_LENGTH)
+                return 0;
+
+        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
+                 sys_name, evt_name);
+        fd = open(evt_path, O_RDONLY);
+        if (fd < 0)
+                return 0;
+
+        if (read(fd, id_buf, sizeof(id_buf)) < 0) {
+                close(fd);
+                return 0;
+        }
+        close(fd);
+        id = atoll(id_buf);
+        attr->config = id;
+        attr->type = PERF_TYPE_TRACEPOINT;
+        *strp = evt_name + evt_length;
+        return 1;
+}
+
+static int check_events(const char *str, unsigned int i)
+{
+        int n;
+
+        n = strlen(event_symbols[i].symbol);
+        if (!strncmp(str, event_symbols[i].symbol, n))
+                return n;
+
+        n = strlen(event_symbols[i].alias);
+        if (n)
+                if (!strncmp(str, event_symbols[i].alias, n))
+                        return n;
+        return 0;
+}
+
+static int
+parse_symbolic_event(const char **strp, struct perf_counter_attr *attr)
+{
+        const char *str = *strp;
+        unsigned int i;
+        int n;
+
+        for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
+                n = check_events(str, i);
+                if (n > 0) {
+                        attr->type = event_symbols[i].type;
+                        attr->config = event_symbols[i].config;
+                        *strp = str + n;
+                        return 1;
+                }
+        }
+        return 0;
+}
+
+static int parse_raw_event(const char **strp, struct perf_counter_attr *attr)
+{
+        const char *str = *strp;
+        u64 config;
+        int n;
+
+        if (*str != 'r')
+                return 0;
+        n = hex2u64(str + 1, &config);
+        if (n > 0) {
+                *strp = str + n + 1;
+                attr->type = PERF_TYPE_RAW;
+                attr->config = config;
+                return 1;
+        }
+        return 0;
+}
+
+static int
+parse_numeric_event(const char **strp, struct perf_counter_attr *attr)
+{
+        const char *str = *strp;
+        char *endp;
+        unsigned long type;
+        u64 config;
+
+        type = strtoul(str, &endp, 0);
+        if (endp > str && type < PERF_TYPE_MAX && *endp == ':') {
+                str = endp + 1;
+                config = strtoul(str, &endp, 0);
+                if (endp > str) {
+                        attr->type = type;
+                        attr->config = config;
+                        *strp = endp;
+                        return 1;
+                }
+        }
+        return 0;
+}
+
+static int
+parse_event_modifier(const char **strp, struct perf_counter_attr *attr)
+{
+        const char *str = *strp;
+        int eu = 1, ek = 1, eh = 1;
+
+        if (*str++ != ':')
+                return 0;
+        while (*str) {
+                if (*str == 'u')
+                        eu = 0;
+                else if (*str == 'k')
+                        ek = 0;
+                else if (*str == 'h')
+                        eh = 0;
+                else
+                        break;
+                ++str;
+        }
+        if (str >= *strp + 2) {
+                *strp = str;
+                attr->exclude_user   = eu;
+                attr->exclude_kernel = ek;
+                attr->exclude_hv     = eh;
+                return 1;
+        }
+        return 0;
+}
+
+/*
+ * Each event can have multiple symbolic names.
+ * Symbolic names are (almost) exactly matched.
+ */
+static int parse_event_symbols(const char **str, struct perf_counter_attr *attr)
+{
+        if (!(parse_tracepoint_event(str, attr) ||
+              parse_raw_event(str, attr) ||
+              parse_numeric_event(str, attr) ||
+              parse_symbolic_event(str, attr) ||
+              parse_generic_hw_event(str, attr)))
+                return 0;
+
+        parse_event_modifier(str, attr);
+
+        return 1;
+}
+
+int parse_events(const struct option *opt __used, const char *str, int unset __used)
+{
+        struct perf_counter_attr attr;
+
+        for (;;) {
+                if (nr_counters == MAX_COUNTERS)
+                        return -1;
+
+                memset(&attr, 0, sizeof(attr));
+                if (!parse_event_symbols(&str, &attr))
+                        return -1;
+
+                if (!(*str == 0 || *str == ',' || isspace(*str)))
+                        return -1;
+
+                attrs[nr_counters] = attr;
+                nr_counters++;
+
+                if (*str == 0)
+                        break;
+                if (*str == ',')
+                        ++str;
+                while (isspace(*str))
+                        ++str;
+        }
+
+        return 0;
+}
+
+static const char * const event_type_descriptors[] = {
+        "",
+        "Hardware event",
+        "Software event",
+        "Tracepoint event",
+        "Hardware cache event",
+};
+
+/*
+ * Print the events from <debugfs_mount_point>/tracing/events
+ */
+
+static void print_tracepoint_events(void)
+{
+        DIR *sys_dir, *evt_dir;
+        struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
+        struct stat st;
+        char evt_path[MAXPATHLEN];
+
+        if (valid_debugfs_mount(debugfs_path))
+                return;
+
+        sys_dir = opendir(debugfs_path);
+        if (!sys_dir)
+                goto cleanup;
+
+        for_each_subsystem(sys_dir, sys_dirent, sys_next, evt_path, st) {
+                evt_dir = opendir(evt_path);
+                if (!evt_dir)
+                        goto cleanup;
+                for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next,
+                                                                evt_path, st) {
+                        snprintf(evt_path, MAXPATHLEN, "%s:%s",
+                                 sys_dirent.d_name, evt_dirent.d_name);
+                        fprintf(stderr, "  %-40s [%s]\n", evt_path,
+                                event_type_descriptors[PERF_TYPE_TRACEPOINT+1]);
+                }
+                closedir(evt_dir);
+        }
+
+cleanup:
+        closedir(sys_dir);
+}
+
+/*
+ * Print the help text for the event symbols:
+ */
+void print_events(void)
+{
+        struct event_symbol *syms = event_symbols;
+        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");
+
+        for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
+                type = syms->type + 1;
+                if (type >= ARRAY_SIZE(event_type_descriptors))
+                        type = 0;
+
+                if (type != prev_type)
+                        fprintf(stderr, "\n");
+
+                if (strlen(syms->alias))
+                        sprintf(name, "%s OR %s", syms->symbol, syms->alias);
+                else
+                        strcpy(name, syms->symbol);
+                fprintf(stderr, "  %-40s [%s]\n", name,
+                        event_type_descriptors[type]);
+
+                prev_type = type;
+        }
+
+        fprintf(stderr, "\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 */
+                        if (!is_cache_op_valid(type, op))
+                                continue;
+
+                        for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
+                                fprintf(stderr, "  %-40s [%s]\n",
+                                        event_cache_name(type, op, i),
+                                        event_type_descriptors[4]);
+                        }
+                }
+        }
+
+        fprintf(stderr, "\n");
+        fprintf(stderr, "  %-40s [raw hardware event descriptor]\n",
+                "rNNN");
+        fprintf(stderr, "\n");
+
+        print_tracepoint_events();
+
+        exit(129);
+}
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
new file mode 100644
index 000000000000..192a962e3a0f
--- /dev/null
+++ b/tools/perf/util/parse-events.h
@@ -0,0 +1,23 @@
+
+/*
+ * Parse symbolic events/counts passed in as options:
+ */
+
+struct option;
+
+extern int                      nr_counters;
+
+extern struct perf_counter_attr attrs[MAX_COUNTERS];
+
+extern char *event_name(int ctr);
+extern char *__event_name(int type, u64 config);
+
+extern int parse_events(const struct option *opt, const char *str, int unset);
+
+#define EVENTS_HELP_MAX (128*1024)
+
+extern void print_events(void);
+
+extern char debugfs_path[];
+extern int valid_debugfs_mount(const char *debugfs);
+
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
new file mode 100644
index 000000000000..1bf67190c820
--- /dev/null
+++ b/tools/perf/util/parse-options.c
@@ -0,0 +1,509 @@
+#include "util.h"
+#include "parse-options.h"
+#include "cache.h"
+
+#define OPT_SHORT 1
+#define OPT_UNSET 2
+
+static int opterror(const struct option *opt, const char *reason, int flags)
+{
+        if (flags & OPT_SHORT)
+                return error("switch `%c' %s", opt->short_name, reason);
+        if (flags & OPT_UNSET)
+                return error("option `no-%s' %s", opt->long_name, reason);
+        return error("option `%s' %s", opt->long_name, reason);
+}
+
+static int get_arg(struct parse_opt_ctx_t *p, const struct option *opt,
+                   int flags, const char **arg)
+{
+        if (p->opt) {
+                *arg = p->opt;
+                p->opt = NULL;
+        } else if ((opt->flags & PARSE_OPT_LASTARG_DEFAULT) && (p->argc == 1 ||
+                    **(p->argv + 1) == '-')) {
+                *arg = (const char *)opt->defval;
+        } else if (p->argc > 1) {
+                p->argc--;
+                *arg = *++p->argv;
+        } else
+                return opterror(opt, "requires a value", flags);
+        return 0;
+}
+
+static int get_value(struct parse_opt_ctx_t *p,
+                     const struct option *opt, int flags)
+{
+        const char *s, *arg = NULL;
+        const int unset = flags & OPT_UNSET;
+
+        if (unset && p->opt)
+                return opterror(opt, "takes no value", flags);
+        if (unset && (opt->flags & PARSE_OPT_NONEG))
+                return opterror(opt, "isn't available", flags);
+
+        if (!(flags & OPT_SHORT) && p->opt) {
+                switch (opt->type) {
+                case OPTION_CALLBACK:
+                        if (!(opt->flags & PARSE_OPT_NOARG))
+                                break;
+                        /* FALLTHROUGH */
+                case OPTION_BOOLEAN:
+                case OPTION_BIT:
+                case OPTION_SET_INT:
+                case OPTION_SET_PTR:
+                        return opterror(opt, "takes no value", flags);
+                default:
+                        break;
+                }
+        }
+
+        switch (opt->type) {
+        case OPTION_BIT:
+                if (unset)
+                        *(int *)opt->value &= ~opt->defval;
+                else
+                        *(int *)opt->value |= opt->defval;
+                return 0;
+
+        case OPTION_BOOLEAN:
+                *(int *)opt->value = unset ? 0 : *(int *)opt->value + 1;
+                return 0;
+
+        case OPTION_SET_INT:
+                *(int *)opt->value = unset ? 0 : opt->defval;
+                return 0;
+
+        case OPTION_SET_PTR:
+                *(void **)opt->value = unset ? NULL : (void *)opt->defval;
+                return 0;
+
+        case OPTION_STRING:
+                if (unset)
+                        *(const char **)opt->value = NULL;
+                else if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
+                        *(const char **)opt->value = (const char *)opt->defval;
+                else
+                        return get_arg(p, opt, flags, (const char **)opt->value);
+                return 0;
+
+        case OPTION_CALLBACK:
+                if (unset)
+                        return (*opt->callback)(opt, NULL, 1) ? (-1) : 0;
+                if (opt->flags & PARSE_OPT_NOARG)
+                        return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
+                if (opt->flags & PARSE_OPT_OPTARG && !p->opt)
+                        return (*opt->callback)(opt, NULL, 0) ? (-1) : 0;
+                if (get_arg(p, opt, flags, &arg))
+                        return -1;
+                return (*opt->callback)(opt, arg, 0) ? (-1) : 0;
+
+        case OPTION_INTEGER:
+                if (unset) {
+                        *(int *)opt->value = 0;
+                        return 0;
+                }
+                if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
+                        *(int *)opt->value = opt->defval;
+                        return 0;
+                }
+                if (get_arg(p, opt, flags, &arg))
+                        return -1;
+                *(int *)opt->value = strtol(arg, (char **)&s, 10);
+                if (*s)
+                        return opterror(opt, "expects a numerical value", flags);
+                return 0;
+
+        case OPTION_LONG:
+                if (unset) {
+                        *(long *)opt->value = 0;
+                        return 0;
+                }
+                if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
+                        *(long *)opt->value = opt->defval;
+                        return 0;
+                }
+                if (get_arg(p, opt, flags, &arg))
+                        return -1;
+                *(long *)opt->value = strtol(arg, (char **)&s, 10);
+                if (*s)
+                        return opterror(opt, "expects a numerical value", flags);
+                return 0;
+
+        default:
+                die("should not happen, someone must be hit on the forehead");
+        }
+}
+
+static int parse_short_opt(struct parse_opt_ctx_t *p, const struct option *options)
+{
+        for (; options->type != OPTION_END; options++) {
+                if (options->short_name == *p->opt) {
+                        p->opt = p->opt[1] ? p->opt + 1 : NULL;
+                        return get_value(p, options, OPT_SHORT);
+                }
+        }
+        return -2;
+}
+
+static int parse_long_opt(struct parse_opt_ctx_t *p, const char *arg,
+                          const struct option *options)
+{
+        const char *arg_end = strchr(arg, '=');
+        const struct option *abbrev_option = NULL, *ambiguous_option = NULL;
+        int abbrev_flags = 0, ambiguous_flags = 0;
+
+        if (!arg_end)
+                arg_end = arg + strlen(arg);
+
+        for (; options->type != OPTION_END; options++) {
+                const char *rest;
+                int flags = 0;
+
+                if (!options->long_name)
+                        continue;
+
+                rest = skip_prefix(arg, options->long_name);
+                if (options->type == OPTION_ARGUMENT) {
+                        if (!rest)
+                                continue;
+                        if (*rest == '=')
+                                return opterror(options, "takes no value", flags);
+                        if (*rest)
+                                continue;
+                        p->out[p->cpidx++] = arg - 2;
+                        return 0;
+                }
+                if (!rest) {
+                        /* abbreviated? */
+                        if (!strncmp(options->long_name, arg, arg_end - arg)) {
+is_abbreviated:
+                                if (abbrev_option) {
+                                        /*
+                                         * If this is abbreviated, it is
+                                         * ambiguous. So when there is no
+                                         * exact match later, we need to
+                                         * error out.
+                                         */
+                                        ambiguous_option = abbrev_option;
+                                        ambiguous_flags = abbrev_flags;
+                                }
+                                if (!(flags & OPT_UNSET) && *arg_end)
+                                        p->opt = arg_end + 1;
+                                abbrev_option = options;
+                                abbrev_flags = flags;
+                                continue;
+                        }
+                        /* negated and abbreviated very much? */
+                        if (!prefixcmp("no-", arg)) {
+                                flags |= OPT_UNSET;
+                                goto is_abbreviated;
+                        }
+                        /* negated? */
+                        if (strncmp(arg, "no-", 3))
+                                continue;
+                        flags |= OPT_UNSET;
+                        rest = skip_prefix(arg + 3, options->long_name);
+                        /* abbreviated and negated? */
+                        if (!rest && !prefixcmp(options->long_name, arg + 3))
+                                goto is_abbreviated;
+                        if (!rest)
+                                continue;
+                }
+                if (*rest) {
+                        if (*rest != '=')
+                                continue;
+                        p->opt = rest + 1;
+                }
+                return get_value(p, options, flags);
+        }
+
+        if (ambiguous_option)
+                return error("Ambiguous option: %s "
+                        "(could be --%s%s or --%s%s)",
+                        arg,
+                        (ambiguous_flags & OPT_UNSET) ?  "no-" : "",
+                        ambiguous_option->long_name,
+                        (abbrev_flags & OPT_UNSET) ?  "no-" : "",
+                        abbrev_option->long_name);
+        if (abbrev_option)
+                return get_value(p, abbrev_option, abbrev_flags);
+        return -2;
+}
+
+static void check_typos(const char *arg, const struct option *options)
+{
+        if (strlen(arg) < 3)
+                return;
+
+        if (!prefixcmp(arg, "no-")) {
+                error ("did you mean `--%s` (with two dashes ?)", arg);
+                exit(129);
+        }
+
+        for (; options->type != OPTION_END; options++) {
+                if (!options->long_name)
+                        continue;
+                if (!prefixcmp(options->long_name, arg)) {
+                        error ("did you mean `--%s` (with two dashes ?)", arg);
+                        exit(129);
+                }
+        }
+}
+
+void parse_options_start(struct parse_opt_ctx_t *ctx,
+                         int argc, const char **argv, int flags)
+{
+        memset(ctx, 0, sizeof(*ctx));
+        ctx->argc = argc - 1;
+        ctx->argv = argv + 1;
+        ctx->out  = argv;
+        ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0);
+        ctx->flags = flags;
+        if ((flags & PARSE_OPT_KEEP_UNKNOWN) &&
+            (flags & PARSE_OPT_STOP_AT_NON_OPTION))
+                die("STOP_AT_NON_OPTION and KEEP_UNKNOWN don't go together");
+}
+
+static int usage_with_options_internal(const char * const *,
+                                       const struct option *, int);
+
+int parse_options_step(struct parse_opt_ctx_t *ctx,
+                       const struct option *options,
+                       const char * const usagestr[])
+{
+        int internal_help = !(ctx->flags & PARSE_OPT_NO_INTERNAL_HELP);
+
+        /* we must reset ->opt, unknown short option leave it dangling */
+        ctx->opt = NULL;
+
+        for (; ctx->argc; ctx->argc--, ctx->argv++) {
+                const char *arg = ctx->argv[0];
+
+                if (*arg != '-' || !arg[1]) {
+                        if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION)
+                                break;
+                        ctx->out[ctx->cpidx++] = ctx->argv[0];
+                        continue;
+                }
+
+                if (arg[1] != '-') {
+                        ctx->opt = arg + 1;
+                        if (internal_help && *ctx->opt == 'h')
+                                return parse_options_usage(usagestr, options);
+                        switch (parse_short_opt(ctx, options)) {
+                        case -1:
+                                return parse_options_usage(usagestr, options);
+                        case -2:
+                                goto unknown;
+                        }
+                        if (ctx->opt)
+                                check_typos(arg + 1, options);
+                        while (ctx->opt) {
+                                if (internal_help && *ctx->opt == 'h')
+                                        return parse_options_usage(usagestr, options);
+                                switch (parse_short_opt(ctx, options)) {
+                                case -1:
+                                        return parse_options_usage(usagestr, options);
+                                case -2:
+                                        /* fake a short option thing to hide the fact that we may have
+                                         * started to parse aggregated stuff
+                                         *
+                                         * This is leaky, too bad.
+                                         */
+                                        ctx->argv[0] = strdup(ctx->opt - 1);
+                                        *(char *)ctx->argv[0] = '-';
+                                        goto unknown;
+                                }
+                        }
+                        continue;
+                }
+
+                if (!arg[2]) { /* "--" */
+                        if (!(ctx->flags & PARSE_OPT_KEEP_DASHDASH)) {
+                                ctx->argc--;
+                                ctx->argv++;
+                        }
+                        break;
+                }
+
+                if (internal_help && !strcmp(arg + 2, "help-all"))
+                        return usage_with_options_internal(usagestr, options, 1);
+                if (internal_help && !strcmp(arg + 2, "help"))
+                        return parse_options_usage(usagestr, options);
+                switch (parse_long_opt(ctx, arg + 2, options)) {
+                case -1:
+                        return parse_options_usage(usagestr, options);
+                case -2:
+                        goto unknown;
+                }
+                continue;
+unknown:
+                if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN))
+                        return PARSE_OPT_UNKNOWN;
+                ctx->out[ctx->cpidx++] = ctx->argv[0];
+                ctx->opt = NULL;
+        }
+        return PARSE_OPT_DONE;
+}
+
+int parse_options_end(struct parse_opt_ctx_t *ctx)
+{
+        memmove(ctx->out + ctx->cpidx, ctx->argv, ctx->argc * sizeof(*ctx->out));
+        ctx->out[ctx->cpidx + ctx->argc] = NULL;
+        return ctx->cpidx + ctx->argc;
+}
+
+int parse_options(int argc, const char **argv, const struct option *options,
+                  const char * const usagestr[], int flags)
+{
+        struct parse_opt_ctx_t ctx;
+
+        parse_options_start(&ctx, argc, argv, flags);
+        switch (parse_options_step(&ctx, options, usagestr)) {
+        case PARSE_OPT_HELP:
+                exit(129);
+        case PARSE_OPT_DONE:
+                break;
+        default: /* PARSE_OPT_UNKNOWN */
+                if (ctx.argv[0][1] == '-') {
+                        error("unknown option `%s'", ctx.argv[0] + 2);
+                } else {
+                        error("unknown switch `%c'", *ctx.opt);
+                }
+                usage_with_options(usagestr, options);
+        }
+
+        return parse_options_end(&ctx);
+}
+
+#define USAGE_OPTS_WIDTH 24
+#define USAGE_GAP         2
+
+int usage_with_options_internal(const char * const *usagestr,
+                                const struct option *opts, int full)
+{
+        if (!usagestr)
+                return PARSE_OPT_HELP;
+
+        fprintf(stderr, "\n usage: %s\n", *usagestr++);
+        while (*usagestr && **usagestr)
+                fprintf(stderr, "    or: %s\n", *usagestr++);
+        while (*usagestr) {
+                fprintf(stderr, "%s%s\n",
+                                **usagestr ? "    " : "",
+                                *usagestr);
+                usagestr++;
+        }
+
+        if (opts->type != OPTION_GROUP)
+                fputc('\n', stderr);
+
+        for (; opts->type != OPTION_END; opts++) {
+                size_t pos;
+                int pad;
+
+                if (opts->type == OPTION_GROUP) {
+                        fputc('\n', stderr);
+                        if (*opts->help)
+                                fprintf(stderr, "%s\n", opts->help);
+                        continue;
+                }
+                if (!full && (opts->flags & PARSE_OPT_HIDDEN))
+                        continue;
+
+                pos = fprintf(stderr, "    ");
+                if (opts->short_name)
+                        pos += fprintf(stderr, "-%c", opts->short_name);
+                if (opts->long_name && opts->short_name)
+                        pos += fprintf(stderr, ", ");
+                if (opts->long_name)
+                        pos += fprintf(stderr, "--%s", opts->long_name);
+
+                switch (opts->type) {
+                case OPTION_ARGUMENT:
+                        break;
+                case OPTION_INTEGER:
+                        if (opts->flags & PARSE_OPT_OPTARG)
+                                if (opts->long_name)
+                                        pos += fprintf(stderr, "[=<n>]");
+                                else
+                                        pos += fprintf(stderr, "[<n>]");
+                        else
+                                pos += fprintf(stderr, " <n>");
+                        break;
+                case OPTION_CALLBACK:
+                        if (opts->flags & PARSE_OPT_NOARG)
+                                break;
+                        /* FALLTHROUGH */
+                case OPTION_STRING:
+                        if (opts->argh) {
+                                if (opts->flags & PARSE_OPT_OPTARG)
+                                        if (opts->long_name)
+                                                pos += fprintf(stderr, "[=<%s>]", opts->argh);
+                                        else
+                                                pos += fprintf(stderr, "[<%s>]", opts->argh);
+                                else
+                                        pos += fprintf(stderr, " <%s>", opts->argh);
+                        } else {
+                                if (opts->flags & PARSE_OPT_OPTARG)
+                                        if (opts->long_name)
+                                                pos += fprintf(stderr, "[=...]");
+                                        else
+                                                pos += fprintf(stderr, "[...]");
+                                else
+                                        pos += fprintf(stderr, " ...");
+                        }
+                        break;
+                default: /* OPTION_{BIT,BOOLEAN,SET_INT,SET_PTR} */
+                        break;
+                }
+
+                if (pos <= USAGE_OPTS_WIDTH)
+                        pad = USAGE_OPTS_WIDTH - pos;
+                else {
+                        fputc('\n', stderr);
+                        pad = USAGE_OPTS_WIDTH;
+                }
+                fprintf(stderr, "%*s%s\n", pad + USAGE_GAP, "", opts->help);
+        }
+        fputc('\n', stderr);
+
+        return PARSE_OPT_HELP;
+}
+
+void usage_with_options(const char * const *usagestr,
+                        const struct option *opts)
+{
+        usage_with_options_internal(usagestr, opts, 0);
+        exit(129);
+}
+
+int parse_options_usage(const char * const *usagestr,
+                        const struct option *opts)
+{
+        return usage_with_options_internal(usagestr, opts, 0);
+}
+
+
+int parse_opt_verbosity_cb(const struct option *opt, const char *arg __used,
+                           int unset)
+{
+        int *target = opt->value;
+
+        if (unset)
+                /* --no-quiet, --no-verbose */
+                *target = 0;
+        else if (opt->short_name == 'v') {
+                if (*target >= 0)
+                        (*target)++;
+                else
+                        *target = 1;
+        } else {
+                if (*target <= 0)
+                        (*target)--;
+                else
+                        *target = -1;
+        }
+        return 0;
+}
diff --git a/tools/perf/util/parse-options.h b/tools/perf/util/parse-options.h
new file mode 100644
index 000000000000..8aa3464c7090
--- /dev/null
+++ b/tools/perf/util/parse-options.h
@@ -0,0 +1,175 @@
+#ifndef PARSE_OPTIONS_H
+#define PARSE_OPTIONS_H
+
+enum parse_opt_type {
+        /* special types */
+        OPTION_END,
+        OPTION_ARGUMENT,
+        OPTION_GROUP,
+        /* options with no arguments */
+        OPTION_BIT,
+        OPTION_BOOLEAN, /* _INCR would have been a better name */
+        OPTION_SET_INT,
+        OPTION_SET_PTR,
+        /* options with arguments (usually) */
+        OPTION_STRING,
+        OPTION_INTEGER,
+        OPTION_LONG,
+        OPTION_CALLBACK,
+};
+
+enum parse_opt_flags {
+        PARSE_OPT_KEEP_DASHDASH = 1,
+        PARSE_OPT_STOP_AT_NON_OPTION = 2,
+        PARSE_OPT_KEEP_ARGV0 = 4,
+        PARSE_OPT_KEEP_UNKNOWN = 8,
+        PARSE_OPT_NO_INTERNAL_HELP = 16,
+};
+
+enum parse_opt_option_flags {
+        PARSE_OPT_OPTARG  = 1,
+        PARSE_OPT_NOARG   = 2,
+        PARSE_OPT_NONEG   = 4,
+        PARSE_OPT_HIDDEN  = 8,
+        PARSE_OPT_LASTARG_DEFAULT = 16,
+};
+
+struct option;
+typedef int parse_opt_cb(const struct option *, const char *arg, int unset);
+
+/*
+ * `type`::
+ *   holds the type of the option, you must have an OPTION_END last in your
+ *   array.
+ *
+ * `short_name`::
+ *   the character to use as a short option name, '\0' if none.
+ *
+ * `long_name`::
+ *   the long option name, without the leading dashes, NULL if none.
+ *
+ * `value`::
+ *   stores pointers to the values to be filled.
+ *
+ * `argh`::
+ *   token to explain the kind of argument this option wants. Keep it
+ *   homogenous across the repository.
+ *
+ * `help`::
+ *   the short help associated to what the option does.
+ *   Must never be NULL (except for OPTION_END).
+ *   OPTION_GROUP uses this pointer to store the group header.
+ *
+ * `flags`::
+ *   mask of parse_opt_option_flags.
+ *   PARSE_OPT_OPTARG: says that the argument is optionnal (not for BOOLEANs)
+ *   PARSE_OPT_NOARG: says that this option takes no argument, for CALLBACKs
+ *   PARSE_OPT_NONEG: says that this option cannot be negated
+ *   PARSE_OPT_HIDDEN this option is skipped in the default usage, showed in
+ *                    the long one.
+ *
+ * `callback`::
+ *   pointer to the callback to use for OPTION_CALLBACK.
+ *
+ * `defval`::
+ *   default value to fill (*->value) with for PARSE_OPT_OPTARG.
+ *   OPTION_{BIT,SET_INT,SET_PTR} store the {mask,integer,pointer} to put in
+ *   the value when met.
+ *   CALLBACKS can use it like they want.
+ */
+struct option {
+        enum parse_opt_type type;
+        int short_name;
+        const char *long_name;
+        void *value;
+        const char *argh;
+        const char *help;
+
+        int flags;
+        parse_opt_cb *callback;
+        intptr_t defval;
+};
+
+#define OPT_END()                   { .type = OPTION_END }
+#define OPT_ARGUMENT(l, h)          { .type = OPTION_ARGUMENT, .long_name = (l), .help = (h) }
+#define OPT_GROUP(h)                { .type = OPTION_GROUP, .help = (h) }
+#define OPT_BIT(s, l, v, h, b)      { .type = OPTION_BIT, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (b) }
+#define OPT_BOOLEAN(s, l, v, h)     { .type = OPTION_BOOLEAN, .short_name = (s), .long_name = (l), .value = (v), .help = (h) }
+#define OPT_SET_INT(s, l, v, h, i)  { .type = OPTION_SET_INT, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (i) }
+#define OPT_SET_PTR(s, l, v, h, p)  { .type = OPTION_SET_PTR, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (p) }
+#define OPT_INTEGER(s, l, v, h)     { .type = OPTION_INTEGER, .short_name = (s), .long_name = (l), .value = (v), .help = (h) }
+#define OPT_LONG(s, l, v, h)        { .type = OPTION_LONG, .short_name = (s), .long_name = (l), .value = (v), .help = (h) }
+#define OPT_STRING(s, l, v, a, h)   { .type = OPTION_STRING,  .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h) }
+#define OPT_DATE(s, l, v, h) \
+        { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), .argh = "time", .help = (h), .callback = parse_opt_approxidate_cb }
+#define OPT_CALLBACK(s, l, v, a, h, f) \
+        { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h), .callback = (f) }
+#define OPT_CALLBACK_DEFAULT(s, l, v, a, h, f, d) \
+        { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h), .callback = (f), .defval = (intptr_t)d, .flags = PARSE_OPT_LASTARG_DEFAULT }
+
+/* parse_options() will filter out the processed options and leave the
+ * non-option argments in argv[].
+ * Returns the number of arguments left in argv[].
+ */
+extern int parse_options(int argc, const char **argv,
+                         const struct option *options,
+                         const char * const usagestr[], int flags);
+
+extern NORETURN void usage_with_options(const char * const *usagestr,
+                                        const struct option *options);
+
+/*----- incremantal advanced APIs -----*/
+
+enum {
+        PARSE_OPT_HELP = -1,
+        PARSE_OPT_DONE,
+        PARSE_OPT_UNKNOWN,
+};
+
+/*
+ * It's okay for the caller to consume argv/argc in the usual way.
+ * Other fields of that structure are private to parse-options and should not
+ * be modified in any way.
+ */
+struct parse_opt_ctx_t {
+        const char **argv;
+        const char **out;
+        int argc, cpidx;
+        const char *opt;
+        int flags;
+};
+
+extern int parse_options_usage(const char * const *usagestr,
+                               const struct option *opts);
+
+extern void parse_options_start(struct parse_opt_ctx_t *ctx,
+                                int argc, const char **argv, int flags);
+
+extern int parse_options_step(struct parse_opt_ctx_t *ctx,
+                              const struct option *options,
+                              const char * const usagestr[]);
+
+extern int parse_options_end(struct parse_opt_ctx_t *ctx);
+
+
+/*----- some often used options -----*/
+extern int parse_opt_abbrev_cb(const struct option *, const char *, int);
+extern int parse_opt_approxidate_cb(const struct option *, const char *, int);
+extern int parse_opt_verbosity_cb(const struct option *, const char *, int);
+
+#define OPT__VERBOSE(var)  OPT_BOOLEAN('v', "verbose", (var), "be verbose")
+#define OPT__QUIET(var)    OPT_BOOLEAN('q', "quiet",   (var), "be quiet")
+#define OPT__VERBOSITY(var) \
+        { OPTION_CALLBACK, 'v', "verbose", (var), NULL, "be more verbose", \
+          PARSE_OPT_NOARG, &parse_opt_verbosity_cb, 0 }, \
+        { OPTION_CALLBACK, 'q', "quiet", (var), NULL, "be more quiet", \
+          PARSE_OPT_NOARG, &parse_opt_verbosity_cb, 0 }
+#define OPT__DRY_RUN(var)  OPT_BOOLEAN('n', "dry-run", (var), "dry run")
+#define OPT__ABBREV(var)  \
+        { OPTION_CALLBACK, 0, "abbrev", (var), "n", \
+          "use <n> digits to display SHA-1s", \
+          PARSE_OPT_OPTARG, &parse_opt_abbrev_cb, 0 }
+
+extern const char *parse_options_fix_filename(const char *prefix, const char *file);
+
+#endif
diff --git a/tools/perf/util/path.c b/tools/perf/util/path.c
new file mode 100644
index 000000000000..a501a40dd2cb
--- /dev/null
+++ b/tools/perf/util/path.c
@@ -0,0 +1,353 @@
+/*
+ * I'm tired of doing "vsnprintf()" etc just to open a
+ * file, so here's a "return static buffer with printf"
+ * interface for paths.
+ *
+ * It's obviously not thread-safe. Sue me. But it's quite
+ * useful for doing things like
+ *
+ *   f = open(mkpath("%s/%s.perf", base, name), O_RDONLY);
+ *
+ * which is what it's designed for.
+ */
+#include "cache.h"
+
+static char bad_path[] = "/bad-path/";
+/*
+ * Two hacks:
+ */
+
+static char *get_perf_dir(void)
+{
+        return ".";
+}
+
+size_t strlcpy(char *dest, const char *src, size_t size)
+{
+        size_t ret = strlen(src);
+
+        if (size) {
+                size_t len = (ret >= size) ? size - 1 : ret;
+                memcpy(dest, src, len);
+                dest[len] = '\0';
+        }
+        return ret;
+}
+
+
+static char *get_pathname(void)
+{
+        static char pathname_array[4][PATH_MAX];
+        static int index;
+        return pathname_array[3 & ++index];
+}
+
+static char *cleanup_path(char *path)
+{
+        /* Clean it up */
+        if (!memcmp(path, "./", 2)) {
+                path += 2;
+                while (*path == '/')
+                        path++;
+        }
+        return path;
+}
+
+char *mksnpath(char *buf, size_t n, const char *fmt, ...)
+{
+        va_list args;
+        unsigned len;
+
+        va_start(args, fmt);
+        len = vsnprintf(buf, n, fmt, args);
+        va_end(args);
+        if (len >= n) {
+                strlcpy(buf, bad_path, n);
+                return buf;
+        }
+        return cleanup_path(buf);
+}
+
+static char *perf_vsnpath(char *buf, size_t n, const char *fmt, va_list args)
+{
+        const char *perf_dir = get_perf_dir();
+        size_t len;
+
+        len = strlen(perf_dir);
+        if (n < len + 1)
+                goto bad;
+        memcpy(buf, perf_dir, len);
+        if (len && !is_dir_sep(perf_dir[len-1]))
+                buf[len++] = '/';
+        len += vsnprintf(buf + len, n - len, fmt, args);
+        if (len >= n)
+                goto bad;
+        return cleanup_path(buf);
+bad:
+        strlcpy(buf, bad_path, n);
+        return buf;
+}
+
+char *perf_snpath(char *buf, size_t n, const char *fmt, ...)
+{
+        va_list args;
+        va_start(args, fmt);
+        (void)perf_vsnpath(buf, n, fmt, args);
+        va_end(args);
+        return buf;
+}
+
+char *perf_pathdup(const char *fmt, ...)
+{
+        char path[PATH_MAX];
+        va_list args;
+        va_start(args, fmt);
+        (void)perf_vsnpath(path, sizeof(path), fmt, args);
+        va_end(args);
+        return xstrdup(path);
+}
+
+char *mkpath(const char *fmt, ...)
+{
+        va_list args;
+        unsigned len;
+        char *pathname = get_pathname();
+
+        va_start(args, fmt);
+        len = vsnprintf(pathname, PATH_MAX, fmt, args);
+        va_end(args);
+        if (len >= PATH_MAX)
+                return bad_path;
+        return cleanup_path(pathname);
+}
+
+char *perf_path(const char *fmt, ...)
+{
+        const char *perf_dir = get_perf_dir();
+        char *pathname = get_pathname();
+        va_list args;
+        unsigned len;
+
+        len = strlen(perf_dir);
+        if (len > PATH_MAX-100)
+                return bad_path;
+        memcpy(pathname, perf_dir, len);
+        if (len && perf_dir[len-1] != '/')
+                pathname[len++] = '/';
+        va_start(args, fmt);
+        len += vsnprintf(pathname + len, PATH_MAX - len, fmt, args);
+        va_end(args);
+        if (len >= PATH_MAX)
+                return bad_path;
+        return cleanup_path(pathname);
+}
+
+
+/* perf_mkstemp() - create tmp file honoring TMPDIR variable */
+int perf_mkstemp(char *path, size_t len, const char *template)
+{
+        const char *tmp;
+        size_t n;
+
+        tmp = getenv("TMPDIR");
+        if (!tmp)
+                tmp = "/tmp";
+        n = snprintf(path, len, "%s/%s", tmp, template);
+        if (len <= n) {
+                errno = ENAMETOOLONG;
+                return -1;
+        }
+        return mkstemp(path);
+}
+
+
+const char *make_relative_path(const char *abs, const char *base)
+{
+        static char buf[PATH_MAX + 1];
+        int baselen;
+        if (!base)
+                return abs;
+        baselen = strlen(base);
+        if (prefixcmp(abs, base))
+                return abs;
+        if (abs[baselen] == '/')
+                baselen++;
+        else if (base[baselen - 1] != '/')
+                return abs;
+        strcpy(buf, abs + baselen);
+        return buf;
+}
+
+/*
+ * It is okay if dst == src, but they should not overlap otherwise.
+ *
+ * Performs the following normalizations on src, storing the result in dst:
+ * - Ensures that components are separated by '/' (Windows only)
+ * - Squashes sequences of '/'.
+ * - Removes "." components.
+ * - Removes ".." components, and the components the precede them.
+ * Returns failure (non-zero) if a ".." component appears as first path
+ * component anytime during the normalization. Otherwise, returns success (0).
+ *
+ * Note that this function is purely textual.  It does not follow symlinks,
+ * verify the existence of the path, or make any system calls.
+ */
+int normalize_path_copy(char *dst, const char *src)
+{
+        char *dst0;
+
+        if (has_dos_drive_prefix(src)) {
+                *dst++ = *src++;
+                *dst++ = *src++;
+        }
+        dst0 = dst;
+
+        if (is_dir_sep(*src)) {
+                *dst++ = '/';
+                while (is_dir_sep(*src))
+                        src++;
+        }
+
+        for (;;) {
+                char c = *src;
+
+                /*
+                 * A path component that begins with . could be
+                 * special:
+                 * (1) "." and ends   -- ignore and terminate.
+                 * (2) "./"           -- ignore them, eat slash and continue.
+                 * (3) ".." and ends  -- strip one and terminate.
+                 * (4) "../"          -- strip one, eat slash and continue.
+                 */
+                if (c == '.') {
+                        if (!src[1]) {
+                                /* (1) */
+                                src++;
+                        } else if (is_dir_sep(src[1])) {
+                                /* (2) */
+                                src += 2;
+                                while (is_dir_sep(*src))
+                                        src++;
+                                continue;
+                        } else if (src[1] == '.') {
+                                if (!src[2]) {
+                                        /* (3) */
+                                        src += 2;
+                                        goto up_one;
+                                } else if (is_dir_sep(src[2])) {
+                                        /* (4) */
+                                        src += 3;
+                                        while (is_dir_sep(*src))
+                                                src++;
+                                        goto up_one;
+                                }
+                        }
+                }
+
+                /* copy up to the next '/', and eat all '/' */
+                while ((c = *src++) != '\0' && !is_dir_sep(c))
+                        *dst++ = c;
+                if (is_dir_sep(c)) {
+                        *dst++ = '/';
+                        while (is_dir_sep(c))
+                                c = *src++;
+                        src--;
+                } else if (!c)
+                        break;
+                continue;
+
+        up_one:
+                /*
+                 * dst0..dst is prefix portion, and dst[-1] is '/';
+                 * go up one level.
+                 */
+                dst--;  /* go to trailing '/' */
+                if (dst <= dst0)
+                        return -1;
+                /* Windows: dst[-1] cannot be backslash anymore */
+                while (dst0 < dst && dst[-1] != '/')
+                        dst--;
+        }
+        *dst = '\0';
+        return 0;
+}
+
+/*
+ * path = Canonical absolute path
+ * prefix_list = Colon-separated list of absolute paths
+ *
+ * Determines, for each path in prefix_list, whether the "prefix" really
+ * is an ancestor directory of path.  Returns the length of the longest
+ * ancestor directory, excluding any trailing slashes, or -1 if no prefix
+ * is an ancestor.  (Note that this means 0 is returned if prefix_list is
+ * "/".) "/foo" is not considered an ancestor of "/foobar".  Directories
+ * are not considered to be their own ancestors.  path must be in a
+ * canonical form: empty components, or "." or ".." components are not
+ * allowed.  prefix_list may be null, which is like "".
+ */
+int longest_ancestor_length(const char *path, const char *prefix_list)
+{
+        char buf[PATH_MAX+1];
+        const char *ceil, *colon;
+        int len, max_len = -1;
+
+        if (prefix_list == NULL || !strcmp(path, "/"))
+                return -1;
+
+        for (colon = ceil = prefix_list; *colon; ceil = colon+1) {
+                for (colon = ceil; *colon && *colon != PATH_SEP; colon++);
+                len = colon - ceil;
+                if (len == 0 || len > PATH_MAX || !is_absolute_path(ceil))
+                        continue;
+                strlcpy(buf, ceil, len+1);
+                if (normalize_path_copy(buf, buf) < 0)
+                        continue;
+                len = strlen(buf);
+                if (len > 0 && buf[len-1] == '/')
+                        buf[--len] = '\0';
+
+                if (!strncmp(path, buf, len) &&
+                    path[len] == '/' &&
+                    len > max_len) {
+                        max_len = len;
+                }
+        }
+
+        return max_len;
+}
+
+/* strip arbitrary amount of directory separators at end of path */
+static inline int chomp_trailing_dir_sep(const char *path, int len)
+{
+        while (len && is_dir_sep(path[len - 1]))
+                len--;
+        return len;
+}
+
+/*
+ * If path ends with suffix (complete path components), returns the
+ * part before suffix (sans trailing directory separators).
+ * Otherwise returns NULL.
+ */
+char *strip_path_suffix(const char *path, const char *suffix)
+{
+        int path_len = strlen(path), suffix_len = strlen(suffix);
+
+        while (suffix_len) {
+                if (!path_len)
+                        return NULL;
+
+                if (is_dir_sep(path[path_len - 1])) {
+                        if (!is_dir_sep(suffix[suffix_len - 1]))
+                                return NULL;
+                        path_len = chomp_trailing_dir_sep(path, path_len);
+                        suffix_len = chomp_trailing_dir_sep(suffix, suffix_len);
+                }
+                else if (path[--path_len] != suffix[--suffix_len])
+                        return NULL;
+        }
+
+        if (path_len && !is_dir_sep(path[path_len - 1]))
+                return NULL;
+        return xstrndup(path, chomp_trailing_dir_sep(path, path_len));
+}
diff --git a/tools/perf/util/quote.c b/tools/perf/util/quote.c
new file mode 100644
index 000000000000..2726fe40eb5d
--- /dev/null
+++ b/tools/perf/util/quote.c
@@ -0,0 +1,485 @@
+#include "cache.h"
+#include "quote.h"
+
+int quote_path_fully = 1;
+
+/* Help to copy the thing properly quoted for the shell safety.
+ * any single quote is replaced with '\'', any exclamation point
+ * is replaced with '\!', and the whole thing is enclosed in a
+ *
+ * E.g.
+ *  original     sq_quote     result
+ *  name     ==> name      ==> 'name'
+ *  a b      ==> a b       ==> 'a b'
+ *  a'b      ==> a'\''b    ==> 'a'\''b'
+ *  a!b      ==> a'\!'b    ==> 'a'\!'b'
+ */
+static inline int need_bs_quote(char c)
+{
+        return (c == '\'' || c == '!');
+}
+
+void sq_quote_buf(struct strbuf *dst, const char *src)
+{
+        char *to_free = NULL;
+
+        if (dst->buf == src)
+                to_free = strbuf_detach(dst, NULL);
+
+        strbuf_addch(dst, '\'');
+        while (*src) {
+                size_t len = strcspn(src, "'!");
+                strbuf_add(dst, src, len);
+                src += len;
+                while (need_bs_quote(*src)) {
+                        strbuf_addstr(dst, "'\\");
+                        strbuf_addch(dst, *src++);
+                        strbuf_addch(dst, '\'');
+                }
+        }
+        strbuf_addch(dst, '\'');
+        free(to_free);
+}
+
+void sq_quote_print(FILE *stream, const char *src)
+{
+        char c;
+
+        fputc('\'', stream);
+        while ((c = *src++)) {
+                if (need_bs_quote(c)) {
+                        fputs("'\\", stream);
+                        fputc(c, stream);
+                        fputc('\'', stream);
+                } else {
+                        fputc(c, stream);
+                }
+        }
+        fputc('\'', stream);
+}
+
+void sq_quote_argv(struct strbuf *dst, const char** argv, size_t maxlen)
+{
+        int i;
+
+        /* Copy into destination buffer. */
+        strbuf_grow(dst, 255);
+        for (i = 0; argv[i]; ++i) {
+                strbuf_addch(dst, ' ');
+                sq_quote_buf(dst, argv[i]);
+                if (maxlen && dst->len > maxlen)
+                        die("Too many or long arguments");
+        }
+}
+
+char *sq_dequote_step(char *arg, char **next)
+{
+        char *dst = arg;
+        char *src = arg;
+        char c;
+
+        if (*src != '\'')
+                return NULL;
+        for (;;) {
+                c = *++src;
+                if (!c)
+                        return NULL;
+                if (c != '\'') {
+                        *dst++ = c;
+                        continue;
+                }
+                /* We stepped out of sq */
+                switch (*++src) {
+                case '\0':
+                        *dst = 0;
+                        if (next)
+                                *next = NULL;
+                        return arg;
+                case '\\':
+                        c = *++src;
+                        if (need_bs_quote(c) && *++src == '\'') {
+                                *dst++ = c;
+                                continue;
+                        }
+                /* Fallthrough */
+                default:
+                        if (!next || !isspace(*src))
+                                return NULL;
+                        do {
+                                c = *++src;
+                        } while (isspace(c));
+                        *dst = 0;
+                        *next = src;
+                        return arg;
+                }
+        }
+}
+
+char *sq_dequote(char *arg)
+{
+        return sq_dequote_step(arg, NULL);
+}
+
+int sq_dequote_to_argv(char *arg, const char ***argv, int *nr, int *alloc)
+{
+        char *next = arg;
+
+        if (!*arg)
+                return 0;
+        do {
+                char *dequoted = sq_dequote_step(next, &next);
+                if (!dequoted)
+                        return -1;
+                ALLOC_GROW(*argv, *nr + 1, *alloc);
+                (*argv)[(*nr)++] = dequoted;
+        } while (next);
+
+        return 0;
+}
+
+/* 1 means: quote as octal
+ * 0 means: quote as octal if (quote_path_fully)
+ * -1 means: never quote
+ * c: quote as "\\c"
+ */
+#define X8(x)   x, x, x, x, x, x, x, x
+#define X16(x)  X8(x), X8(x)
+static signed char const sq_lookup[256] = {
+        /*           0    1    2    3    4    5    6    7 */
+        /* 0x00 */   1,   1,   1,   1,   1,   1,   1, 'a',
+        /* 0x08 */ 'b', 't', 'n', 'v', 'f', 'r',   1,   1,
+        /* 0x10 */ X16(1),
+        /* 0x20 */  -1,  -1, '"',  -1,  -1,  -1,  -1,  -1,
+        /* 0x28 */ X16(-1), X16(-1), X16(-1),
+        /* 0x58 */  -1,  -1,  -1,  -1,'\\',  -1,  -1,  -1,
+        /* 0x60 */ X16(-1), X8(-1),
+        /* 0x78 */  -1,  -1,  -1,  -1,  -1,  -1,  -1,   1,
+        /* 0x80 */ /* set to 0 */
+};
+
+static inline int sq_must_quote(char c)
+{
+        return sq_lookup[(unsigned char)c] + quote_path_fully > 0;
+}
+
+/*
+ * Returns the longest prefix not needing a quote up to maxlen if
+ * positive.
+ * This stops at the first \0 because it's marked as a character
+ * needing an escape.
+ */
+static ssize_t next_quote_pos(const char *s, ssize_t maxlen)
+{
+        ssize_t len;
+
+        if (maxlen < 0) {
+                for (len = 0; !sq_must_quote(s[len]); len++);
+        } else {
+                for (len = 0; len < maxlen && !sq_must_quote(s[len]); len++);
+        }
+        return len;
+}
+
+/*
+ * C-style name quoting.
+ *
+ * (1) if sb and fp are both NULL, inspect the input name and counts the
+ *     number of bytes that are needed to hold c_style quoted version of name,
+ *     counting the double quotes around it but not terminating NUL, and
+ *     returns it.
+ *     However, if name does not need c_style quoting, it returns 0.
+ *
+ * (2) if sb or fp are not NULL, it emits the c_style quoted version
+ *     of name, enclosed with double quotes if asked and needed only.
+ *     Return value is the same as in (1).
+ */
+static size_t quote_c_style_counted(const char *name, ssize_t maxlen,
+                                    struct strbuf *sb, FILE *fp, int no_dq)
+{
+#define EMIT(c)                                                 \
+        do {                                                    \
+                if (sb) strbuf_addch(sb, (c));                  \
+                if (fp) fputc((c), fp);                         \
+                count++;                                        \
+        } while (0)
+
+#define EMITBUF(s, l)                                           \
+        do {                                                    \
+                int __ret;                                      \
+                if (sb) strbuf_add(sb, (s), (l));               \
+                if (fp) __ret = fwrite((s), (l), 1, fp);        \
+                count += (l);                                   \
+        } while (0)
+
+        ssize_t len, count = 0;
+        const char *p = name;
+
+        for (;;) {
+                int ch;
+
+                len = next_quote_pos(p, maxlen);
+                if (len == maxlen || !p[len])
+                        break;
+
+                if (!no_dq && p == name)
+                        EMIT('"');
+
+                EMITBUF(p, len);
+                EMIT('\\');
+                p += len;
+                ch = (unsigned char)*p++;
+                if (sq_lookup[ch] >= ' ') {
+                        EMIT(sq_lookup[ch]);
+                } else {
+                        EMIT(((ch >> 6) & 03) + '0');
+                        EMIT(((ch >> 3) & 07) + '0');
+                        EMIT(((ch >> 0) & 07) + '0');
+                }
+        }
+
+        EMITBUF(p, len);
+        if (p == name)   /* no ending quote needed */
+                return 0;
+
+        if (!no_dq)
+                EMIT('"');
+        return count;
+}
+
+size_t quote_c_style(const char *name, struct strbuf *sb, FILE *fp, int nodq)
+{
+        return quote_c_style_counted(name, -1, sb, fp, nodq);
+}
+
+void quote_two_c_style(struct strbuf *sb, const char *prefix, const char *path, int nodq)
+{
+        if (quote_c_style(prefix, NULL, NULL, 0) ||
+            quote_c_style(path, NULL, NULL, 0)) {
+                if (!nodq)
+                        strbuf_addch(sb, '"');
+                quote_c_style(prefix, sb, NULL, 1);
+                quote_c_style(path, sb, NULL, 1);
+                if (!nodq)
+                        strbuf_addch(sb, '"');
+        } else {
+                strbuf_addstr(sb, prefix);
+                strbuf_addstr(sb, path);
+        }
+}
+
+void write_name_quoted(const char *name, FILE *fp, int terminator)
+{
+        if (terminator) {
+                quote_c_style(name, NULL, fp, 0);
+        } else {
+                fputs(name, fp);
+        }
+        fputc(terminator, fp);
+}
+
+void write_name_quotedpfx(const char *pfx, ssize_t pfxlen,
+                          const char *name, FILE *fp, int terminator)
+{
+        int needquote = 0;
+
+        if (terminator) {
+                needquote = next_quote_pos(pfx, pfxlen) < pfxlen
+                        || name[next_quote_pos(name, -1)];
+        }
+        if (needquote) {
+                fputc('"', fp);
+                quote_c_style_counted(pfx, pfxlen, NULL, fp, 1);
+                quote_c_style(name, NULL, fp, 1);
+                fputc('"', fp);
+        } else {
+                int ret;
+
+                ret = fwrite(pfx, pfxlen, 1, fp);
+                fputs(name, fp);
+        }
+        fputc(terminator, fp);
+}
+
+/* quote path as relative to the given prefix */
+char *quote_path_relative(const char *in, int len,
+                          struct strbuf *out, const char *prefix)
+{
+        int needquote;
+
+        if (len < 0)
+                len = strlen(in);
+
+        /* "../" prefix itself does not need quoting, but "in" might. */
+        needquote = (next_quote_pos(in, len) < len);
+        strbuf_setlen(out, 0);
+        strbuf_grow(out, len);
+
+        if (needquote)
+                strbuf_addch(out, '"');
+        if (prefix) {
+                int off = 0;
+                while (off < len && prefix[off] && prefix[off] == in[off])
+                        if (prefix[off] == '/') {
+                                prefix += off + 1;
+                                in += off + 1;
+                                len -= off + 1;
+                                off = 0;
+                        } else
+                                off++;
+
+                for (; *prefix; prefix++)
+                        if (*prefix == '/')
+                                strbuf_addstr(out, "../");
+        }
+
+        quote_c_style_counted (in, len, out, NULL, 1);
+
+        if (needquote)
+                strbuf_addch(out, '"');
+        if (!out->len)
+                strbuf_addstr(out, "./");
+
+        return out->buf;
+}
+
+/*
+ * C-style name unquoting.
+ *
+ * Quoted should point at the opening double quote.
+ * + Returns 0 if it was able to unquote the string properly, and appends the
+ *   result in the strbuf `sb'.
+ * + Returns -1 in case of error, and doesn't touch the strbuf. Though note
+ *   that this function will allocate memory in the strbuf, so calling
+ *   strbuf_release is mandatory whichever result unquote_c_style returns.
+ *
+ * Updates endp pointer to point at one past the ending double quote if given.
+ */
+int unquote_c_style(struct strbuf *sb, const char *quoted, const char **endp)
+{
+        size_t oldlen = sb->len, len;
+        int ch, ac;
+
+        if (*quoted++ != '"')
+                return -1;
+
+        for (;;) {
+                len = strcspn(quoted, "\"\\");
+                strbuf_add(sb, quoted, len);
+                quoted += len;
+
+                switch (*quoted++) {
+                  case '"':
+                        if (endp)
+                                *endp = quoted;
+                        return 0;
+                  case '\\':
+                        break;
+                  default:
+                        goto error;
+                }
+
+                switch ((ch = *quoted++)) {
+                case 'a': ch = '\a'; break;
+                case 'b': ch = '\b'; break;
+                case 'f': ch = '\f'; break;
+                case 'n': ch = '\n'; break;
+                case 'r': ch = '\r'; break;
+                case 't': ch = '\t'; break;
+                case 'v': ch = '\v'; break;
+
+                case '\\': case '"':
+                        break; /* verbatim */
+
+                /* octal values with first digit over 4 overflow */
+                case '0': case '1': case '2': case '3':
+                                        ac = ((ch - '0') << 6);
+                        if ((ch = *quoted++) < '0' || '7' < ch)
+                                goto error;
+                                        ac |= ((ch - '0') << 3);
+                        if ((ch = *quoted++) < '0' || '7' < ch)
+                                goto error;
+                                        ac |= (ch - '0');
+                                        ch = ac;
+                                        break;
+                                default:
+                        goto error;
+                        }
+                strbuf_addch(sb, ch);
+                }
+
+  error:
+        strbuf_setlen(sb, oldlen);
+        return -1;
+}
+
+/* quoting as a string literal for other languages */
+
+void perl_quote_print(FILE *stream, const char *src)
+{
+        const char sq = '\'';
+        const char bq = '\\';
+        char c;
+
+        fputc(sq, stream);
+        while ((c = *src++)) {
+                if (c == sq || c == bq)
+                        fputc(bq, stream);
+                fputc(c, stream);
+        }
+        fputc(sq, stream);
+}
+
+void python_quote_print(FILE *stream, const char *src)
+{
+        const char sq = '\'';
+        const char bq = '\\';
+        const char nl = '\n';
+        char c;
+
+        fputc(sq, stream);
+        while ((c = *src++)) {
+                if (c == nl) {
+                        fputc(bq, stream);
+                        fputc('n', stream);
+                        continue;
+                }
+                if (c == sq || c == bq)
+                        fputc(bq, stream);
+                fputc(c, stream);
+        }
+        fputc(sq, stream);
+}
+
+void tcl_quote_print(FILE *stream, const char *src)
+{
+        char c;
+
+        fputc('"', stream);
+        while ((c = *src++)) {
+                switch (c) {
+                case '[': case ']':
+                case '{': case '}':
+                case '$': case '\\': case '"':
+                        fputc('\\', stream);
+                default:
+                        fputc(c, stream);
+                        break;
+                case '\f':
+                        fputs("\\f", stream);
+                        break;
+                case '\r':
+                        fputs("\\r", stream);
+                        break;
+                case '\n':
+                        fputs("\\n", stream);
+                        break;
+                case '\t':
+                        fputs("\\t", stream);
+                        break;
+                case '\v':
+                        fputs("\\v", stream);
+                        break;
+                }
+        }
+        fputc('"', stream);
+}
diff --git a/tools/perf/util/quote.h b/tools/perf/util/quote.h
new file mode 100644
index 000000000000..a5454a1d1c13
--- /dev/null
+++ b/tools/perf/util/quote.h
@@ -0,0 +1,68 @@
+#ifndef QUOTE_H
+#define QUOTE_H
+
+#include <stddef.h>
+#include <stdio.h>
+
+/* Help to copy the thing properly quoted for the shell safety.
+ * any single quote is replaced with '\'', any exclamation point
+ * is replaced with '\!', and the whole thing is enclosed in a
+ * single quote pair.
+ *
+ * For example, if you are passing the result to system() as an
+ * argument:
+ *
+ * sprintf(cmd, "foobar %s %s", sq_quote(arg0), sq_quote(arg1))
+ *
+ * would be appropriate.  If the system() is going to call ssh to
+ * run the command on the other side:
+ *
+ * sprintf(cmd, "git-diff-tree %s %s", sq_quote(arg0), sq_quote(arg1));
+ * sprintf(rcmd, "ssh %s %s", sq_util/quote.host), sq_quote(cmd));
+ *
+ * Note that the above examples leak memory!  Remember to free result from
+ * sq_quote() in a real application.
+ *
+ * sq_quote_buf() writes to an existing buffer of specified size; it
+ * will return the number of characters that would have been written
+ * excluding the final null regardless of the buffer size.
+ */
+
+extern void sq_quote_print(FILE *stream, const char *src);
+
+extern void sq_quote_buf(struct strbuf *, const char *src);
+extern void sq_quote_argv(struct strbuf *, const char **argv, size_t maxlen);
+
+/* This unwraps what sq_quote() produces in place, but returns
+ * NULL if the input does not look like what sq_quote would have
+ * produced.
+ */
+extern char *sq_dequote(char *);
+
+/*
+ * Same as the above, but can be used to unwrap many arguments in the
+ * same string separated by space. "next" is changed to point to the
+ * next argument that should be passed as first parameter. When there
+ * is no more argument to be dequoted, "next" is updated to point to NULL.
+ */
+extern char *sq_dequote_step(char *arg, char **next);
+extern int sq_dequote_to_argv(char *arg, const char ***argv, int *nr, int *alloc);
+
+extern int unquote_c_style(struct strbuf *, const char *quoted, const char **endp);
+extern size_t quote_c_style(const char *name, struct strbuf *, FILE *, int no_dq);
+extern void quote_two_c_style(struct strbuf *, const char *, const char *, int);
+
+extern void write_name_quoted(const char *name, FILE *, int terminator);
+extern void write_name_quotedpfx(const char *pfx, ssize_t pfxlen,
+                                 const char *name, FILE *, int terminator);
+
+/* quote path as relative to the given prefix */
+char *quote_path_relative(const char *in, int len,
+                          struct strbuf *out, const char *prefix);
+
+/* quoting as a string literal for other languages */
+extern void perl_quote_print(FILE *stream, const char *src);
+extern void python_quote_print(FILE *stream, const char *src);
+extern void tcl_quote_print(FILE *stream, const char *src);
+
+#endif
diff --git a/tools/perf/util/run-command.c b/tools/perf/util/run-command.c
new file mode 100644
index 000000000000..a3935343091a
--- /dev/null
+++ b/tools/perf/util/run-command.c
@@ -0,0 +1,304 @@
+#include "cache.h"
+#include "run-command.h"
+#include "exec_cmd.h"
+
+static inline void close_pair(int fd[2])
+{
+        close(fd[0]);
+        close(fd[1]);
+}
+
+static inline void dup_devnull(int to)
+{
+        int fd = open("/dev/null", O_RDWR);
+        dup2(fd, to);
+        close(fd);
+}
+
+int start_command(struct child_process *cmd)
+{
+        int need_in, need_out, need_err;
+        int fdin[2], fdout[2], fderr[2];
+
+        /*
+         * In case of errors we must keep the promise to close FDs
+         * that have been passed in via ->in and ->out.
+         */
+
+        need_in = !cmd->no_stdin && cmd->in < 0;
+        if (need_in) {
+                if (pipe(fdin) < 0) {
+                        if (cmd->out > 0)
+                                close(cmd->out);
+                        return -ERR_RUN_COMMAND_PIPE;
+                }
+                cmd->in = fdin[1];
+        }
+
+        need_out = !cmd->no_stdout
+                && !cmd->stdout_to_stderr
+                && cmd->out < 0;
+        if (need_out) {
+                if (pipe(fdout) < 0) {
+                        if (need_in)
+                                close_pair(fdin);
+                        else if (cmd->in)
+                                close(cmd->in);
+                        return -ERR_RUN_COMMAND_PIPE;
+                }
+                cmd->out = fdout[0];
+        }
+
+        need_err = !cmd->no_stderr && cmd->err < 0;
+        if (need_err) {
+                if (pipe(fderr) < 0) {
+                        if (need_in)
+                                close_pair(fdin);
+                        else if (cmd->in)
+                                close(cmd->in);
+                        if (need_out)
+                                close_pair(fdout);
+                        else if (cmd->out)
+                                close(cmd->out);
+                        return -ERR_RUN_COMMAND_PIPE;
+                }
+                cmd->err = fderr[0];
+        }
+
+        fflush(NULL);
+        cmd->pid = fork();
+        if (!cmd->pid) {
+                if (cmd->no_stdin)
+                        dup_devnull(0);
+                else if (need_in) {
+                        dup2(fdin[0], 0);
+                        close_pair(fdin);
+                } else if (cmd->in) {
+                        dup2(cmd->in, 0);
+                        close(cmd->in);
+                }
+
+                if (cmd->no_stderr)
+                        dup_devnull(2);
+                else if (need_err) {
+                        dup2(fderr[1], 2);
+                        close_pair(fderr);
+                }
+
+                if (cmd->no_stdout)
+                        dup_devnull(1);
+                else if (cmd->stdout_to_stderr)
+                        dup2(2, 1);
+                else if (need_out) {
+                        dup2(fdout[1], 1);
+                        close_pair(fdout);
+                } else if (cmd->out > 1) {
+                        dup2(cmd->out, 1);
+                        close(cmd->out);
+                }
+
+                if (cmd->dir && chdir(cmd->dir))
+                        die("exec %s: cd to %s failed (%s)", cmd->argv[0],
+                            cmd->dir, strerror(errno));
+                if (cmd->env) {
+                        for (; *cmd->env; cmd->env++) {
+                                if (strchr(*cmd->env, '='))
+                                        putenv((char*)*cmd->env);
+                                else
+                                        unsetenv(*cmd->env);
+                        }
+                }
+                if (cmd->preexec_cb)
+                        cmd->preexec_cb();
+                if (cmd->perf_cmd) {
+                        execv_perf_cmd(cmd->argv);
+                } else {
+                        execvp(cmd->argv[0], (char *const*) cmd->argv);
+                }
+                exit(127);
+        }
+
+        if (cmd->pid < 0) {
+                int err = errno;
+                if (need_in)
+                        close_pair(fdin);
+                else if (cmd->in)
+                        close(cmd->in);
+                if (need_out)
+                        close_pair(fdout);
+                else if (cmd->out)
+                        close(cmd->out);
+                if (need_err)
+                        close_pair(fderr);
+                return err == ENOENT ?
+                        -ERR_RUN_COMMAND_EXEC :
+                        -ERR_RUN_COMMAND_FORK;
+        }
+
+        if (need_in)
+                close(fdin[0]);
+        else if (cmd->in)
+                close(cmd->in);
+
+        if (need_out)
+                close(fdout[1]);
+        else if (cmd->out)
+                close(cmd->out);
+
+        if (need_err)
+                close(fderr[1]);
+
+        return 0;
+}
+
+static int wait_or_whine(pid_t pid)
+{
+        for (;;) {
+                int status, code;
+                pid_t waiting = waitpid(pid, &status, 0);
+
+                if (waiting < 0) {
+                        if (errno == EINTR)
+                                continue;
+                        error("waitpid failed (%s)", strerror(errno));
+                        return -ERR_RUN_COMMAND_WAITPID;
+                }
+                if (waiting != pid)
+                        return -ERR_RUN_COMMAND_WAITPID_WRONG_PID;
+                if (WIFSIGNALED(status))
+                        return -ERR_RUN_COMMAND_WAITPID_SIGNAL;
+
+                if (!WIFEXITED(status))
+                        return -ERR_RUN_COMMAND_WAITPID_NOEXIT;
+                code = WEXITSTATUS(status);
+                switch (code) {
+                case 127:
+                        return -ERR_RUN_COMMAND_EXEC;
+                case 0:
+                        return 0;
+                default:
+                        return -code;
+                }
+        }
+}
+
+int finish_command(struct child_process *cmd)
+{
+        return wait_or_whine(cmd->pid);
+}
+
+int run_command(struct child_process *cmd)
+{
+        int code = start_command(cmd);
+        if (code)
+                return code;
+        return finish_command(cmd);
+}
+
+static void prepare_run_command_v_opt(struct child_process *cmd,
+                                      const char **argv,
+                                      int opt)
+{
+        memset(cmd, 0, sizeof(*cmd));
+        cmd->argv = argv;
+        cmd->no_stdin = opt & RUN_COMMAND_NO_STDIN ? 1 : 0;
+        cmd->perf_cmd = opt & RUN_PERF_CMD ? 1 : 0;
+        cmd->stdout_to_stderr = opt & RUN_COMMAND_STDOUT_TO_STDERR ? 1 : 0;
+}
+
+int run_command_v_opt(const char **argv, int opt)
+{
+        struct child_process cmd;
+        prepare_run_command_v_opt(&cmd, argv, opt);
+        return run_command(&cmd);
+}
+
+int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
+{
+        struct child_process cmd;
+        prepare_run_command_v_opt(&cmd, argv, opt);
+        cmd.dir = dir;
+        cmd.env = env;
+        return run_command(&cmd);
+}
+
+int start_async(struct async *async)
+{
+        int pipe_out[2];
+
+        if (pipe(pipe_out) < 0)
+                return error("cannot create pipe: %s", strerror(errno));
+        async->out = pipe_out[0];
+
+        /* Flush stdio before fork() to avoid cloning buffers */
+        fflush(NULL);
+
+        async->pid = fork();
+        if (async->pid < 0) {
+                error("fork (async) failed: %s", strerror(errno));
+                close_pair(pipe_out);
+                return -1;
+        }
+        if (!async->pid) {
+                close(pipe_out[0]);
+                exit(!!async->proc(pipe_out[1], async->data));
+        }
+        close(pipe_out[1]);
+
+        return 0;
+}
+
+int finish_async(struct async *async)
+{
+        int ret = 0;
+
+        if (wait_or_whine(async->pid))
+                ret = error("waitpid (async) failed");
+
+        return ret;
+}
+
+int run_hook(const char *index_file, const char *name, ...)
+{
+        struct child_process hook;
+        const char **argv = NULL, *env[2];
+        char index[PATH_MAX];
+        va_list args;
+        int ret;
+        size_t i = 0, alloc = 0;
+
+        if (access(perf_path("hooks/%s", name), X_OK) < 0)
+                return 0;
+
+        va_start(args, name);
+        ALLOC_GROW(argv, i + 1, alloc);
+        argv[i++] = perf_path("hooks/%s", name);
+        while (argv[i-1]) {
+                ALLOC_GROW(argv, i + 1, alloc);
+                argv[i++] = va_arg(args, const char *);
+        }
+        va_end(args);
+
+        memset(&hook, 0, sizeof(hook));
+        hook.argv = argv;
+        hook.no_stdin = 1;
+        hook.stdout_to_stderr = 1;
+        if (index_file) {
+                snprintf(index, sizeof(index), "PERF_INDEX_FILE=%s", index_file);
+                env[0] = index;
+                env[1] = NULL;
+                hook.env = env;
+        }
+
+        ret = start_command(&hook);
+        free(argv);
+        if (ret) {
+                warning("Could not spawn %s", argv[0]);
+                return ret;
+        }
+        ret = finish_command(&hook);
+        if (ret == -ERR_RUN_COMMAND_WAITPID_SIGNAL)
+                warning("%s exited due to uncaught signal", argv[0]);
+
+        return ret;
+}
diff --git a/tools/perf/util/run-command.h b/tools/perf/util/run-command.h
new file mode 100644
index 000000000000..cc1837deba88
--- /dev/null
+++ b/tools/perf/util/run-command.h
@@ -0,0 +1,88 @@
+#ifndef RUN_COMMAND_H
+#define RUN_COMMAND_H
+
+enum {
+        ERR_RUN_COMMAND_FORK = 10000,
+        ERR_RUN_COMMAND_EXEC,
+        ERR_RUN_COMMAND_PIPE,
+        ERR_RUN_COMMAND_WAITPID,
+        ERR_RUN_COMMAND_WAITPID_WRONG_PID,
+        ERR_RUN_COMMAND_WAITPID_SIGNAL,
+        ERR_RUN_COMMAND_WAITPID_NOEXIT,
+};
+#define IS_RUN_COMMAND_ERR(x) (-(x) >= ERR_RUN_COMMAND_FORK)
+
+struct child_process {
+        const char **argv;
+        pid_t pid;
+        /*
+         * Using .in, .out, .err:
+         * - Specify 0 for no redirections (child inherits stdin, stdout,
+         *   stderr from parent).
+         * - Specify -1 to have a pipe allocated as follows:
+         *     .in: returns the writable pipe end; parent writes to it,
+         *          the readable pipe end becomes child's stdin
+         *     .out, .err: returns the readable pipe end; parent reads from
+         *          it, the writable pipe end becomes child's stdout/stderr
+         *   The caller of start_command() must close the returned FDs
+         *   after it has completed reading from/writing to it!
+         * - Specify > 0 to set a channel to a particular FD as follows:
+         *     .in: a readable FD, becomes child's stdin
+         *     .out: a writable FD, becomes child's stdout/stderr
+         *     .err > 0 not supported
+         *   The specified FD is closed by start_command(), even in case
+         *   of errors!
+         */
+        int in;
+        int out;
+        int err;
+        const char *dir;
+        const char *const *env;
+        unsigned no_stdin:1;
+        unsigned no_stdout:1;
+        unsigned no_stderr:1;
+        unsigned perf_cmd:1; /* if this is to be perf sub-command */
+        unsigned stdout_to_stderr:1;
+        void (*preexec_cb)(void);
+};
+
+int start_command(struct child_process *);
+int finish_command(struct child_process *);
+int run_command(struct child_process *);
+
+extern int run_hook(const char *index_file, const char *name, ...);
+
+#define RUN_COMMAND_NO_STDIN 1
+#define RUN_PERF_CMD         2  /*If this is to be perf sub-command */
+#define RUN_COMMAND_STDOUT_TO_STDERR 4
+int run_command_v_opt(const char **argv, int opt);
+
+/*
+ * env (the environment) is to be formatted like environ: "VAR=VALUE".
+ * To unset an environment variable use just "VAR".
+ */
+int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env);
+
+/*
+ * The purpose of the following functions is to feed a pipe by running
+ * a function asynchronously and providing output that the caller reads.
+ *
+ * It is expected that no synchronization and mutual exclusion between
+ * the caller and the feed function is necessary so that the function
+ * can run in a thread without interfering with the caller.
+ */
+struct async {
+        /*
+         * proc writes to fd and closes it;
+         * returns 0 on success, non-zero on failure
+         */
+        int (*proc)(int fd, void *data);
+        void *data;
+        int out;        /* caller reads from here and closes it */
+        pid_t pid;
+};
+
+int start_async(struct async *async);
+int finish_async(struct async *async);
+
+#endif
diff --git a/tools/perf/util/sigchain.c b/tools/perf/util/sigchain.c
new file mode 100644
index 000000000000..1118b99e57d3
--- /dev/null
+++ b/tools/perf/util/sigchain.c
@@ -0,0 +1,52 @@
+#include "sigchain.h"
+#include "cache.h"
+
+#define SIGCHAIN_MAX_SIGNALS 32
+
+struct sigchain_signal {
+        sigchain_fun *old;
+        int n;
+        int alloc;
+};
+static struct sigchain_signal signals[SIGCHAIN_MAX_SIGNALS];
+
+static void check_signum(int sig)
+{
+        if (sig < 1 || sig >= SIGCHAIN_MAX_SIGNALS)
+                die("BUG: signal out of range: %d", sig);
+}
+
+int sigchain_push(int sig, sigchain_fun f)
+{
+        struct sigchain_signal *s = signals + sig;
+        check_signum(sig);
+
+        ALLOC_GROW(s->old, s->n + 1, s->alloc);
+        s->old[s->n] = signal(sig, f);
+        if (s->old[s->n] == SIG_ERR)
+                return -1;
+        s->n++;
+        return 0;
+}
+
+int sigchain_pop(int sig)
+{
+        struct sigchain_signal *s = signals + sig;
+        check_signum(sig);
+        if (s->n < 1)
+                return 0;
+
+        if (signal(sig, s->old[s->n - 1]) == SIG_ERR)
+                return -1;
+        s->n--;
+        return 0;
+}
+
+void sigchain_push_common(sigchain_fun f)
+{
+        sigchain_push(SIGINT, f);
+        sigchain_push(SIGHUP, f);
+        sigchain_push(SIGTERM, f);
+        sigchain_push(SIGQUIT, f);
+        sigchain_push(SIGPIPE, f);
+}
diff --git a/tools/perf/util/sigchain.h b/tools/perf/util/sigchain.h
new file mode 100644
index 000000000000..618083bce0c6
--- /dev/null
+++ b/tools/perf/util/sigchain.h
@@ -0,0 +1,11 @@
+#ifndef SIGCHAIN_H
+#define SIGCHAIN_H
+
+typedef void (*sigchain_fun)(int);
+
+int sigchain_push(int sig, sigchain_fun f);
+int sigchain_pop(int sig);
+
+void sigchain_push_common(sigchain_fun f);
+
+#endif /* SIGCHAIN_H */
diff --git a/tools/perf/util/strbuf.c b/tools/perf/util/strbuf.c
new file mode 100644
index 000000000000..5249d5a1b0c2
--- /dev/null
+++ b/tools/perf/util/strbuf.c
@@ -0,0 +1,360 @@
+#include "cache.h"
+
+int prefixcmp(const char *str, const char *prefix)
+{
+        for (; ; str++, prefix++)
+                if (!*prefix)
+                        return 0;
+                else if (*str != *prefix)
+                        return (unsigned char)*prefix - (unsigned char)*str;
+}
+
+/*
+ * Used as the default ->buf value, so that people can always assume
+ * buf is non NULL and ->buf is NUL terminated even for a freshly
+ * initialized strbuf.
+ */
+char strbuf_slopbuf[1];
+
+void strbuf_init(struct strbuf *sb, ssize_t hint)
+{
+        sb->alloc = sb->len = 0;
+        sb->buf = strbuf_slopbuf;
+        if (hint)
+                strbuf_grow(sb, hint);
+}
+
+void strbuf_release(struct strbuf *sb)
+{
+        if (sb->alloc) {
+                free(sb->buf);
+                strbuf_init(sb, 0);
+        }
+}
+
+char *strbuf_detach(struct strbuf *sb, size_t *sz)
+{
+        char *res = sb->alloc ? sb->buf : NULL;
+        if (sz)
+                *sz = sb->len;
+        strbuf_init(sb, 0);
+        return res;
+}
+
+void strbuf_attach(struct strbuf *sb, void *buf, size_t len, size_t alloc)
+{
+        strbuf_release(sb);
+        sb->buf   = buf;
+        sb->len   = len;
+        sb->alloc = alloc;
+        strbuf_grow(sb, 0);
+        sb->buf[sb->len] = '\0';
+}
+
+void strbuf_grow(struct strbuf *sb, size_t extra)
+{
+        if (sb->len + extra + 1 <= sb->len)
+                die("you want to use way too much memory");
+        if (!sb->alloc)
+                sb->buf = NULL;
+        ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);
+}
+
+void strbuf_trim(struct strbuf *sb)
+{
+        char *b = sb->buf;
+        while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
+                sb->len--;
+        while (sb->len > 0 && isspace(*b)) {
+                b++;
+                sb->len--;
+        }
+        memmove(sb->buf, b, sb->len);
+        sb->buf[sb->len] = '\0';
+}
+void strbuf_rtrim(struct strbuf *sb)
+{
+        while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
+                sb->len--;
+        sb->buf[sb->len] = '\0';
+}
+
+void strbuf_ltrim(struct strbuf *sb)
+{
+        char *b = sb->buf;
+        while (sb->len > 0 && isspace(*b)) {
+                b++;
+                sb->len--;
+        }
+        memmove(sb->buf, b, sb->len);
+        sb->buf[sb->len] = '\0';
+}
+
+void strbuf_tolower(struct strbuf *sb)
+{
+        unsigned int i;
+
+        for (i = 0; i < sb->len; i++)
+                sb->buf[i] = tolower(sb->buf[i]);
+}
+
+struct strbuf **strbuf_split(const struct strbuf *sb, int delim)
+{
+        int alloc = 2, pos = 0;
+        char *n, *p;
+        struct strbuf **ret;
+        struct strbuf *t;
+
+        ret = calloc(alloc, sizeof(struct strbuf *));
+        p = n = sb->buf;
+        while (n < sb->buf + sb->len) {
+                int len;
+                n = memchr(n, delim, sb->len - (n - sb->buf));
+                if (pos + 1 >= alloc) {
+                        alloc = alloc * 2;
+                        ret = realloc(ret, sizeof(struct strbuf *) * alloc);
+                }
+                if (!n)
+                        n = sb->buf + sb->len - 1;
+                len = n - p + 1;
+                t = malloc(sizeof(struct strbuf));
+                strbuf_init(t, len);
+                strbuf_add(t, p, len);
+                ret[pos] = t;
+                ret[++pos] = NULL;
+                p = ++n;
+        }
+        return ret;
+}
+
+void strbuf_list_free(struct strbuf **sbs)
+{
+        struct strbuf **s = sbs;
+
+        while (*s) {
+                strbuf_release(*s);
+                free(*s++);
+        }
+        free(sbs);
+}
+
+int strbuf_cmp(const struct strbuf *a, const struct strbuf *b)
+{
+        int len = a->len < b->len ? a->len: b->len;
+        int cmp = memcmp(a->buf, b->buf, len);
+        if (cmp)
+                return cmp;
+        return a->len < b->len ? -1: a->len != b->len;
+}
+
+void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
+                                   const void *data, size_t dlen)
+{
+        if (pos + len < pos)
+                die("you want to use way too much memory");
+        if (pos > sb->len)
+                die("`pos' is too far after the end of the buffer");
+        if (pos + len > sb->len)
+                die("`pos + len' is too far after the end of the buffer");
+
+        if (dlen >= len)
+                strbuf_grow(sb, dlen - len);
+        memmove(sb->buf + pos + dlen,
+                        sb->buf + pos + len,
+                        sb->len - pos - len);
+        memcpy(sb->buf + pos, data, dlen);
+        strbuf_setlen(sb, sb->len + dlen - len);
+}
+
+void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len)
+{
+        strbuf_splice(sb, pos, 0, data, len);
+}
+
+void strbuf_remove(struct strbuf *sb, size_t pos, size_t len)
+{
+        strbuf_splice(sb, pos, len, NULL, 0);
+}
+
+void strbuf_add(struct strbuf *sb, const void *data, size_t len)
+{
+        strbuf_grow(sb, len);
+        memcpy(sb->buf + sb->len, data, len);
+        strbuf_setlen(sb, sb->len + len);
+}
+
+void strbuf_adddup(struct strbuf *sb, size_t pos, size_t len)
+{
+        strbuf_grow(sb, len);
+        memcpy(sb->buf + sb->len, sb->buf + pos, len);
+        strbuf_setlen(sb, sb->len + len);
+}
+
+void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
+{
+        int len;
+        va_list ap;
+
+        if (!strbuf_avail(sb))
+                strbuf_grow(sb, 64);
+        va_start(ap, fmt);
+        len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
+        va_end(ap);
+        if (len < 0)
+                die("your vsnprintf is broken");
+        if (len > strbuf_avail(sb)) {
+                strbuf_grow(sb, len);
+                va_start(ap, fmt);
+                len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
+                va_end(ap);
+                if (len > strbuf_avail(sb)) {
+                        die("this should not happen, your snprintf is broken");
+                }
+        }
+        strbuf_setlen(sb, sb->len + len);
+}
+
+void strbuf_expand(struct strbuf *sb, const char *format, expand_fn_t fn,
+                   void *context)
+{
+        for (;;) {
+                const char *percent;
+                size_t consumed;
+
+                percent = strchrnul(format, '%');
+                strbuf_add(sb, format, percent - format);
+                if (!*percent)
+                        break;
+                format = percent + 1;
+
+                consumed = fn(sb, format, context);
+                if (consumed)
+                        format += consumed;
+                else
+                        strbuf_addch(sb, '%');
+        }
+}
+
+size_t strbuf_expand_dict_cb(struct strbuf *sb, const char *placeholder,
+                void *context)
+{
+        struct strbuf_expand_dict_entry *e = context;
+        size_t len;
+
+        for (; e->placeholder && (len = strlen(e->placeholder)); e++) {
+                if (!strncmp(placeholder, e->placeholder, len)) {
+                        if (e->value)
+                                strbuf_addstr(sb, e->value);
+                        return len;
+                }
+        }
+        return 0;
+}
+
+size_t strbuf_fread(struct strbuf *sb, size_t size, FILE *f)
+{
+        size_t res;
+        size_t oldalloc = sb->alloc;
+
+        strbuf_grow(sb, size);
+        res = fread(sb->buf + sb->len, 1, size, f);
+        if (res > 0)
+                strbuf_setlen(sb, sb->len + res);
+        else if (oldalloc == 0)
+                strbuf_release(sb);
+        return res;
+}
+
+ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint)
+{
+        size_t oldlen = sb->len;
+        size_t oldalloc = sb->alloc;
+
+        strbuf_grow(sb, hint ? hint : 8192);
+        for (;;) {
+                ssize_t cnt;
+
+                cnt = read(fd, sb->buf + sb->len, sb->alloc - sb->len - 1);
+                if (cnt < 0) {
+                        if (oldalloc == 0)
+                                strbuf_release(sb);
+                        else
+                                strbuf_setlen(sb, oldlen);
+                        return -1;
+                }
+                if (!cnt)
+                        break;
+                sb->len += cnt;
+                strbuf_grow(sb, 8192);
+        }
+
+        sb->buf[sb->len] = '\0';
+        return sb->len - oldlen;
+}
+
+#define STRBUF_MAXLINK (2*PATH_MAX)
+
+int strbuf_readlink(struct strbuf *sb, const char *path, ssize_t hint)
+{
+        size_t oldalloc = sb->alloc;
+
+        if (hint < 32)
+                hint = 32;
+
+        while (hint < STRBUF_MAXLINK) {
+                ssize_t len;
+
+                strbuf_grow(sb, hint);
+                len = readlink(path, sb->buf, hint);
+                if (len < 0) {
+                        if (errno != ERANGE)
+                                break;
+                } else if (len < hint) {
+                        strbuf_setlen(sb, len);
+                        return 0;
+                }
+
+                /* .. the buffer was too small - try again */
+                hint *= 2;
+        }
+        if (oldalloc == 0)
+                strbuf_release(sb);
+        return -1;
+}
+
+int strbuf_getline(struct strbuf *sb, FILE *fp, int term)
+{
+        int ch;
+
+        strbuf_grow(sb, 0);
+        if (feof(fp))
+                return EOF;
+
+        strbuf_reset(sb);
+        while ((ch = fgetc(fp)) != EOF) {
+                if (ch == term)
+                        break;
+                strbuf_grow(sb, 1);
+                sb->buf[sb->len++] = ch;
+        }
+        if (ch == EOF && sb->len == 0)
+                return EOF;
+
+        sb->buf[sb->len] = '\0';
+        return 0;
+}
+
+int strbuf_read_file(struct strbuf *sb, const char *path, ssize_t hint)
+{
+        int fd, len;
+
+        fd = open(path, O_RDONLY);
+        if (fd < 0)
+                return -1;
+        len = strbuf_read(sb, fd, hint);
+        close(fd);
+        if (len < 0)
+                return -1;
+
+        return len;
+}
diff --git a/tools/perf/util/strbuf.h b/tools/perf/util/strbuf.h
new file mode 100644
index 000000000000..d2aa86c014c1
--- /dev/null
+++ b/tools/perf/util/strbuf.h
@@ -0,0 +1,137 @@
+#ifndef STRBUF_H
+#define STRBUF_H
+
+/*
+ * Strbuf's can be use in many ways: as a byte array, or to store arbitrary
+ * long, overflow safe strings.
+ *
+ * Strbufs has some invariants that are very important to keep in mind:
+ *
+ * 1. the ->buf member is always malloc-ed, hence strbuf's can be used to
+ *    build complex strings/buffers whose final size isn't easily known.
+ *
+ *    It is NOT legal to copy the ->buf pointer away.
+ *    `strbuf_detach' is the operation that detachs a buffer from its shell
+ *    while keeping the shell valid wrt its invariants.
+ *
+ * 2. the ->buf member is a byte array that has at least ->len + 1 bytes
+ *    allocated. The extra byte is used to store a '\0', allowing the ->buf
+ *    member to be a valid C-string. Every strbuf function ensure this
+ *    invariant is preserved.
+ *
+ *    Note that it is OK to "play" with the buffer directly if you work it
+ *    that way:
+ *
+ *    strbuf_grow(sb, SOME_SIZE);
+ *       ... Here, the memory array starting at sb->buf, and of length
+ *       ... strbuf_avail(sb) is all yours, and you are sure that
+ *       ... strbuf_avail(sb) is at least SOME_SIZE.
+ *    strbuf_setlen(sb, sb->len + SOME_OTHER_SIZE);
+ *
+ *    Of course, SOME_OTHER_SIZE must be smaller or equal to strbuf_avail(sb).
+ *
+ *    Doing so is safe, though if it has to be done in many places, adding the
+ *    missing API to the strbuf module is the way to go.
+ *
+ *    XXX: do _not_ assume that the area that is yours is of size ->alloc - 1
+ *         even if it's true in the current implementation. Alloc is somehow a
+ *         "private" member that should not be messed with.
+ */
+
+#include <assert.h>
+
+extern char strbuf_slopbuf[];
+struct strbuf {
+        size_t alloc;
+        size_t len;
+        char *buf;
+};
+
+#define STRBUF_INIT  { 0, 0, strbuf_slopbuf }
+
+/*----- strbuf life cycle -----*/
+extern void strbuf_init(struct strbuf *buf, ssize_t hint);
+extern void strbuf_release(struct strbuf *);
+extern char *strbuf_detach(struct strbuf *, size_t *);
+extern void strbuf_attach(struct strbuf *, void *, size_t, size_t);
+static inline void strbuf_swap(struct strbuf *a, struct strbuf *b) {
+        struct strbuf tmp = *a;
+        *a = *b;
+        *b = tmp;
+}
+
+/*----- strbuf size related -----*/
+static inline ssize_t strbuf_avail(const struct strbuf *sb) {
+        return sb->alloc ? sb->alloc - sb->len - 1 : 0;
+}
+
+extern void strbuf_grow(struct strbuf *, size_t);
+
+static inline void strbuf_setlen(struct strbuf *sb, size_t len) {
+        if (!sb->alloc)
+                strbuf_grow(sb, 0);
+        assert(len < sb->alloc);
+        sb->len = len;
+        sb->buf[len] = '\0';
+}
+#define strbuf_reset(sb)  strbuf_setlen(sb, 0)
+
+/*----- content related -----*/
+extern void strbuf_trim(struct strbuf *);
+extern void strbuf_rtrim(struct strbuf *);
+extern void strbuf_ltrim(struct strbuf *);
+extern int strbuf_cmp(const struct strbuf *, const struct strbuf *);
+extern void strbuf_tolower(struct strbuf *);
+
+extern struct strbuf **strbuf_split(const struct strbuf *, int delim);
+extern void strbuf_list_free(struct strbuf **);
+
+/*----- add data in your buffer -----*/
+static inline void strbuf_addch(struct strbuf *sb, int c) {
+        strbuf_grow(sb, 1);
+        sb->buf[sb->len++] = c;
+        sb->buf[sb->len] = '\0';
+}
+
+extern void strbuf_insert(struct strbuf *, size_t pos, const void *, size_t);
+extern void strbuf_remove(struct strbuf *, size_t pos, size_t len);
+
+/* splice pos..pos+len with given data */
+extern void strbuf_splice(struct strbuf *, size_t pos, size_t len,
+                          const void *, size_t);
+
+extern void strbuf_add(struct strbuf *, const void *, size_t);
+static inline void strbuf_addstr(struct strbuf *sb, const char *s) {
+        strbuf_add(sb, s, strlen(s));
+}
+static inline void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2) {
+        strbuf_add(sb, sb2->buf, sb2->len);
+}
+extern void strbuf_adddup(struct strbuf *sb, size_t pos, size_t len);
+
+typedef size_t (*expand_fn_t) (struct strbuf *sb, const char *placeholder, void *context);
+extern void strbuf_expand(struct strbuf *sb, const char *format, expand_fn_t fn, void *context);
+struct strbuf_expand_dict_entry {
+        const char *placeholder;
+        const char *value;
+};
+extern size_t strbuf_expand_dict_cb(struct strbuf *sb, const char *placeholder, void *context);
+
+__attribute__((format(printf,2,3)))
+extern void strbuf_addf(struct strbuf *sb, const char *fmt, ...);
+
+extern size_t strbuf_fread(struct strbuf *, size_t, FILE *);
+/* XXX: if read fails, any partial read is undone */
+extern ssize_t strbuf_read(struct strbuf *, int fd, ssize_t hint);
+extern int strbuf_read_file(struct strbuf *sb, const char *path, ssize_t hint);
+extern int strbuf_readlink(struct strbuf *sb, const char *path, ssize_t hint);
+
+extern int strbuf_getline(struct strbuf *, FILE *, int);
+
+extern void stripspace(struct strbuf *buf, int skip_comments);
+extern int launch_editor(const char *path, struct strbuf *buffer, const char *const *env);
+
+extern int strbuf_branchname(struct strbuf *sb, const char *name);
+extern int strbuf_check_branch_ref(struct strbuf *sb, const char *name);
+
+#endif /* STRBUF_H */
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
new file mode 100644
index 000000000000..c93eca9a7be3
--- /dev/null
+++ b/tools/perf/util/string.c
@@ -0,0 +1,34 @@
+#include "string.h"
+
+static int hex(char ch)
+{
+        if ((ch >= '0') && (ch <= '9'))
+                return ch - '0';
+        if ((ch >= 'a') && (ch <= 'f'))
+                return ch - 'a' + 10;
+        if ((ch >= 'A') && (ch <= 'F'))
+                return ch - 'A' + 10;
+        return -1;
+}
+
+/*
+ * While we find nice hex chars, build a long_val.
+ * Return number of chars processed.
+ */
+int hex2u64(const char *ptr, u64 *long_val)
+{
+        const char *p = ptr;
+        *long_val = 0;
+
+        while (*p) {
+                const int hex_val = hex(*p);
+
+                if (hex_val < 0)
+                        break;
+
+                *long_val = (*long_val << 4) | hex_val;
+                p++;
+        }
+
+        return p - ptr;
+}
diff --git a/tools/perf/util/string.h b/tools/perf/util/string.h
new file mode 100644
index 000000000000..bf39dfadfd24
--- /dev/null
+++ b/tools/perf/util/string.h
@@ -0,0 +1,11 @@
+#ifndef _PERF_STRING_H_
+#define _PERF_STRING_H_
+
+#include "types.h"
+
+int hex2u64(const char *ptr, u64 *val);
+
+#define _STR(x) #x
+#define STR(x) _STR(x)
+
+#endif
diff --git a/tools/perf/util/strlist.c b/tools/perf/util/strlist.c
new file mode 100644
index 000000000000..7ad38171dc2b
--- /dev/null
+++ b/tools/perf/util/strlist.c
@@ -0,0 +1,200 @@
+/*
+ * (c) 2009 Arnaldo Carvalho de Melo <acme@redhat.com>
+ *
+ * Licensed under the GPLv2.
+ */
+
+#include "strlist.h"
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static struct str_node *str_node__new(const char *s, bool dupstr)
+{
+        struct str_node *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                if (dupstr) {
+                        s = strdup(s);
+                        if (s == NULL)
+                                goto out_delete;
+                }
+                self->s = s;
+        }
+
+        return self;
+
+out_delete:
+        free(self);
+        return NULL;
+}
+
+static void str_node__delete(struct str_node *self, bool dupstr)
+{
+        if (dupstr)
+                free((void *)self->s);
+        free(self);
+}
+
+int strlist__add(struct strlist *self, const char *new_entry)
+{
+        struct rb_node **p = &self->entries.rb_node;
+        struct rb_node *parent = NULL;
+        struct str_node *sn;
+
+        while (*p != NULL) {
+                int rc;
+
+                parent = *p;
+                sn = rb_entry(parent, struct str_node, rb_node);
+                rc = strcmp(sn->s, new_entry);
+
+                if (rc > 0)
+                        p = &(*p)->rb_left;
+                else if (rc < 0)
+                        p = &(*p)->rb_right;
+                else
+                        return -EEXIST;
+        }
+
+        sn = str_node__new(new_entry, self->dupstr);
+        if (sn == NULL)
+                return -ENOMEM;
+
+        rb_link_node(&sn->rb_node, parent, p);
+        rb_insert_color(&sn->rb_node, &self->entries);
+        ++self->nr_entries;
+
+        return 0;
+}
+
+int strlist__load(struct strlist *self, const char *filename)
+{
+        char entry[1024];
+        int err;
+        FILE *fp = fopen(filename, "r");
+
+        if (fp == NULL)
+                return errno;
+
+        while (fgets(entry, sizeof(entry), fp) != NULL) {
+                const size_t len = strlen(entry);
+
+                if (len == 0)
+                        continue;
+                entry[len - 1] = '\0';
+
+                err = strlist__add(self, entry);
+                if (err != 0)
+                        goto out;
+        }
+
+        err = 0;
+out:
+        fclose(fp);
+        return err;
+}
+
+void strlist__remove(struct strlist *self, struct str_node *sn)
+{
+        rb_erase(&sn->rb_node, &self->entries);
+        str_node__delete(sn, self->dupstr);
+}
+
+bool strlist__has_entry(struct strlist *self, const char *entry)
+{
+        struct rb_node **p = &self->entries.rb_node;
+        struct rb_node *parent = NULL;
+
+        while (*p != NULL) {
+                struct str_node *sn;
+                int rc;
+
+                parent = *p;
+                sn = rb_entry(parent, struct str_node, rb_node);
+                rc = strcmp(sn->s, entry);
+
+                if (rc > 0)
+                        p = &(*p)->rb_left;
+                else if (rc < 0)
+                        p = &(*p)->rb_right;
+                else
+                        return true;
+        }
+
+        return false;
+}
+
+static int strlist__parse_list_entry(struct strlist *self, const char *s)
+{
+        if (strncmp(s, "file://", 7) == 0)
+                return strlist__load(self, s + 7);
+
+        return strlist__add(self, s);
+}
+
+int strlist__parse_list(struct strlist *self, const char *s)
+{
+        char *sep;
+        int err;
+
+        while ((sep = strchr(s, ',')) != NULL) {
+                *sep = '\0';
+                err = strlist__parse_list_entry(self, s);
+                *sep = ',';
+                if (err != 0)
+                        return err;
+                s = sep + 1;
+        }
+
+        return *s ? strlist__parse_list_entry(self, s) : 0;
+}
+
+struct strlist *strlist__new(bool dupstr, const char *slist)
+{
+        struct strlist *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                self->entries    = RB_ROOT;
+                self->dupstr     = dupstr;
+                self->nr_entries = 0;
+                if (slist && strlist__parse_list(self, slist) != 0)
+                        goto out_error;
+        }
+
+        return self;
+out_error:
+        free(self);
+        return NULL;
+}
+
+void strlist__delete(struct strlist *self)
+{
+        if (self != NULL) {
+                struct str_node *pos;
+                struct rb_node *next = rb_first(&self->entries);
+
+                while (next) {
+                        pos = rb_entry(next, struct str_node, rb_node);
+                        next = rb_next(&pos->rb_node);
+                        strlist__remove(self, pos);
+                }
+                self->entries = RB_ROOT;
+                free(self);
+        }
+}
+
+struct str_node *strlist__entry(const struct strlist *self, unsigned int idx)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
+                struct str_node *pos = rb_entry(nd, struct str_node, rb_node);
+
+                if (!idx--)
+                        return pos;
+        }
+
+        return NULL;
+}
diff --git a/tools/perf/util/strlist.h b/tools/perf/util/strlist.h
new file mode 100644
index 000000000000..921818e44a54
--- /dev/null
+++ b/tools/perf/util/strlist.h
@@ -0,0 +1,39 @@
+#ifndef STRLIST_H_
+#define STRLIST_H_
+
+#include <linux/rbtree.h>
+#include <stdbool.h>
+
+struct str_node {
+        struct rb_node rb_node;
+        const char     *s;
+};
+
+struct strlist {
+        struct rb_root entries;
+        unsigned int   nr_entries;
+        bool           dupstr;
+};
+
+struct strlist *strlist__new(bool dupstr, const char *slist);
+void strlist__delete(struct strlist *self);
+
+void strlist__remove(struct strlist *self, struct str_node *sn);
+int strlist__load(struct strlist *self, const char *filename);
+int strlist__add(struct strlist *self, const char *str);
+
+struct str_node *strlist__entry(const struct strlist *self, unsigned int idx);
+bool strlist__has_entry(struct strlist *self, const char *entry);
+
+static inline bool strlist__empty(const struct strlist *self)
+{
+        return self->nr_entries == 0;
+}
+
+static inline unsigned int strlist__nr_entries(const struct strlist *self)
+{
+        return self->nr_entries;
+}
+
+int strlist__parse_list(struct strlist *self, const char *s);
+#endif /* STRLIST_H_ */
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
new file mode 100644
index 000000000000..5c0f42e6b33b
--- /dev/null
+++ b/tools/perf/util/symbol.c
@@ -0,0 +1,930 @@
+#include "util.h"
+#include "../perf.h"
+#include "string.h"
+#include "symbol.h"
+
+#include <libelf.h>
+#include <gelf.h>
+#include <elf.h>
+
+const char *sym_hist_filter;
+
+enum dso_origin {
+        DSO__ORIG_KERNEL = 0,
+        DSO__ORIG_JAVA_JIT,
+        DSO__ORIG_FEDORA,
+        DSO__ORIG_UBUNTU,
+        DSO__ORIG_BUILDID,
+        DSO__ORIG_DSO,
+        DSO__ORIG_NOT_FOUND,
+};
+
+static struct symbol *symbol__new(u64 start, u64 len,
+                                  const char *name, unsigned int priv_size,
+                                  u64 obj_start, int verbose)
+{
+        size_t namelen = strlen(name) + 1;
+        struct symbol *self = calloc(1, priv_size + sizeof(*self) + namelen);
+
+        if (!self)
+                return NULL;
+
+        if (verbose >= 2)
+                printf("new symbol: %016Lx [%08lx]: %s, hist: %p, obj_start: %p\n",
+                        (u64)start, (unsigned long)len, name, self->hist, (void *)(unsigned long)obj_start);
+
+        self->obj_start= obj_start;
+        self->hist = NULL;
+        self->hist_sum = 0;
+
+        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;
+        memcpy(self->name, name, namelen);
+
+        return self;
+}
+
+static void symbol__delete(struct symbol *self, unsigned int priv_size)
+{
+        free(((void *)self) - priv_size);
+}
+
+static size_t symbol__fprintf(struct symbol *self, FILE *fp)
+{
+        if (!self->module)
+                return fprintf(fp, " %llx-%llx %s\n",
+                       self->start, self->end, self->name);
+        else
+                return fprintf(fp, " %llx-%llx %s \t[%s]\n",
+                       self->start, self->end, self->name, self->module->name);
+}
+
+struct dso *dso__new(const char *name, unsigned int sym_priv_size)
+{
+        struct dso *self = malloc(sizeof(*self) + strlen(name) + 1);
+
+        if (self != NULL) {
+                strcpy(self->name, name);
+                self->syms = RB_ROOT;
+                self->sym_priv_size = sym_priv_size;
+                self->find_symbol = dso__find_symbol;
+                self->slen_calculated = 0;
+                self->origin = DSO__ORIG_NOT_FOUND;
+        }
+
+        return self;
+}
+
+static void dso__delete_symbols(struct dso *self)
+{
+        struct symbol *pos;
+        struct rb_node *next = rb_first(&self->syms);
+
+        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);
+        }
+}
+
+void dso__delete(struct dso *self)
+{
+        dso__delete_symbols(self);
+        free(self);
+}
+
+static void dso__insert_symbol(struct dso *self, struct symbol *sym)
+{
+        struct rb_node **p = &self->syms.rb_node;
+        struct rb_node *parent = NULL;
+        const u64 ip = sym->start;
+        struct symbol *s;
+
+        while (*p != NULL) {
+                parent = *p;
+                s = rb_entry(parent, struct symbol, rb_node);
+                if (ip < s->start)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+        rb_link_node(&sym->rb_node, parent, p);
+        rb_insert_color(&sym->rb_node, &self->syms);
+}
+
+struct symbol *dso__find_symbol(struct dso *self, u64 ip)
+{
+        struct rb_node *n;
+
+        if (self == NULL)
+                return NULL;
+
+        n = self->syms.rb_node;
+
+        while (n) {
+                struct symbol *s = rb_entry(n, struct symbol, rb_node);
+
+                if (ip < s->start)
+                        n = n->rb_left;
+                else if (ip > s->end)
+                        n = n->rb_right;
+                else
+                        return s;
+        }
+
+        return NULL;
+}
+
+size_t dso__fprintf(struct dso *self, FILE *fp)
+{
+        size_t ret = fprintf(fp, "dso: %s\n", self->name);
+
+        struct rb_node *nd;
+        for (nd = rb_first(&self->syms); nd; nd = rb_next(nd)) {
+                struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
+                ret += symbol__fprintf(pos, fp);
+        }
+
+        return ret;
+}
+
+static int dso__load_kallsyms(struct dso *self, symbol_filter_t filter, int verbose)
+{
+        struct rb_node *nd, *prevnd;
+        char *line = NULL;
+        size_t n;
+        FILE *file = fopen("/proc/kallsyms", "r");
+        int count = 0;
+
+        if (file == NULL)
+                goto out_failure;
+
+        while (!feof(file)) {
+                u64 start;
+                struct symbol *sym;
+                int line_len, len;
+                char symbol_type;
+
+                line_len = getline(&line, &n, file);
+                if (line_len < 0)
+                        break;
+
+                if (!line)
+                        goto out_failure;
+
+                line[--line_len] = '\0'; /* \n */
+
+                len = hex2u64(line, &start);
+
+                len++;
+                if (len + 2 >= line_len)
+                        continue;
+
+                symbol_type = toupper(line[len]);
+                /*
+                 * We're interested only in code ('T'ext)
+                 */
+                if (symbol_type != 'T' && symbol_type != 'W')
+                        continue;
+                /*
+                 * Well fix up the end later, when we have all sorted.
+                 */
+                sym = symbol__new(start, 0xdead, line + len + 2,
+                                  self->sym_priv_size, 0, verbose);
+
+                if (sym == NULL)
+                        goto out_delete_line;
+
+                if (filter && filter(self, sym))
+                        symbol__delete(sym, self->sym_priv_size);
+                else {
+                        dso__insert_symbol(self, sym);
+                        count++;
+                }
+        }
+
+        /*
+         * Now that we have all sorted out, just set the ->end of all
+         * symbols
+         */
+        prevnd = rb_first(&self->syms);
+
+        if (prevnd == NULL)
+                goto out_delete_line;
+
+        for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
+                struct symbol *prev = rb_entry(prevnd, struct symbol, rb_node),
+                              *curr = rb_entry(nd, struct symbol, rb_node);
+
+                prev->end = curr->start - 1;
+                prevnd = nd;
+        }
+
+        free(line);
+        fclose(file);
+
+        return count;
+
+out_delete_line:
+        free(line);
+out_failure:
+        return -1;
+}
+
+static int dso__load_perf_map(struct dso *self, symbol_filter_t filter, int verbose)
+{
+        char *line = NULL;
+        size_t n;
+        FILE *file;
+        int nr_syms = 0;
+
+        file = fopen(self->name, "r");
+        if (file == NULL)
+                goto out_failure;
+
+        while (!feof(file)) {
+                u64 start, size;
+                struct symbol *sym;
+                int line_len, len;
+
+                line_len = getline(&line, &n, file);
+                if (line_len < 0)
+                        break;
+
+                if (!line)
+                        goto out_failure;
+
+                line[--line_len] = '\0'; /* \n */
+
+                len = hex2u64(line, &start);
+
+                len++;
+                if (len + 2 >= line_len)
+                        continue;
+
+                len += hex2u64(line + len, &size);
+
+                len++;
+                if (len + 2 >= line_len)
+                        continue;
+
+                sym = symbol__new(start, size, line + len,
+                                  self->sym_priv_size, start, verbose);
+
+                if (sym == NULL)
+                        goto out_delete_line;
+
+                if (filter && filter(self, sym))
+                        symbol__delete(sym, self->sym_priv_size);
+                else {
+                        dso__insert_symbol(self, sym);
+                        nr_syms++;
+                }
+        }
+
+        free(line);
+        fclose(file);
+
+        return nr_syms;
+
+out_delete_line:
+        free(line);
+out_failure:
+        return -1;
+}
+
+/**
+ * elf_symtab__for_each_symbol - iterate thru all the symbols
+ *
+ * @self: struct elf_symtab instance to iterate
+ * @index: uint32_t index
+ * @sym: GElf_Sym iterator
+ */
+#define elf_symtab__for_each_symbol(syms, nr_syms, index, sym) \
+        for (index = 0, gelf_getsym(syms, index, &sym);\
+             index < nr_syms; \
+             index++, gelf_getsym(syms, index, &sym))
+
+static inline uint8_t elf_sym__type(const GElf_Sym *sym)
+{
+        return GELF_ST_TYPE(sym->st_info);
+}
+
+static inline int elf_sym__is_function(const GElf_Sym *sym)
+{
+        return elf_sym__type(sym) == STT_FUNC &&
+               sym->st_name != 0 &&
+               sym->st_shndx != SHN_UNDEF &&
+               sym->st_size != 0;
+}
+
+static inline int elf_sym__is_label(const GElf_Sym *sym)
+{
+        return elf_sym__type(sym) == STT_NOTYPE &&
+                sym->st_name != 0 &&
+                sym->st_shndx != SHN_UNDEF &&
+                sym->st_shndx != SHN_ABS;
+}
+
+static inline const char *elf_sec__name(const GElf_Shdr *shdr,
+                                        const Elf_Data *secstrs)
+{
+        return secstrs->d_buf + shdr->sh_name;
+}
+
+static inline int elf_sec__is_text(const GElf_Shdr *shdr,
+                                        const Elf_Data *secstrs)
+{
+        return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
+}
+
+static inline const char *elf_sym__name(const GElf_Sym *sym,
+                                        const Elf_Data *symstrs)
+{
+        return symstrs->d_buf + sym->st_name;
+}
+
+static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
+                                    GElf_Shdr *shp, const char *name,
+                                    size_t *index)
+{
+        Elf_Scn *sec = NULL;
+        size_t cnt = 1;
+
+        while ((sec = elf_nextscn(elf, sec)) != NULL) {
+                char *str;
+
+                gelf_getshdr(sec, shp);
+                str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
+                if (!strcmp(name, str)) {
+                        if (index)
+                                *index = cnt;
+                        break;
+                }
+                ++cnt;
+        }
+
+        return sec;
+}
+
+#define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
+        for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
+             idx < nr_entries; \
+             ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
+
+#define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
+        for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
+             idx < nr_entries; \
+             ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
+
+/*
+ * We need to check if we have a .dynsym, so that we can handle the
+ * .plt, synthesizing its symbols, that aren't on the symtabs (be it
+ * .dynsym or .symtab).
+ * 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 verbose)
+{
+        uint32_t nr_rel_entries, idx;
+        GElf_Sym sym;
+        u64 plt_offset;
+        GElf_Shdr shdr_plt;
+        struct symbol *f;
+        GElf_Shdr shdr_rel_plt, shdr_dynsym;
+        Elf_Data *reldata, *syms, *symstrs;
+        Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
+        size_t dynsym_idx;
+        GElf_Ehdr ehdr;
+        char sympltname[1024];
+        Elf *elf;
+        int nr = 0, symidx, fd, err = 0;
+
+        fd = open(self->name, O_RDONLY);
+        if (fd < 0)
+                goto out;
+
+        elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
+        if (elf == NULL)
+                goto out_close;
+
+        if (gelf_getehdr(elf, &ehdr) == NULL)
+                goto out_elf_end;
+
+        scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
+                                         ".dynsym", &dynsym_idx);
+        if (scn_dynsym == NULL)
+                goto out_elf_end;
+
+        scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
+                                          ".rela.plt", NULL);
+        if (scn_plt_rel == NULL) {
+                scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
+                                                  ".rel.plt", NULL);
+                if (scn_plt_rel == NULL)
+                        goto out_elf_end;
+        }
+
+        err = -1;
+
+        if (shdr_rel_plt.sh_link != dynsym_idx)
+                goto out_elf_end;
+
+        if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
+                goto out_elf_end;
+
+        /*
+         * Fetch the relocation section to find the indexes to the GOT
+         * and the symbols in the .dynsym they refer to.
+         */
+        reldata = elf_getdata(scn_plt_rel, NULL);
+        if (reldata == NULL)
+                goto out_elf_end;
+
+        syms = elf_getdata(scn_dynsym, NULL);
+        if (syms == NULL)
+                goto out_elf_end;
+
+        scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
+        if (scn_symstrs == NULL)
+                goto out_elf_end;
+
+        symstrs = elf_getdata(scn_symstrs, NULL);
+        if (symstrs == NULL)
+                goto out_elf_end;
+
+        nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
+        plt_offset = shdr_plt.sh_offset;
+
+        if (shdr_rel_plt.sh_type == SHT_RELA) {
+                GElf_Rela pos_mem, *pos;
+
+                elf_section__for_each_rela(reldata, pos, pos_mem, idx,
+                                           nr_rel_entries) {
+                        symidx = GELF_R_SYM(pos->r_info);
+                        plt_offset += shdr_plt.sh_entsize;
+                        gelf_getsym(syms, symidx, &sym);
+                        snprintf(sympltname, sizeof(sympltname),
+                                 "%s@plt", elf_sym__name(&sym, symstrs));
+
+                        f = symbol__new(plt_offset, shdr_plt.sh_entsize,
+                                        sympltname, self->sym_priv_size, 0, verbose);
+                        if (!f)
+                                goto out_elf_end;
+
+                        dso__insert_symbol(self, f);
+                        ++nr;
+                }
+        } else if (shdr_rel_plt.sh_type == SHT_REL) {
+                GElf_Rel pos_mem, *pos;
+                elf_section__for_each_rel(reldata, pos, pos_mem, idx,
+                                          nr_rel_entries) {
+                        symidx = GELF_R_SYM(pos->r_info);
+                        plt_offset += shdr_plt.sh_entsize;
+                        gelf_getsym(syms, symidx, &sym);
+                        snprintf(sympltname, sizeof(sympltname),
+                                 "%s@plt", elf_sym__name(&sym, symstrs));
+
+                        f = symbol__new(plt_offset, shdr_plt.sh_entsize,
+                                        sympltname, self->sym_priv_size, 0, verbose);
+                        if (!f)
+                                goto out_elf_end;
+
+                        dso__insert_symbol(self, f);
+                        ++nr;
+                }
+        }
+
+        err = 0;
+out_elf_end:
+        elf_end(elf);
+out_close:
+        close(fd);
+
+        if (err == 0)
+                return nr;
+out:
+        fprintf(stderr, "%s: problems reading %s PLT info.\n",
+                __func__, self->name);
+        return 0;
+}
+
+static int dso__load_sym(struct dso *self, int fd, const char *name,
+                         symbol_filter_t filter, int verbose, struct module *mod)
+{
+        Elf_Data *symstrs, *secstrs;
+        uint32_t nr_syms;
+        int err = -1;
+        uint32_t index;
+        GElf_Ehdr ehdr;
+        GElf_Shdr shdr;
+        Elf_Data *syms;
+        GElf_Sym sym;
+        Elf_Scn *sec, *sec_strndx;
+        Elf *elf;
+        int nr = 0, kernel = !strcmp("[kernel]", self->name);
+
+        elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
+        if (elf == NULL) {
+                if (verbose)
+                        fprintf(stderr, "%s: cannot read %s ELF file.\n",
+                                __func__, name);
+                goto out_close;
+        }
+
+        if (gelf_getehdr(elf, &ehdr) == NULL) {
+                if (verbose)
+                        fprintf(stderr, "%s: cannot get elf header.\n", __func__);
+                goto out_elf_end;
+        }
+
+        sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
+        if (sec == NULL) {
+                sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
+                if (sec == NULL)
+                        goto out_elf_end;
+        }
+
+        syms = elf_getdata(sec, NULL);
+        if (syms == NULL)
+                goto out_elf_end;
+
+        sec = elf_getscn(elf, shdr.sh_link);
+        if (sec == NULL)
+                goto out_elf_end;
+
+        symstrs = elf_getdata(sec, NULL);
+        if (symstrs == NULL)
+                goto out_elf_end;
+
+        sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
+        if (sec_strndx == NULL)
+                goto out_elf_end;
+
+        secstrs = elf_getdata(sec_strndx, NULL);
+        if (secstrs == NULL)
+                goto out_elf_end;
+
+        nr_syms = shdr.sh_size / shdr.sh_entsize;
+
+        memset(&sym, 0, sizeof(sym));
+        if (!kernel) {
+                self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
+                                elf_section_by_name(elf, &ehdr, &shdr,
+                                                     ".gnu.prelink_undo",
+                                                     NULL) != NULL);
+        } else self->adjust_symbols = 0;
+
+        elf_symtab__for_each_symbol(syms, nr_syms, index, sym) {
+                struct symbol *f;
+                const char *name;
+                char *demangled;
+                u64 obj_start;
+                struct section *section = NULL;
+                int is_label = elf_sym__is_label(&sym);
+                const char *section_name;
+
+                if (!is_label && !elf_sym__is_function(&sym))
+                        continue;
+
+                sec = elf_getscn(elf, sym.st_shndx);
+                if (!sec)
+                        goto out_elf_end;
+
+                gelf_getshdr(sec, &shdr);
+
+                if (is_label && !elf_sec__is_text(&shdr, secstrs))
+                        continue;
+
+                section_name = elf_sec__name(&shdr, secstrs);
+                obj_start = sym.st_value;
+
+                if (self->adjust_symbols) {
+                        if (verbose >= 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);
+
+                        sym.st_value -= shdr.sh_addr - shdr.sh_offset;
+                }
+
+                if (mod) {
+                        section = mod->sections->find_section(mod->sections, section_name);
+                        if (section)
+                                sym.st_value += section->vma;
+                        else {
+                                fprintf(stderr, "dso__load_sym() module %s lookup of %s failed\n",
+                                        mod->name, section_name);
+                                goto out_elf_end;
+                        }
+                }
+                /*
+                 * We need to figure out if the object was created from C++ sources
+                 * DWARF DW_compile_unit has this, but we don't always have access
+                 * to it...
+                 */
+                name = elf_sym__name(&sym, symstrs);
+                demangled = bfd_demangle(NULL, name, DMGL_PARAMS | DMGL_ANSI);
+                if (demangled != NULL)
+                        name = demangled;
+
+                f = symbol__new(sym.st_value, sym.st_size, name,
+                                self->sym_priv_size, obj_start, verbose);
+                free(demangled);
+                if (!f)
+                        goto out_elf_end;
+
+                if (filter && filter(self, f))
+                        symbol__delete(f, self->sym_priv_size);
+                else {
+                        f->module = mod;
+                        dso__insert_symbol(self, f);
+                        nr++;
+                }
+        }
+
+        err = nr;
+out_elf_end:
+        elf_end(elf);
+out_close:
+        return err;
+}
+
+#define BUILD_ID_SIZE 128
+
+static char *dso__read_build_id(struct dso *self, int verbose)
+{
+        int i;
+        GElf_Ehdr ehdr;
+        GElf_Shdr shdr;
+        Elf_Data *build_id_data;
+        Elf_Scn *sec;
+        char *build_id = NULL, *bid;
+        unsigned char *raw;
+        Elf *elf;
+        int fd = open(self->name, O_RDONLY);
+
+        if (fd < 0)
+                goto out;
+
+        elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);
+        if (elf == NULL) {
+                if (verbose)
+                        fprintf(stderr, "%s: cannot read %s ELF file.\n",
+                                __func__, self->name);
+                goto out_close;
+        }
+
+        if (gelf_getehdr(elf, &ehdr) == NULL) {
+                if (verbose)
+                        fprintf(stderr, "%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;
+
+        build_id_data = elf_getdata(sec, NULL);
+        if (build_id_data == NULL)
+                goto out_elf_end;
+        build_id = malloc(BUILD_ID_SIZE);
+        if (build_id == NULL)
+                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;
+        }
+        if (verbose >= 2)
+                printf("%s(%s): %s\n", __func__, self->name, build_id);
+out_elf_end:
+        elf_end(elf);
+out_close:
+        close(fd);
+out:
+        return build_id;
+}
+
+char dso__symtab_origin(const struct dso *self)
+{
+        static const char origin[] = {
+                [DSO__ORIG_KERNEL] =   'k',
+                [DSO__ORIG_JAVA_JIT] = 'j',
+                [DSO__ORIG_FEDORA] =   'f',
+                [DSO__ORIG_UBUNTU] =   'u',
+                [DSO__ORIG_BUILDID] =  'b',
+                [DSO__ORIG_DSO] =      'd',
+        };
+
+        if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
+                return '!';
+        return origin[self->origin];
+}
+
+int dso__load(struct dso *self, symbol_filter_t filter, int verbose)
+{
+        int size = PATH_MAX;
+        char *name = malloc(size), *build_id = NULL;
+        int ret = -1;
+        int fd;
+
+        if (!name)
+                return -1;
+
+        self->adjust_symbols = 0;
+
+        if (strncmp(self->name, "/tmp/perf-", 10) == 0) {
+                ret = dso__load_perf_map(self, filter, verbose);
+                self->origin = ret > 0 ? DSO__ORIG_JAVA_JIT :
+                                         DSO__ORIG_NOT_FOUND;
+                return ret;
+        }
+
+        self->origin = DSO__ORIG_FEDORA - 1;
+
+more:
+        do {
+                self->origin++;
+                switch (self->origin) {
+                case DSO__ORIG_FEDORA:
+                        snprintf(name, size, "/usr/lib/debug%s.debug", self->name);
+                        break;
+                case DSO__ORIG_UBUNTU:
+                        snprintf(name, size, "/usr/lib/debug%s", self->name);
+                        break;
+                case DSO__ORIG_BUILDID:
+                        build_id = dso__read_build_id(self, verbose);
+                        if (build_id != NULL) {
+                                snprintf(name, size,
+                                         "/usr/lib/debug/.build-id/%.2s/%s.debug",
+                                        build_id, build_id + 2);
+                                free(build_id);
+                                break;
+                        }
+                        self->origin++;
+                        /* Fall thru */
+                case DSO__ORIG_DSO:
+                        snprintf(name, size, "%s", self->name);
+                        break;
+
+                default:
+                        goto out;
+                }
+
+                fd = open(name, O_RDONLY);
+        } while (fd < 0);
+
+        ret = dso__load_sym(self, fd, name, filter, verbose, NULL);
+        close(fd);
+
+        /*
+         * Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
+         */
+        if (!ret)
+                goto more;
+
+        if (ret > 0) {
+                int nr_plt = dso__synthesize_plt_symbols(self, verbose);
+                if (nr_plt > 0)
+                        ret += nr_plt;
+        }
+out:
+        free(name);
+        if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
+                return 0;
+        return ret;
+}
+
+static int dso__load_module(struct dso *self, struct mod_dso *mods, const char *name,
+                             symbol_filter_t filter, int verbose)
+{
+        struct module *mod = mod_dso__find_module(mods, name);
+        int err = 0, fd;
+
+        if (mod == NULL || !mod->active)
+                return err;
+
+        fd = open(mod->path, O_RDONLY);
+
+        if (fd < 0)
+                return err;
+
+        err = dso__load_sym(self, fd, name, filter, verbose, mod);
+        close(fd);
+
+        return err;
+}
+
+int dso__load_modules(struct dso *self, symbol_filter_t filter, int verbose)
+{
+        struct mod_dso *mods = mod_dso__new_dso("modules");
+        struct module *pos;
+        struct rb_node *next;
+        int err;
+
+        err = mod_dso__load_modules(mods);
+
+        if (err <= 0)
+                return err;
+
+        /*
+         * Iterate over modules, and load active symbols.
+         */
+        next = rb_first(&mods->mods);
+        while (next) {
+                pos = rb_entry(next, struct module, rb_node);
+                err = dso__load_module(self, mods, pos->name, filter, verbose);
+
+                if (err < 0)
+                        break;
+
+                next = rb_next(&pos->rb_node);
+        }
+
+        if (err < 0) {
+                mod_dso__delete_modules(mods);
+                mod_dso__delete_self(mods);
+        }
+
+        return err;
+}
+
+static inline void dso__fill_symbol_holes(struct dso *self)
+{
+        struct symbol *prev = NULL;
+        struct rb_node *nd;
+
+        for (nd = rb_last(&self->syms); nd; nd = rb_prev(nd)) {
+                struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
+
+                if (prev) {
+                        u64 hole = 0;
+                        int alias = pos->start == prev->start;
+
+                        if (!alias)
+                                hole = prev->start - pos->end - 1;
+
+                        if (hole || alias) {
+                                if (alias)
+                                        pos->end = prev->end;
+                                else if (hole)
+                                        pos->end = prev->start - 1;
+                        }
+                }
+                prev = pos;
+        }
+}
+
+static int dso__load_vmlinux(struct dso *self, const char *vmlinux,
+                             symbol_filter_t filter, int verbose)
+{
+        int err, fd = open(vmlinux, O_RDONLY);
+
+        if (fd < 0)
+                return -1;
+
+        err = dso__load_sym(self, fd, vmlinux, filter, verbose, NULL);
+
+        if (err > 0)
+                dso__fill_symbol_holes(self);
+
+        close(fd);
+
+        return err;
+}
+
+int dso__load_kernel(struct dso *self, const char *vmlinux,
+                     symbol_filter_t filter, int verbose, int modules)
+{
+        int err = -1;
+
+        if (vmlinux) {
+                err = dso__load_vmlinux(self, vmlinux, filter, verbose);
+                if (err > 0 && modules)
+                        err = dso__load_modules(self, filter, verbose);
+        }
+
+        if (err <= 0)
+                err = dso__load_kallsyms(self, filter, verbose);
+
+        if (err > 0)
+                self->origin = DSO__ORIG_KERNEL;
+
+        return err;
+}
+
+void symbol__init(void)
+{
+        elf_version(EV_CURRENT);
+}
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
new file mode 100644
index 000000000000..b53bf0125c1b
--- /dev/null
+++ b/tools/perf/util/symbol.h
@@ -0,0 +1,80 @@
+#ifndef _PERF_SYMBOL_
+#define _PERF_SYMBOL_ 1
+
+#include <linux/types.h>
+#include "types.h"
+#include <linux/list.h>
+#include <linux/rbtree.h>
+#include "module.h"
+
+#ifdef HAVE_CPLUS_DEMANGLE
+extern char *cplus_demangle(const char *, int);
+
+static inline char *bfd_demangle(void __used *v, const char *c, int i)
+{
+        return cplus_demangle(c, i);
+}
+#else
+#ifdef NO_DEMANGLE
+static inline char *bfd_demangle(void __used *v, const char __used *c,
+                                 int __used i)
+{
+        return NULL;
+}
+#else
+#include <bfd.h>
+#endif
+#endif
+
+#ifndef DMGL_PARAMS
+#define DMGL_PARAMS      (1 << 0)       /* Include function args */
+#define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
+#endif
+
+struct symbol {
+        struct rb_node  rb_node;
+        u64             start;
+        u64             end;
+        u64             obj_start;
+        u64             hist_sum;
+        u64             *hist;
+        struct module   *module;
+        void            *priv;
+        char            name[0];
+};
+
+struct 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;
+        unsigned char    origin;
+        char             name[0];
+};
+
+const char *sym_hist_filter;
+
+typedef int (*symbol_filter_t)(struct dso *self, struct symbol *sym);
+
+struct dso *dso__new(const char *name, unsigned int sym_priv_size);
+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;
+}
+
+struct symbol *dso__find_symbol(struct dso *self, u64 ip);
+
+int dso__load_kernel(struct dso *self, const char *vmlinux,
+                     symbol_filter_t filter, int verbose, int modules);
+int dso__load_modules(struct dso *self, symbol_filter_t filter, int verbose);
+int dso__load(struct dso *self, symbol_filter_t filter, int verbose);
+
+size_t dso__fprintf(struct dso *self, FILE *fp);
+char dso__symtab_origin(const struct dso *self);
+
+void symbol__init(void);
+#endif /* _PERF_SYMBOL_ */
diff --git a/tools/perf/util/types.h b/tools/perf/util/types.h
new file mode 100644
index 000000000000..5e75f9005940
--- /dev/null
+++ b/tools/perf/util/types.h
@@ -0,0 +1,17 @@
+#ifndef _PERF_TYPES_H
+#define _PERF_TYPES_H
+
+/*
+ * We define u64 as unsigned long long for every architecture
+ * so that we can print it with %Lx without getting warnings.
+ */
+typedef unsigned long long u64;
+typedef signed long long   s64;
+typedef unsigned int       u32;
+typedef signed int         s32;
+typedef unsigned short     u16;
+typedef signed short       s16;
+typedef unsigned char      u8;
+typedef signed char        s8;
+
+#endif /* _PERF_TYPES_H */
diff --git a/tools/perf/util/usage.c b/tools/perf/util/usage.c
new file mode 100644
index 000000000000..e16bf9a707e8
--- /dev/null
+++ b/tools/perf/util/usage.c
@@ -0,0 +1,80 @@
+/*
+ * GIT - The information manager from hell
+ *
+ * Copyright (C) Linus Torvalds, 2005
+ */
+#include "util.h"
+
+static void report(const char *prefix, const char *err, va_list params)
+{
+        char msg[1024];
+        vsnprintf(msg, sizeof(msg), err, params);
+        fprintf(stderr, " %s%s\n", prefix, msg);
+}
+
+static NORETURN void usage_builtin(const char *err)
+{
+        fprintf(stderr, "\n Usage: %s\n", err);
+        exit(129);
+}
+
+static NORETURN void die_builtin(const char *err, va_list params)
+{
+        report(" Fatal: ", err, params);
+        exit(128);
+}
+
+static void error_builtin(const char *err, va_list params)
+{
+        report(" Error: ", err, params);
+}
+
+static void warn_builtin(const char *warn, va_list params)
+{
+        report(" Warning: ", warn, params);
+}
+
+/* If we are in a dlopen()ed .so write to a global variable would segfault
+ * (ugh), so keep things static. */
+static void (*usage_routine)(const char *err) NORETURN = usage_builtin;
+static void (*die_routine)(const char *err, va_list params) NORETURN = die_builtin;
+static void (*error_routine)(const char *err, va_list params) = error_builtin;
+static void (*warn_routine)(const char *err, va_list params) = warn_builtin;
+
+void set_die_routine(void (*routine)(const char *err, va_list params) NORETURN)
+{
+        die_routine = routine;
+}
+
+void usage(const char *err)
+{
+        usage_routine(err);
+}
+
+void die(const char *err, ...)
+{
+        va_list params;
+
+        va_start(params, err);
+        die_routine(err, params);
+        va_end(params);
+}
+
+int error(const char *err, ...)
+{
+        va_list params;
+
+        va_start(params, err);
+        error_routine(err, params);
+        va_end(params);
+        return -1;
+}
+
+void warning(const char *warn, ...)
+{
+        va_list params;
+
+        va_start(params, warn);
+        warn_routine(warn, params);
+        va_end(params);
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
new file mode 100644
index 000000000000..68fe157d72fb
--- /dev/null
+++ b/tools/perf/util/util.h
@@ -0,0 +1,395 @@
+#ifndef GIT_COMPAT_UTIL_H
+#define GIT_COMPAT_UTIL_H
+
+#define _FILE_OFFSET_BITS 64
+
+#ifndef FLEX_ARRAY
+/*
+ * See if our compiler is known to support flexible array members.
+ */
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+# define FLEX_ARRAY /* empty */
+#elif defined(__GNUC__)
+# if (__GNUC__ >= 3)
+#  define FLEX_ARRAY /* empty */
+# else
+#  define FLEX_ARRAY 0 /* older GNU extension */
+# endif
+#endif
+
+/*
+ * Otherwise, default to safer but a bit wasteful traditional style
+ */
+#ifndef FLEX_ARRAY
+# define FLEX_ARRAY 1
+#endif
+#endif
+
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
+
+#ifdef __GNUC__
+#define TYPEOF(x) (__typeof__(x))
+#else
+#define TYPEOF(x)
+#endif
+
+#define MSB(x, bits) ((x) & TYPEOF(x)(~0ULL << (sizeof(x) * 8 - (bits))))
+#define HAS_MULTI_BITS(i)  ((i) & ((i) - 1))  /* checks if an integer has more than 1 bit set */
+
+/* Approximation of the length of the decimal representation of this type. */
+#define decimal_length(x)       ((int)(sizeof(x) * 2.56 + 0.5) + 1)
+
+#if !defined(__APPLE__) && !defined(__FreeBSD__)  && !defined(__USLC__) && !defined(_M_UNIX)
+#define _XOPEN_SOURCE 600 /* glibc2 and AIX 5.3L need 500, OpenBSD needs 600 for S_ISLNK() */
+#define _XOPEN_SOURCE_EXTENDED 1 /* AIX 5.3L needs this */
+#endif
+#define _ALL_SOURCE 1
+#define _GNU_SOURCE 1
+#define _BSD_SOURCE 1
+
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>
+#include <fcntl.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+#include <limits.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <sys/time.h>
+#include <time.h>
+#include <signal.h>
+#include <fnmatch.h>
+#include <assert.h>
+#include <regex.h>
+#include <utime.h>
+#include <sys/wait.h>
+#include <sys/poll.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#ifndef NO_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <pwd.h>
+#include <inttypes.h>
+#include "../../../include/linux/magic.h"
+
+#ifndef NO_ICONV
+#include <iconv.h>
+#endif
+
+/* On most systems <limits.h> would have given us this, but
+ * not on some systems (e.g. GNU/Hurd).
+ */
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
+
+#ifndef PRIuMAX
+#define PRIuMAX "llu"
+#endif
+
+#ifndef PRIu32
+#define PRIu32 "u"
+#endif
+
+#ifndef PRIx32
+#define PRIx32 "x"
+#endif
+
+#ifndef PATH_SEP
+#define PATH_SEP ':'
+#endif
+
+#ifndef STRIP_EXTENSION
+#define STRIP_EXTENSION ""
+#endif
+
+#ifndef has_dos_drive_prefix
+#define has_dos_drive_prefix(path) 0
+#endif
+
+#ifndef is_dir_sep
+#define is_dir_sep(c) ((c) == '/')
+#endif
+
+#ifdef __GNUC__
+#define NORETURN __attribute__((__noreturn__))
+#else
+#define NORETURN
+#ifndef __attribute__
+#define __attribute__(x)
+#endif
+#endif
+
+/* General helper functions */
+extern void usage(const char *err) NORETURN;
+extern void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
+extern int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
+extern void warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
+
+extern void set_die_routine(void (*routine)(const char *err, va_list params) NORETURN);
+
+extern int prefixcmp(const char *str, const char *prefix);
+extern time_t tm_to_time_t(const struct tm *tm);
+
+static inline const char *skip_prefix(const char *str, const char *prefix)
+{
+        size_t len = strlen(prefix);
+        return strncmp(str, prefix, len) ? NULL : str + len;
+}
+
+#if defined(NO_MMAP) || defined(USE_WIN32_MMAP)
+
+#ifndef PROT_READ
+#define PROT_READ 1
+#define PROT_WRITE 2
+#define MAP_PRIVATE 1
+#define MAP_FAILED ((void*)-1)
+#endif
+
+#define mmap git_mmap
+#define munmap git_munmap
+extern void *git_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
+extern int git_munmap(void *start, size_t length);
+
+#else /* NO_MMAP || USE_WIN32_MMAP */
+
+#include <sys/mman.h>
+
+#endif /* NO_MMAP || USE_WIN32_MMAP */
+
+#ifdef NO_MMAP
+
+/* This value must be multiple of (pagesize * 2) */
+#define DEFAULT_PACKED_GIT_WINDOW_SIZE (1 * 1024 * 1024)
+
+#else /* NO_MMAP */
+
+/* This value must be multiple of (pagesize * 2) */
+#define DEFAULT_PACKED_GIT_WINDOW_SIZE \
+        (sizeof(void*) >= 8 \
+                ?  1 * 1024 * 1024 * 1024 \
+                : 32 * 1024 * 1024)
+
+#endif /* NO_MMAP */
+
+#ifdef NO_ST_BLOCKS_IN_STRUCT_STAT
+#define on_disk_bytes(st) ((st).st_size)
+#else
+#define on_disk_bytes(st) ((st).st_blocks * 512)
+#endif
+
+#define DEFAULT_PACKED_GIT_LIMIT \
+        ((1024L * 1024L) * (sizeof(void*) >= 8 ? 8192 : 256))
+
+#ifdef NO_PREAD
+#define pread git_pread
+extern ssize_t git_pread(int fd, void *buf, size_t count, off_t offset);
+#endif
+/*
+ * Forward decl that will remind us if its twin in cache.h changes.
+ * This function is used in compat/pread.c.  But we can't include
+ * cache.h there.
+ */
+extern ssize_t read_in_full(int fd, void *buf, size_t count);
+
+#ifdef NO_SETENV
+#define setenv gitsetenv
+extern int gitsetenv(const char *, const char *, int);
+#endif
+
+#ifdef NO_MKDTEMP
+#define mkdtemp gitmkdtemp
+extern char *gitmkdtemp(char *);
+#endif
+
+#ifdef NO_UNSETENV
+#define unsetenv gitunsetenv
+extern void gitunsetenv(const char *);
+#endif
+
+#ifdef NO_STRCASESTR
+#define strcasestr gitstrcasestr
+extern char *gitstrcasestr(const char *haystack, const char *needle);
+#endif
+
+#ifdef NO_STRLCPY
+#define strlcpy gitstrlcpy
+extern size_t gitstrlcpy(char *, const char *, size_t);
+#endif
+
+#ifdef NO_STRTOUMAX
+#define strtoumax gitstrtoumax
+extern uintmax_t gitstrtoumax(const char *, char **, int);
+#endif
+
+#ifdef NO_HSTRERROR
+#define hstrerror githstrerror
+extern const char *githstrerror(int herror);
+#endif
+
+#ifdef NO_MEMMEM
+#define memmem gitmemmem
+void *gitmemmem(const void *haystack, size_t haystacklen,
+                const void *needle, size_t needlelen);
+#endif
+
+#ifdef FREAD_READS_DIRECTORIES
+#ifdef fopen
+#undef fopen
+#endif
+#define fopen(a,b) git_fopen(a,b)
+extern FILE *git_fopen(const char*, const char*);
+#endif
+
+#ifdef SNPRINTF_RETURNS_BOGUS
+#define snprintf git_snprintf
+extern int git_snprintf(char *str, size_t maxsize,
+                        const char *format, ...);
+#define vsnprintf git_vsnprintf
+extern int git_vsnprintf(char *str, size_t maxsize,
+                         const char *format, va_list ap);
+#endif
+
+#ifdef __GLIBC_PREREQ
+#if __GLIBC_PREREQ(2, 1)
+#define HAVE_STRCHRNUL
+#endif
+#endif
+
+#ifndef HAVE_STRCHRNUL
+#define strchrnul gitstrchrnul
+static inline char *gitstrchrnul(const char *s, int c)
+{
+        while (*s && *s != c)
+                s++;
+        return (char *)s;
+}
+#endif
+
+/*
+ * Wrappers:
+ */
+extern char *xstrdup(const char *str);
+extern void *xmalloc(size_t size);
+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);
+
+static inline size_t xsize_t(off_t len)
+{
+        return (size_t)len;
+}
+
+static inline int has_extension(const char *filename, const char *ext)
+{
+        size_t len = strlen(filename);
+        size_t extlen = strlen(ext);
+        return len > extlen && !memcmp(filename + len - extlen, ext, extlen);
+}
+
+/* Sane ctype - no locale, and works with signed chars */
+#undef isascii
+#undef isspace
+#undef isdigit
+#undef isalpha
+#undef isalnum
+#undef tolower
+#undef toupper
+extern unsigned char sane_ctype[256];
+#define GIT_SPACE               0x01
+#define GIT_DIGIT               0x02
+#define GIT_ALPHA               0x04
+#define GIT_GLOB_SPECIAL        0x08
+#define GIT_REGEX_SPECIAL       0x10
+#define GIT_PRINT_EXTRA         0x20
+#define GIT_PRINT               0x3E
+#define sane_istest(x,mask) ((sane_ctype[(unsigned char)(x)] & (mask)) != 0)
+#define isascii(x) (((x) & ~0x7f) == 0)
+#define isspace(x) sane_istest(x,GIT_SPACE)
+#define isdigit(x) sane_istest(x,GIT_DIGIT)
+#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)
+#define is_glob_special(x) sane_istest(x,GIT_GLOB_SPECIAL)
+#define is_regex_special(x) sane_istest(x,GIT_GLOB_SPECIAL | GIT_REGEX_SPECIAL)
+#define tolower(x) sane_case((unsigned char)(x), 0x20)
+#define toupper(x) sane_case((unsigned char)(x), 0)
+
+static inline int sane_case(int x, int high)
+{
+        if (sane_istest(x, GIT_ALPHA))
+                x = (x & ~0x20) | high;
+        return x;
+}
+
+static inline int strtoul_ui(char const *s, int base, unsigned int *result)
+{
+        unsigned long ul;
+        char *p;
+
+        errno = 0;
+        ul = strtoul(s, &p, base);
+        if (errno || *p || p == s || (unsigned int) ul != ul)
+                return -1;
+        *result = ul;
+        return 0;
+}
+
+static inline int strtol_i(char const *s, int base, int *result)
+{
+        long ul;
+        char *p;
+
+        errno = 0;
+        ul = strtol(s, &p, base);
+        if (errno || *p || p == s || (int) ul != ul)
+                return -1;
+        *result = ul;
+        return 0;
+}
+
+#ifdef INTERNAL_QSORT
+void git_qsort(void *base, size_t nmemb, size_t size,
+               int(*compar)(const void *, const void *));
+#define qsort git_qsort
+#endif
+
+#ifndef DIR_HAS_BSD_GROUP_SEMANTICS
+# define FORCE_DIR_SET_GID S_ISGID
+#else
+# define FORCE_DIR_SET_GID 0
+#endif
+
+#ifdef NO_NSEC
+#undef USE_NSEC
+#define ST_CTIME_NSEC(st) 0
+#define ST_MTIME_NSEC(st) 0
+#else
+#ifdef USE_ST_TIMESPEC
+#define ST_CTIME_NSEC(st) ((unsigned int)((st).st_ctimespec.tv_nsec))
+#define ST_MTIME_NSEC(st) ((unsigned int)((st).st_mtimespec.tv_nsec))
+#else
+#define ST_CTIME_NSEC(st) ((unsigned int)((st).st_ctim.tv_nsec))
+#define ST_MTIME_NSEC(st) ((unsigned int)((st).st_mtim.tv_nsec))
+#endif
+#endif
+
+#endif
diff --git a/tools/perf/util/wrapper.c b/tools/perf/util/wrapper.c
new file mode 100644
index 000000000000..4574ac28396f
--- /dev/null
+++ b/tools/perf/util/wrapper.c
@@ -0,0 +1,207 @@
+/*
+ * Various trivial helper wrappers around standard functions
+ */
+#include "cache.h"
+
+/*
+ * There's no pack memory to release - but stay close to the Git
+ * version so wrap this away:
+ */
+static inline void release_pack_memory(size_t size __used, int flag __used)
+{
+}
+
+char *xstrdup(const char *str)
+{
+        char *ret = strdup(str);
+        if (!ret) {
+                release_pack_memory(strlen(str) + 1, -1);
+                ret = strdup(str);
+                if (!ret)
+                        die("Out of memory, strdup failed");
+        }
+        return ret;
+}
+
+void *xmalloc(size_t size)
+{
+        void *ret = malloc(size);
+        if (!ret && !size)
+                ret = malloc(1);
+        if (!ret) {
+                release_pack_memory(size, -1);
+                ret = malloc(size);
+                if (!ret && !size)
+                        ret = malloc(1);
+                if (!ret)
+                        die("Out of memory, malloc failed");
+        }
+#ifdef XMALLOC_POISON
+        memset(ret, 0xA5, size);
+#endif
+        return ret;
+}
+
+/*
+ * xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
+ * "data" to the allocated memory, zero terminates the allocated memory,
+ * and returns a pointer to the allocated memory. If the allocation fails,
+ * the program dies.
+ */
+void *xmemdupz(const void *data, size_t len)
+{
+        char *p = xmalloc(len + 1);
+        memcpy(p, data, len);
+        p[len] = '\0';
+        return p;
+}
+
+char *xstrndup(const char *str, size_t len)
+{
+        char *p = memchr(str, '\0', len);
+
+        return xmemdupz(str, p ? (size_t)(p - str) : len);
+}
+
+void *xrealloc(void *ptr, size_t size)
+{
+        void *ret = realloc(ptr, size);
+        if (!ret && !size)
+                ret = realloc(ptr, 1);
+        if (!ret) {
+                release_pack_memory(size, -1);
+                ret = realloc(ptr, size);
+                if (!ret && !size)
+                        ret = realloc(ptr, 1);
+                if (!ret)
+                        die("Out of memory, realloc failed");
+        }
+        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)
+{
+        ssize_t nr;
+        while (1) {
+                nr = read(fd, buf, len);
+                if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
+                        continue;
+                return nr;
+        }
+}
+
+/*
+ * xwrite() is the same a write(), but it automatically restarts write()
+ * 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)
+{
+        ssize_t nr;
+        while (1) {
+                nr = write(fd, buf, len);
+                if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
+                        continue;
+                return nr;
+        }
+}
+
+ssize_t read_in_full(int fd, void *buf, size_t count)
+{
+        char *p = buf;
+        ssize_t total = 0;
+
+        while (count > 0) {
+                ssize_t loaded = xread(fd, p, count);
+                if (loaded <= 0)
+                        return total ? total : loaded;
+                count -= loaded;
+                p += loaded;
+                total += loaded;
+        }
+
+        return total;
+}
+
+ssize_t write_in_full(int fd, const void *buf, size_t count)
+{
+        const char *p = buf;
+        ssize_t total = 0;
+
+        while (count > 0) {
+                ssize_t written = xwrite(fd, p, count);
+                if (written < 0)
+                        return -1;
+                if (!written) {
+                        errno = ENOSPC;
+                        return -1;
+                }
+                count -= written;
+                p += written;
+                total += written;
+        }
+
+        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;
+}