35 files changed, 7953 insertions, 859 deletions

diff --git a/Documentation/perf_counter/.gitignore b/Documentation/perf_counter/.gitignore
new file mode 100644
index 000000000000..41c0b20a76ce
--- /dev/null
+++ b/Documentation/perf_counter/.gitignore
@@ -0,0 +1,179 @@
+GIT-BUILD-OPTIONS
+GIT-CFLAGS
+GIT-GUI-VARS
+GIT-VERSION-FILE
+git
+git-add
+git-add--interactive
+git-am
+git-annotate
+git-apply
+git-archimport
+git-archive
+git-bisect
+git-bisect--helper
+git-blame
+git-branch
+git-bundle
+git-cat-file
+git-check-attr
+git-check-ref-format
+git-checkout
+git-checkout-index
+git-cherry
+git-cherry-pick
+git-clean
+git-clone
+git-commit
+git-commit-tree
+git-config
+git-count-objects
+git-cvsexportcommit
+git-cvsimport
+git-cvsserver
+git-daemon
+git-diff
+git-diff-files
+git-diff-index
+git-diff-tree
+git-difftool
+git-difftool--helper
+git-describe
+git-fast-export
+git-fast-import
+git-fetch
+git-fetch--tool
+git-fetch-pack
+git-filter-branch
+git-fmt-merge-msg
+git-for-each-ref
+git-format-patch
+git-fsck
+git-fsck-objects
+git-gc
+git-get-tar-commit-id
+git-grep
+git-hash-object
+git-help
+git-http-fetch
+git-http-push
+git-imap-send
+git-index-pack
+git-init
+git-init-db
+git-instaweb
+git-log
+git-lost-found
+git-ls-files
+git-ls-remote
+git-ls-tree
+git-mailinfo
+git-mailsplit
+git-merge
+git-merge-base
+git-merge-index
+git-merge-file
+git-merge-tree
+git-merge-octopus
+git-merge-one-file
+git-merge-ours
+git-merge-recursive
+git-merge-resolve
+git-merge-subtree
+git-mergetool
+git-mergetool--lib
+git-mktag
+git-mktree
+git-name-rev
+git-mv
+git-pack-redundant
+git-pack-objects
+git-pack-refs
+git-parse-remote
+git-patch-id
+git-peek-remote
+git-prune
+git-prune-packed
+git-pull
+git-push
+git-quiltimport
+git-read-tree
+git-rebase
+git-rebase--interactive
+git-receive-pack
+git-reflog
+git-relink
+git-remote
+git-repack
+git-repo-config
+git-request-pull
+git-rerere
+git-reset
+git-rev-list
+git-rev-parse
+git-revert
+git-rm
+git-send-email
+git-send-pack
+git-sh-setup
+git-shell
+git-shortlog
+git-show
+git-show-branch
+git-show-index
+git-show-ref
+git-stage
+git-stash
+git-status
+git-stripspace
+git-submodule
+git-svn
+git-symbolic-ref
+git-tag
+git-tar-tree
+git-unpack-file
+git-unpack-objects
+git-update-index
+git-update-ref
+git-update-server-info
+git-upload-archive
+git-upload-pack
+git-var
+git-verify-pack
+git-verify-tag
+git-web--browse
+git-whatchanged
+git-write-tree
+git-core-*/?*
+gitk-wish
+gitweb/gitweb.cgi
+test-chmtime
+test-ctype
+test-date
+test-delta
+test-dump-cache-tree
+test-genrandom
+test-match-trees
+test-parse-options
+test-path-utils
+test-sha1
+test-sigchain
+common-cmds.h
+*.tar.gz
+*.dsc
+*.deb
+git.spec
+*.exe
+*.[aos]
+*.py[co]
+config.mak
+autom4te.cache
+config.cache
+config.log
+config.status
+config.mak.autogen
+config.mak.append
+configure
+tags
+TAGS
+cscope*
diff --git a/Documentation/perf_counter/Makefile b/Documentation/perf_counter/Makefile
index 6e0838b03ad1..11809b943fc3 100644
--- a/Documentation/perf_counter/Makefile
+++ b/Documentation/perf_counter/Makefile
@@ -13,16 +13,9 @@ all::
 # Define NO_OPENSSL environment variable if you do not have OpenSSL.
 # This also implies MOZILLA_SHA1.
 #
-# Define NO_CURL if you do not have libcurl installed.  git-http-pull and
-# git-http-push are not built, and you cannot use http:// and https://
-# transports.
-#
 # Define CURLDIR=/foo/bar if your curl header and library files are in
 # /foo/bar/include and /foo/bar/lib directories.
 #
-# Define NO_EXPAT if you do not have expat installed.  git-http-push is
-# not built, and you cannot push using http:// and https:// transports.
-#
 # Define EXPATDIR=/foo/bar if your expat header and library files are in
 # /foo/bar/include and /foo/bar/lib directories.
 #
@@ -40,8 +33,6 @@ all::
 #
 # Define NO_MEMMEM if you don't have memmem.
 #
-# Define NO_STRLCPY if you don't have strlcpy.
-#
 # 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.
@@ -54,7 +45,7 @@ all::
 #
 # Define NO_SYS_SELECT_H if you don't have sys/select.h.
 #
-# Define NO_SYMLINK_HEAD if you never want .git/HEAD to be a symbolic link.
+# 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
@@ -62,13 +53,13 @@ all::
 # 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 GIT to link against any libraries
+# 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 GIT to
+# 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.
@@ -120,7 +111,7 @@ all::
 # that tells runtime paths to dynamic libraries;
 # "-Wl,-rpath=/path/lib" is used instead.
 #
-# Define USE_NSEC below if you want git to care about sub-second file mtimes
+# 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
@@ -132,7 +123,7 @@ all::
 # 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 git to care about the underlying device
+# 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
@@ -150,27 +141,24 @@ all::
 # Define NO_TCLTK if you do not want Tcl/Tk GUI.
 #
 # The TCL_PATH variable governs the location of the Tcl interpreter
-# used to optimize git-gui for your system.  Only used if NO_TCLTK
+# used to optimize perf-gui for your system.  Only used if NO_TCLTK
 # is not set.  Defaults to the bare 'tclsh'.
 #
 # The TCLTK_PATH variable governs the location of the Tcl/Tk interpreter.
 # If not set it defaults to the bare 'wish'. If it is set to the empty
 # string then NO_TCLTK will be forced (this is used by configure script).
 #
-# Define THREADED_DELTA_SEARCH if you have pthreads and wish to exploit
-# parallel delta searching when packing objects.
-#
 # 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 "git grep" to ever call
+# 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 git has).
+# broken, or spawning external process is slower than built-in grep perf has).
 
-GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
-        @$(SHELL_PATH) ./GIT-VERSION-GEN
--include GIT-VERSION-FILE
+PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
+        @$(SHELL_PATH) ./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')
@@ -182,20 +170,20 @@ uname_V := $(shell sh -c 'uname -v 2>/dev/null || echo not')
 # CFLAGS and LDFLAGS are for the users to override from the command line.
 
 CFLAGS = -g -O2 -Wall
-LDFLAGS =
+LDFLAGS = -lpthread -lrt
 ALL_CFLAGS = $(CFLAGS)
 ALL_LDFLAGS = $(LDFLAGS)
 STRIP ?= strip
 
 # Among the variables below, these:
-#   gitexecdir
+#   perfexecdir
 #   template_dir
 #   mandir
 #   infodir
 #   htmldir
-#   ETC_GITCONFIG (but not sysconfdir)
+#   ETC_PERFCONFIG (but not sysconfdir)
 # can be specified as a relative path some/where/else;
-# this is interpreted as relative to $(prefix) and "git" at
+# 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.
 
@@ -204,38 +192,20 @@ bindir_relative = bin
 bindir = $(prefix)/$(bindir_relative)
 mandir = share/man
 infodir = share/info
-gitexecdir = libexec/git-core
+perfexecdir = libexec/perf-core
 sharedir = $(prefix)/share
-template_dir = share/git-core/templates
-htmldir = share/doc/git-doc
+template_dir = share/perf-core/templates
+htmldir = share/doc/perf-doc
 ifeq ($(prefix),/usr)
 sysconfdir = /etc
-ETC_GITCONFIG = $(sysconfdir)/gitconfig
+ETC_PERFCONFIG = $(sysconfdir)/perfconfig
 else
 sysconfdir = $(prefix)/etc
-ETC_GITCONFIG = etc/gitconfig
+ETC_PERFCONFIG = etc/perfconfig
 endif
 lib = lib
 # DESTDIR=
 
-# default configuration for gitweb
-GITWEB_CONFIG = gitweb_config.perl
-GITWEB_CONFIG_SYSTEM = /etc/gitweb.conf
-GITWEB_HOME_LINK_STR = projects
-GITWEB_SITENAME =
-GITWEB_PROJECTROOT = /pub/git
-GITWEB_PROJECT_MAXDEPTH = 2007
-GITWEB_EXPORT_OK =
-GITWEB_STRICT_EXPORT =
-GITWEB_BASE_URL =
-GITWEB_LIST =
-GITWEB_HOMETEXT = indextext.html
-GITWEB_CSS = gitweb.css
-GITWEB_LOGO = git-logo.png
-GITWEB_FAVICON = git-favicon.png
-GITWEB_SITE_HEADER =
-GITWEB_SITE_FOOTER =
-
 export prefix bindir sharedir sysconfdir
 
 CC = gcc
@@ -277,89 +247,46 @@ SCRIPT_PERL =
 SCRIPT_SH =
 TEST_PROGRAMS =
 
-SCRIPT_SH += git-am.sh
-SCRIPT_SH += git-bisect.sh
-SCRIPT_SH += git-difftool--helper.sh
-SCRIPT_SH += git-filter-branch.sh
-SCRIPT_SH += git-lost-found.sh
-SCRIPT_SH += git-merge-octopus.sh
-SCRIPT_SH += git-merge-one-file.sh
-SCRIPT_SH += git-merge-resolve.sh
-SCRIPT_SH += git-mergetool.sh
-SCRIPT_SH += git-mergetool--lib.sh
-SCRIPT_SH += git-parse-remote.sh
-SCRIPT_SH += git-pull.sh
-SCRIPT_SH += git-quiltimport.sh
-SCRIPT_SH += git-rebase--interactive.sh
-SCRIPT_SH += git-rebase.sh
-SCRIPT_SH += git-repack.sh
-SCRIPT_SH += git-request-pull.sh
-SCRIPT_SH += git-sh-setup.sh
-SCRIPT_SH += git-stash.sh
-SCRIPT_SH += git-submodule.sh
-SCRIPT_SH += git-web--browse.sh
-
-SCRIPT_PERL += git-add--interactive.perl
-SCRIPT_PERL += git-difftool.perl
-SCRIPT_PERL += git-archimport.perl
-SCRIPT_PERL += git-cvsexportcommit.perl
-SCRIPT_PERL += git-cvsimport.perl
-SCRIPT_PERL += git-cvsserver.perl
-SCRIPT_PERL += git-relink.perl
-SCRIPT_PERL += git-send-email.perl
-SCRIPT_PERL += git-svn.perl
+#
+# 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)) \
-          git-instaweb
+          $(patsubst %.perl,%,$(SCRIPT_PERL))
 
 # Empty...
 EXTRA_PROGRAMS =
 
-# ... and all the rest that could be moved out of bindir to gitexecdir
+# ... and all the rest that could be moved out of bindir to perfexecdir
 PROGRAMS += $(EXTRA_PROGRAMS)
-PROGRAMS += git-fast-import$X
-PROGRAMS += git-hash-object$X
-PROGRAMS += git-index-pack$X
-PROGRAMS += git-merge-index$X
-PROGRAMS += git-merge-tree$X
-PROGRAMS += git-mktag$X
-PROGRAMS += git-mktree$X
-PROGRAMS += git-pack-redundant$X
-PROGRAMS += git-patch-id$X
-PROGRAMS += git-shell$X
-PROGRAMS += git-show-index$X
-PROGRAMS += git-unpack-file$X
-PROGRAMS += git-update-server-info$X
-PROGRAMS += git-upload-pack$X
-PROGRAMS += git-var$X
+
+#
+# None right now:
+#
+# PROGRAMS += perf-fast-import$X
 
 # 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.
-BUILT_INS += $(patsubst builtin-%.o,git-%$X,$(BUILTIN_OBJS))
-
-BUILT_INS += git-cherry$X
-BUILT_INS += git-cherry-pick$X
-BUILT_INS += git-format-patch$X
-BUILT_INS += git-fsck-objects$X
-BUILT_INS += git-get-tar-commit-id$X
-BUILT_INS += git-init$X
-BUILT_INS += git-merge-subtree$X
-BUILT_INS += git-peek-remote$X
-BUILT_INS += git-repo-config$X
-BUILT_INS += git-show$X
-BUILT_INS += git-stage$X
-BUILT_INS += git-status$X
-BUILT_INS += git-whatchanged$X
-
-# what 'all' will build and 'install' will install, in gitexecdir
+BUILT_INS += $(patsubst builtin-%.o,perf-%$X,$(BUILTIN_OBJS))
+
+#
+# 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 gitexecdir
-OTHER_PROGRAMS = git$X
-ifndef NO_PERL
-OTHER_PROGRAMS += gitweb/gitweb.cgi
-endif
+# 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
@@ -371,250 +298,34 @@ endif
 
 export PERL_PATH
 
-LIB_FILE=libgit.a
-XDIFF_LIB=xdiff/lib.a
-
-LIB_H += archive.h
-LIB_H += attr.h
-LIB_H += blob.h
-LIB_H += builtin.h
-LIB_H += cache.h
-LIB_H += cache-tree.h
-LIB_H += commit.h
-LIB_H += compat/cygwin.h
-LIB_H += compat/mingw.h
-LIB_H += csum-file.h
-LIB_H += decorate.h
-LIB_H += delta.h
-LIB_H += diffcore.h
-LIB_H += diff.h
-LIB_H += dir.h
-LIB_H += fsck.h
-LIB_H += git-compat-util.h
-LIB_H += graph.h
-LIB_H += grep.h
-LIB_H += hash.h
-LIB_H += help.h
+LIB_FILE=libperf.a
+
+LIB_H += ../../include/linux/perf_counter.h
 LIB_H += levenshtein.h
-LIB_H += list-objects.h
-LIB_H += ll-merge.h
-LIB_H += log-tree.h
-LIB_H += mailmap.h
-LIB_H += merge-recursive.h
-LIB_H += object.h
-LIB_H += pack.h
-LIB_H += pack-refs.h
-LIB_H += pack-revindex.h
 LIB_H += parse-options.h
-LIB_H += patch-ids.h
-LIB_H += pkt-line.h
-LIB_H += progress.h
 LIB_H += quote.h
-LIB_H += reflog-walk.h
-LIB_H += refs.h
-LIB_H += remote.h
-LIB_H += rerere.h
-LIB_H += revision.h
-LIB_H += run-command.h
-LIB_H += sha1-lookup.h
-LIB_H += sideband.h
-LIB_H += sigchain.h
 LIB_H += strbuf.h
-LIB_H += string-list.h
-LIB_H += tag.h
-LIB_H += transport.h
-LIB_H += tree.h
-LIB_H += tree-walk.h
-LIB_H += unpack-trees.h
-LIB_H += userdiff.h
-LIB_H += utf8.h
-LIB_H += wt-status.h
+LIB_H += run-command.h
 
 LIB_OBJS += abspath.o
 LIB_OBJS += alias.o
-LIB_OBJS += alloc.o
-LIB_OBJS += archive.o
-LIB_OBJS += archive-tar.o
-LIB_OBJS += archive-zip.o
-LIB_OBJS += attr.o
-LIB_OBJS += base85.o
-LIB_OBJS += bisect.o
-LIB_OBJS += blob.o
-LIB_OBJS += branch.o
-LIB_OBJS += bundle.o
-LIB_OBJS += cache-tree.o
-LIB_OBJS += color.o
-LIB_OBJS += combine-diff.o
-LIB_OBJS += commit.o
 LIB_OBJS += config.o
-LIB_OBJS += connect.o
-LIB_OBJS += convert.o
-LIB_OBJS += copy.o
-LIB_OBJS += csum-file.o
 LIB_OBJS += ctype.o
-LIB_OBJS += date.o
-LIB_OBJS += decorate.o
-LIB_OBJS += diffcore-break.o
-LIB_OBJS += diffcore-delta.o
-LIB_OBJS += diffcore-order.o
-LIB_OBJS += diffcore-pickaxe.o
-LIB_OBJS += diffcore-rename.o
-LIB_OBJS += diff-delta.o
-LIB_OBJS += diff-lib.o
-LIB_OBJS += diff-no-index.o
-LIB_OBJS += diff.o
-LIB_OBJS += dir.o
-LIB_OBJS += editor.o
-LIB_OBJS += entry.o
-LIB_OBJS += environment.o
 LIB_OBJS += exec_cmd.o
-LIB_OBJS += fsck.o
-LIB_OBJS += graph.o
-LIB_OBJS += grep.o
-LIB_OBJS += hash.o
 LIB_OBJS += help.o
-LIB_OBJS += ident.o
 LIB_OBJS += levenshtein.o
-LIB_OBJS += list-objects.o
-LIB_OBJS += ll-merge.o
-LIB_OBJS += lockfile.o
-LIB_OBJS += log-tree.o
-LIB_OBJS += mailmap.o
-LIB_OBJS += match-trees.o
-LIB_OBJS += merge-file.o
-LIB_OBJS += merge-recursive.o
-LIB_OBJS += name-hash.o
-LIB_OBJS += object.o
-LIB_OBJS += pack-check.o
-LIB_OBJS += pack-refs.o
-LIB_OBJS += pack-revindex.o
-LIB_OBJS += pack-write.o
-LIB_OBJS += pager.o
 LIB_OBJS += parse-options.o
-LIB_OBJS += patch-delta.o
-LIB_OBJS += patch-ids.o
 LIB_OBJS += path.o
-LIB_OBJS += pkt-line.o
-LIB_OBJS += preload-index.o
-LIB_OBJS += pretty.o
-LIB_OBJS += progress.o
-LIB_OBJS += quote.o
-LIB_OBJS += reachable.o
-LIB_OBJS += read-cache.o
-LIB_OBJS += reflog-walk.o
-LIB_OBJS += refs.o
-LIB_OBJS += remote.o
-LIB_OBJS += rerere.o
-LIB_OBJS += revision.o
 LIB_OBJS += run-command.o
-LIB_OBJS += server-info.o
-LIB_OBJS += setup.o
-LIB_OBJS += sha1-lookup.o
-LIB_OBJS += sha1_file.o
-LIB_OBJS += sha1_name.o
-LIB_OBJS += shallow.o
-LIB_OBJS += sideband.o
-LIB_OBJS += sigchain.o
+LIB_OBJS += quote.o
 LIB_OBJS += strbuf.o
-LIB_OBJS += string-list.o
-LIB_OBJS += symlinks.o
-LIB_OBJS += tag.o
-LIB_OBJS += trace.o
-LIB_OBJS += transport.o
-LIB_OBJS += tree-diff.o
-LIB_OBJS += tree.o
-LIB_OBJS += tree-walk.o
-LIB_OBJS += unpack-trees.o
 LIB_OBJS += usage.o
-LIB_OBJS += userdiff.o
-LIB_OBJS += utf8.o
-LIB_OBJS += walker.o
 LIB_OBJS += wrapper.o
-LIB_OBJS += write_or_die.o
-LIB_OBJS += ws.o
-LIB_OBJS += wt-status.o
-LIB_OBJS += xdiff-interface.o
-
-BUILTIN_OBJS += builtin-add.o
-BUILTIN_OBJS += builtin-annotate.o
-BUILTIN_OBJS += builtin-apply.o
-BUILTIN_OBJS += builtin-archive.o
-BUILTIN_OBJS += builtin-bisect--helper.o
-BUILTIN_OBJS += builtin-blame.o
-BUILTIN_OBJS += builtin-branch.o
-BUILTIN_OBJS += builtin-bundle.o
-BUILTIN_OBJS += builtin-cat-file.o
-BUILTIN_OBJS += builtin-check-attr.o
-BUILTIN_OBJS += builtin-check-ref-format.o
-BUILTIN_OBJS += builtin-checkout-index.o
-BUILTIN_OBJS += builtin-checkout.o
-BUILTIN_OBJS += builtin-clean.o
-BUILTIN_OBJS += builtin-clone.o
-BUILTIN_OBJS += builtin-commit-tree.o
-BUILTIN_OBJS += builtin-commit.o
-BUILTIN_OBJS += builtin-config.o
-BUILTIN_OBJS += builtin-count-objects.o
-BUILTIN_OBJS += builtin-describe.o
-BUILTIN_OBJS += builtin-diff-files.o
-BUILTIN_OBJS += builtin-diff-index.o
-BUILTIN_OBJS += builtin-diff-tree.o
-BUILTIN_OBJS += builtin-diff.o
-BUILTIN_OBJS += builtin-fast-export.o
-BUILTIN_OBJS += builtin-fetch--tool.o
-BUILTIN_OBJS += builtin-fetch-pack.o
-BUILTIN_OBJS += builtin-fetch.o
-BUILTIN_OBJS += builtin-fmt-merge-msg.o
-BUILTIN_OBJS += builtin-for-each-ref.o
-BUILTIN_OBJS += builtin-fsck.o
-BUILTIN_OBJS += builtin-gc.o
-BUILTIN_OBJS += builtin-grep.o
+
 BUILTIN_OBJS += builtin-help.o
-BUILTIN_OBJS += builtin-init-db.o
-BUILTIN_OBJS += builtin-log.o
-BUILTIN_OBJS += builtin-ls-files.o
-BUILTIN_OBJS += builtin-ls-remote.o
-BUILTIN_OBJS += builtin-ls-tree.o
-BUILTIN_OBJS += builtin-mailinfo.o
-BUILTIN_OBJS += builtin-mailsplit.o
-BUILTIN_OBJS += builtin-merge.o
-BUILTIN_OBJS += builtin-merge-base.o
-BUILTIN_OBJS += builtin-merge-file.o
-BUILTIN_OBJS += builtin-merge-ours.o
-BUILTIN_OBJS += builtin-merge-recursive.o
-BUILTIN_OBJS += builtin-mv.o
-BUILTIN_OBJS += builtin-name-rev.o
-BUILTIN_OBJS += builtin-pack-objects.o
-BUILTIN_OBJS += builtin-pack-refs.o
-BUILTIN_OBJS += builtin-prune-packed.o
-BUILTIN_OBJS += builtin-prune.o
-BUILTIN_OBJS += builtin-push.o
-BUILTIN_OBJS += builtin-read-tree.o
-BUILTIN_OBJS += builtin-receive-pack.o
-BUILTIN_OBJS += builtin-reflog.o
-BUILTIN_OBJS += builtin-remote.o
-BUILTIN_OBJS += builtin-rerere.o
-BUILTIN_OBJS += builtin-reset.o
-BUILTIN_OBJS += builtin-rev-list.o
-BUILTIN_OBJS += builtin-rev-parse.o
-BUILTIN_OBJS += builtin-revert.o
-BUILTIN_OBJS += builtin-rm.o
-BUILTIN_OBJS += builtin-send-pack.o
-BUILTIN_OBJS += builtin-shortlog.o
-BUILTIN_OBJS += builtin-show-branch.o
-BUILTIN_OBJS += builtin-show-ref.o
-BUILTIN_OBJS += builtin-stripspace.o
-BUILTIN_OBJS += builtin-symbolic-ref.o
-BUILTIN_OBJS += builtin-tag.o
-BUILTIN_OBJS += builtin-tar-tree.o
-BUILTIN_OBJS += builtin-unpack-objects.o
-BUILTIN_OBJS += builtin-update-index.o
-BUILTIN_OBJS += builtin-update-ref.o
-BUILTIN_OBJS += builtin-upload-archive.o
-BUILTIN_OBJS += builtin-verify-pack.o
-BUILTIN_OBJS += builtin-verify-tag.o
-BUILTIN_OBJS += builtin-write-tree.o
-
-GITLIBS = $(LIB_FILE) $(XDIFF_LIB)
+BUILTIN_OBJS += builtin-top.o
+
+PERFLIBS = $(LIB_FILE)
 EXTLIBS =
 
 #
@@ -625,221 +336,6 @@ EXTLIBS =
 # because maintaining the nesting to match is a pain.  If
 # we had "elif" things would have been much nicer...
 
-ifeq ($(uname_S),Linux)
-        NO_STRLCPY = YesPlease
-        THREADED_DELTA_SEARCH = YesPlease
-endif
-ifeq ($(uname_S),GNU/kFreeBSD)
-        NO_STRLCPY = YesPlease
-        THREADED_DELTA_SEARCH = YesPlease
-endif
-ifeq ($(uname_S),UnixWare)
-        CC = cc
-        NEEDS_SOCKET = YesPlease
-        NEEDS_NSL = YesPlease
-        NEEDS_SSL_WITH_CRYPTO = YesPlease
-        NEEDS_LIBICONV = YesPlease
-        SHELL_PATH = /usr/local/bin/bash
-        NO_IPV6 = YesPlease
-        NO_HSTRERROR = YesPlease
-        BASIC_CFLAGS += -Kthread
-        BASIC_CFLAGS += -I/usr/local/include
-        BASIC_LDFLAGS += -L/usr/local/lib
-        INSTALL = ginstall
-        TAR = gtar
-        NO_STRCASESTR = YesPlease
-        NO_MEMMEM = YesPlease
-endif
-ifeq ($(uname_S),SCO_SV)
-        ifeq ($(uname_R),3.2)
-                CFLAGS = -O2
-        endif
-        ifeq ($(uname_R),5)
-                CC = cc
-                BASIC_CFLAGS += -Kthread
-        endif
-        NEEDS_SOCKET = YesPlease
-        NEEDS_NSL = YesPlease
-        NEEDS_SSL_WITH_CRYPTO = YesPlease
-        NEEDS_LIBICONV = YesPlease
-        SHELL_PATH = /usr/bin/bash
-        NO_IPV6 = YesPlease
-        NO_HSTRERROR = YesPlease
-        BASIC_CFLAGS += -I/usr/local/include
-        BASIC_LDFLAGS += -L/usr/local/lib
-        NO_STRCASESTR = YesPlease
-        NO_MEMMEM = YesPlease
-        INSTALL = ginstall
-        TAR = gtar
-endif
-ifeq ($(uname_S),Darwin)
-        NEEDS_SSL_WITH_CRYPTO = YesPlease
-        NEEDS_LIBICONV = YesPlease
-        ifeq ($(shell expr "$(uname_R)" : '[15678]\.'),2)
-                OLD_ICONV = UnfortunatelyYes
-        endif
-        ifeq ($(shell expr "$(uname_R)" : '[15]\.'),2)
-                NO_STRLCPY = YesPlease
-        endif
-        NO_MEMMEM = YesPlease
-        THREADED_DELTA_SEARCH = YesPlease
-        USE_ST_TIMESPEC = YesPlease
-endif
-ifeq ($(uname_S),SunOS)
-        NEEDS_SOCKET = YesPlease
-        NEEDS_NSL = YesPlease
-        SHELL_PATH = /bin/bash
-        NO_STRCASESTR = YesPlease
-        NO_MEMMEM = YesPlease
-        NO_HSTRERROR = YesPlease
-        NO_MKDTEMP = YesPlease
-        OLD_ICONV = UnfortunatelyYes
-        ifeq ($(uname_R),5.8)
-                NO_UNSETENV = YesPlease
-                NO_SETENV = YesPlease
-                NO_C99_FORMAT = YesPlease
-                NO_STRTOUMAX = YesPlease
-        endif
-        ifeq ($(uname_R),5.9)
-                NO_UNSETENV = YesPlease
-                NO_SETENV = YesPlease
-                NO_C99_FORMAT = YesPlease
-                NO_STRTOUMAX = YesPlease
-        endif
-        INSTALL = ginstall
-        TAR = gtar
-        BASIC_CFLAGS += -D__EXTENSIONS__
-endif
-ifeq ($(uname_O),Cygwin)
-        NO_D_TYPE_IN_DIRENT = YesPlease
-        NO_D_INO_IN_DIRENT = YesPlease
-        NO_STRCASESTR = YesPlease
-        NO_MEMMEM = YesPlease
-        NO_SYMLINK_HEAD = YesPlease
-        NEEDS_LIBICONV = YesPlease
-        NO_FAST_WORKING_DIRECTORY = UnfortunatelyYes
-        NO_TRUSTABLE_FILEMODE = UnfortunatelyYes
-        OLD_ICONV = UnfortunatelyYes
-        # There are conflicting reports about this.
-        # On some boxes NO_MMAP is needed, and not so elsewhere.
-        # Try commenting this out if you suspect MMAP is more efficient
-        NO_MMAP = YesPlease
-        NO_IPV6 = YesPlease
-        X = .exe
-endif
-ifeq ($(uname_S),FreeBSD)
-        NEEDS_LIBICONV = YesPlease
-        NO_MEMMEM = YesPlease
-        BASIC_CFLAGS += -I/usr/local/include
-        BASIC_LDFLAGS += -L/usr/local/lib
-        DIR_HAS_BSD_GROUP_SEMANTICS = YesPlease
-        USE_ST_TIMESPEC = YesPlease
-        THREADED_DELTA_SEARCH = YesPlease
-        ifeq ($(shell expr "$(uname_R)" : '4\.'),2)
-                PTHREAD_LIBS = -pthread
-                NO_UINTMAX_T = YesPlease
-                NO_STRTOUMAX = YesPlease
-        endif
-endif
-ifeq ($(uname_S),OpenBSD)
-        NO_STRCASESTR = YesPlease
-        NO_MEMMEM = YesPlease
-        NEEDS_LIBICONV = YesPlease
-        BASIC_CFLAGS += -I/usr/local/include
-        BASIC_LDFLAGS += -L/usr/local/lib
-        THREADED_DELTA_SEARCH = YesPlease
-endif
-ifeq ($(uname_S),NetBSD)
-        ifeq ($(shell expr "$(uname_R)" : '[01]\.'),2)
-                NEEDS_LIBICONV = YesPlease
-        endif
-        BASIC_CFLAGS += -I/usr/pkg/include
-        BASIC_LDFLAGS += -L/usr/pkg/lib $(CC_LD_DYNPATH)/usr/pkg/lib
-        THREADED_DELTA_SEARCH = YesPlease
-endif
-ifeq ($(uname_S),AIX)
-        NO_STRCASESTR=YesPlease
-        NO_MEMMEM = YesPlease
-        NO_MKDTEMP = YesPlease
-        NO_STRLCPY = YesPlease
-        NO_NSEC = YesPlease
-        FREAD_READS_DIRECTORIES = UnfortunatelyYes
-        INTERNAL_QSORT = UnfortunatelyYes
-        NEEDS_LIBICONV=YesPlease
-        BASIC_CFLAGS += -D_LARGE_FILES
-        ifneq ($(shell expr "$(uname_V)" : '[1234]'),1)
-                THREADED_DELTA_SEARCH = YesPlease
-        else
-                NO_PTHREADS = YesPlease
-        endif
-endif
-ifeq ($(uname_S),GNU)
-        # GNU/Hurd
-        NO_STRLCPY=YesPlease
-endif
-ifeq ($(uname_S),IRIX64)
-        NO_IPV6=YesPlease
-        NO_SETENV=YesPlease
-        NO_STRCASESTR=YesPlease
-        NO_MEMMEM = YesPlease
-        NO_STRLCPY = YesPlease
-        NO_SOCKADDR_STORAGE=YesPlease
-        SHELL_PATH=/usr/gnu/bin/bash
-        BASIC_CFLAGS += -DPATH_MAX=1024
-        # for now, build 32-bit version
-        BASIC_LDFLAGS += -L/usr/lib32
-endif
-ifeq ($(uname_S),HP-UX)
-        NO_IPV6=YesPlease
-        NO_SETENV=YesPlease
-        NO_STRCASESTR=YesPlease
-        NO_MEMMEM = YesPlease
-        NO_STRLCPY = YesPlease
-        NO_MKDTEMP = YesPlease
-        NO_UNSETENV = YesPlease
-        NO_HSTRERROR = YesPlease
-        NO_SYS_SELECT_H = YesPlease
-        SNPRINTF_RETURNS_BOGUS = YesPlease
-endif
-ifneq (,$(findstring CYGWIN,$(uname_S)))
-        COMPAT_OBJS += compat/cygwin.o
-endif
-ifneq (,$(findstring MINGW,$(uname_S)))
-        NO_PREAD = YesPlease
-        NO_OPENSSL = YesPlease
-        NO_CURL = YesPlease
-        NO_SYMLINK_HEAD = YesPlease
-        NO_IPV6 = YesPlease
-        NO_SETENV = YesPlease
-        NO_UNSETENV = YesPlease
-        NO_STRCASESTR = YesPlease
-        NO_STRLCPY = YesPlease
-        NO_MEMMEM = YesPlease
-        NO_PTHREADS = YesPlease
-        NEEDS_LIBICONV = YesPlease
-        OLD_ICONV = YesPlease
-        NO_C99_FORMAT = YesPlease
-        NO_STRTOUMAX = YesPlease
-        NO_MKDTEMP = YesPlease
-        SNPRINTF_RETURNS_BOGUS = YesPlease
-        NO_SVN_TESTS = YesPlease
-        NO_PERL_MAKEMAKER = YesPlease
-        RUNTIME_PREFIX = YesPlease
-        NO_POSIX_ONLY_PROGRAMS = YesPlease
-        NO_ST_BLOCKS_IN_STRUCT_STAT = YesPlease
-        NO_NSEC = YesPlease
-        USE_WIN32_MMAP = YesPlease
-        COMPAT_CFLAGS += -D__USE_MINGW_ACCESS -DNOGDI -Icompat -Icompat/regex -Icompat/fnmatch
-        COMPAT_CFLAGS += -DSNPRINTF_SIZE_CORR=1
-        COMPAT_CFLAGS += -DSTRIP_EXTENSION=\".exe\"
-        COMPAT_OBJS += compat/mingw.o compat/fnmatch/fnmatch.o compat/regex/regex.o compat/winansi.o
-        EXTLIBS += -lws2_32
-        X = .exe
-endif
-ifneq (,$(findstring arm,$(uname_M)))
-        ARM_SHA1 = YesPlease
-endif
-
 -include config.mak.autogen
 -include config.mak
 
@@ -869,72 +365,12 @@ ifndef CC_LD_DYNPATH
         endif
 endif
 
-ifdef NO_CURL
-        BASIC_CFLAGS += -DNO_CURL
-else
-        ifdef CURLDIR
-                # Try "-Wl,-rpath=$(CURLDIR)/$(lib)" in such a case.
-                BASIC_CFLAGS += -I$(CURLDIR)/include
-                CURL_LIBCURL = -L$(CURLDIR)/$(lib) $(CC_LD_DYNPATH)$(CURLDIR)/$(lib) -lcurl
-        else
-                CURL_LIBCURL = -lcurl
-        endif
-        BUILTIN_OBJS += builtin-http-fetch.o
-        EXTLIBS += $(CURL_LIBCURL)
-        LIB_OBJS += http.o http-walker.o
-        curl_check := $(shell (echo 070908; curl-config --vernum) | sort -r | sed -ne 2p)
-        ifeq "$(curl_check)" "070908"
-                ifndef NO_EXPAT
-                        PROGRAMS += git-http-push$X
-                endif
-        endif
-        ifndef NO_EXPAT
-                ifdef EXPATDIR
-                        BASIC_CFLAGS += -I$(EXPATDIR)/include
-                        EXPAT_LIBEXPAT = -L$(EXPATDIR)/$(lib) $(CC_LD_DYNPATH)$(EXPATDIR)/$(lib) -lexpat
-                else
-                        EXPAT_LIBEXPAT = -lexpat
-                endif
-        endif
-endif
-
 ifdef ZLIB_PATH
         BASIC_CFLAGS += -I$(ZLIB_PATH)/include
         EXTLIBS += -L$(ZLIB_PATH)/$(lib) $(CC_LD_DYNPATH)$(ZLIB_PATH)/$(lib)
 endif
 EXTLIBS += -lz
 
-ifndef NO_POSIX_ONLY_PROGRAMS
-        PROGRAMS += git-daemon$X
-        PROGRAMS += git-imap-send$X
-endif
-ifndef NO_OPENSSL
-        OPENSSL_LIBSSL = -lssl
-        ifdef OPENSSLDIR
-                BASIC_CFLAGS += -I$(OPENSSLDIR)/include
-                OPENSSL_LINK = -L$(OPENSSLDIR)/$(lib) $(CC_LD_DYNPATH)$(OPENSSLDIR)/$(lib)
-        else
-                OPENSSL_LINK =
-        endif
-else
-        BASIC_CFLAGS += -DNO_OPENSSL
-        MOZILLA_SHA1 = 1
-        OPENSSL_LIBSSL =
-endif
-ifdef NEEDS_SSL_WITH_CRYPTO
-        LIB_4_CRYPTO = $(OPENSSL_LINK) -lcrypto -lssl
-else
-        LIB_4_CRYPTO = $(OPENSSL_LINK) -lcrypto
-endif
-ifdef NEEDS_LIBICONV
-        ifdef ICONVDIR
-                BASIC_CFLAGS += -I$(ICONVDIR)/include
-                ICONV_LINK = -L$(ICONVDIR)/$(lib) $(CC_LD_DYNPATH)$(ICONVDIR)/$(lib)
-        else
-                ICONV_LINK =
-        endif
-        EXTLIBS += $(ICONV_LINK) -liconv
-endif
 ifdef NEEDS_SOCKET
         EXTLIBS += -lsocket
 endif
@@ -977,10 +413,6 @@ ifdef NO_STRCASESTR
         COMPAT_CFLAGS += -DNO_STRCASESTR
         COMPAT_OBJS += compat/strcasestr.o
 endif
-ifdef NO_STRLCPY
-        COMPAT_CFLAGS += -DNO_STRLCPY
-        COMPAT_OBJS += compat/strlcpy.o
-endif
 ifdef NO_STRTOUMAX
         COMPAT_CFLAGS += -DNO_STRTOUMAX
         COMPAT_OBJS += compat/strtoumax.o
@@ -1090,17 +522,6 @@ ifdef RUNTIME_PREFIX
         COMPAT_CFLAGS += -DRUNTIME_PREFIX
 endif
 
-ifdef NO_PTHREADS
-        THREADED_DELTA_SEARCH =
-        BASIC_CFLAGS += -DNO_PTHREADS
-else
-        EXTLIBS += $(PTHREAD_LIBS)
-endif
-
-ifdef THREADED_DELTA_SEARCH
-        BASIC_CFLAGS += -DTHREADED_DELTA_SEARCH
-        LIB_OBJS += thread-utils.o
-endif
 ifdef DIR_HAS_BSD_GROUP_SEMANTICS
         COMPAT_CFLAGS += -DDIR_HAS_BSD_GROUP_SEMANTICS
 endif
@@ -1148,14 +569,14 @@ endif
 # Shell quote (do not use $(call) to accommodate ancient setups);
 
 SHA1_HEADER_SQ = $(subst ','\'',$(SHA1_HEADER))
-ETC_GITCONFIG_SQ = $(subst ','\'',$(ETC_GITCONFIG))
+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))
-gitexecdir_SQ = $(subst ','\'',$(gitexecdir))
+perfexecdir_SQ = $(subst ','\'',$(perfexecdir))
 template_dir_SQ = $(subst ','\'',$(template_dir))
 htmldir_SQ = $(subst ','\'',$(htmldir))
 prefix_SQ = $(subst ','\'',$(prefix))
@@ -1164,7 +585,7 @@ SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))
 PERL_PATH_SQ = $(subst ','\'',$(PERL_PATH))
 TCLTK_PATH_SQ = $(subst ','\'',$(TCLTK_PATH))
 
-LIBS = $(GITLIBS) $(EXTLIBS)
+LIBS = $(PERFLIBS) $(EXTLIBS)
 
 BASIC_CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER_SQ)' \
         $(COMPAT_CFLAGS)
@@ -1180,15 +601,15 @@ export TAR INSTALL DESTDIR SHELL_PATH
 
 SHELL = $(SHELL_PATH)
 
-all:: shell_compatibility_test $(ALL_PROGRAMS) $(BUILT_INS) $(OTHER_PROGRAMS) GIT-BUILD-OPTIONS
+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) git$X)), test '$p' -ef '$p$X' || $(RM) '$p';)
+        $(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) perf$X)), test '$p' -ef '$p$X' || $(RM) '$p';)
 endif
 
 all::
 ifndef NO_TCLTK
-        $(QUIET_SUBDIR0)git-gui $(QUIET_SUBDIR1) gitexecdir='$(gitexec_instdir_SQ)' all
-        $(QUIET_SUBDIR0)gitk-git $(QUIET_SUBDIR1) all
+        $(QUIET_SUBDIR0)perf-gui $(QUIET_SUBDIR1) perfexecdir='$(perfexec_instdir_SQ)' all
+        $(QUIET_SUBDIR0)perfk-perf $(QUIET_SUBDIR1) all
 endif
 ifndef NO_PERL
         $(QUIET_SUBDIR0)perl $(QUIET_SUBDIR1) PERL_PATH='$(PERL_PATH_SQ)' prefix='$(prefix_SQ)' all
@@ -1200,33 +621,33 @@ please_set_SHELL_PATH_to_a_more_modern_shell:
 
 shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell
 
-strip: $(PROGRAMS) git$X
-        $(STRIP) $(STRIP_OPTS) $(PROGRAMS) git$X
+strip: $(PROGRAMS) perf$X
+        $(STRIP) $(STRIP_OPTS) $(PROGRAMS) perf$X
 
-git.o: git.c common-cmds.h GIT-CFLAGS
-        $(QUIET_CC)$(CC) -DGIT_VERSION='"$(GIT_VERSION)"' \
-                '-DGIT_HTML_PATH="$(htmldir_SQ)"' \
+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,$^)
 
-git$X: git.o $(BUILTIN_OBJS) $(GITLIBS)
-        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ git.o \
+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 GIT-CFLAGS
+builtin-help.o: builtin-help.c common-cmds.h PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) \
-                '-DGIT_HTML_PATH="$(htmldir_SQ)"' \
-                '-DGIT_MAN_PATH="$(mandir_SQ)"' \
-                '-DGIT_INFO_PATH="$(infodir_SQ)"' $<
+                '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
+                '-DPERF_MAN_PATH="$(mandir_SQ)"' \
+                '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
 
-$(BUILT_INS): git$X
+$(BUILT_INS): perf$X
         $(QUIET_BUILT_IN)$(RM) $@ && \
-        ln git$X $@ 2>/dev/null || \
-        ln -s git$X $@ 2>/dev/null || \
-        cp git$X $@
+        ln perf$X $@ 2>/dev/null || \
+        ln -s perf$X $@ 2>/dev/null || \
+        cp perf$X $@
 
 common-cmds.h: ./generate-cmdlist.sh command-list.txt
 
-common-cmds.h: $(wildcard Documentation/git-*.txt)
+common-cmds.h: $(wildcard Documentation/perf-*.txt)
         $(QUIET_GEN)./generate-cmdlist.sh > $@+ && mv $@+ $@
 
 $(patsubst %.sh,%,$(SCRIPT_SH)) : % : %.sh
@@ -1234,152 +655,55 @@ $(patsubst %.sh,%,$(SCRIPT_SH)) : % : %.sh
         sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
             -e 's|@SHELL_PATH@|$(SHELL_PATH_SQ)|' \
             -e 's|@@PERL@@|$(PERL_PATH_SQ)|g' \
-            -e 's/@@GIT_VERSION@@/$(GIT_VERSION)/g' \
+            -e 's/@@PERF_VERSION@@/$(PERF_VERSION)/g' \
             -e 's/@@NO_CURL@@/$(NO_CURL)/g' \
             $@.sh >$@+ && \
         chmod +x $@+ && \
         mv $@+ $@
 
-ifndef NO_PERL
-$(patsubst %.perl,%,$(SCRIPT_PERL)): perl/perl.mak
-
-perl/perl.mak: GIT-CFLAGS perl/Makefile perl/Makefile.PL
-        $(QUIET_SUBDIR0)perl $(QUIET_SUBDIR1) PERL_PATH='$(PERL_PATH_SQ)' prefix='$(prefix_SQ)' $(@F)
-
-$(patsubst %.perl,%,$(SCRIPT_PERL)): % : %.perl
-        $(QUIET_GEN)$(RM) $@ $@+ && \
-        INSTLIBDIR=`MAKEFLAGS= $(MAKE) -C perl -s --no-print-directory instlibdir` && \
-        sed -e '1{' \
-            -e '        s|#!.*perl|#!$(PERL_PATH_SQ)|' \
-            -e '        h' \
-            -e '        s=.*=use lib (split(/:/, $$ENV{GITPERLLIB} || "@@INSTLIBDIR@@"));=' \
-            -e '        H' \
-            -e '        x' \
-            -e '}' \
-            -e 's|@@INSTLIBDIR@@|'"$$INSTLIBDIR"'|g' \
-            -e 's/@@GIT_VERSION@@/$(GIT_VERSION)/g' \
-            $@.perl >$@+ && \
-        chmod +x $@+ && \
-        mv $@+ $@
-
-gitweb/gitweb.cgi: gitweb/gitweb.perl
-        $(QUIET_GEN)$(RM) $@ $@+ && \
-        sed -e '1s|#!.*perl|#!$(PERL_PATH_SQ)|' \
-            -e 's|++GIT_VERSION++|$(GIT_VERSION)|g' \
-            -e 's|++GIT_BINDIR++|$(bindir)|g' \
-            -e 's|++GITWEB_CONFIG++|$(GITWEB_CONFIG)|g' \
-            -e 's|++GITWEB_CONFIG_SYSTEM++|$(GITWEB_CONFIG_SYSTEM)|g' \
-            -e 's|++GITWEB_HOME_LINK_STR++|$(GITWEB_HOME_LINK_STR)|g' \
-            -e 's|++GITWEB_SITENAME++|$(GITWEB_SITENAME)|g' \
-            -e 's|++GITWEB_PROJECTROOT++|$(GITWEB_PROJECTROOT)|g' \
-            -e 's|"++GITWEB_PROJECT_MAXDEPTH++"|$(GITWEB_PROJECT_MAXDEPTH)|g' \
-            -e 's|++GITWEB_EXPORT_OK++|$(GITWEB_EXPORT_OK)|g' \
-            -e 's|++GITWEB_STRICT_EXPORT++|$(GITWEB_STRICT_EXPORT)|g' \
-            -e 's|++GITWEB_BASE_URL++|$(GITWEB_BASE_URL)|g' \
-            -e 's|++GITWEB_LIST++|$(GITWEB_LIST)|g' \
-            -e 's|++GITWEB_HOMETEXT++|$(GITWEB_HOMETEXT)|g' \
-            -e 's|++GITWEB_CSS++|$(GITWEB_CSS)|g' \
-            -e 's|++GITWEB_LOGO++|$(GITWEB_LOGO)|g' \
-            -e 's|++GITWEB_FAVICON++|$(GITWEB_FAVICON)|g' \
-            -e 's|++GITWEB_SITE_HEADER++|$(GITWEB_SITE_HEADER)|g' \
-            -e 's|++GITWEB_SITE_FOOTER++|$(GITWEB_SITE_FOOTER)|g' \
-            $< >$@+ && \
-        chmod +x $@+ && \
-        mv $@+ $@
-
-git-instaweb: git-instaweb.sh gitweb/gitweb.cgi gitweb/gitweb.css
-        $(QUIET_GEN)$(RM) $@ $@+ && \
-        sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
-            -e 's/@@GIT_VERSION@@/$(GIT_VERSION)/g' \
-            -e 's/@@NO_CURL@@/$(NO_CURL)/g' \
-            -e '/@@GITWEB_CGI@@/r gitweb/gitweb.cgi' \
-            -e '/@@GITWEB_CGI@@/d' \
-            -e '/@@GITWEB_CSS@@/r gitweb/gitweb.css' \
-            -e '/@@GITWEB_CSS@@/d' \
-            -e 's|@@PERL@@|$(PERL_PATH_SQ)|g' \
-            $@.sh > $@+ && \
-        chmod +x $@+ && \
-        mv $@+ $@
-else # NO_PERL
-$(patsubst %.perl,%,$(SCRIPT_PERL)) git-instaweb: % : unimplemented.sh
-        $(QUIET_GEN)$(RM) $@ $@+ && \
-        sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
-            -e 's|@@REASON@@|NO_PERL=$(NO_PERL)|g' \
-            unimplemented.sh >$@+ && \
-        chmod +x $@+ && \
-        mv $@+ $@
-endif # NO_PERL
-
 configure: configure.ac
         $(QUIET_GEN)$(RM) $@ $<+ && \
-        sed -e 's/@@GIT_VERSION@@/$(GIT_VERSION)/g' \
+        sed -e 's/@@PERF_VERSION@@/$(PERF_VERSION)/g' \
             $< > $<+ && \
         autoconf -o $@ $<+ && \
         $(RM) $<+
 
-# These can record GIT_VERSION
-git.o git.spec \
+# These can record PERF_VERSION
+perf.o perf.spec \
         $(patsubst %.sh,%,$(SCRIPT_SH)) \
         $(patsubst %.perl,%,$(SCRIPT_PERL)) \
-        : GIT-VERSION-FILE
+        : PERF-VERSION-FILE
 
-%.o: %.c GIT-CFLAGS
+%.o: %.c PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) $<
-%.s: %.c GIT-CFLAGS
+%.s: %.c PERF-CFLAGS
         $(QUIET_CC)$(CC) -S $(ALL_CFLAGS) $<
 %.o: %.S
         $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) $<
 
-exec_cmd.o: exec_cmd.c GIT-CFLAGS
+exec_cmd.o: exec_cmd.c PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) \
-                '-DGIT_EXEC_PATH="$(gitexecdir_SQ)"' \
+                '-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
                 '-DBINDIR="$(bindir_relative_SQ)"' \
                 '-DPREFIX="$(prefix_SQ)"' \
                 $<
 
-builtin-init-db.o: builtin-init-db.c GIT-CFLAGS
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DDEFAULT_GIT_TEMPLATE_DIR='"$(template_dir_SQ)"' $<
-
-config.o: config.c GIT-CFLAGS
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DETC_GITCONFIG='"$(ETC_GITCONFIG_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)"' $<
 
-http.o: http.c GIT-CFLAGS
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DGIT_USER_AGENT='"git/$(GIT_VERSION)"' $<
+config.o: config.c PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
-ifdef NO_EXPAT
-http-walker.o: http-walker.c http.h GIT-CFLAGS
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DNO_EXPAT $<
-endif
-
-git-%$X: %.o $(GITLIBS)
+perf-%$X: %.o $(PERFLIBS)
         $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)
 
-git-imap-send$X: imap-send.o $(GITLIBS)
-        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \
-                $(LIBS) $(OPENSSL_LINK) $(OPENSSL_LIBSSL)
-
-http.o http-walker.o http-push.o transport.o: http.h
-
-git-http-push$X: revision.o http.o http-push.o $(GITLIBS)
-        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \
-                $(LIBS) $(CURL_LIBCURL) $(EXPAT_LIBEXPAT)
-
 $(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
-$(patsubst git-%$X,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.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)
 
-XDIFF_OBJS=xdiff/xdiffi.o xdiff/xprepare.o xdiff/xutils.o xdiff/xemit.o \
-        xdiff/xmerge.o xdiff/xpatience.o
-$(XDIFF_OBJS): xdiff/xinclude.h xdiff/xmacros.h xdiff/xdiff.h xdiff/xtypes.h \
-        xdiff/xutils.h xdiff/xprepare.h xdiff/xdiffi.h xdiff/xemit.h
-
-$(XDIFF_LIB): $(XDIFF_OBJS)
-        $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(XDIFF_OBJS)
-
-
 doc:
         $(MAKE) -C Documentation all
 
@@ -1409,19 +733,19 @@ cscope:
 
 ### Detect prefix changes
 TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\
-             $(bindir_SQ):$(gitexecdir_SQ):$(template_dir_SQ):$(prefix_SQ)
+             $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ)
 
-GIT-CFLAGS: .FORCE-GIT-CFLAGS
+PERF-CFLAGS: .FORCE-PERF-CFLAGS
         @FLAGS='$(TRACK_CFLAGS)'; \
-            if test x"$$FLAGS" != x"`cat GIT-CFLAGS 2>/dev/null`" ; then \
+            if test x"$$FLAGS" != x"`cat PERF-CFLAGS 2>/dev/null`" ; then \
                 echo 1>&2 "    * new build flags or prefix"; \
-                echo "$$FLAGS" >GIT-CFLAGS; \
+                echo "$$FLAGS" >PERF-CFLAGS; \
             fi
 
 # We need to apply sq twice, once to protect from the shell
-# that runs GIT-BUILD-OPTIONS, and then again to protect it
+# that runs PERF-BUILD-OPTIONS, and then again to protect it
 # and the first level quoting from the shell that runs "echo".
-GIT-BUILD-OPTIONS: .FORCE-GIT-BUILD-OPTIONS
+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)))'\' >>$@
@@ -1431,14 +755,14 @@ GIT-BUILD-OPTIONS: .FORCE-GIT-BUILD-OPTIONS
 ifndef NO_TCLTK
 TRACK_VARS = $(subst ','\'',-DTCLTK_PATH='$(TCLTK_PATH_SQ)')
 
-GIT-GUI-VARS: .FORCE-GIT-GUI-VARS
+PERF-GUI-VARS: .FORCE-PERF-GUI-VARS
         @VARS='$(TRACK_VARS)'; \
             if test x"$$VARS" != x"`cat $@ 2>/dev/null`" ; then \
                 echo 1>&2 "    * new Tcl/Tk interpreter location"; \
                 echo "$$VARS" >$@; \
             fi
 
-.PHONY: .FORCE-GIT-GUI-VARS
+.PHONY: .FORCE-PERF-GUI-VARS
 endif
 
 ### Testing rules
@@ -1476,7 +800,7 @@ test-parse-options$X: parse-options.o
 
 .PRECIOUS: $(patsubst test-%$X,test-%.o,$(TEST_PROGRAMS))
 
-test-%$X: test-%.o $(GITLIBS)
+test-%$X: test-%.o $(PERFLIBS)
         $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)
 
 check-sha1:: test-sha1$X
@@ -1506,40 +830,40 @@ template_instdir = $(prefix)/$(template_dir)
 endif
 export template_instdir
 
-ifneq ($(filter /%,$(firstword $(gitexecdir))),)
-gitexec_instdir = $(gitexecdir)
+ifneq ($(filter /%,$(firstword $(perfexecdir))),)
+perfexec_instdir = $(perfexecdir)
 else
-gitexec_instdir = $(prefix)/$(gitexecdir)
+perfexec_instdir = $(prefix)/$(perfexecdir)
 endif
-gitexec_instdir_SQ = $(subst ','\'',$(gitexec_instdir))
-export gitexec_instdir
+perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))
+export perfexec_instdir
 
 install: all
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'
-        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(gitexec_instdir_SQ)'
-        $(INSTALL) $(ALL_PROGRAMS) '$(DESTDIR_SQ)$(gitexec_instdir_SQ)'
-        $(INSTALL) git$X git-upload-pack$X git-receive-pack$X git-upload-archive$X git-shell$X git-cvsserver '$(DESTDIR_SQ)$(bindir_SQ)'
+        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
+        $(INSTALL) $(ALL_PROGRAMS) '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
+        $(INSTALL) perf$X perf-upload-pack$X perf-receive-pack$X perf-upload-archive$X perf-shell$X perf-cvsserver '$(DESTDIR_SQ)$(bindir_SQ)'
         $(MAKE) -C templates DESTDIR='$(DESTDIR_SQ)' install
         $(MAKE) -C perl prefix='$(prefix_SQ)' DESTDIR='$(DESTDIR_SQ)' install
 ifndef NO_TCLTK
-        $(MAKE) -C gitk-git install
-        $(MAKE) -C git-gui gitexecdir='$(gitexec_instdir_SQ)' install
+        $(MAKE) -C perfk-perf install
+        $(MAKE) -C perf-gui perfexecdir='$(perfexec_instdir_SQ)' install
 endif
 ifneq (,$X)
-        $(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) git$X)), $(RM) '$(DESTDIR_SQ)$(gitexec_instdir_SQ)/$p';)
+        $(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) perf$X)), $(RM) '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/$p';)
 endif
         bindir=$$(cd '$(DESTDIR_SQ)$(bindir_SQ)' && pwd) && \
-        execdir=$$(cd '$(DESTDIR_SQ)$(gitexec_instdir_SQ)' && pwd) && \
-        { $(RM) "$$execdir/git-add$X" && \
-                ln "$$bindir/git$X" "$$execdir/git-add$X" 2>/dev/null || \
-                cp "$$bindir/git$X" "$$execdir/git-add$X"; } && \
-        { for p in $(filter-out git-add$X,$(BUILT_INS)); do \
+        execdir=$$(cd '$(DESTDIR_SQ)$(perfexec_instdir_SQ)' && pwd) && \
+        { $(RM) "$$execdir/perf-add$X" && \
+                ln "$$bindir/perf$X" "$$execdir/perf-add$X" 2>/dev/null || \
+                cp "$$bindir/perf$X" "$$execdir/perf-add$X"; } && \
+        { for p in $(filter-out perf-add$X,$(BUILT_INS)); do \
                 $(RM) "$$execdir/$$p" && \
-                ln "$$execdir/git-add$X" "$$execdir/$$p" 2>/dev/null || \
-                ln -s "git-add$X" "$$execdir/$$p" 2>/dev/null || \
-                cp "$$execdir/git-add$X" "$$execdir/$$p" || exit; \
+                ln "$$execdir/perf-add$X" "$$execdir/$$p" 2>/dev/null || \
+                ln -s "perf-add$X" "$$execdir/$$p" 2>/dev/null || \
+                cp "$$execdir/perf-add$X" "$$execdir/$$p" || exit; \
           done } && \
-        ./check_bindir "z$$bindir" "z$$execdir" "$$bindir/git-add$X"
+        ./check_bindir "z$$bindir" "z$$execdir" "$$bindir/perf-add$X"
 
 install-doc:
         $(MAKE) -C Documentation install
@@ -1569,31 +893,31 @@ quick-install-html:
 
 ### Maintainer's dist rules
 
-git.spec: git.spec.in
-        sed -e 's/@@VERSION@@/$(GIT_VERSION)/g' < $< > $@+
+perf.spec: perf.spec.in
+        sed -e 's/@@VERSION@@/$(PERF_VERSION)/g' < $< > $@+
         mv $@+ $@
 
-GIT_TARNAME=git-$(GIT_VERSION)
-dist: git.spec git-archive$(X) configure
-        ./git-archive --format=tar \
-                --prefix=$(GIT_TARNAME)/ HEAD^{tree} > $(GIT_TARNAME).tar
-        @mkdir -p $(GIT_TARNAME)
-        @cp git.spec configure $(GIT_TARNAME)
-        @echo $(GIT_VERSION) > $(GIT_TARNAME)/version
-        @$(MAKE) -C git-gui TARDIR=../$(GIT_TARNAME)/git-gui dist-version
-        $(TAR) rf $(GIT_TARNAME).tar \
-                $(GIT_TARNAME)/git.spec \
-                $(GIT_TARNAME)/configure \
-                $(GIT_TARNAME)/version \
-                $(GIT_TARNAME)/git-gui/version
-        @$(RM) -r $(GIT_TARNAME)
-        gzip -f -9 $(GIT_TARNAME).tar
+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
+        @$(MAKE) -C perf-gui TARDIR=../$(PERF_TARNAME)/perf-gui dist-version
+        $(TAR) rf $(PERF_TARNAME).tar \
+                $(PERF_TARNAME)/perf.spec \
+                $(PERF_TARNAME)/configure \
+                $(PERF_TARNAME)/version \
+                $(PERF_TARNAME)/perf-gui/version
+        @$(RM) -r $(PERF_TARNAME)
+        gzip -f -9 $(PERF_TARNAME).tar
 
 rpm: dist
-        $(RPMBUILD) -ta $(GIT_TARNAME).tar.gz
+        $(RPMBUILD) -ta $(PERF_TARNAME).tar.gz
 
-htmldocs = git-htmldocs-$(GIT_VERSION)
-manpages = git-manpages-$(GIT_VERSION)
+htmldocs = perf-htmldocs-$(PERF_VERSION)
+manpages = perf-manpages-$(PERF_VERSION)
 dist-doc:
         $(RM) -r .doc-tmp-dir
         mkdir .doc-tmp-dir
@@ -1618,51 +942,46 @@ distclean: clean
         $(RM) configure
 
 clean:
-        $(RM) *.o mozilla-sha1/*.o arm/*.o ppc/*.o compat/*.o xdiff/*.o \
-                $(LIB_FILE) $(XDIFF_LIB)
-        $(RM) $(ALL_PROGRAMS) $(BUILT_INS) git$X
+        $(RM) *.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 $(GIT_TARNAME) .doc-tmp-dir
-        $(RM) $(GIT_TARNAME).tar.gz git-core_$(GIT_VERSION)-*.tar.gz
+        $(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
-ifndef NO_PERL
-        $(RM) gitweb/gitweb.cgi
-        $(MAKE) -C perl clean
-endif
         $(MAKE) -C templates/ clean
         $(MAKE) -C t/ clean
 ifndef NO_TCLTK
-        $(MAKE) -C gitk-git clean
-        $(MAKE) -C git-gui clean
+        $(MAKE) -C perfk-perf clean
+        $(MAKE) -C perf-gui clean
 endif
-        $(RM) GIT-VERSION-FILE GIT-CFLAGS GIT-GUI-VARS GIT-BUILD-OPTIONS
+        $(RM) PERF-VERSION-FILE PERF-CFLAGS PERF-GUI-VARS PERF-BUILD-OPTIONS
 
 .PHONY: all install clean strip
 .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
-.PHONY: .FORCE-GIT-VERSION-FILE TAGS tags cscope .FORCE-GIT-CFLAGS
-.PHONY: .FORCE-GIT-BUILD-OPTIONS
+.PHONY: .FORCE-PERF-VERSION-FILE TAGS tags cscope .FORCE-PERF-CFLAGS
+.PHONY: .FORCE-PERF-BUILD-OPTIONS
 
 ### Check documentation
 #
 check-docs::
-        @(for v in $(ALL_PROGRAMS) $(BUILT_INS) git gitk; \
+        @(for v in $(ALL_PROGRAMS) $(BUILT_INS) perf perfk; \
         do \
                 case "$$v" in \
-                git-merge-octopus | git-merge-ours | git-merge-recursive | \
-                git-merge-resolve | git-merge-subtree | \
-                git-fsck-objects | git-init-db | \
-                git-?*--?* ) continue ;; \
+                perf-merge-octopus | perf-merge-ours | perf-merge-recursive | \
+                perf-merge-resolve | perf-merge-subtree | \
+                perf-fsck-objects | perf-init-db | \
+                perf-?*--?* ) continue ;; \
                 esac ; \
                 test -f "Documentation/$$v.txt" || \
                 echo "no doc: $$v"; \
                 sed -e '/^#/d' command-list.txt | \
                 grep -q "^$$v[  ]" || \
                 case "$$v" in \
-                git) ;; \
+                perf) ;; \
                 *) echo "no link: $$v";; \
                 esac ; \
         done; \
@@ -1670,37 +989,37 @@ check-docs::
                 sed -e '/^#/d' \
                     -e 's/[     ].*//' \
                     -e 's/^/listed /' command-list.txt; \
-                ls -1 Documentation/git*txt | \
+                ls -1 Documentation/perf*txt | \
                 sed -e 's|Documentation/|documented |' \
                     -e 's/\.txt//'; \
         ) | while read how cmd; \
         do \
                 case "$$how,$$cmd" in \
-                *,git-citool | \
-                *,git-gui | \
-                *,git-help | \
-                documented,gitattributes | \
-                documented,gitignore | \
-                documented,gitmodules | \
-                documented,gitcli | \
-                documented,git-tools | \
-                documented,gitcore-tutorial | \
-                documented,gitcvs-migration | \
-                documented,gitdiffcore | \
-                documented,gitglossary | \
-                documented,githooks | \
-                documented,gitrepository-layout | \
-                documented,gittutorial | \
-                documented,gittutorial-2 | \
+                *,perf-citool | \
+                *,perf-gui | \
+                *,perf-help | \
+                documented,perfattributes | \
+                documented,perfignore | \
+                documented,perfmodules | \
+                documented,perfcli | \
+                documented,perf-tools | \
+                documented,perfcore-tutorial | \
+                documented,perfcvs-migration | \
+                documented,perfdiffcore | \
+                documented,perfglossary | \
+                documented,perfhooks | \
+                documented,perfrepository-layout | \
+                documented,perftutorial | \
+                documented,perftutorial-2 | \
                 sentinel,not,matching,is,ok ) continue ;; \
                 esac; \
-                case " $(ALL_PROGRAMS) $(BUILT_INS) git gitk " in \
+                case " $(ALL_PROGRAMS) $(BUILT_INS) perf perfk " in \
                 *" $$cmd "*)    ;; \
                 *) echo "removed but $$how: $$cmd" ;; \
                 esac; \
         done ) | sort
 
-### Make sure built-ins do not have dups and listed in git.c
+### Make sure built-ins do not have dups and listed in perf.c
 #
 check-builtins::
         ./check-builtins.sh
diff --git a/Documentation/perf_counter/PERF-BUILD-OPTIONS b/Documentation/perf_counter/PERF-BUILD-OPTIONS
new file mode 100644
index 000000000000..46d8d6ceb2f4
--- /dev/null
+++ b/Documentation/perf_counter/PERF-BUILD-OPTIONS
@@ -0,0 +1,4 @@
+SHELL_PATH='/bin/sh'
+TAR='tar'
+NO_CURL=''
+NO_PERL=''
diff --git a/Documentation/perf_counter/PERF-CFLAGS b/Documentation/perf_counter/PERF-CFLAGS
new file mode 100644
index 000000000000..f24906ca688d
--- /dev/null
+++ b/Documentation/perf_counter/PERF-CFLAGS
@@ -0,0 +1 @@
+-g -O2 -Wall  -DSHA1_HEADER='<openssl/sha.h>' : /home/mingo/bin:libexec/perf-core:share/perf-core/templates:/home/mingo
diff --git a/Documentation/perf_counter/PERF-VERSION-FILE b/Documentation/perf_counter/PERF-VERSION-FILE
new file mode 100644
index 000000000000..328e244c0c81
--- /dev/null
+++ b/Documentation/perf_counter/PERF-VERSION-FILE
@@ -0,0 +1 @@
+PERF_VERSION = 0.0.1.PERF
diff --git a/Documentation/perf_counter/PERF-VERSION-GEN b/Documentation/perf_counter/PERF-VERSION-GEN
new file mode 100755
index 000000000000..c561d1538c03
--- /dev/null
+++ b/Documentation/perf_counter/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/Documentation/perf_counter/abspath.c b/Documentation/perf_counter/abspath.c
new file mode 100644
index 000000000000..649f34f83365
--- /dev/null
+++ b/Documentation/perf_counter/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.
+ */
+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/Documentation/perf_counter/alias.c b/Documentation/perf_counter/alias.c
new file mode 100644
index 000000000000..9b3dd2b428df
--- /dev/null
+++ b/Documentation/perf_counter/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)
+{
+        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/Documentation/perf_counter/builtin-help.c b/Documentation/perf_counter/builtin-help.c
new file mode 100644
index 000000000000..125fcc2f4901
--- /dev/null
+++ b/Documentation/perf_counter/builtin-help.c
@@ -0,0 +1,463 @@
+/*
+ * builtin-help.c
+ *
+ * Builtin help command
+ */
+#include "cache.h"
+#include "builtin.h"
+#include "exec_cmd.h"
+#include "common-cmds.h"
+#include "parse-options.h"
+#include "run-command.h"
+#include "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)
+{
+        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
+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)
+{
+        int nonperf;
+        const char *alias;
+        load_command_list("perf-", &main_cmds, &other_cmds);
+
+        /* setup_perf_directory_gently(&nonperf); */
+        perf_config(perf_help_config, NULL);
+
+        argc = parse_options(argc, argv, builtin_help_options,
+                        builtin_help_usage, 0);
+
+        if (show_all) {
+                printf("usage: %s\n\n", perf_usage_string);
+                list_commands("perf commands", &main_cmds, &other_cmds);
+                printf("%s\n", perf_more_info_string);
+                return 0;
+        }
+
+        if (!argv[0]) {
+                printf("usage: %s\n\n", perf_usage_string);
+                list_common_cmds_help();
+                printf("\n%s\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/Documentation/perf_counter/builtin-top.c b/Documentation/perf_counter/builtin-top.c
new file mode 100644
index 000000000000..9d2c769e5f83
--- /dev/null
+++ b/Documentation/perf_counter/builtin-top.c
@@ -0,0 +1,1411 @@
+/*
+ * kerneltop.c: show top kernel functions - performance counters showcase
+
+   Build with:
+
+     cc -O6 -Wall -c -o kerneltop.o kerneltop.c -lrt
+
+   Sample output:
+
+------------------------------------------------------------------------------
+ KernelTop:    2669 irqs/sec  [NMI, cache-misses/cache-refs],  (all, cpu: 2)
+------------------------------------------------------------------------------
+
+             weight         RIP          kernel function
+             ______   ________________   _______________
+
+              35.20 - ffffffff804ce74b : skb_copy_and_csum_dev
+              33.00 - ffffffff804cb740 : sock_alloc_send_skb
+              31.26 - ffffffff804ce808 : skb_push
+              22.43 - ffffffff80510004 : tcp_established_options
+              19.00 - ffffffff8027d250 : find_get_page
+              15.76 - ffffffff804e4fc9 : eth_type_trans
+              15.20 - ffffffff804d8baa : dst_release
+              14.86 - ffffffff804cf5d8 : skb_release_head_state
+              14.00 - ffffffff802217d5 : read_hpet
+              12.00 - ffffffff804ffb7f : __ip_local_out
+              11.97 - ffffffff804fc0c8 : ip_local_deliver_finish
+               8.54 - ffffffff805001a3 : ip_queue_xmit
+ */
+
+/*
+ * perfstat:  /usr/bin/time -alike performance counter statistics utility
+
+          It summarizes the counter events of all tasks (and child tasks),
+          covering all CPUs that the command (or workload) executes on.
+          It only counts the per-task events of the workload started,
+          independent of how many other tasks run on those CPUs.
+
+   Sample output:
+
+   $ ./perfstat -e 1 -e 3 -e 5 ls -lR /usr/include/ >/dev/null
+
+   Performance counter stats for 'ls':
+
+           163516953 instructions
+                2295 cache-misses
+             2855182 branch-misses
+ */
+
+ /*
+  * 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 "util.h"
+
+#define _GNU_SOURCE
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <getopt.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <ctype.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>
+
+#include "../../include/linux/perf_counter.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
+
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+#define rdclock()                                       \
+({                                                      \
+        struct timespec ts;                             \
+                                                        \
+        clock_gettime(CLOCK_MONOTONIC, &ts);            \
+        ts.tv_sec * 1000000000ULL + ts.tv_nsec;         \
+})
+
+/*
+ * Pick up some kernel type conventions:
+ */
+#define __user
+#define asmlinkage
+
+#ifdef __x86_64__
+#define __NR_perf_counter_open 295
+#define rmb()           asm volatile("lfence" ::: "memory")
+#define cpu_relax()     asm volatile("rep; nop" ::: "memory");
+#endif
+
+#ifdef __i386__
+#define __NR_perf_counter_open 333
+#define rmb()           asm volatile("lfence" ::: "memory")
+#define cpu_relax()     asm volatile("rep; nop" ::: "memory");
+#endif
+
+#ifdef __powerpc__
+#define __NR_perf_counter_open 319
+#define rmb()           asm volatile ("sync" ::: "memory")
+#define cpu_relax()     asm volatile ("" ::: "memory");
+#endif
+
+#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; })
+
+asmlinkage int sys_perf_counter_open(
+        struct perf_counter_hw_event    *hw_event_uptr          __user,
+        pid_t                           pid,
+        int                             cpu,
+        int                             group_fd,
+        unsigned long                   flags)
+{
+        return syscall(
+                __NR_perf_counter_open, hw_event_uptr, pid, cpu, group_fd, flags);
+}
+
+#define MAX_COUNTERS                    64
+#define MAX_NR_CPUS                     256
+
+#define EID(type, id) (((__u64)(type) << PERF_COUNTER_TYPE_SHIFT) | (id))
+
+static int                      run_perfstat                    =  0;
+static int                      system_wide                     =  0;
+
+static int                      nr_counters                     =  0;
+static __u64                    event_id[MAX_COUNTERS]          = {
+        EID(PERF_TYPE_SOFTWARE, PERF_COUNT_TASK_CLOCK),
+        EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CONTEXT_SWITCHES),
+        EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_MIGRATIONS),
+        EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS),
+
+        EID(PERF_TYPE_HARDWARE, PERF_COUNT_CPU_CYCLES),
+        EID(PERF_TYPE_HARDWARE, PERF_COUNT_INSTRUCTIONS),
+        EID(PERF_TYPE_HARDWARE, PERF_COUNT_CACHE_REFERENCES),
+        EID(PERF_TYPE_HARDWARE, PERF_COUNT_CACHE_MISSES),
+};
+static int                      default_interval = 100000;
+static int                      event_count[MAX_COUNTERS];
+static int                      fd[MAX_NR_CPUS][MAX_COUNTERS];
+
+static __u64                    count_filter                   = 100;
+
+static int                      tid                             = -1;
+static int                      profile_cpu                     = -1;
+static int                      nr_cpus                         =  0;
+static int                      nmi                             =  1;
+static unsigned int             realtime_prio                   =  0;
+static int                      group                           =  0;
+static unsigned int             page_size;
+static unsigned int             mmap_pages                      =  16;
+static int                      use_mmap                        = 0;
+static int                      use_munmap                      = 0;
+
+static char                     *vmlinux;
+
+static char                     *sym_filter;
+static unsigned long            filter_start;
+static unsigned long            filter_end;
+
+static int                      delay_secs                      =  2;
+static int                      zero;
+static int                      dump_symtab;
+
+static int                      scale;
+
+struct source_line {
+        uint64_t                EIP;
+        unsigned long           count;
+        char                    *line;
+        struct source_line      *next;
+};
+
+static struct source_line       *lines;
+static struct source_line       **lines_tail;
+
+const unsigned int default_count[] = {
+        1000000,
+        1000000,
+          10000,
+          10000,
+        1000000,
+          10000,
+};
+
+static char *hw_event_names[] = {
+        "CPU cycles",
+        "instructions",
+        "cache references",
+        "cache misses",
+        "branches",
+        "branch misses",
+        "bus cycles",
+};
+
+static char *sw_event_names[] = {
+        "cpu clock ticks",
+        "task clock ticks",
+        "pagefaults",
+        "context switches",
+        "CPU migrations",
+        "minor faults",
+        "major faults",
+};
+
+struct event_symbol {
+        __u64 event;
+        char *symbol;
+};
+
+static struct event_symbol event_symbols[] = {
+        {EID(PERF_TYPE_HARDWARE, PERF_COUNT_CPU_CYCLES),                "cpu-cycles",           },
+        {EID(PERF_TYPE_HARDWARE, PERF_COUNT_CPU_CYCLES),                "cycles",               },
+        {EID(PERF_TYPE_HARDWARE, PERF_COUNT_INSTRUCTIONS),              "instructions",         },
+        {EID(PERF_TYPE_HARDWARE, PERF_COUNT_CACHE_REFERENCES),          "cache-references",     },
+        {EID(PERF_TYPE_HARDWARE, PERF_COUNT_CACHE_MISSES),              "cache-misses",         },
+        {EID(PERF_TYPE_HARDWARE, PERF_COUNT_BRANCH_INSTRUCTIONS),       "branch-instructions",  },
+        {EID(PERF_TYPE_HARDWARE, PERF_COUNT_BRANCH_INSTRUCTIONS),       "branches",             },
+        {EID(PERF_TYPE_HARDWARE, PERF_COUNT_BRANCH_MISSES),             "branch-misses",        },
+        {EID(PERF_TYPE_HARDWARE, PERF_COUNT_BUS_CYCLES),                "bus-cycles",           },
+
+        {EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_CLOCK),                 "cpu-clock",            },
+        {EID(PERF_TYPE_SOFTWARE, PERF_COUNT_TASK_CLOCK),                "task-clock",           },
+        {EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS),               "page-faults",          },
+        {EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS),               "faults",               },
+        {EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS_MIN),           "minor-faults",         },
+        {EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS_MAJ),           "major-faults",         },
+        {EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CONTEXT_SWITCHES),          "context-switches",     },
+        {EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CONTEXT_SWITCHES),          "cs",                   },
+        {EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_MIGRATIONS),            "cpu-migrations",       },
+        {EID(PERF_TYPE_SOFTWARE, PERF_COUNT_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 void display_events_help(void)
+{
+        unsigned int i;
+        __u64 e;
+
+        printf(
+        " -e EVENT     --event=EVENT   #  symbolic-name        abbreviations");
+
+        for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
+                int type, id;
+
+                e = event_symbols[i].event;
+                type = PERF_COUNTER_TYPE(e);
+                id = PERF_COUNTER_ID(e);
+
+                printf("\n                             %d:%d: %-20s",
+                                type, id, event_symbols[i].symbol);
+        }
+
+        printf("\n"
+        "                           rNNN: raw PMU events (eventsel+umask)\n\n");
+}
+
+static void display_perfstat_help(void)
+{
+        printf(
+        "Usage: perfstat [<events...>] <cmd...>\n\n"
+        "PerfStat Options (up to %d event types can be specified):\n\n",
+                 MAX_COUNTERS);
+
+        display_events_help();
+
+        printf(
+        " -l                           # scale counter values\n"
+        " -a                           # system-wide collection\n");
+        exit(0);
+}
+
+static void display_help(void)
+{
+        if (run_perfstat)
+                return display_perfstat_help();
+
+        printf(
+        "Usage: kerneltop [<options>]\n"
+        "   Or: kerneltop -S [<options>] COMMAND [ARGS]\n\n"
+        "KernelTop Options (up to %d event types can be specified at once):\n\n",
+                 MAX_COUNTERS);
+
+        display_events_help();
+
+        printf(
+        " -S        --stat             # perfstat COMMAND\n"
+        " -a                           # system-wide collection (for perfstat)\n\n"
+        " -c CNT    --count=CNT        # event period to sample\n\n"
+        " -C CPU    --cpu=CPU          # CPU (-1 for all)                 [default: -1]\n"
+        " -p PID    --pid=PID          # PID of sampled task (-1 for all) [default: -1]\n\n"
+        " -l                           # show scale factor for RR events\n"
+        " -d delay  --delay=<seconds>  # sampling/display delay           [default:  2]\n"
+        " -f CNT    --filter=CNT       # min-event-count filter          [default: 100]\n\n"
+        " -r prio   --realtime=<prio>  # event acquisition runs with SCHED_FIFO policy\n"
+        " -s symbol --symbol=<symbol>  # function to be showed annotated one-shot\n"
+        " -x path   --vmlinux=<path>   # the vmlinux binary, required for -s use\n"
+        " -z        --zero             # zero counts after display\n"
+        " -D        --dump_symtab      # dump symbol table to stderr on startup\n"
+        " -m pages  --mmap_pages=<pages> # number of mmap data pages\n"
+        " -M        --mmap_info        # print mmap info stream\n"
+        " -U        --munmap_info      # print munmap info stream\n"
+        );
+
+        exit(0);
+}
+
+static char *event_name(int ctr)
+{
+        __u64 config = event_id[ctr];
+        int type = PERF_COUNTER_TYPE(config);
+        int id = PERF_COUNTER_ID(config);
+        static char buf[32];
+
+        if (PERF_COUNTER_RAW(config)) {
+                sprintf(buf, "raw 0x%llx", PERF_COUNTER_CONFIG(config));
+                return buf;
+        }
+
+        switch (type) {
+        case PERF_TYPE_HARDWARE:
+                if (id < PERF_HW_EVENTS_MAX)
+                        return hw_event_names[id];
+                return "unknown-hardware";
+
+        case PERF_TYPE_SOFTWARE:
+                if (id < PERF_SW_EVENTS_MAX)
+                        return sw_event_names[id];
+                return "unknown-software";
+
+        default:
+                break;
+        }
+
+        return "unknown";
+}
+
+/*
+ * Each event can have multiple symbolic names.
+ * Symbolic names are (almost) exactly matched.
+ */
+static __u64 match_event_symbols(char *str)
+{
+        __u64 config, id;
+        int type;
+        unsigned int i;
+
+        if (sscanf(str, "r%llx", &config) == 1)
+                return config | PERF_COUNTER_RAW_MASK;
+
+        if (sscanf(str, "%d:%llu", &type, &id) == 2)
+                return EID(type, id);
+
+        for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
+                if (!strncmp(str, event_symbols[i].symbol,
+                             strlen(event_symbols[i].symbol)))
+                        return event_symbols[i].event;
+        }
+
+        return ~0ULL;
+}
+
+static int parse_events(char *str)
+{
+        __u64 config;
+
+again:
+        if (nr_counters == MAX_COUNTERS)
+                return -1;
+
+        config = match_event_symbols(str);
+        if (config == ~0ULL)
+                return -1;
+
+        event_id[nr_counters] = config;
+        nr_counters++;
+
+        str = strstr(str, ",");
+        if (str) {
+                str++;
+                goto again;
+        }
+
+        return 0;
+}
+
+
+/*
+ * perfstat
+ */
+
+char fault_here[1000000];
+
+static void create_perfstat_counter(int counter)
+{
+        struct perf_counter_hw_event hw_event;
+
+        memset(&hw_event, 0, sizeof(hw_event));
+        hw_event.config         = event_id[counter];
+        hw_event.record_type    = 0;
+        hw_event.nmi            = 0;
+        if (scale)
+                hw_event.read_format    = PERF_FORMAT_TOTAL_TIME_ENABLED |
+                                          PERF_FORMAT_TOTAL_TIME_RUNNING;
+
+        if (system_wide) {
+                int cpu;
+                for (cpu = 0; cpu < nr_cpus; cpu ++) {
+                        fd[cpu][counter] = sys_perf_counter_open(&hw_event, -1, cpu, -1, 0);
+                        if (fd[cpu][counter] < 0) {
+                                printf("perfstat error: syscall returned with %d (%s)\n",
+                                                fd[cpu][counter], strerror(errno));
+                                exit(-1);
+                        }
+                }
+        } else {
+                hw_event.inherit        = 1;
+                hw_event.disabled       = 1;
+
+                fd[0][counter] = sys_perf_counter_open(&hw_event, 0, -1, -1, 0);
+                if (fd[0][counter] < 0) {
+                        printf("perfstat error: syscall returned with %d (%s)\n",
+                                        fd[0][counter], strerror(errno));
+                        exit(-1);
+                }
+        }
+}
+
+int do_perfstat(int argc, char *argv[])
+{
+        unsigned long long t0, t1;
+        int counter;
+        ssize_t res;
+        int status;
+        int pid;
+
+        if (!system_wide)
+                nr_cpus = 1;
+
+        for (counter = 0; counter < nr_counters; counter++)
+                create_perfstat_counter(counter);
+
+        argc -= optind;
+        argv += optind;
+
+        if (!argc)
+                display_help();
+
+        /*
+         * Enable counters and exec the command:
+         */
+        t0 = rdclock();
+        prctl(PR_TASK_PERF_COUNTERS_ENABLE);
+
+        if ((pid = fork()) < 0)
+                perror("failed to fork");
+        if (!pid) {
+                if (execvp(argv[0], argv)) {
+                        perror(argv[0]);
+                        exit(-1);
+                }
+        }
+        while (wait(&status) >= 0)
+                ;
+        prctl(PR_TASK_PERF_COUNTERS_DISABLE);
+        t1 = rdclock();
+
+        fflush(stdout);
+
+        fprintf(stderr, "\n");
+        fprintf(stderr, " Performance counter stats for \'%s\':\n",
+                argv[0]);
+        fprintf(stderr, "\n");
+
+        for (counter = 0; counter < nr_counters; counter++) {
+                int cpu, nv;
+                __u64 count[3], single_count[3];
+                int scaled;
+
+                count[0] = count[1] = count[2] = 0;
+                nv = scale ? 3 : 1;
+                for (cpu = 0; cpu < nr_cpus; cpu ++) {
+                        res = read(fd[cpu][counter],
+                                   single_count, nv * sizeof(__u64));
+                        assert(res == nv * sizeof(__u64));
+
+                        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) {
+                                fprintf(stderr, " %14s  %-20s\n",
+                                        "<not counted>", event_name(counter));
+                                continue;
+                        }
+                        if (count[2] < count[1]) {
+                                scaled = 1;
+                                count[0] = (unsigned long long)
+                                        ((double)count[0] * count[1] / count[2] + 0.5);
+                        }
+                }
+
+                if (event_id[counter] == EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_CLOCK) ||
+                    event_id[counter] == EID(PERF_TYPE_SOFTWARE, PERF_COUNT_TASK_CLOCK)) {
+
+                        double msecs = (double)count[0] / 1000000;
+
+                        fprintf(stderr, " %14.6f  %-20s (msecs)",
+                                msecs, event_name(counter));
+                } else {
+                        fprintf(stderr, " %14Ld  %-20s (events)",
+                                count[0], event_name(counter));
+                }
+                if (scaled)
+                        fprintf(stderr, "  (scaled from %.2f%%)",
+                                (double) count[2] / count[1] * 100);
+                fprintf(stderr, "\n");
+        }
+        fprintf(stderr, "\n");
+        fprintf(stderr, " Wall-clock time elapsed: %12.6f msecs\n",
+                        (double)(t1-t0)/1e6);
+        fprintf(stderr, "\n");
+
+        return 0;
+}
+
+/*
+ * Symbols
+ */
+
+static uint64_t                 min_ip;
+static uint64_t                 max_ip = -1ll;
+
+struct sym_entry {
+        unsigned long long      addr;
+        char                    *sym;
+        unsigned long           count[MAX_COUNTERS];
+        int                     skip;
+        struct source_line      *source;
+};
+
+#define MAX_SYMS                100000
+
+static int sym_table_count;
+
+struct sym_entry                *sym_filter_entry;
+
+static struct sym_entry         sym_table[MAX_SYMS];
+
+static void show_details(struct sym_entry *sym);
+
+/*
+ * Ordering weight: count-1 * count-2 * ... / count-n
+ */
+static double sym_weight(const struct sym_entry *sym)
+{
+        double weight;
+        int counter;
+
+        weight = sym->count[0];
+
+        for (counter = 1; counter < nr_counters-1; counter++)
+                weight *= sym->count[counter];
+
+        weight /= (sym->count[counter] + 1);
+
+        return weight;
+}
+
+static int compare(const void *__sym1, const void *__sym2)
+{
+        const struct sym_entry *sym1 = __sym1, *sym2 = __sym2;
+
+        return sym_weight(sym1) < sym_weight(sym2);
+}
+
+static long                     events;
+static long                     userspace_events;
+static const char               CONSOLE_CLEAR[] = "";
+
+static struct sym_entry         tmp[MAX_SYMS];
+
+static void print_sym_table(void)
+{
+        int i, printed;
+        int counter;
+        float events_per_sec = events/delay_secs;
+        float kevents_per_sec = (events-userspace_events)/delay_secs;
+        float sum_kevents = 0.0;
+
+        events = userspace_events = 0;
+        memcpy(tmp, sym_table, sizeof(sym_table[0])*sym_table_count);
+        qsort(tmp, sym_table_count, sizeof(tmp[0]), compare);
+
+        for (i = 0; i < sym_table_count && tmp[i].count[0]; i++)
+                sum_kevents += tmp[i].count[0];
+
+        write(1, CONSOLE_CLEAR, strlen(CONSOLE_CLEAR));
+
+        printf(
+"------------------------------------------------------------------------------\n");
+        printf( " KernelTop:%8.0f irqs/sec  kernel:%4.1f%% [%s, ",
+                events_per_sec,
+                100.0 - (100.0*((events_per_sec-kevents_per_sec)/events_per_sec)),
+                nmi ? "NMI" : "IRQ");
+
+        if (nr_counters == 1)
+                printf("%d ", event_count[0]);
+
+        for (counter = 0; counter < nr_counters; counter++) {
+                if (counter)
+                        printf("/");
+
+                printf("%s", event_name(counter));
+        }
+
+        printf( "], ");
+
+        if (tid != -1)
+                printf(" (tid: %d", tid);
+        else
+                printf(" (all");
+
+        if (profile_cpu != -1)
+                printf(", cpu: %d)\n", profile_cpu);
+        else {
+                if (tid != -1)
+                        printf(")\n");
+                else
+                        printf(", %d CPUs)\n", nr_cpus);
+        }
+
+        printf("------------------------------------------------------------------------------\n\n");
+
+        if (nr_counters == 1)
+                printf("             events    pcnt");
+        else
+                printf("  weight     events    pcnt");
+
+        printf("         RIP          kernel function\n"
+                       "  ______     ______   _____   ________________   _______________\n\n"
+        );
+
+        for (i = 0, printed = 0; i < sym_table_count; i++) {
+                float pcnt;
+                int count;
+
+                if (printed <= 18 && tmp[i].count[0] >= count_filter) {
+                        pcnt = 100.0 - (100.0*((sum_kevents-tmp[i].count[0])/sum_kevents));
+
+                        if (nr_counters == 1)
+                                printf("%19.2f - %4.1f%% - %016llx : %s\n",
+                                        sym_weight(tmp + i),
+                                        pcnt, tmp[i].addr, tmp[i].sym);
+                        else
+                                printf("%8.1f %10ld - %4.1f%% - %016llx : %s\n",
+                                        sym_weight(tmp + i),
+                                        tmp[i].count[0],
+                                        pcnt, tmp[i].addr, tmp[i].sym);
+                        printed++;
+                }
+                /*
+                 * Add decay to the counts:
+                 */
+                for (count = 0; count < nr_counters; count++)
+                        sym_table[i].count[count] = zero ? 0 : sym_table[i].count[count] * 7 / 8;
+        }
+
+        if (sym_filter_entry)
+                show_details(sym_filter_entry);
+
+        {
+                struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
+
+                if (poll(&stdin_poll, 1, 0) == 1) {
+                        printf("key pressed - exiting.\n");
+                        exit(0);
+                }
+        }
+}
+
+static void *display_thread(void *arg)
+{
+        printf("KernelTop refresh period: %d seconds\n", delay_secs);
+
+        while (!sleep(delay_secs))
+                print_sym_table();
+
+        return NULL;
+}
+
+static int read_symbol(FILE *in, struct sym_entry *s)
+{
+        static int filter_match = 0;
+        char *sym, stype;
+        char str[500];
+        int rc, pos;
+
+        rc = fscanf(in, "%llx %c %499s", &s->addr, &stype, str);
+        if (rc == EOF)
+                return -1;
+
+        assert(rc == 3);
+
+        /* skip until end of line: */
+        pos = strlen(str);
+        do {
+                rc = fgetc(in);
+                if (rc == '\n' || rc == EOF || pos >= 499)
+                        break;
+                str[pos] = rc;
+                pos++;
+        } while (1);
+        str[pos] = 0;
+
+        sym = str;
+
+        /* Filter out known duplicates and non-text symbols. */
+        if (!strcmp(sym, "_text"))
+                return 1;
+        if (!min_ip && !strcmp(sym, "_stext"))
+                return 1;
+        if (!strcmp(sym, "_etext") || !strcmp(sym, "_sinittext"))
+                return 1;
+        if (stype != 'T' && stype != 't')
+                return 1;
+        if (!strncmp("init_module", sym, 11) || !strncmp("cleanup_module", sym, 14))
+                return 1;
+        if (strstr(sym, "_text_start") || strstr(sym, "_text_end"))
+                return 1;
+
+        s->sym = malloc(strlen(str));
+        assert(s->sym);
+
+        strcpy((char *)s->sym, str);
+        s->skip = 0;
+
+        /* Tag events to be skipped. */
+        if (!strcmp("default_idle", s->sym) || !strcmp("cpu_idle", s->sym))
+                s->skip = 1;
+        else if (!strcmp("enter_idle", s->sym) || !strcmp("exit_idle", s->sym))
+                s->skip = 1;
+        else if (!strcmp("mwait_idle", s->sym))
+                s->skip = 1;
+
+        if (filter_match == 1) {
+                filter_end = s->addr;
+                filter_match = -1;
+                if (filter_end - filter_start > 10000) {
+                        printf("hm, too large filter symbol <%s> - skipping.\n",
+                                sym_filter);
+                        printf("symbol filter start: %016lx\n", filter_start);
+                        printf("                end: %016lx\n", filter_end);
+                        filter_end = filter_start = 0;
+                        sym_filter = NULL;
+                        sleep(1);
+                }
+        }
+        if (filter_match == 0 && sym_filter && !strcmp(s->sym, sym_filter)) {
+                filter_match = 1;
+                filter_start = s->addr;
+        }
+
+        return 0;
+}
+
+int compare_addr(const void *__sym1, const void *__sym2)
+{
+        const struct sym_entry *sym1 = __sym1, *sym2 = __sym2;
+
+        return sym1->addr > sym2->addr;
+}
+
+static void sort_symbol_table(void)
+{
+        int i, dups;
+
+        do {
+                qsort(sym_table, sym_table_count, sizeof(sym_table[0]), compare_addr);
+                for (i = 0, dups = 0; i < sym_table_count; i++) {
+                        if (sym_table[i].addr == sym_table[i+1].addr) {
+                                sym_table[i+1].addr = -1ll;
+                                dups++;
+                        }
+                }
+                sym_table_count -= dups;
+        } while(dups);
+}
+
+static void parse_symbols(void)
+{
+        struct sym_entry *last;
+
+        FILE *kallsyms = fopen("/proc/kallsyms", "r");
+
+        if (!kallsyms) {
+                printf("Could not open /proc/kallsyms - no CONFIG_KALLSYMS_ALL=y?\n");
+                exit(-1);
+        }
+
+        while (!feof(kallsyms)) {
+                if (read_symbol(kallsyms, &sym_table[sym_table_count]) == 0) {
+                        sym_table_count++;
+                        assert(sym_table_count <= MAX_SYMS);
+                }
+        }
+
+        sort_symbol_table();
+        min_ip = sym_table[0].addr;
+        max_ip = sym_table[sym_table_count-1].addr;
+        last = sym_table + sym_table_count++;
+
+        last->addr = -1ll;
+        last->sym = "<end>";
+
+        if (filter_end) {
+                int count;
+                for (count=0; count < sym_table_count; count ++) {
+                        if (!strcmp(sym_table[count].sym, sym_filter)) {
+                                sym_filter_entry = &sym_table[count];
+                                break;
+                        }
+                }
+        }
+        if (dump_symtab) {
+                int i;
+
+                for (i = 0; i < sym_table_count; i++)
+                        fprintf(stderr, "%llx %s\n",
+                                sym_table[i].addr, sym_table[i].sym);
+        }
+}
+
+/*
+ * Source lines
+ */
+
+static void parse_vmlinux(char *filename)
+{
+        FILE *file;
+        char command[PATH_MAX*2];
+        if (!filename)
+                return;
+
+        sprintf(command, "objdump --start-address=0x%016lx --stop-address=0x%016lx -dS %s", filter_start, filter_end, filename);
+
+        file = popen(command, "r");
+        if (!file)
+                return;
+
+        lines_tail = &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;
+                *lines_tail = src;
+                lines_tail = &src->next;
+
+                if (strlen(src->line)>8 && src->line[8] == ':')
+                        src->EIP = strtoull(src->line, NULL, 16);
+                if (strlen(src->line)>8 && src->line[16] == ':')
+                        src->EIP = strtoull(src->line, NULL, 16);
+        }
+        pclose(file);
+}
+
+static void record_precise_ip(uint64_t ip)
+{
+        struct source_line *line;
+
+        for (line = lines; line; line = line->next) {
+                if (line->EIP == ip)
+                        line->count++;
+                if (line->EIP > ip)
+                        break;
+        }
+}
+
+static void lookup_sym_in_vmlinux(struct sym_entry *sym)
+{
+        struct source_line *line;
+        char pattern[PATH_MAX];
+        sprintf(pattern, "<%s>:", sym->sym);
+
+        for (line = lines; line; line = line->next) {
+                if (strstr(line->line, pattern)) {
+                        sym->source = line;
+                        break;
+                }
+        }
+}
+
+static void show_lines(struct source_line *line_queue, int line_queue_count)
+{
+        int i;
+        struct source_line *line;
+
+        line = line_queue;
+        for (i = 0; i < line_queue_count; i++) {
+                printf("%8li\t%s\n", line->count, line->line);
+                line = line->next;
+        }
+}
+
+#define TRACE_COUNT     3
+
+static void show_details(struct sym_entry *sym)
+{
+        struct source_line *line;
+        struct source_line *line_queue = NULL;
+        int displayed = 0;
+        int line_queue_count = 0;
+
+        if (!sym->source)
+                lookup_sym_in_vmlinux(sym);
+        if (!sym->source)
+                return;
+
+        printf("Showing details for %s\n", sym->sym);
+
+        line = sym->source;
+        while (line) {
+                if (displayed && strstr(line->line, ">:"))
+                        break;
+
+                if (!line_queue_count)
+                        line_queue = line;
+                line_queue_count ++;
+
+                if (line->count >= count_filter) {
+                        show_lines(line_queue, 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 = 0;
+                displayed++;
+                if (displayed > 300)
+                        break;
+                line = line->next;
+        }
+}
+
+/*
+ * Binary search in the histogram table and record the hit:
+ */
+static void record_ip(uint64_t ip, int counter)
+{
+        int left_idx, middle_idx, right_idx, idx;
+        unsigned long left, middle, right;
+
+        record_precise_ip(ip);
+
+        left_idx = 0;
+        right_idx = sym_table_count-1;
+        assert(ip <= max_ip && ip >= min_ip);
+
+        while (left_idx + 1 < right_idx) {
+                middle_idx = (left_idx + right_idx) / 2;
+
+                left   = sym_table[  left_idx].addr;
+                middle = sym_table[middle_idx].addr;
+                right  = sym_table[ right_idx].addr;
+
+                if (!(left <= middle && middle <= right)) {
+                        printf("%016lx...\n%016lx...\n%016lx\n", left, middle, right);
+                        printf("%d %d %d\n", left_idx, middle_idx, right_idx);
+                }
+                assert(left <= middle && middle <= right);
+                if (!(left <= ip && ip <= right)) {
+                        printf(" left: %016lx\n", left);
+                        printf("   ip: %016lx\n", (unsigned long)ip);
+                        printf("right: %016lx\n", right);
+                }
+                assert(left <= ip && ip <= right);
+                /*
+                 * [ left .... target .... middle .... right ]
+                 *   => right := middle
+                 */
+                if (ip < middle) {
+                        right_idx = middle_idx;
+                        continue;
+                }
+                /*
+                 * [ left .... middle ... target ... right ]
+                 *   => left := middle
+                 */
+                left_idx = middle_idx;
+        }
+
+        idx = left_idx;
+
+        if (!sym_table[idx].skip)
+                sym_table[idx].count[counter]++;
+        else events--;
+}
+
+static void process_event(uint64_t ip, int counter)
+{
+        events++;
+
+        if (ip < min_ip || ip > max_ip) {
+                userspace_events++;
+                return;
+        }
+
+        record_ip(ip, counter);
+}
+
+static void process_options(int argc, char *argv[])
+{
+        int error = 0, counter;
+
+        if (strstr(argv[0], "perfstat"))
+                run_perfstat = 1;
+
+        for (;;) {
+                int option_index = 0;
+                /** Options for getopt */
+                static struct option long_options[] = {
+                        {"count",       required_argument,      NULL, 'c'},
+                        {"cpu",         required_argument,      NULL, 'C'},
+                        {"delay",       required_argument,      NULL, 'd'},
+                        {"dump_symtab", no_argument,            NULL, 'D'},
+                        {"event",       required_argument,      NULL, 'e'},
+                        {"filter",      required_argument,      NULL, 'f'},
+                        {"group",       required_argument,      NULL, 'g'},
+                        {"help",        no_argument,            NULL, 'h'},
+                        {"nmi",         required_argument,      NULL, 'n'},
+                        {"mmap_info",   no_argument,            NULL, 'M'},
+                        {"mmap_pages",  required_argument,      NULL, 'm'},
+                        {"munmap_info", no_argument,            NULL, 'U'},
+                        {"pid",         required_argument,      NULL, 'p'},
+                        {"realtime",    required_argument,      NULL, 'r'},
+                        {"scale",       no_argument,            NULL, 'l'},
+                        {"symbol",      required_argument,      NULL, 's'},
+                        {"stat",        no_argument,            NULL, 'S'},
+                        {"vmlinux",     required_argument,      NULL, 'x'},
+                        {"zero",        no_argument,            NULL, 'z'},
+                        {NULL,          0,                      NULL,  0 }
+                };
+                int c = getopt_long(argc, argv, "+:ac:C:d:De:f:g:hln:m:p:r:s:Sx:zMU",
+                                    long_options, &option_index);
+                if (c == -1)
+                        break;
+
+                switch (c) {
+                case 'a': system_wide                   =              1; break;
+                case 'c': default_interval              =   atoi(optarg); break;
+                case 'C':
+                        /* CPU and PID are mutually exclusive */
+                        if (tid != -1) {
+                                printf("WARNING: CPU switch overriding PID\n");
+                                sleep(1);
+                                tid = -1;
+                        }
+                        profile_cpu                     =   atoi(optarg); break;
+                case 'd': delay_secs                    =   atoi(optarg); break;
+                case 'D': dump_symtab                   =              1; break;
+
+                case 'e': error                         = parse_events(optarg); break;
+
+                case 'f': count_filter                  =   atoi(optarg); break;
+                case 'g': group                         =   atoi(optarg); break;
+                case 'h':                                 display_help(); break;
+                case 'l': scale                         =              1; break;
+                case 'n': nmi                           =   atoi(optarg); break;
+                case 'p':
+                        /* CPU and PID are mutually exclusive */
+                        if (profile_cpu != -1) {
+                                printf("WARNING: PID switch overriding CPU\n");
+                                sleep(1);
+                                profile_cpu = -1;
+                        }
+                        tid                             =   atoi(optarg); break;
+                case 'r': realtime_prio                 =   atoi(optarg); break;
+                case 's': sym_filter                    = strdup(optarg); break;
+                case 'S': run_perfstat                  =              1; break;
+                case 'x': vmlinux                       = strdup(optarg); break;
+                case 'z': zero                          =              1; break;
+                case 'm': mmap_pages                    =   atoi(optarg); break;
+                case 'M': use_mmap                      =              1; break;
+                case 'U': use_munmap                    =              1; break;
+                default: error = 1; break;
+                }
+        }
+        if (error)
+                display_help();
+
+        if (!nr_counters) {
+                if (run_perfstat)
+                        nr_counters = 8;
+                else {
+                        nr_counters = 1;
+                        event_id[0] = 0;
+                }
+        }
+
+        for (counter = 0; counter < nr_counters; counter++) {
+                if (event_count[counter])
+                        continue;
+
+                event_count[counter] = default_interval;
+        }
+}
+
+struct mmap_data {
+        int counter;
+        void *base;
+        unsigned 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(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 screw up the events 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, tid;
+                };
+                struct mmap_event {
+                        struct perf_event_header header;
+                        __u32 pid, tid;
+                        __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;
+
+                unsigned int 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.misc & PERF_EVENT_MISC_OVERFLOW) {
+                        if (event->header.type & PERF_RECORD_IP)
+                                process_event(event->ip.ip, md->counter);
+                } else {
+                        switch (event->header.type) {
+                                case PERF_EVENT_MMAP:
+                                case PERF_EVENT_MUNMAP:
+                                        printf("%s: %Lu %Lu %Lu %s\n",
+                                                        event->header.type == PERF_EVENT_MMAP
+                                                        ? "mmap" : "munmap",
+                                                        event->mmap.start,
+                                                        event->mmap.len,
+                                                        event->mmap.pgoff,
+                                                        event->mmap.filename);
+                                        break;
+                        }
+                }
+        }
+
+        md->prev = old;
+}
+
+int cmd_top(int argc, const char **argv, const char *prefix)
+{
+        struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
+        struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
+        struct perf_counter_hw_event hw_event;
+        pthread_t thread;
+        int i, counter, group_fd, nr_poll = 0;
+        unsigned int cpu;
+        int ret;
+
+        page_size = sysconf(_SC_PAGE_SIZE);
+
+        process_options(argc, argv);
+
+        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+        assert(nr_cpus <= MAX_NR_CPUS);
+        assert(nr_cpus >= 0);
+
+        if (run_perfstat)
+                return do_perfstat(argc, argv);
+
+        if (tid != -1 || profile_cpu != -1)
+                nr_cpus = 1;
+
+        parse_symbols();
+        if (vmlinux && sym_filter_entry)
+                parse_vmlinux(vmlinux);
+
+        for (i = 0; i < nr_cpus; i++) {
+                group_fd = -1;
+                for (counter = 0; counter < nr_counters; counter++) {
+
+                        cpu     = profile_cpu;
+                        if (tid == -1 && profile_cpu == -1)
+                                cpu = i;
+
+                        memset(&hw_event, 0, sizeof(hw_event));
+                        hw_event.config         = event_id[counter];
+                        hw_event.irq_period     = event_count[counter];
+                        hw_event.record_type    = PERF_RECORD_IP | PERF_RECORD_TID;
+                        hw_event.nmi            = nmi;
+                        hw_event.mmap           = use_mmap;
+                        hw_event.munmap         = use_munmap;
+
+                        fd[i][counter] = sys_perf_counter_open(&hw_event, tid, cpu, group_fd, 0);
+                        if (fd[i][counter] < 0) {
+                                int err = errno;
+                                printf("kerneltop error: syscall returned with %d (%s)\n",
+                                        fd[i][counter], strerror(err));
+                                if (err == EPERM)
+                                        printf("Are you root?\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) {
+                                printf("kerneltop error: failed to mmap with %d (%s)\n",
+                                                errno, strerror(errno));
+                                exit(-1);
+                        }
+                }
+        }
+
+        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 = events;
+
+                for (i = 0; i < nr_cpus; i++) {
+                        for (counter = 0; counter < nr_counters; counter++)
+                                mmap_read(&mmap_array[i][counter]);
+                }
+
+                if (hits == events)
+                        ret = poll(event_array, nr_poll, 100);
+        }
+
+        return 0;
+}
diff --git a/Documentation/perf_counter/builtin.h b/Documentation/perf_counter/builtin.h
new file mode 100644
index 000000000000..41637444ce2d
--- /dev/null
+++ b/Documentation/perf_counter/builtin.h
@@ -0,0 +1,18 @@
+#ifndef BUILTIN_H
+#define BUILTIN_H
+
+#include "util.h"
+#include "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_top(int argc, const char **argv, const char *prefix);
+#endif
diff --git a/Documentation/perf_counter/cache.h b/Documentation/perf_counter/cache.h
new file mode 100644
index 000000000000..dc085640a57d
--- /dev/null
+++ b/Documentation/perf_counter/cache.h
@@ -0,0 +1,97 @@
+#ifndef CACHE_H
+#define CACHE_H
+
+#include "util.h"
+#include "strbuf.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]"
+
+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] == '/';
+}
+#endif /* CACHE_H */
diff --git a/Documentation/perf_counter/command-list.txt b/Documentation/perf_counter/command-list.txt
new file mode 100644
index 000000000000..1eab3659b206
--- /dev/null
+++ b/Documentation/perf_counter/command-list.txt
@@ -0,0 +1,4 @@
+# List of known perf commands.
+# command name                          category [deprecated] [common]
+perf-top                                mainporcelain common
+
diff --git a/Documentation/perf_counter/config.c b/Documentation/perf_counter/config.c
new file mode 100644
index 000000000000..672d53959334
--- /dev/null
+++ b/Documentation/perf_counter/config.c
@@ -0,0 +1,966 @@
+/*
+ * 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;
+static int zlib_compression_seen;
+
+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, len = 0, space = 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, const char *value)
+{
+        /* Add other config variables here and to Documentation/config.txt. */
+        return 0;
+}
+
+int perf_default_config(const char *var, const char *value, void *dummy)
+{
+        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)
+{
+        const char *ep;
+        size_t section_len;
+
+        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 write_error(const char *filename)
+{
+        error("failed to write new configuration file %s", filename);
+
+        /* Same error code as "failed to rename". */
+        return 4;
+}
+
+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) == 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) == 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;
+        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;
+                size_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;
+
+}
+
+static int section_name_match (const char *buf, const char *name)
+{
+        int i = 0, j = 0, dot = 0;
+        for (; buf[i] && buf[i] != ']'; i++) {
+                if (!dot && isspace(buf[i])) {
+                        dot = 1;
+                        if (name[j++] != '.')
+                                break;
+                        for (i++; isspace(buf[i]); i++)
+                                ; /* do nothing */
+                        if (buf[i] != '"')
+                                break;
+                        continue;
+                }
+                if (buf[i] == '\\' && dot)
+                        i++;
+                else if (buf[i] == '"' && dot) {
+                        for (i++; isspace(buf[i]); i++)
+                                ; /* do_nothing */
+                        break;
+                }
+                if (buf[i] != name[j++])
+                        break;
+        }
+        return (buf[i] == ']' && name[j] == 0);
+}
+
+/* if new_name == NULL, the section is removed instead */
+int perf_config_rename_section(const char *old_name, const char *new_name)
+{
+        int ret = 0, remove = 0;
+        char *config_filename;
+        int out_fd;
+        char buf[1024];
+
+        if (config_exclusive_filename)
+                config_filename = strdup(config_exclusive_filename);
+        else
+                config_filename = perf_pathdup("config");
+        if (out_fd < 0) {
+                ret = error("could not lock config file %s", config_filename);
+                goto out;
+        }
+
+        if (!(config_file = fopen(config_filename, "rb"))) {
+                /* no config file means nothing to rename, no error */
+                goto unlock_and_out;
+        }
+
+        while (fgets(buf, sizeof(buf), config_file)) {
+                int i;
+                int length;
+                for (i = 0; buf[i] && isspace(buf[i]); i++)
+                        ; /* do nothing */
+                if (buf[i] == '[') {
+                        /* it's a section */
+                        if (section_name_match (&buf[i+1], old_name)) {
+                                ret++;
+                                if (new_name == NULL) {
+                                        remove = 1;
+                                        continue;
+                                }
+                                store.baselen = strlen(new_name);
+                                if (!store_write_section(out_fd, new_name)) {
+                                        goto out;
+                                }
+                                continue;
+                        }
+                        remove = 0;
+                }
+                if (remove)
+                        continue;
+                length = strlen(buf);
+                if (write_in_full(out_fd, buf, length) != length) {
+                        goto out;
+                }
+        }
+        fclose(config_file);
+ unlock_and_out:
+ out:
+        free(config_filename);
+        return ret;
+}
+
+/*
+ * 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/Documentation/perf_counter/ctype.c b/Documentation/perf_counter/ctype.c
new file mode 100644
index 000000000000..b90ec004f29c
--- /dev/null
+++ b/Documentation/perf_counter/ctype.c
@@ -0,0 +1,26 @@
+/*
+ * 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,  /* $, (, ), +, ., ^, {, | * */
+};
+
+unsigned char sane_ctype[256] = {
+        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 */
+        S, 0, 0, 0, R, 0, 0, 0, R, R, G, R, 0, 0, R, 0,         /*  32.. 47 */
+        D, D, D, D, D, D, D, D, D, D, 0, 0, 0, 0, 0, G,         /*  48.. 63 */
+        0, 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, 0, R, 0,         /*  80.. 95 */
+        0, 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, 0, 0, 0,         /* 112..127 */
+        /* Nothing in the 128.. range */
+};
diff --git a/Documentation/perf_counter/exec_cmd.c b/Documentation/perf_counter/exec_cmd.c
new file mode 100644
index 000000000000..d39292263153
--- /dev/null
+++ b/Documentation/perf_counter/exec_cmd.c
@@ -0,0 +1,165 @@
+#include "cache.h"
+#include "exec_cmd.h"
+#include "quote.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 = strndup(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/Documentation/perf_counter/exec_cmd.h b/Documentation/perf_counter/exec_cmd.h
new file mode 100644
index 000000000000..effe25eb1545
--- /dev/null
+++ b/Documentation/perf_counter/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/Documentation/perf_counter/generate-cmdlist.sh b/Documentation/perf_counter/generate-cmdlist.sh
new file mode 100755
index 000000000000..75c68d948fd3
--- /dev/null
+++ b/Documentation/perf_counter/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/^git-\([^  ]*\)[   ].* common.*/\1/p' command-list.txt |
+sort |
+while read cmd
+do
+     sed -n '
+     /^NAME/,/git-'"$cmd"'/H
+     ${
+            x
+            s/.*git-'"$cmd"' - \(.*\)/  {"'"$cmd"'", "\1"},/
+            p
+     }' "Documentation/git-$cmd.txt"
+done
+echo "};"
diff --git a/Documentation/perf_counter/help.c b/Documentation/perf_counter/help.c
new file mode 100644
index 000000000000..ec0116721660
--- /dev/null
+++ b/Documentation/perf_counter/help.c
@@ -0,0 +1,366 @@
+#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, int 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)
+{
+        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)
+{
+        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)
+{
+        int 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++) {
+                        int n = j * rows + i;
+                        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;
+
+#ifdef __MINGW32__
+        /* cannot trust the executable bit, peek into the file instead */
+        char buf[3] = { 0 };
+        int n;
+        int fd = open(name, O_RDONLY);
+        st.st_mode &= ~S_IXUSR;
+        if (fd >= 0) {
+                n = read(fd, buf, 2);
+                if (n == 2)
+                        /* DOS executables start with "MZ" */
+                        if (!strcmp(buf, "#!") || !strcmp(buf, "MZ"))
+                                st.st_mode |= S_IXUSR;
+                close(fd);
+        }
+#endif
+        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)
+{
+        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)
+{
+        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)
+{
+        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)
+{
+        int i, n, 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);
+
+        /* 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);
+
+        if (!main_cmds.cnt)
+                die ("Uh oh. Your system reports no Git commands at all.");
+
+        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 (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, const char **argv, const char *prefix)
+{
+        printf("perf version %s\n", perf_version_string);
+        return 0;
+}
diff --git a/Documentation/perf_counter/help.h b/Documentation/perf_counter/help.h
new file mode 100644
index 000000000000..56bc15406ffc
--- /dev/null
+++ b/Documentation/perf_counter/help.h
@@ -0,0 +1,29 @@
+#ifndef HELP_H
+#define HELP_H
+
+struct cmdnames {
+        int alloc;
+        int 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, int 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/Documentation/perf_counter/levenshtein.c b/Documentation/perf_counter/levenshtein.c
new file mode 100644
index 000000000000..e521d1516df6
--- /dev/null
+++ b/Documentation/perf_counter/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/Documentation/perf_counter/levenshtein.h b/Documentation/perf_counter/levenshtein.h
new file mode 100644
index 000000000000..0173abeef52c
--- /dev/null
+++ b/Documentation/perf_counter/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/Documentation/perf_counter/parse-options.c b/Documentation/perf_counter/parse-options.c
new file mode 100644
index 000000000000..7464f34e5407
--- /dev/null
+++ b/Documentation/perf_counter/parse-options.c
@@ -0,0 +1,495 @@
+#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 (p->argc == 1 && (opt->flags & PARSE_OPT_LASTARG_DEFAULT)) {
+                *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;
+        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;
+
+        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, "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);
+}
+
+
+/*----- some often used options -----*/
+#include "cache.h"
+
+int parse_opt_verbosity_cb(const struct option *opt, const char *arg,
+                           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/Documentation/perf_counter/parse-options.h b/Documentation/perf_counter/parse-options.h
new file mode 100644
index 000000000000..a81c7faff68e
--- /dev/null
+++ b/Documentation/perf_counter/parse-options.h
@@ -0,0 +1,172 @@
+#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_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()                   { OPTION_END }
+#define OPT_ARGUMENT(l, h)          { OPTION_ARGUMENT, 0, (l), NULL, NULL, (h) }
+#define OPT_GROUP(h)                { OPTION_GROUP, 0, NULL, NULL, NULL, (h) }
+#define OPT_BIT(s, l, v, h, b)      { OPTION_BIT, (s), (l), (v), NULL, (h), 0, NULL, (b) }
+#define OPT_BOOLEAN(s, l, v, h)     { OPTION_BOOLEAN, (s), (l), (v), NULL, (h) }
+#define OPT_SET_INT(s, l, v, h, i)  { OPTION_SET_INT, (s), (l), (v), NULL, (h), 0, NULL, (i) }
+#define OPT_SET_PTR(s, l, v, h, p)  { OPTION_SET_PTR, (s), (l), (v), NULL, (h), 0, NULL, (p) }
+#define OPT_INTEGER(s, l, v, h)     { OPTION_INTEGER, (s), (l), (v), NULL, (h) }
+#define OPT_STRING(s, l, v, a, h)   { OPTION_STRING,  (s), (l), (v), (a), (h) }
+#define OPT_DATE(s, l, v, h) \
+        { OPTION_CALLBACK, (s), (l), (v), "time",(h), 0, \
+          parse_opt_approxidate_cb }
+#define OPT_CALLBACK(s, l, v, a, h, f) \
+        { OPTION_CALLBACK, (s), (l), (v), (a), (h), 0, (f) }
+
+/* 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/Documentation/perf_counter/path.c b/Documentation/perf_counter/path.c
new file mode 100644
index 000000000000..891b612ec1a9
--- /dev/null
+++ b/Documentation/perf_counter/path.c
@@ -0,0 +1,392 @@
+/*
+ * 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);
+}
+
+
+static char *user_path(char *buf, char *path, int sz)
+{
+        struct passwd *pw;
+        char *slash;
+        int len, baselen;
+
+        if (!path || path[0] != '~')
+                return NULL;
+        path++;
+        slash = strchr(path, '/');
+        if (path[0] == '/' || !path[0]) {
+                pw = getpwuid(getuid());
+        }
+        else {
+                if (slash) {
+                        *slash = 0;
+                        pw = getpwnam(path);
+                        *slash = '/';
+                }
+                else
+                        pw = getpwnam(path);
+        }
+        if (!pw || !pw->pw_dir || sz <= strlen(pw->pw_dir))
+                return NULL;
+        baselen = strlen(pw->pw_dir);
+        memcpy(buf, pw->pw_dir, baselen);
+        while ((1 < baselen) && (buf[baselen-1] == '/')) {
+                buf[baselen-1] = 0;
+                baselen--;
+        }
+        if (slash && slash[1]) {
+                len = strlen(slash);
+                if (sz <= baselen + len)
+                        return NULL;
+                memcpy(buf + baselen, slash, len + 1);
+        }
+        return buf;
+}
+
+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/Documentation/perf_counter/perf.c b/Documentation/perf_counter/perf.c
new file mode 100644
index 000000000000..9256f6a16446
--- /dev/null
+++ b/Documentation/perf_counter/perf.c
@@ -0,0 +1,411 @@
+#include "builtin.h"
+#include "exec_cmd.h"
+#include "cache.h"
+//#include "quote.h"
+#include "run-command.h"
+
+const char perf_usage_string[] =
+        "perf [--version] [--exec-path[=PERF_EXEC_PATH]] [--html-path] [-p|--paginate|--no-pager] [--bare] [--perf-dir=PERF_DIR] [--work-tree=PERF_WORK_TREE] [--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 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 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 {
+                        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;
+        int unused_nonperf;
+
+        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();
+
+        if (p->option & NEED_WORK_TREE)
+                /* setup_work_tree() */;
+
+        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[] = {
+                { "top", cmd_top, 0 },
+        };
+        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;
+}
+
+
+int main(int argc, const char **argv)
+{
+        const char *cmd;
+
+        cmd = perf_extract_argv0_path(argv[0]);
+        if (!cmd)
+                cmd = "perf-help";
+
+        /*
+         * "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 += 4;
+                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();
+        if (argc > 0) {
+                if (!prefixcmp(argv[0], "--"))
+                        argv[0] += 2;
+        } else {
+                /* The user didn't specify a command; give them help */
+                printf("usage: %s\n\n", perf_usage_string);
+                list_common_cmds_help();
+                printf("\n%s\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/Documentation/perf_counter/quote.c b/Documentation/perf_counter/quote.c
new file mode 100644
index 000000000000..7a49fcf69671
--- /dev/null
+++ b/Documentation/perf_counter/quote.c
@@ -0,0 +1,478 @@
+#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 size_t next_quote_pos(const char *s, ssize_t maxlen)
+{
+        size_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)
+{
+#undef EMIT
+#define EMIT(c)                                 \
+        do {                                        \
+                if (sb) strbuf_addch(sb, (c));          \
+                if (fp) fputc((c), fp);                 \
+                count++;                                \
+        } while (0)
+#define EMITBUF(s, l)                           \
+        do {                                        \
+                if (sb) strbuf_add(sb, (s), (l));       \
+                if (fp) fwrite((s), (l), 1, fp);        \
+                count += (l);                           \
+        } while (0)
+
+        size_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);
+}
+
+extern void write_name_quotedpfx(const char *pfx, size_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 {
+                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 (prefix[off] && off < len && 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/Documentation/perf_counter/quote.h b/Documentation/perf_counter/quote.h
new file mode 100644
index 000000000000..66730f2bff3c
--- /dev/null
+++ b/Documentation/perf_counter/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_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, size_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/Documentation/perf_counter/run-command.c b/Documentation/perf_counter/run-command.c
new file mode 100644
index 000000000000..b2f5e854f40a
--- /dev/null
+++ b/Documentation/perf_counter/run-command.c
@@ -0,0 +1,395 @@
+#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];
+        }
+
+#ifndef __MINGW32__
+        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);
+        }
+#else
+        int s0 = -1, s1 = -1, s2 = -1;  /* backups of stdin, stdout, stderr */
+        const char **sargv = cmd->argv;
+        char **env = environ;
+
+        if (cmd->no_stdin) {
+                s0 = dup(0);
+                dup_devnull(0);
+        } else if (need_in) {
+                s0 = dup(0);
+                dup2(fdin[0], 0);
+        } else if (cmd->in) {
+                s0 = dup(0);
+                dup2(cmd->in, 0);
+        }
+
+        if (cmd->no_stderr) {
+                s2 = dup(2);
+                dup_devnull(2);
+        } else if (need_err) {
+                s2 = dup(2);
+                dup2(fderr[1], 2);
+        }
+
+        if (cmd->no_stdout) {
+                s1 = dup(1);
+                dup_devnull(1);
+        } else if (cmd->stdout_to_stderr) {
+                s1 = dup(1);
+                dup2(2, 1);
+        } else if (need_out) {
+                s1 = dup(1);
+                dup2(fdout[1], 1);
+        } else if (cmd->out > 1) {
+                s1 = dup(1);
+                dup2(cmd->out, 1);
+        }
+
+        if (cmd->dir)
+                die("chdir in start_command() not implemented");
+        if (cmd->env) {
+                env = copy_environ();
+                for (; *cmd->env; cmd->env++)
+                        env = env_setenv(env, *cmd->env);
+        }
+
+        if (cmd->perf_cmd) {
+                cmd->argv = prepare_perf_cmd(cmd->argv);
+        }
+
+        cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, env);
+
+        if (cmd->env)
+                free_environ(env);
+        if (cmd->perf_cmd)
+                free(cmd->argv);
+
+        cmd->argv = sargv;
+        if (s0 >= 0)
+                dup2(s0, 0), close(s0);
+        if (s1 >= 0)
+                dup2(s1, 1), close(s1);
+        if (s2 >= 0)
+                dup2(s2, 2), close(s2);
+#endif
+
+        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);
+}
+
+#ifdef __MINGW32__
+static __stdcall unsigned run_thread(void *data)
+{
+        struct async *async = data;
+        return async->proc(async->fd_for_proc, async->data);
+}
+#endif
+
+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];
+
+#ifndef __MINGW32__
+        /* 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]);
+#else
+        async->fd_for_proc = pipe_out[1];
+        async->tid = (HANDLE) _beginthreadex(NULL, 0, run_thread, async, 0, NULL);
+        if (!async->tid) {
+                error("cannot create thread: %s", strerror(errno));
+                close_pair(pipe_out);
+                return -1;
+        }
+#endif
+        return 0;
+}
+
+int finish_async(struct async *async)
+{
+#ifndef __MINGW32__
+        int ret = 0;
+
+        if (wait_or_whine(async->pid))
+                ret = error("waitpid (async) failed");
+#else
+        DWORD ret = 0;
+        if (WaitForSingleObject(async->tid, INFINITE) != WAIT_OBJECT_0)
+                ret = error("waiting for thread failed: %lu", GetLastError());
+        else if (!GetExitCodeThread(async->tid, &ret))
+                ret = error("cannot get thread exit code: %lu", GetLastError());
+        CloseHandle(async->tid);
+#endif
+        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/Documentation/perf_counter/run-command.h b/Documentation/perf_counter/run-command.h
new file mode 100644
index 000000000000..328289f23669
--- /dev/null
+++ b/Documentation/perf_counter/run-command.h
@@ -0,0 +1,93 @@
+#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 */
+#ifndef __MINGW32__
+        pid_t pid;
+#else
+        HANDLE tid;
+        int fd_for_proc;
+#endif
+};
+
+int start_async(struct async *async);
+int finish_async(struct async *async);
+
+#endif
diff --git a/Documentation/perf_counter/strbuf.c b/Documentation/perf_counter/strbuf.c
new file mode 100644
index 000000000000..eaba09306802
--- /dev/null
+++ b/Documentation/perf_counter/strbuf.c
@@ -0,0 +1,359 @@
+#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, size_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)
+{
+        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 (res < 0 && oldalloc == 0)
+                strbuf_release(sb);
+        return res;
+}
+
+ssize_t strbuf_read(struct strbuf *sb, int fd, size_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, size_t hint)
+{
+        size_t oldalloc = sb->alloc;
+
+        if (hint < 32)
+                hint = 32;
+
+        while (hint < STRBUF_MAXLINK) {
+                int 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, size_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/Documentation/perf_counter/strbuf.h b/Documentation/perf_counter/strbuf.h
new file mode 100644
index 000000000000..9ee908a3ec5d
--- /dev/null
+++ b/Documentation/perf_counter/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 *, size_t);
+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 size_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, size_t hint);
+extern int strbuf_read_file(struct strbuf *sb, const char *path, size_t hint);
+extern int strbuf_readlink(struct strbuf *sb, const char *path, size_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/Documentation/perf_counter/usage.c b/Documentation/perf_counter/usage.c
new file mode 100644
index 000000000000..7a10421fe6b4
--- /dev/null
+++ b/Documentation/perf_counter/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, "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/Documentation/perf_counter/util.h b/Documentation/perf_counter/util.h
new file mode 100644
index 000000000000..13f8bdce7600
--- /dev/null
+++ b/Documentation/perf_counter/util.h
@@ -0,0 +1,394 @@
+#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 <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>
+#ifndef __MINGW32__
+#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>
+#if defined(__CYGWIN__)
+#undef _XOPEN_SOURCE
+#include <grp.h>
+#define _XOPEN_SOURCE 600
+#include "compat/cygwin.h"
+#else
+#undef _ALL_SOURCE /* AIX 5.3L defines a struct list with _ALL_SOURCE. */
+#include <grp.h>
+#define _ALL_SOURCE 1
+#endif
+#else   /* __MINGW32__ */
+/* pull in Windows compatibility stuff */
+#include "compat/mingw.h"
+#endif  /* __MINGW32__ */
+
+#ifndef NO_ICONV
+#include <iconv.h>
+#endif
+
+#ifndef NO_OPENSSL
+#include <openssl/ssl.h>
+#include <openssl/err.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
+
+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 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 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/Documentation/perf_counter/wrapper.c b/Documentation/perf_counter/wrapper.c
new file mode 100644
index 000000000000..6350d65f6d9e
--- /dev/null
+++ b/Documentation/perf_counter/wrapper.c
@@ -0,0 +1,206 @@
+/*
+ * 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, int flag)
+{
+}
+
+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 ? 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;
+}