Merge branch 'perf/core' into perf/timer, before applying new changes

Signed-off-by: Ingo Molnar <mingo@kernel.org>
author: Ingo Molnar <mingo@kernel.org> 2015-03-27 05:10:47 -0400
committer: Ingo Molnar <mingo@kernel.org> 2015-03-27 05:10:47 -0400
commit: b381e63b48a0b6befc7b4e55408c39012a0dcf8c (patch)
tree: 92e70447e1b0cf721ef40515db6b97cb881c5066 /tools
parent: 4e6d7c2aa95158315902647963b359b32da5c295 (diff)
parent: ccd41c86ad4d464d0ed4e48d80759ff85c2115b0 (diff)
216 files changed, 5636 insertions, 2090 deletions
diff --git a/tools/build/Build.include b/tools/build/Build.include
new file mode 100644
index 000000000000..4c8daaccb82a
--- /dev/null
+++ b/tools/build/Build.include
@@ -0,0 +1,81 @@
+###
+# build: Generic definitions
+#
+#  Lots of this code have been borrowed or heavily inspired from parts
+#  of kbuild code, which is not credited, but mostly developed by:
+#
+#  Copyright (C) Sam Ravnborg <sam@mars.ravnborg.org>, 2015
+#  Copyright (C) Linus Torvalds <torvalds@linux-foundation.org>, 2015
+#
+###
+# Convenient variables
+comma   := ,
+squote  := '
+###
+# Name of target with a '.' as filename prefix. foo/bar.o => foo/.bar.o
+dot-target = $(dir $@).$(notdir $@)
+###
+# filename of target with directory and extension stripped
+basetarget = $(basename $(notdir $@))
+###
+# The temporary file to save gcc -MD generated dependencies must not
+# contain a comma
+depfile = $(subst $(comma),_,$(dot-target).d)
+###
+# Check if both arguments has same arguments. Result is empty string if equal.
+arg-check = $(strip $(filter-out $(cmd_$(1)), $(cmd_$@)) \
+                    $(filter-out $(cmd_$@),   $(cmd_$(1))) )
+###
+# Escape single quote for use in echo statements
+escsq = $(subst $(squote),'\$(squote)',$1)
+# Echo command
+# Short version is used, if $(quiet) equals `quiet_', otherwise full one.
+echo-cmd = $(if $($(quiet)cmd_$(1)),\
+           echo '  $(call escsq,$($(quiet)cmd_$(1)))';)
+###
+# Replace >$< with >$$< to preserve $ when reloading the .cmd file
+# (needed for make)
+# Replace >#< with >\#< to avoid starting a comment in the .cmd file
+# (needed for make)
+# Replace >'< with >'\''< to be able to enclose the whole string in '...'
+# (needed for the shell)
+make-cmd = $(call escsq,$(subst \#,\\\#,$(subst $$,$$$$,$(cmd_$(1)))))
+###
+# Find any prerequisites that is newer than target or that does not exist.
+# PHONY targets skipped in both cases.
+any-prereq = $(filter-out $(PHONY),$?) $(filter-out $(PHONY) $(wildcard $^),$^)
+###
+# if_changed_dep  - execute command if any prerequisite is newer than
+#                   target, or command line has changed and update
+#                   dependencies in the cmd file
+if_changed_dep = $(if $(strip $(any-prereq) $(arg-check)),         \
+        @set -e;                                                   \
+        $(echo-cmd) $(cmd_$(1));                                   \
+        cat $(depfile) > $(dot-target).cmd;                        \
+        printf '%s\n' 'cmd_$@ := $(make-cmd)' >> $(dot-target).cmd)
+# if_changed      - execute command if any prerequisite is newer than
+#                   target, or command line has changed
+if_changed = $(if $(strip $(any-prereq) $(arg-check)),             \
+        @set -e;                                                   \
+        $(echo-cmd) $(cmd_$(1));                                   \
+        printf '%s\n' 'cmd_$@ := $(make-cmd)' > $(dot-target).cmd)
+###
+# C flags to be used in rule definitions, includes:
+# - depfile generation
+# - global $(CFLAGS)
+# - per target C flags
+# - per object C flags
+# - BUILD_STR macro to allow '-D"$(variable)"' constructs
+c_flags = -Wp,-MD,$(depfile),-MT,$@ $(CFLAGS) -D"BUILD_STR(s)=\#s" $(CFLAGS_$(basetarget).o) $(CFLAGS_$(obj))
diff --git a/tools/build/Documentation/Build.txt b/tools/build/Documentation/Build.txt
new file mode 100644
index 000000000000..00ad2d608727
--- /dev/null
+++ b/tools/build/Documentation/Build.txt
@@ -0,0 +1,139 @@
+Build Framework
+===============
+The perf build framework was adopted from the kernel build system, hence the
+idea and the way how objects are built is the same.
+Basically the user provides set of 'Build' files that list objects and
+directories to nest for specific target to be build.
+Unlike the kernel we don't have a single build object 'obj-y' list that where
+we setup source objects, but we support more. This allows one 'Build' file to
+carry a sources list for multiple build objects.
+a) Build framework makefiles
+----------------------------
+The build framework consists of 2 Makefiles:
+  Build.include
+  Makefile.build
+While the 'Build.include' file contains just some generic definitions, the
+'Makefile.build' file is the makefile used from the outside. It's
+interface/usage is following:
+  $ make -f tools/build/Makefile srctree=$(KSRC) dir=$(DIR) obj=$(OBJECT)
+where:
+  KSRC   - is the path to kernel sources
+  DIR    - is the path to the project to be built
+  OBJECT - is the name of the build object
+When succefully finished the $(DIR) directory contains the final object file
+called $(OBJECT)-in.o:
+  $ ls $(DIR)/$(OBJECT)-in.o
+which includes all compiled sources described in 'Build' makefiles.
+a) Build makefiles
+------------------
+The user supplies 'Build' makefiles that contains a objects list, and connects
+the build to nested directories.
+Assume we have the following project structure:
+  ex/a.c
+    /b.c
+    /c.c
+    /d.c
+    /arch/e.c
+    /arch/f.c
+Out of which you build the 'ex' binary ' and the 'libex.a' library:
+  'ex'      - consists of 'a.o', 'b.o' and libex.a
+  'libex.a' - consists of 'c.o', 'd.o', 'e.o' and 'f.o'
+The build framework does not create the 'ex' and 'libex.a' binaries for you, it
+only prepares proper objects to be compiled and grouped together.
+To follow the above example, the user provides following 'Build' files:
+  ex/Build:
+    ex-y += a.o
+    ex-y += b.o
+    libex-y += c.o
+    libex-y += d.o
+    libex-y += arch/
+  ex/arch/Build:
+    libex-y += e.o
+    libex-y += f.o
+and runs:
+  $ make -f tools/build/Makefile.build dir=. obj=ex
+  $ make -f tools/build/Makefile.build dir=. obj=libex
+which creates the following objects:
+  ex/ex-in.o
+  ex/libex-in.o
+that contain request objects names in Build files.
+It's only a matter of 2 single commands to create the final binaries:
+  $ ar  rcs libex.a libex-in.o
+  $ gcc -o ex ex-in.o libex.a
+You can check the 'ex' example in 'tools/build/tests/ex' for more details.
+b) Rules
+--------
+The build framework provides standard compilation rules to handle .S and .c
+compilation.
+It's possible to include special rule if needed (like we do for flex or bison
+code generation).
+c) CFLAGS
+---------
+It's possible to alter the standard object C flags in the following way:
+  CFLAGS_perf.o += '...' - alters CFLAGS for perf.o object
+  CFLAGS_gtk += '...'    - alters CFLAGS for gtk build object
+This C flags changes has the scope of the Build makefile they are defined in.
+d) Dependencies
+---------------
+For each built object file 'a.o' the '.a.cmd' is created and holds:
+  - Command line used to built that object
+    (for each object)
+  - Dependency rules generated by 'gcc -Wp,-MD,...'
+    (for compiled object)
+All existing '.cmd' files are included in the Build process to follow properly
+the dependencies and trigger a rebuild when necessary.
+e) Single rules
+---------------
+It's possible to build single object file by choice, like:
+  $ make util/map.o    # objects
+  $ make util/map.i    # preprocessor
+  $ make util/map.s    # assembly
diff --git a/tools/build/Makefile.build b/tools/build/Makefile.build
new file mode 100644
index 000000000000..10df57237a66
--- /dev/null
+++ b/tools/build/Makefile.build
@@ -0,0 +1,130 @@
+###
+# Main build makefile.
+#
+#  Lots of this code have been borrowed or heavily inspired from parts
+#  of kbuild code, which is not credited, but mostly developed by:
+#
+#  Copyright (C) Sam Ravnborg <sam@mars.ravnborg.org>, 2015
+#  Copyright (C) Linus Torvalds <torvalds@linux-foundation.org>, 2015
+#
+PHONY := __build
+__build:
+ifeq ($(V),1)
+  quiet =
+  Q =
+else
+  quiet=quiet_
+  Q=@
+endif
+build-dir := $(srctree)/tools/build
+# Generic definitions
+include $(build-dir)/Build.include
+# do not force detected configuration
+-include .config-detected
+# Init all relevant variables used in build files so
+# 1) they have correct type
+# 2) they do not inherit any value from the environment
+subdir-y     :=
+obj-y        :=
+subdir-y     :=
+subdir-obj-y :=
+# Build definitions
+build-file := $(dir)/Build
+include $(build-file)
+quiet_cmd_flex  = FLEX     $@
+quiet_cmd_bison = BISON    $@
+# Create directory unless it exists
+quiet_cmd_mkdir = MKDIR    $(dir $@)
+      cmd_mkdir = mkdir -p $(dir $@)
+     rule_mkdir = $(if $(wildcard $(dir $@)),,@$(call echo-cmd,mkdir) $(cmd_mkdir))
+# Compile command
+quiet_cmd_cc_o_c = CC       $@
+      cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<
+quiet_cmd_cc_i_c = CPP      $@
+      cmd_cc_i_c = $(CC) $(c_flags) -E -o $@ $<
+quiet_cmd_cc_s_c = AS       $@
+      cmd_cc_s_c = $(CC) $(c_flags) -S -o $@ $<
+# Link agregate command
+# If there's nothing to link, create empty $@ object.
+quiet_cmd_ld_multi = LD       $@
+      cmd_ld_multi = $(if $(strip $(obj-y)),\
+                       $(LD) -r -o $@ $(obj-y),rm -f $@; $(AR) rcs $@)
+# Build rules
+$(OUTPUT)%.o: %.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
+$(OUTPUT)%.o: %.S FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
+$(OUTPUT)%.i: %.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_i_c)
+$(OUTPUT)%.i: %.S FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_i_c)
+$(OUTPUT)%.s: %.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_s_c)
+# Gather build data:
+#   obj-y        - list of build objects
+#   subdir-y     - list of directories to nest
+#   subdir-obj-y - list of directories objects 'dir/$(obj)-in.o'
+obj-y        := $($(obj)-y)
+subdir-y     := $(patsubst %/,%,$(filter %/, $(obj-y)))
+obj-y        := $(patsubst %/, %/$(obj)-in.o, $(obj-y))
+subdir-obj-y := $(filter %/$(obj)-in.o, $(obj-y))
+# '$(OUTPUT)/dir' prefix to all objects
+prefix       := $(subst ./,,$(OUTPUT)$(dir)/)
+obj-y        := $(addprefix $(prefix),$(obj-y))
+subdir-obj-y := $(addprefix $(prefix),$(subdir-obj-y))
+# Final '$(obj)-in.o' object
+in-target := $(prefix)$(obj)-in.o
+PHONY += $(subdir-y)
+$(subdir-y):
+        $(Q)$(MAKE) -f $(build-dir)/Makefile.build dir=$(dir)/$@ obj=$(obj)
+$(sort $(subdir-obj-y)): $(subdir-y) ;
+$(in-target): $(obj-y) FORCE
+        $(call rule_mkdir)
+        $(call if_changed,ld_multi)
+__build: $(in-target)
+        @:
+PHONY += FORCE
+FORCE:
+# Include all cmd files to get all the dependency rules
+# for all objects included
+targets   := $(wildcard $(sort $(obj-y) $(in-target) $(MAKECMDGOALS)))
+cmd_files := $(wildcard $(foreach f,$(targets),$(dir $(f)).$(notdir $(f)).cmd))
+ifneq ($(cmd_files),)
+  include $(cmd_files)
+endif
+.PHONY: $(PHONY)
diff --git a/tools/build/Makefile.feature b/tools/build/Makefile.feature
new file mode 100644
index 000000000000..3a0b0ca2a28c
--- /dev/null
+++ b/tools/build/Makefile.feature
@@ -0,0 +1,171 @@
+feature_dir := $(srctree)/tools/build/feature
+ifneq ($(OUTPUT),)
+  OUTPUT_FEATURES = $(OUTPUT)feature/
+  $(shell mkdir -p $(OUTPUT_FEATURES))
+endif
+feature_check = $(eval $(feature_check_code))
+define feature_check_code
+  feature-$(1) := $(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS) $(FEATURE_CHECK_CFLAGS-$(1))" LDFLAGS="$(LDFLAGS) $(FEATURE_CHECK_LDFLAGS-$(1))" -C $(feature_dir) test-$1.bin >/dev/null 2>/dev/null && echo 1 || echo 0)
+endef
+feature_set = $(eval $(feature_set_code))
+define feature_set_code
+  feature-$(1) := 1
+endef
+#
+# Build the feature check binaries in parallel, ignore errors, ignore return value and suppress output:
+#
+#
+# Note that this is not a complete list of all feature tests, just
+# those that are typically built on a fully configured system.
+#
+# [ Feature tests not mentioned here have to be built explicitly in
+#   the rule that uses them - an example for that is the 'bionic'
+#   feature check. ]
+#
+FEATURE_TESTS =                 \
+        backtrace                       \
+        dwarf                           \
+        fortify-source                  \
+        sync-compare-and-swap           \
+        glibc                           \
+        gtk2                            \
+        gtk2-infobar                    \
+        libaudit                        \
+        libbfd                          \
+        libelf                          \
+        libelf-getphdrnum               \
+        libelf-mmap                     \
+        libnuma                         \
+        libperl                         \
+        libpython                       \
+        libpython-version               \
+        libslang                        \
+        libunwind                       \
+        pthread-attr-setaffinity-np     \
+        stackprotector-all              \
+        timerfd                         \
+        libdw-dwarf-unwind              \
+        zlib                            \
+        lzma
+FEATURE_DISPLAY =                       \
+        dwarf                           \
+        glibc                           \
+        gtk2                            \
+        libaudit                        \
+        libbfd                          \
+        libelf                          \
+        libnuma                         \
+        libperl                         \
+        libpython                       \
+        libslang                        \
+        libunwind                       \
+        libdw-dwarf-unwind              \
+        zlib                            \
+        lzma
+# Set FEATURE_CHECK_(C|LD)FLAGS-all for all FEATURE_TESTS features.
+# If in the future we need per-feature checks/flags for features not
+# mentioned in this list we need to refactor this ;-).
+set_test_all_flags = $(eval $(set_test_all_flags_code))
+define set_test_all_flags_code
+  FEATURE_CHECK_CFLAGS-all  += $(FEATURE_CHECK_CFLAGS-$(1))
+  FEATURE_CHECK_LDFLAGS-all += $(FEATURE_CHECK_LDFLAGS-$(1))
+endef
+$(foreach feat,$(FEATURE_TESTS),$(call set_test_all_flags,$(feat)))
+#
+# Special fast-path for the 'all features are available' case:
+#
+$(call feature_check,all,$(MSG))
+#
+# Just in case the build freshly failed, make sure we print the
+# feature matrix:
+#
+ifeq ($(feature-all), 1)
+  #
+  # test-all.c passed - just set all the core feature flags to 1:
+  #
+  $(foreach feat,$(FEATURE_TESTS),$(call feature_set,$(feat)))
+else
+  $(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS)" LDFLAGS=$(LDFLAGS) -i -j -C $(feature_dir) $(addsuffix .bin,$(FEATURE_TESTS)) >/dev/null 2>&1)
+  $(foreach feat,$(FEATURE_TESTS),$(call feature_check,$(feat)))
+endif
+#
+# Print the result of the feature test:
+#
+feature_print_status = $(eval $(feature_print_status_code)) $(info $(MSG))
+define feature_print_status_code
+  ifeq ($(feature-$(1)), 1)
+    MSG = $(shell printf '...%30s: [ \033[32mon\033[m  ]' $(1))
+  else
+    MSG = $(shell printf '...%30s: [ \033[31mOFF\033[m ]' $(1))
+  endif
+endef
+feature_print_text = $(eval $(feature_print_text_code)) $(info $(MSG))
+define feature_print_text_code
+    MSG = $(shell printf '...%30s: %s' $(1) $(2))
+endef
+FEATURE_DUMP := $(foreach feat,$(FEATURE_DISPLAY),feature-$(feat)($(feature-$(feat))))
+FEATURE_DUMP_FILE := $(shell touch $(OUTPUT)FEATURE-DUMP; cat $(OUTPUT)FEATURE-DUMP)
+ifeq ($(dwarf-post-unwind),1)
+  FEATURE_DUMP += dwarf-post-unwind($(dwarf-post-unwind-text))
+endif
+# The $(feature_display) controls the default detection message
+# output. It's set if:
+# - detected features differes from stored features from
+#   last build (in FEATURE-DUMP file)
+# - one of the $(FEATURE_DISPLAY) is not detected
+# - VF is enabled
+ifneq ("$(FEATURE_DUMP)","$(FEATURE_DUMP_FILE)")
+  $(shell echo "$(FEATURE_DUMP)" > $(OUTPUT)FEATURE-DUMP)
+  feature_display := 1
+endif
+feature_display_check = $(eval $(feature_check_code))
+define feature_display_check_code
+  ifneq ($(feature-$(1)), 1)
+    feature_display := 1
+  endif
+endef
+$(foreach feat,$(FEATURE_DISPLAY),$(call feature_display_check,$(feat)))
+ifeq ($(VF),1)
+  feature_display := 1
+  feature_verbose := 1
+endif
+ifeq ($(feature_display),1)
+  $(info )
+  $(info Auto-detecting system features:)
+  $(foreach feat,$(FEATURE_DISPLAY),$(call feature_print_status,$(feat),))
+  ifeq ($(dwarf-post-unwind),1)
+    $(call feature_print_text,"DWARF post unwind library", $(dwarf-post-unwind-text))
+  endif
+  ifneq ($(feature_verbose),1)
+    $(info )
+  endif
+endif
+ifeq ($(feature_verbose),1)
+  TMP := $(filter-out $(FEATURE_DISPLAY),$(FEATURE_TESTS))
+  $(foreach feat,$(TMP),$(call feature_print_status,$(feat),))
+  $(info )
+endif
diff --git a/tools/perf/config/feature-checks/.gitignore b/tools/build/feature/.gitignore
index 80f3da0c3515..09b335b98842 100644
--- a/tools/perf/config/feature-checks/.gitignore
+++ b/tools/build/feature/.gitignore
@@ -1,2 +1,3 @@
 *.d
 *.bin
+*.output
diff --git a/tools/perf/config/feature-checks/Makefile b/tools/build/feature/Makefile
index b32ff3372514..463ed8f2a267 100644
--- a/tools/perf/config/feature-checks/Makefile
+++ b/tools/build/feature/Makefile
@@ -29,33 +29,36 @@ FILES=					\
        test-stackprotector-all.bin     \
        test-timerfd.bin                \
        test-libdw-dwarf-unwind.bin     \
+        test-libbabeltrace.bin          \
        test-compile-32.bin             \
        test-compile-x32.bin            \
-        test-zlib.bin
+        test-zlib.bin                   \
+        test-lzma.bin
 CC := $(CROSS_COMPILE)gcc -MD
 PKG_CONFIG := $(CROSS_COMPILE)pkg-config
 all: $(FILES)
-BUILD = $(CC) $(CFLAGS) -o $(OUTPUT)$@ $(patsubst %.bin,%.c,$@) $(LDFLAGS)
+__BUILD = $(CC) $(CFLAGS) -Wall -Werror -o $(OUTPUT)$@ $(patsubst %.bin,%.c,$@) $(LDFLAGS)
+  BUILD = $(__BUILD) > $(OUTPUT)$(@:.bin=.make.output) 2>&1
 ###############################
 test-all.bin:
-        $(BUILD) -Werror -fstack-protector-all -O2 -Werror -D_FORTIFY_SOURCE=2 -ldw -lelf -lnuma -lelf -laudit -I/usr/include/slang -lslang $(shell $(PKG_CONFIG) --libs --cflags gtk+-2.0 2>/dev/null) $(FLAGS_PERL_EMBED) $(FLAGS_PYTHON_EMBED) -DPACKAGE='"perf"' -lbfd -ldl -lz
+        $(BUILD) -fstack-protector-all -O2 -D_FORTIFY_SOURCE=2 -ldw -lelf -lnuma -lelf -laudit -I/usr/include/slang -lslang $(shell $(PKG_CONFIG) --libs --cflags gtk+-2.0 2>/dev/null) $(FLAGS_PERL_EMBED) $(FLAGS_PYTHON_EMBED) -DPACKAGE='"perf"' -lbfd -ldl -lz -llzma
 test-hello.bin:
        $(BUILD)
 test-pthread-attr-setaffinity-np.bin:
-        $(BUILD) -D_GNU_SOURCE -Werror -lpthread
+        $(BUILD) -D_GNU_SOURCE -lpthread
 test-stackprotector-all.bin:
-        $(BUILD) -Werror -fstack-protector-all
+        $(BUILD) -fstack-protector-all
 test-fortify-source.bin:
-        $(BUILD) -O2 -Werror -D_FORTIFY_SOURCE=2
+        $(BUILD) -O2 -D_FORTIFY_SOURCE=2
 test-bionic.bin:
        $(BUILD)
@@ -118,10 +121,10 @@ test-libbfd.bin:
        $(BUILD) -DPACKAGE='"perf"' -lbfd -lz -liberty -ldl
 test-liberty.bin:
-        $(CC) -o $(OUTPUT)$@ test-libbfd.c -DPACKAGE='"perf"' -lbfd -ldl -liberty
+        $(CC) -Wall -Werror -o $(OUTPUT)$@ test-libbfd.c -DPACKAGE='"perf"' -lbfd -ldl -liberty
 test-liberty-z.bin:
-        $(CC) -o $(OUTPUT)$@ test-libbfd.c -DPACKAGE='"perf"' -lbfd -ldl -liberty -lz
+        $(CC) -Wall -Werror -o $(OUTPUT)$@ test-libbfd.c -DPACKAGE='"perf"' -lbfd -ldl -liberty -lz
 test-cplus-demangle.bin:
        $(BUILD) -liberty
@@ -133,10 +136,13 @@ test-timerfd.bin:
        $(BUILD)
 test-libdw-dwarf-unwind.bin:
-        $(BUILD)
+        $(BUILD) # -ldw provided by $(FEATURE_CHECK_LDFLAGS-libdw-dwarf-unwind)
+test-libbabeltrace.bin:
+        $(BUILD) # -lbabeltrace provided by $(FEATURE_CHECK_LDFLAGS-libbabeltrace)
 test-sync-compare-and-swap.bin:
-        $(BUILD) -Werror
+        $(BUILD)
 test-compile-32.bin:
        $(CC) -m32 -o $(OUTPUT)$@ test-compile.c
@@ -147,9 +153,12 @@ test-compile-x32.bin:
 test-zlib.bin:
        $(BUILD) -lz
+test-lzma.bin:
+        $(BUILD) -llzma
 -include *.d
 ###############################
 clean:
-        rm -f $(FILES) *.d
+        rm -f $(FILES) *.d $(FILES:.bin=.make.output)
diff --git a/tools/perf/config/feature-checks/test-all.c b/tools/build/feature/test-all.c
index 6d4d09323922..84689a67814a 100644
--- a/tools/perf/config/feature-checks/test-all.c
+++ b/tools/build/feature/test-all.c
@@ -98,7 +98,23 @@
 #undef main
 #define main main_test_pthread_attr_setaffinity_np
-# include "test-pthread_attr_setaffinity_np.c"
+# include "test-pthread-attr-setaffinity-np.c"
+#undef main
+# if 0
+/*
+ * Disable libbabeltrace check for test-all, because the requested
+ * library version is not released yet in most distributions. Will
+ * reenable later.
+ */
+#define main main_test_libbabeltrace
+# include "test-libbabeltrace.c"
+#undef main
+#endif
+#define main main_test_lzma
+# include "test-lzma.c"
 #undef main
 int main(int argc, char *argv[])
@@ -126,6 +142,7 @@ int main(int argc, char *argv[])
        main_test_sync_compare_and_swap(argc, argv);
        main_test_zlib();
        main_test_pthread_attr_setaffinity_np();
+        main_test_lzma();
        return 0;
 }
diff --git a/tools/perf/config/feature-checks/test-backtrace.c b/tools/build/feature/test-backtrace.c
index 7124aa1dc8fb..7124aa1dc8fb 100644
--- a/tools/perf/config/feature-checks/test-backtrace.c
+++ b/tools/build/feature/test-backtrace.c
diff --git a/tools/perf/config/feature-checks/test-bionic.c b/tools/build/feature/test-bionic.c
index eac24e9513eb..eac24e9513eb 100644
--- a/tools/perf/config/feature-checks/test-bionic.c
+++ b/tools/build/feature/test-bionic.c
diff --git a/tools/perf/config/feature-checks/test-compile.c b/tools/build/feature/test-compile.c
index 31dbf45bf99c..31dbf45bf99c 100644
--- a/tools/perf/config/feature-checks/test-compile.c
+++ b/tools/build/feature/test-compile.c
diff --git a/tools/perf/config/feature-checks/test-cplus-demangle.c b/tools/build/feature/test-cplus-demangle.c
index 610c686e0009..610c686e0009 100644
--- a/tools/perf/config/feature-checks/test-cplus-demangle.c
+++ b/tools/build/feature/test-cplus-demangle.c
diff --git a/tools/perf/config/feature-checks/test-dwarf.c b/tools/build/feature/test-dwarf.c
index 3fc1801ce4a9..3fc1801ce4a9 100644
--- a/tools/perf/config/feature-checks/test-dwarf.c
+++ b/tools/build/feature/test-dwarf.c
diff --git a/tools/perf/config/feature-checks/test-fortify-source.c b/tools/build/feature/test-fortify-source.c
index c9f398d87868..c9f398d87868 100644
--- a/tools/perf/config/feature-checks/test-fortify-source.c
+++ b/tools/build/feature/test-fortify-source.c
diff --git a/tools/perf/config/feature-checks/test-glibc.c b/tools/build/feature/test-glibc.c
index b0820345cd98..b0820345cd98 100644
--- a/tools/perf/config/feature-checks/test-glibc.c
+++ b/tools/build/feature/test-glibc.c
diff --git a/tools/perf/config/feature-checks/test-gtk2-infobar.c b/tools/build/feature/test-gtk2-infobar.c
index 397b4646d066..397b4646d066 100644
--- a/tools/perf/config/feature-checks/test-gtk2-infobar.c
+++ b/tools/build/feature/test-gtk2-infobar.c
diff --git a/tools/perf/config/feature-checks/test-gtk2.c b/tools/build/feature/test-gtk2.c
index 6bd80e509439..6bd80e509439 100644
--- a/tools/perf/config/feature-checks/test-gtk2.c
+++ b/tools/build/feature/test-gtk2.c
diff --git a/tools/perf/config/feature-checks/test-hello.c b/tools/build/feature/test-hello.c
index c9f398d87868..c9f398d87868 100644
--- a/tools/perf/config/feature-checks/test-hello.c
+++ b/tools/build/feature/test-hello.c
diff --git a/tools/perf/config/feature-checks/test-libaudit.c b/tools/build/feature/test-libaudit.c
index afc019f08641..afc019f08641 100644
--- a/tools/perf/config/feature-checks/test-libaudit.c
+++ b/tools/build/feature/test-libaudit.c
diff --git a/tools/build/feature/test-libbabeltrace.c b/tools/build/feature/test-libbabeltrace.c
new file mode 100644
index 000000000000..9cf802a04885
--- /dev/null
+++ b/tools/build/feature/test-libbabeltrace.c
@@ -0,0 +1,9 @@
+#include <babeltrace/ctf-writer/writer.h>
+#include <babeltrace/ctf-ir/stream-class.h>
+int main(void)
+{
+        bt_ctf_stream_class_get_packet_context_type((void *) 0);
+        return 0;
+}
diff --git a/tools/perf/config/feature-checks/test-libbfd.c b/tools/build/feature/test-libbfd.c
index 24059907e990..24059907e990 100644
--- a/tools/perf/config/feature-checks/test-libbfd.c
+++ b/tools/build/feature/test-libbfd.c
diff --git a/tools/perf/config/feature-checks/test-libdw-dwarf-unwind.c b/tools/build/feature/test-libdw-dwarf-unwind.c
index f676a3ff442a..f676a3ff442a 100644
--- a/tools/perf/config/feature-checks/test-libdw-dwarf-unwind.c
+++ b/tools/build/feature/test-libdw-dwarf-unwind.c
diff --git a/tools/perf/config/feature-checks/test-libelf-getphdrnum.c b/tools/build/feature/test-libelf-getphdrnum.c
index d710459306c3..d710459306c3 100644
--- a/tools/perf/config/feature-checks/test-libelf-getphdrnum.c
+++ b/tools/build/feature/test-libelf-getphdrnum.c
diff --git a/tools/perf/config/feature-checks/test-libelf-mmap.c b/tools/build/feature/test-libelf-mmap.c
index 564427d7ef18..564427d7ef18 100644
--- a/tools/perf/config/feature-checks/test-libelf-mmap.c
+++ b/tools/build/feature/test-libelf-mmap.c
diff --git a/tools/perf/config/feature-checks/test-libelf.c b/tools/build/feature/test-libelf.c
index 08db322d8957..08db322d8957 100644
--- a/tools/perf/config/feature-checks/test-libelf.c
+++ b/tools/build/feature/test-libelf.c
diff --git a/tools/perf/config/feature-checks/test-libnuma.c b/tools/build/feature/test-libnuma.c
index 4763d9cd587d..4763d9cd587d 100644
--- a/tools/perf/config/feature-checks/test-libnuma.c
+++ b/tools/build/feature/test-libnuma.c
diff --git a/tools/perf/config/feature-checks/test-libperl.c b/tools/build/feature/test-libperl.c
index 8871f6a0fdb4..8871f6a0fdb4 100644
--- a/tools/perf/config/feature-checks/test-libperl.c
+++ b/tools/build/feature/test-libperl.c
diff --git a/tools/perf/config/feature-checks/test-libpython-version.c b/tools/build/feature/test-libpython-version.c
index facea122d812..facea122d812 100644
--- a/tools/perf/config/feature-checks/test-libpython-version.c
+++ b/tools/build/feature/test-libpython-version.c
diff --git a/tools/perf/config/feature-checks/test-libpython.c b/tools/build/feature/test-libpython.c
index b24b28ad6324..b24b28ad6324 100644
--- a/tools/perf/config/feature-checks/test-libpython.c
+++ b/tools/build/feature/test-libpython.c
diff --git a/tools/perf/config/feature-checks/test-libslang.c b/tools/build/feature/test-libslang.c
index 22ff22ed94d1..22ff22ed94d1 100644
--- a/tools/perf/config/feature-checks/test-libslang.c
+++ b/tools/build/feature/test-libslang.c
diff --git a/tools/perf/config/feature-checks/test-libunwind-debug-frame.c b/tools/build/feature/test-libunwind-debug-frame.c
index 0ef8087a104a..0ef8087a104a 100644
--- a/tools/perf/config/feature-checks/test-libunwind-debug-frame.c
+++ b/tools/build/feature/test-libunwind-debug-frame.c
diff --git a/tools/perf/config/feature-checks/test-libunwind.c b/tools/build/feature/test-libunwind.c
index 43b9369bcab7..43b9369bcab7 100644
--- a/tools/perf/config/feature-checks/test-libunwind.c
+++ b/tools/build/feature/test-libunwind.c
diff --git a/tools/build/feature/test-lzma.c b/tools/build/feature/test-lzma.c
new file mode 100644
index 000000000000..95adc8ced3dd
--- /dev/null
+++ b/tools/build/feature/test-lzma.c
@@ -0,0 +1,10 @@
+#include <lzma.h>
+int main(void)
+{
+        lzma_stream strm = LZMA_STREAM_INIT;
+        int ret;
+        ret = lzma_stream_decoder(&strm, UINT64_MAX, LZMA_CONCATENATED);
+        return ret ? -1 : 0;
+}
diff --git a/tools/perf/config/feature-checks/test-pthread-attr-setaffinity-np.c b/tools/build/feature/test-pthread-attr-setaffinity-np.c
index 2b81b72eca23..fdada5e8d454 100644
--- a/tools/perf/config/feature-checks/test-pthread-attr-setaffinity-np.c
+++ b/tools/build/feature/test-pthread-attr-setaffinity-np.c
@@ -1,5 +1,6 @@
 #include <stdint.h>
 #include <pthread.h>
+#include <sched.h>
 int main(void)
 {
@@ -8,7 +9,8 @@ int main(void)
        cpu_set_t cs;
        pthread_attr_init(&thread_attr);
-        /* don't care abt exact args, just the API itself in libpthread */
+        CPU_ZERO(&cs);
        ret = pthread_attr_setaffinity_np(&thread_attr, sizeof(cs), &cs);
        return ret;
diff --git a/tools/perf/config/feature-checks/test-stackprotector-all.c b/tools/build/feature/test-stackprotector-all.c
index c9f398d87868..c9f398d87868 100644
--- a/tools/perf/config/feature-checks/test-stackprotector-all.c
+++ b/tools/build/feature/test-stackprotector-all.c
diff --git a/tools/perf/config/feature-checks/test-sync-compare-and-swap.c b/tools/build/feature/test-sync-compare-and-swap.c
index c34d4ca4af56..c34d4ca4af56 100644
--- a/tools/perf/config/feature-checks/test-sync-compare-and-swap.c
+++ b/tools/build/feature/test-sync-compare-and-swap.c
diff --git a/tools/perf/config/feature-checks/test-timerfd.c b/tools/build/feature/test-timerfd.c
index 8c5c083b4d3c..8c5c083b4d3c 100644
--- a/tools/perf/config/feature-checks/test-timerfd.c
+++ b/tools/build/feature/test-timerfd.c
diff --git a/tools/perf/config/feature-checks/test-zlib.c b/tools/build/feature/test-zlib.c
index e111fff6240e..e111fff6240e 100644
--- a/tools/perf/config/feature-checks/test-zlib.c
+++ b/tools/build/feature/test-zlib.c
diff --git a/tools/build/tests/ex/Build b/tools/build/tests/ex/Build
new file mode 100644
index 000000000000..0e6c3e6767e6
--- /dev/null
+++ b/tools/build/tests/ex/Build
@@ -0,0 +1,8 @@
+ex-y += ex.o
+ex-y += a.o
+ex-y += b.o
+ex-y += empty/
+libex-y += c.o
+libex-y += d.o
+libex-y += arch/
diff --git a/tools/build/tests/ex/Makefile b/tools/build/tests/ex/Makefile
new file mode 100644
index 000000000000..52d2476073a3
--- /dev/null
+++ b/tools/build/tests/ex/Makefile
@@ -0,0 +1,23 @@
+export srctree := ../../../..
+export CC      := gcc
+export LD      := ld
+export AR      := ar
+build := -f $(srctree)/tools/build/Makefile.build dir=. obj
+ex: ex-in.o libex-in.o
+        gcc -o $@ $^
+ex.%: FORCE
+        make -f $(srctree)/tools/build/Makefile.build dir=. $@
+ex-in.o: FORCE
+        make $(build)=ex
+libex-in.o: FORCE
+        make $(build)=libex
+clean:
+        find . -name '*.o' -delete -o -name '\.*.cmd' -delete -o -name '\.*.d' -delete
+        rm -f ex ex.i ex.s
+.PHONY: FORCE
diff --git a/tools/build/tests/ex/a.c b/tools/build/tests/ex/a.c
new file mode 100644
index 000000000000..851762798c83
--- /dev/null
+++ b/tools/build/tests/ex/a.c
@@ -0,0 +1,5 @@
+int a(void)
+{
+        return 0;
+}
diff --git a/tools/build/tests/ex/arch/Build b/tools/build/tests/ex/arch/Build
new file mode 100644
index 000000000000..55506189efae
--- /dev/null
+++ b/tools/build/tests/ex/arch/Build
@@ -0,0 +1,2 @@
+libex-y += e.o
+libex-y += f.o
diff --git a/tools/build/tests/ex/arch/e.c b/tools/build/tests/ex/arch/e.c
new file mode 100644
index 000000000000..beaa4a1d7ba8
--- /dev/null
+++ b/tools/build/tests/ex/arch/e.c
@@ -0,0 +1,5 @@
+int e(void)
+{
+        return 0;
+}
diff --git a/tools/build/tests/ex/arch/f.c b/tools/build/tests/ex/arch/f.c
new file mode 100644
index 000000000000..7c3e9e9da5b7
--- /dev/null
+++ b/tools/build/tests/ex/arch/f.c
@@ -0,0 +1,5 @@
+int f(void)
+{
+        return 0;
+}
diff --git a/tools/build/tests/ex/b.c b/tools/build/tests/ex/b.c
new file mode 100644
index 000000000000..c24ff9ca9a97
--- /dev/null
+++ b/tools/build/tests/ex/b.c
@@ -0,0 +1,5 @@
+int b(void)
+{
+        return 0;
+}
diff --git a/tools/build/tests/ex/c.c b/tools/build/tests/ex/c.c
new file mode 100644
index 000000000000..e216d0217499
--- /dev/null
+++ b/tools/build/tests/ex/c.c
@@ -0,0 +1,5 @@
+int c(void)
+{
+        return 0;
+}
diff --git a/tools/build/tests/ex/d.c b/tools/build/tests/ex/d.c
new file mode 100644
index 000000000000..80dc0f06151b
--- /dev/null
+++ b/tools/build/tests/ex/d.c
@@ -0,0 +1,5 @@
+int d(void)
+{
+        return 0;
+}
diff --git a/tools/build/tests/ex/empty/Build b/tools/build/tests/ex/empty/Build
new file mode 100644
index 000000000000..e69de29bb2d1
--- /dev/null
+++ b/tools/build/tests/ex/empty/Build
diff --git a/tools/build/tests/ex/ex.c b/tools/build/tests/ex/ex.c
new file mode 100644
index 000000000000..dc42eb2e1a67
--- /dev/null
+++ b/tools/build/tests/ex/ex.c
@@ -0,0 +1,19 @@
+int a(void);
+int b(void);
+int c(void);
+int d(void);
+int e(void);
+int f(void);
+int main(void)
+{
+        a();
+        b();
+        c();
+        d();
+        e();
+        f();
+        return 0;
+}
diff --git a/tools/build/tests/run.sh b/tools/build/tests/run.sh
new file mode 100755
index 000000000000..5494f8ea7567
--- /dev/null
+++ b/tools/build/tests/run.sh
@@ -0,0 +1,42 @@
+#!/bin/sh
+function test_ex {
+        make -C ex V=1 clean > ex.out 2>&1
+        make -C ex V=1 >> ex.out 2>&1
+        if [ ! -x ./ex/ex ]; then
+          echo FAILED
+          exit -1
+        fi
+        make -C ex V=1 clean > /dev/null 2>&1
+        rm -f ex.out
+}
+function test_ex_suffix {
+        make -C ex V=1 clean > ex.out 2>&1
+        # use -rR to disable make's builtin rules
+        make -rR -C ex V=1 ex.o >> ex.out 2>&1
+        make -rR -C ex V=1 ex.i >> ex.out 2>&1
+        make -rR -C ex V=1 ex.s >> ex.out 2>&1
+        if [ -x ./ex/ex ]; then
+          echo FAILED
+          exit -1
+        fi
+        if [ ! -f ./ex/ex.o -o ! -f ./ex/ex.i -o ! -f ./ex/ex.s ]; then
+          echo FAILED
+          exit -1
+        fi
+        make -C ex V=1 clean > /dev/null 2>&1
+        rm -f ex.out
+}
+echo -n Testing..
+test_ex
+test_ex_suffix
+echo OK
diff --git a/tools/lib/api/Build b/tools/lib/api/Build
new file mode 100644
index 000000000000..3653965cf481
--- /dev/null
+++ b/tools/lib/api/Build
@@ -0,0 +1,2 @@
+libapi-y += fd/
+libapi-y += fs/
diff --git a/tools/lib/api/Makefile b/tools/lib/api/Makefile
index 36c08b1f4afb..d8fe29fc19a4 100644
--- a/tools/lib/api/Makefile
+++ b/tools/lib/api/Makefile
@@ -1,49 +1,43 @@
 include ../../scripts/Makefile.include
 include ../../perf/config/utilities.mak         # QUIET_CLEAN
+ifeq ($(srctree),)
+srctree := $(patsubst %/,%,$(dir $(shell pwd)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+#$(info Determined 'srctree' to be $(srctree))
+endif
 CC = $(CROSS_COMPILE)gcc
 AR = $(CROSS_COMPILE)ar
-# guard against environment variables
+MAKEFLAGS += --no-print-directory
-LIB_H=
-LIB_OBJS=
-LIB_H += fs/debugfs.h
-LIB_H += fs/fs.h
-# See comment below about piggybacking...
-LIB_H += fd/array.h
-LIB_OBJS += $(OUTPUT)fs/debugfs.o
-LIB_OBJS += $(OUTPUT)fs/fs.o
-# XXX piggybacking here, need to introduce libapikfd, or rename this
-# to plain libapik.a and make it have it all api goodies
-LIB_OBJS += $(OUTPUT)fd/array.o
-LIBFILE = libapikfs.a
+LIBFILE = $(OUTPUT)libapi.a
-CFLAGS = -ggdb3 -Wall -Wextra -std=gnu99 -Werror -O6 -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS) -fPIC
+CFLAGS := $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
-EXTLIBS = -lelf -lpthread -lrt -lm
+CFLAGS += -ggdb3 -Wall -Wextra -std=gnu99 -Werror -O6 -D_FORTIFY_SOURCE=2 -fPIC
-ALL_CFLAGS = $(CFLAGS) $(BASIC_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
+CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
-ALL_LDFLAGS = $(LDFLAGS)
 RM = rm -f
-$(LIBFILE): $(LIB_OBJS)
+build  := -f $(srctree)/tools/build/Makefile.build dir=. obj
-        $(QUIET_AR)$(RM) $@ && $(AR) rcs $(OUTPUT)$@ $(LIB_OBJS)
+API_IN := $(OUTPUT)libapi-in.o
-$(LIB_OBJS): $(LIB_H)
+export srctree OUTPUT CC LD CFLAGS V
-libapi_dirs:
+all: $(LIBFILE)
-        $(QUIET_MKDIR)mkdir -p $(OUTPUT)fd $(OUTPUT)fs
-$(OUTPUT)%.o: %.c libapi_dirs
+$(API_IN): FORCE
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
+        @$(MAKE) $(build)=libapi
-$(OUTPUT)%.s: %.c libapi_dirs
-        $(QUIET_CC)$(CC) -S $(ALL_CFLAGS) $<
+$(LIBFILE): $(API_IN)
-$(OUTPUT)%.o: %.S libapi_dirs
+        $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(API_IN)
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
 clean:
-        $(call QUIET_CLEAN, libapi) $(RM) $(LIB_OBJS) $(LIBFILE)
+        $(call QUIET_CLEAN, libapi) $(RM) $(LIBFILE); \
+        find $(if $(OUTPUT),$(OUTPUT),.) -name \*.o | xargs $(RM)
+FORCE:
-.PHONY: clean
+.PHONY: clean FORCE
diff --git a/tools/lib/api/fd/Build b/tools/lib/api/fd/Build
new file mode 100644
index 000000000000..605d99f6d71a
--- /dev/null
+++ b/tools/lib/api/fd/Build
@@ -0,0 +1 @@
+libapi-y += array.o
diff --git a/tools/lib/api/fs/Build b/tools/lib/api/fs/Build
new file mode 100644
index 000000000000..6de5a4f0b501
--- /dev/null
+++ b/tools/lib/api/fs/Build
@@ -0,0 +1,4 @@
+libapi-y += fs.o
+libapi-y += debugfs.o
+libapi-y += findfs.o
+libapi-y += tracefs.o
diff --git a/tools/lib/api/fs/debugfs.c b/tools/lib/api/fs/debugfs.c
index d2b18e887071..8305b3e9d48e 100644
--- a/tools/lib/api/fs/debugfs.c
+++ b/tools/lib/api/fs/debugfs.c
@@ -3,75 +3,50 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 #include <stdbool.h>
 #include <sys/vfs.h>
+#include <sys/types.h>
+#include <sys/stat.h>
 #include <sys/mount.h>
 #include <linux/kernel.h>
 #include "debugfs.h"
-char debugfs_mountpoint[PATH_MAX + 1] = "/sys/kernel/debug";
+#ifndef DEBUGFS_DEFAULT_PATH
+#define DEBUGFS_DEFAULT_PATH            "/sys/kernel/debug"
+#endif
+char debugfs_mountpoint[PATH_MAX + 1] = DEBUGFS_DEFAULT_PATH;
 static const char * const debugfs_known_mountpoints[] = {
-        "/sys/kernel/debug",
+        DEBUGFS_DEFAULT_PATH,
        "/debug",
        0,
 };
 static bool debugfs_found;
+bool debugfs_configured(void)
+{
+        return debugfs_find_mountpoint() != NULL;
+}
 /* find the path to the mounted debugfs */
 const char *debugfs_find_mountpoint(void)
 {
-        const char * const *ptr;
+        const char *ret;
-        char type[100];
-        FILE *fp;
        if (debugfs_found)
                return (const char *)debugfs_mountpoint;
-        ptr = debugfs_known_mountpoints;
+        ret = find_mountpoint("debugfs", (long) DEBUGFS_MAGIC,
-        while (*ptr) {
+                              debugfs_mountpoint, PATH_MAX + 1,
-                if (debugfs_valid_mountpoint(*ptr) == 0) {
+                              debugfs_known_mountpoints);
-                        debugfs_found = true;
+        if (ret)
-                        strcpy(debugfs_mountpoint, *ptr);
+                debugfs_found = true;
-                        return debugfs_mountpoint;
-                }
-                ptr++;
-        }
-        /* give up and parse /proc/mounts */
-        fp = fopen("/proc/mounts", "r");
-        if (fp == NULL)
-                return NULL;
-        while (fscanf(fp, "%*s %" STR(PATH_MAX) "s %99s %*s %*d %*d\n",
-                      debugfs_mountpoint, type) == 2) {
-                if (strcmp(type, "debugfs") == 0)
-                        break;
-        }
-        fclose(fp);
-        if (strcmp(type, "debugfs") != 0)
+        return ret;
-                return NULL;
-        debugfs_found = true;
-        return debugfs_mountpoint;
-}
-/* verify that a mountpoint is actually a debugfs instance */
-int debugfs_valid_mountpoint(const char *debugfs)
-{
-        struct statfs st_fs;
-        if (statfs(debugfs, &st_fs) < 0)
-                return -ENOENT;
-        else if ((long)st_fs.f_type != (long)DEBUGFS_MAGIC)
-                return -ENOENT;
-        return 0;
 }
 /* mount the debugfs somewhere if it's not mounted */
@@ -87,7 +62,7 @@ char *debugfs_mount(const char *mountpoint)
                mountpoint = getenv(PERF_DEBUGFS_ENVIRONMENT);
                /* if no environment variable, use default */
                if (mountpoint == NULL)
-                        mountpoint = "/sys/kernel/debug";
+                        mountpoint = DEBUGFS_DEFAULT_PATH;
        }
        if (mount(NULL, mountpoint, "debugfs", 0, NULL) < 0)
diff --git a/tools/lib/api/fs/debugfs.h b/tools/lib/api/fs/debugfs.h
index 0739881a9897..455023698d2b 100644
--- a/tools/lib/api/fs/debugfs.h
+++ b/tools/lib/api/fs/debugfs.h
@@ -1,16 +1,7 @@
 #ifndef __API_DEBUGFS_H__
 #define __API_DEBUGFS_H__
-#define _STR(x) #x
+#include "findfs.h"
-#define STR(x) _STR(x)
-/*
- * 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 DEBUGFS_MAGIC
 #define DEBUGFS_MAGIC          0x64626720
@@ -20,8 +11,8 @@
 #define PERF_DEBUGFS_ENVIRONMENT "PERF_DEBUGFS_DIR"
 #endif
+bool debugfs_configured(void);
 const char *debugfs_find_mountpoint(void);
-int debugfs_valid_mountpoint(const char *debugfs);
 char *debugfs_mount(const char *mountpoint);
 extern char debugfs_mountpoint[];
diff --git a/tools/lib/api/fs/findfs.c b/tools/lib/api/fs/findfs.c
new file mode 100644
index 000000000000..49946cb6d7af
--- /dev/null
+++ b/tools/lib/api/fs/findfs.c
@@ -0,0 +1,63 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <sys/vfs.h>
+#include "findfs.h"
+/* verify that a mountpoint is actually the type we want */
+int valid_mountpoint(const char *mount, long magic)
+{
+        struct statfs st_fs;
+        if (statfs(mount, &st_fs) < 0)
+                return -ENOENT;
+        else if ((long)st_fs.f_type != magic)
+                return -ENOENT;
+        return 0;
+}
+/* find the path to a mounted file system */
+const char *find_mountpoint(const char *fstype, long magic,
+                            char *mountpoint, int len,
+                            const char * const *known_mountpoints)
+{
+        const char * const *ptr;
+        char format[128];
+        char type[100];
+        FILE *fp;
+        if (known_mountpoints) {
+                ptr = known_mountpoints;
+                while (*ptr) {
+                        if (valid_mountpoint(*ptr, magic) == 0) {
+                                strncpy(mountpoint, *ptr, len - 1);
+                                mountpoint[len-1] = 0;
+                                return mountpoint;
+                        }
+                        ptr++;
+                }
+        }
+        /* give up and parse /proc/mounts */
+        fp = fopen("/proc/mounts", "r");
+        if (fp == NULL)
+                return NULL;
+        snprintf(format, 128, "%%*s %%%ds %%99s %%*s %%*d %%*d\n", len);
+        while (fscanf(fp, format, mountpoint, type) == 2) {
+                if (strcmp(type, fstype) == 0)
+                        break;
+        }
+        fclose(fp);
+        if (strcmp(type, fstype) != 0)
+                return NULL;
+        return mountpoint;
+}
diff --git a/tools/lib/api/fs/findfs.h b/tools/lib/api/fs/findfs.h
new file mode 100644
index 000000000000..b6f5d05acc42
--- /dev/null
+++ b/tools/lib/api/fs/findfs.h
@@ -0,0 +1,23 @@
+#ifndef __API_FINDFS_H__
+#define __API_FINDFS_H__
+#include <stdbool.h>
+#define _STR(x) #x
+#define STR(x) _STR(x)
+/*
+ * 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
+const char *find_mountpoint(const char *fstype, long magic,
+                            char *mountpoint, int len,
+                            const char * const *known_mountpoints);
+int valid_mountpoint(const char *mount, long magic);
+#endif /* __API_FINDFS_H__ */
diff --git a/tools/lib/api/fs/tracefs.c b/tools/lib/api/fs/tracefs.c
new file mode 100644
index 000000000000..e4aa9688b71e
--- /dev/null
+++ b/tools/lib/api/fs/tracefs.c
@@ -0,0 +1,78 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <sys/vfs.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <linux/kernel.h>
+#include "tracefs.h"
+#ifndef TRACEFS_DEFAULT_PATH
+#define TRACEFS_DEFAULT_PATH            "/sys/kernel/tracing"
+#endif
+char tracefs_mountpoint[PATH_MAX + 1] = TRACEFS_DEFAULT_PATH;
+static const char * const tracefs_known_mountpoints[] = {
+        TRACEFS_DEFAULT_PATH,
+        "/sys/kernel/debug/tracing",
+        "/tracing",
+        "/trace",
+        0,
+};
+static bool tracefs_found;
+bool tracefs_configured(void)
+{
+        return tracefs_find_mountpoint() != NULL;
+}
+/* find the path to the mounted tracefs */
+const char *tracefs_find_mountpoint(void)
+{
+        const char *ret;
+        if (tracefs_found)
+                return (const char *)tracefs_mountpoint;
+        ret = find_mountpoint("tracefs", (long) TRACEFS_MAGIC,
+                              tracefs_mountpoint, PATH_MAX + 1,
+                              tracefs_known_mountpoints);
+        if (ret)
+                tracefs_found = true;
+        return ret;
+}
+/* mount the tracefs somewhere if it's not mounted */
+char *tracefs_mount(const char *mountpoint)
+{
+        /* see if it's already mounted */
+        if (tracefs_find_mountpoint())
+                goto out;
+        /* if not mounted and no argument */
+        if (mountpoint == NULL) {
+                /* see if environment variable set */
+                mountpoint = getenv(PERF_TRACEFS_ENVIRONMENT);
+                /* if no environment variable, use default */
+                if (mountpoint == NULL)
+                        mountpoint = TRACEFS_DEFAULT_PATH;
+        }
+        if (mount(NULL, mountpoint, "tracefs", 0, NULL) < 0)
+                return NULL;
+        /* save the mountpoint */
+        tracefs_found = true;
+        strncpy(tracefs_mountpoint, mountpoint, sizeof(tracefs_mountpoint));
+out:
+        return tracefs_mountpoint;
+}
diff --git a/tools/lib/api/fs/tracefs.h b/tools/lib/api/fs/tracefs.h
new file mode 100644
index 000000000000..da780ac49acb
--- /dev/null
+++ b/tools/lib/api/fs/tracefs.h
@@ -0,0 +1,21 @@
+#ifndef __API_TRACEFS_H__
+#define __API_TRACEFS_H__
+#include "findfs.h"
+#ifndef TRACEFS_MAGIC
+#define TRACEFS_MAGIC          0x74726163
+#endif
+#ifndef PERF_TRACEFS_ENVIRONMENT
+#define PERF_TRACEFS_ENVIRONMENT "PERF_TRACEFS_DIR"
+#endif
+bool tracefs_configured(void);
+const char *tracefs_find_mountpoint(void);
+int tracefs_valid_mountpoint(const char *debugfs);
+char *tracefs_mount(const char *mountpoint);
+extern char tracefs_mountpoint[];
+#endif /* __API_DEBUGFS_H__ */
diff --git a/tools/lib/lockdep/Build b/tools/lib/lockdep/Build
new file mode 100644
index 000000000000..6f667355b068
--- /dev/null
+++ b/tools/lib/lockdep/Build
@@ -0,0 +1 @@
+liblockdep-y += common.o lockdep.o preload.o rbtree.o
diff --git a/tools/lib/lockdep/Makefile b/tools/lib/lockdep/Makefile
index 4b866c54f624..0c356fb65022 100644
--- a/tools/lib/lockdep/Makefile
+++ b/tools/lib/lockdep/Makefile
@@ -35,6 +35,10 @@ bindir = $(prefix)/$(bindir_relative)
 export DESTDIR DESTDIR_SQ INSTALL
+MAKEFLAGS += --no-print-directory
+include ../../scripts/Makefile.include
 # copy a bit from Linux kbuild
 ifeq ("$(origin V)", "command line")
@@ -44,56 +48,21 @@ ifndef VERBOSE
  VERBOSE = 0
 endif
-ifeq ("$(origin O)", "command line")
+ifeq ($(srctree),)
-  BUILD_OUTPUT := $(O)
+srctree := $(patsubst %/,%,$(dir $(shell pwd)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+#$(info Determined 'srctree' to be $(srctree))
 endif
-ifeq ($(BUILD_SRC),)
-ifneq ($(BUILD_OUTPUT),)
-define build_output
-        $(if $(VERBOSE:1=),@)$(MAKE) -C $(BUILD_OUTPUT) \
-        BUILD_SRC=$(CURDIR) -f $(CURDIR)/Makefile $1
-endef
-saved-output := $(BUILD_OUTPUT)
-BUILD_OUTPUT := $(shell cd $(BUILD_OUTPUT) && /bin/pwd)
-$(if $(BUILD_OUTPUT),, \
-     $(error output directory "$(saved-output)" does not exist))
-all: sub-make
-gui: force
-        $(call build_output, all_cmd)
-$(filter-out gui,$(MAKECMDGOALS)): sub-make
-sub-make: force
-        $(call build_output, $(MAKECMDGOALS))
-# Leave processing to above invocation of make
-skip-makefile := 1
-endif # BUILD_OUTPUT
-endif # BUILD_SRC
-# We process the rest of the Makefile if this is the final invocation of make
-ifeq ($(skip-makefile),)
-srctree         := $(realpath $(if $(BUILD_SRC),$(BUILD_SRC),$(CURDIR)))
-objtree         := $(realpath $(CURDIR))
-src             := $(srctree)
-obj             := $(objtree)
-export prefix libdir bindir src obj
 # Shell quotes
 libdir_SQ = $(subst ','\'',$(libdir))
 bindir_SQ = $(subst ','\'',$(bindir))
-LIB_FILE = liblockdep.a liblockdep.so.$(LIBLOCKDEP_VERSION)
+LIB_IN := $(OUTPUT)liblockdep-in.o
 BIN_FILE = lockdep
+LIB_FILE = $(OUTPUT)liblockdep.a $(OUTPUT)liblockdep.so.$(LIBLOCKDEP_VERSION)
 CONFIG_INCLUDES =
 CONFIG_LIBS     =
@@ -108,33 +77,23 @@ INCLUDES = -I. -I./uinclude -I./include -I../../include $(CONFIG_INCLUDES)
 # Set compile option CFLAGS if not set elsewhere
 CFLAGS ?= -g -DCONFIG_LOCKDEP -DCONFIG_STACKTRACE -DCONFIG_PROVE_LOCKING -DBITS_PER_LONG=__WORDSIZE -DLIBLOCKDEP_VERSION='"$(LIBLOCKDEP_VERSION)"' -rdynamic -O0 -g
+CFLAGS += -fPIC
 override CFLAGS += $(CONFIG_FLAGS) $(INCLUDES) $(PLUGIN_DIR_SQ)
 ifeq ($(VERBOSE),1)
  Q =
-  print_compile =
-  print_app_build =
-  print_fpic_compile =
  print_shared_lib_compile =
  print_install =
 else
  Q = @
-  print_compile =               echo '  CC                 '$(OBJ);
+  print_shared_lib_compile =    echo '  LD       '$(OBJ);
-  print_app_build =             echo '  BUILD              '$(OBJ);
+  print_static_lib_build =      echo '  LD       '$(OBJ);
-  print_fpic_compile =          echo '  CC FPIC            '$(OBJ);
+  print_install =               echo '  INSTALL  '$1'   to      $(DESTDIR_SQ)$2';
-  print_shared_lib_compile =    echo '  BUILD SHARED LIB   '$(OBJ);
-  print_static_lib_build =      echo '  BUILD STATIC LIB   '$(OBJ);
-  print_install =               echo '  INSTALL     '$1'        to      $(DESTDIR_SQ)$2';
 endif
-do_fpic_compile =                                       \
+export srctree OUTPUT CC LD CFLAGS V
-        ($(print_fpic_compile)                          \
+build := -f $(srctree)/tools/build/Makefile.build dir=. obj
-        $(CC) -c $(CFLAGS) $(EXT) -fPIC $< -o $@)
-do_app_build =                                          \
-        ($(print_app_build)                             \
-        $(CC) $^ -rdynamic -o $@ $(CONFIG_LIBS) $(LIBS))
 do_compile_shared_library =                     \
        ($(print_shared_lib_compile)            \
@@ -144,22 +103,6 @@ do_build_static_lib =				\
        ($(print_static_lib_build)              \
        $(RM) $@;  $(AR) rcs $@ $^)
-define do_compile
-        $(print_compile)                                                \
-        $(CC) -c $(CFLAGS) $(EXT) $< -o $(obj)/$@;
-endef
-$(obj)/%.o: $(src)/%.c
-        $(Q)$(call do_compile)
-%.o: $(src)/%.c
-        $(Q)$(call do_compile)
-PEVENT_LIB_OBJS = common.o lockdep.o preload.o rbtree.o
-ALL_OBJS = $(PEVENT_LIB_OBJS)
 CMD_TARGETS = $(LIB_FILE)
 TARGETS = $(CMD_TARGETS)
@@ -169,42 +112,15 @@ all: all_cmd
 all_cmd: $(CMD_TARGETS)
-liblockdep.so.$(LIBLOCKDEP_VERSION): $(PEVENT_LIB_OBJS)
+$(LIB_IN): force
+        $(Q)$(MAKE) $(build)=liblockdep
+liblockdep.so.$(LIBLOCKDEP_VERSION): $(LIB_IN)
        $(Q)$(do_compile_shared_library)
-liblockdep.a: $(PEVENT_LIB_OBJS)
+liblockdep.a: $(LIB_IN)
        $(Q)$(do_build_static_lib)
-$(PEVENT_LIB_OBJS): %.o: $(src)/%.c
-        $(Q)$(do_fpic_compile)
-## make deps
-all_objs := $(sort $(ALL_OBJS))
-all_deps := $(all_objs:%.o=.%.d)
-# let .d file also depends on the source and header files
-define check_deps
-                @set -e; $(RM) $@; \
-                $(CC) -MM $(CFLAGS) $< > $@.$$$$; \
-                sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
-                $(RM) $@.$$$$
-endef
-$(all_deps): .%.d: $(src)/%.c
-        $(Q)$(call check_deps)
-$(all_objs) : %.o : .%.d
-dep_includes := $(wildcard $(all_deps))
-ifneq ($(dep_includes),)
- include $(dep_includes)
-endif
-### Detect environment changes
-TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):$(ARCH):$(CROSS_COMPILE)
 tags:   force
        $(RM) tags
        find . -name '*.[ch]' | xargs ctags --extra=+f --c-kinds=+px \
@@ -233,8 +149,6 @@ clean:
        $(RM) *.o *~ $(TARGETS) *.a *liblockdep*.so* $(VERSION_FILES) .*.d
        $(RM) tags TAGS
-endif # skip-makefile
 PHONY += force
 force:
diff --git a/tools/lib/traceevent/Build b/tools/lib/traceevent/Build
new file mode 100644
index 000000000000..c681d0575d16
--- /dev/null
+++ b/tools/lib/traceevent/Build
@@ -0,0 +1,17 @@
+libtraceevent-y += event-parse.o
+libtraceevent-y += event-plugin.o
+libtraceevent-y += trace-seq.o
+libtraceevent-y += parse-filter.o
+libtraceevent-y += parse-utils.o
+libtraceevent-y += kbuffer-parse.o
+plugin_jbd2-y         += plugin_jbd2.o
+plugin_hrtimer-y      += plugin_hrtimer.o
+plugin_kmem-y         += plugin_kmem.o
+plugin_kvm-y          += plugin_kvm.o
+plugin_mac80211-y     += plugin_mac80211.o
+plugin_sched_switch-y += plugin_sched_switch.o
+plugin_function-y     += plugin_function.o
+plugin_xen-y          += plugin_xen.o
+plugin_scsi-y         += plugin_scsi.o
+plugin_cfg80211-y     += plugin_cfg80211.o
diff --git a/tools/lib/traceevent/Makefile b/tools/lib/traceevent/Makefile
index 005c9cc06935..d410da335e3d 100644
--- a/tools/lib/traceevent/Makefile
+++ b/tools/lib/traceevent/Makefile
@@ -67,7 +67,7 @@ PLUGIN_DIR = -DPLUGIN_DIR="$(plugin_dir)"
 PLUGIN_DIR_SQ = '$(subst ','\'',$(PLUGIN_DIR))'
 endif
-include $(if $(BUILD_SRC),$(BUILD_SRC)/)../../scripts/Makefile.include
+include ../../scripts/Makefile.include
 # copy a bit from Linux kbuild
@@ -78,40 +78,13 @@ ifndef VERBOSE
  VERBOSE = 0
 endif
-ifeq ("$(origin O)", "command line")
+ifeq ($(srctree),)
-  BUILD_OUTPUT := $(O)
+srctree := $(patsubst %/,%,$(dir $(shell pwd)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+#$(info Determined 'srctree' to be $(srctree))
 endif
-ifeq ($(BUILD_SRC),)
-ifneq ($(OUTPUT),)
-define build_output
-  $(if $(VERBOSE:1=),@)+$(MAKE) -C $(OUTPUT) \
-  BUILD_SRC=$(CURDIR)/ -f $(CURDIR)/Makefile $1
-endef
-all: sub-make
-$(MAKECMDGOALS): sub-make
-sub-make: force
-        $(call build_output, $(MAKECMDGOALS))
-# Leave processing to above invocation of make
-skip-makefile := 1
-endif # OUTPUT
-endif # BUILD_SRC
-# We process the rest of the Makefile if this is the final invocation of make
-ifeq ($(skip-makefile),)
-srctree         := $(if $(BUILD_SRC),$(BUILD_SRC),$(CURDIR))
-objtree         := $(CURDIR)
-src             := $(srctree)
-obj             := $(objtree)
 export prefix bindir src obj
 # Shell quotes
@@ -132,16 +105,19 @@ EXTRAVERSION	= $(EP_EXTRAVERSION)
 OBJ             = $@
 N               =
-export Q VERBOSE
 EVENT_PARSE_VERSION = $(EP_VERSION).$(EP_PATCHLEVEL).$(EP_EXTRAVERSION)
-INCLUDES = -I. -I $(srctree)/../../include $(CONFIG_INCLUDES)
+INCLUDES = -I. -I $(srctree)/tools/include $(CONFIG_INCLUDES)
-# Set compile option CFLAGS if not set elsewhere
+# Set compile option CFLAGS
-CFLAGS ?= -g -Wall
+ifdef EXTRA_CFLAGS
+  CFLAGS := $(EXTRA_CFLAGS)
+else
+  CFLAGS := -g -Wall
+endif
 # Append required CFLAGS
+override CFLAGS += -fPIC
 override CFLAGS += $(CONFIG_FLAGS) $(INCLUDES) $(PLUGIN_DIR_SQ)
 override CFLAGS += $(udis86-flags) -D_GNU_SOURCE
@@ -151,74 +127,58 @@ else
  Q = @
 endif
-do_compile_shared_library =                     \
+# Disable command line variables (CFLAGS) overide from top
-        ($(print_shared_lib_compile)            \
+# level Makefile (perf), otherwise build Makefile will get
-        $(CC) --shared $^ -o $@)
+# the same command line setup.
+MAKEOVERRIDES=
-do_plugin_build =                               \
-        ($(print_plugin_build)                  \
-        $(CC) $(CFLAGS) -shared -nostartfiles -o $@ $<)
-do_build_static_lib =                           \
-        ($(print_static_lib_build)              \
-        $(RM) $@;  $(AR) rcs $@ $^)
-do_compile = $(QUIET_CC)$(CC) -c $(CFLAGS) $(EXT) $< -o $(obj)/$@;
-$(obj)/%.o: $(src)/%.c
+export srctree OUTPUT CC LD CFLAGS V
-        $(call do_compile)
+build := -f $(srctree)/tools/build/Makefile.build dir=. obj
-%.o: $(src)/%.c
+PLUGINS  = plugin_jbd2.so
-        $(call do_compile)
+PLUGINS += plugin_hrtimer.so
+PLUGINS += plugin_kmem.so
+PLUGINS += plugin_kvm.so
+PLUGINS += plugin_mac80211.so
+PLUGINS += plugin_sched_switch.so
+PLUGINS += plugin_function.so
+PLUGINS += plugin_xen.so
+PLUGINS += plugin_scsi.so
+PLUGINS += plugin_cfg80211.so
-PEVENT_LIB_OBJS  = event-parse.o
+PLUGINS    := $(addprefix $(OUTPUT),$(PLUGINS))
-PEVENT_LIB_OBJS += event-plugin.o
+PLUGINS_IN := $(PLUGINS:.so=-in.o)
-PEVENT_LIB_OBJS += trace-seq.o
-PEVENT_LIB_OBJS += parse-filter.o
-PEVENT_LIB_OBJS += parse-utils.o
-PEVENT_LIB_OBJS += kbuffer-parse.o
-PLUGIN_OBJS  = plugin_jbd2.o
+TE_IN    := $(OUTPUT)libtraceevent-in.o
-PLUGIN_OBJS += plugin_hrtimer.o
+LIB_FILE := $(addprefix $(OUTPUT),$(LIB_FILE))
-PLUGIN_OBJS += plugin_kmem.o
-PLUGIN_OBJS += plugin_kvm.o
-PLUGIN_OBJS += plugin_mac80211.o
-PLUGIN_OBJS += plugin_sched_switch.o
-PLUGIN_OBJS += plugin_function.o
-PLUGIN_OBJS += plugin_xen.o
-PLUGIN_OBJS += plugin_scsi.o
-PLUGIN_OBJS += plugin_cfg80211.o
-PLUGINS := $(PLUGIN_OBJS:.o=.so)
-ALL_OBJS = $(PEVENT_LIB_OBJS) $(PLUGIN_OBJS)
 CMD_TARGETS = $(LIB_FILE) $(PLUGINS)
 TARGETS = $(CMD_TARGETS)
 all: all_cmd
 all_cmd: $(CMD_TARGETS)
-libtraceevent.so: $(PEVENT_LIB_OBJS)
+$(TE_IN): force
+        $(Q)$(MAKE) $(build)=libtraceevent
+$(OUTPUT)libtraceevent.so: $(TE_IN)
        $(QUIET_LINK)$(CC) --shared $^ -o $@
-libtraceevent.a: $(PEVENT_LIB_OBJS)
+$(OUTPUT)libtraceevent.a: $(TE_IN)
        $(QUIET_LINK)$(RM) $@; $(AR) rcs $@ $^
 plugins: $(PLUGINS)
-$(PEVENT_LIB_OBJS): %.o: $(src)/%.c TRACEEVENT-CFLAGS
+__plugin_obj = $(notdir $@)
-        $(QUIET_CC_FPIC)$(CC) -c $(CFLAGS) $(EXT) -fPIC $< -o $@
+  plugin_obj = $(__plugin_obj:-in.o=)
-$(PLUGIN_OBJS): %.o : $(src)/%.c
+$(PLUGINS_IN): force
-        $(QUIET_CC_FPIC)$(CC) -c $(CFLAGS) -fPIC -o $@ $<
+        $(Q)$(MAKE) $(build)=$(plugin_obj)
-$(PLUGINS): %.so: %.o
+$(OUTPUT)%.so: $(OUTPUT)%-in.o
-        $(QUIET_LINK)$(CC) $(CFLAGS) -shared -nostartfiles -o $@ $<
+        $(QUIET_LINK)$(CC) $(CFLAGS) -shared -nostartfiles -o $@ $^
 define make_version.h
  (echo '/* This file is automatically generated. Do not modify. */';           \
@@ -255,40 +215,6 @@ define update_dir
   fi);
 endef
-## make deps
-all_objs := $(sort $(ALL_OBJS))
-all_deps := $(all_objs:%.o=.%.d)
-# let .d file also depends on the source and header files
-define check_deps
-  @set -e; $(RM) $@; \
-  $(CC) -MM $(CFLAGS) $< > $@.$$$$; \
-  sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
-  $(RM) $@.$$$$
-endef
-$(all_deps): .%.d: $(src)/%.c
-        $(Q)$(call check_deps)
-$(all_objs) : %.o : .%.d
-dep_includes := $(wildcard $(all_deps))
-ifneq ($(dep_includes),)
- include $(dep_includes)
-endif
-### Detect environment changes
-TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):$(ARCH):$(CROSS_COMPILE)
-TRACEEVENT-CFLAGS: force
-        @FLAGS='$(TRACK_CFLAGS)'; \
-            if test x"$$FLAGS" != x"`cat TRACEEVENT-CFLAGS 2>/dev/null`" ; then \
-                echo 1>&2 "  FLAGS:   * new build flags or cross compiler"; \
-                echo "$$FLAGS" >TRACEEVENT-CFLAGS; \
-            fi
 tags:   force
        $(RM) tags
        find . -name '*.[ch]' | xargs ctags --extra=+f --c-kinds=+px \
@@ -327,14 +253,9 @@ clean:
                $(RM) *.o *~ $(TARGETS) *.a *.so $(VERSION_FILES) .*.d \
                $(RM) TRACEEVENT-CFLAGS tags TAGS
-endif # skip-makefile
 PHONY += force plugins
 force:
-plugins:
-        @echo > /dev/null
 # Declare the contents of the .PHONY variable as phony.  We keep that
 # information in a variable so we can use it in if_changed and friends.
 .PHONY: $(PHONY)
diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index afe20ed9fac8..6d31b6419d37 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -304,7 +304,10 @@ int pevent_register_comm(struct pevent *pevent, const char *comm, int pid)
        if (!item)
                return -1;
-        item->comm = strdup(comm);
+        if (comm)
+                item->comm = strdup(comm);
+        else
+                item->comm = strdup("<...>");
        if (!item->comm) {
                free(item);
                return -1;
@@ -318,9 +321,14 @@ int pevent_register_comm(struct pevent *pevent, const char *comm, int pid)
        return 0;
 }
-void pevent_register_trace_clock(struct pevent *pevent, char *trace_clock)
+int pevent_register_trace_clock(struct pevent *pevent, const char *trace_clock)
 {
-        pevent->trace_clock = trace_clock;
+        pevent->trace_clock = strdup(trace_clock);
+        if (!pevent->trace_clock) {
+                errno = ENOMEM;
+                return -1;
+        }
+        return 0;
 }
 struct func_map {
@@ -758,6 +766,11 @@ static void free_arg(struct print_arg *arg)
                free_arg(arg->hex.field);
                free_arg(arg->hex.size);
                break;
+        case PRINT_INT_ARRAY:
+                free_arg(arg->int_array.field);
+                free_arg(arg->int_array.count);
+                free_arg(arg->int_array.el_size);
+                break;
        case PRINT_TYPE:
                free(arg->typecast.type);
                free_arg(arg->typecast.item);
@@ -2014,6 +2027,38 @@ process_entry(struct event_format *event __maybe_unused, struct print_arg *arg,
        return EVENT_ERROR;
 }
+static int alloc_and_process_delim(struct event_format *event, char *next_token,
+                                   struct print_arg **print_arg)
+{
+        struct print_arg *field;
+        enum event_type type;
+        char *token;
+        int ret = 0;
+        field = alloc_arg();
+        if (!field) {
+                do_warning_event(event, "%s: not enough memory!", __func__);
+                errno = ENOMEM;
+                return -1;
+        }
+        type = process_arg(event, field, &token);
+        if (test_type_token(type, token, EVENT_DELIM, next_token)) {
+                errno = EINVAL;
+                ret = -1;
+                free_arg(field);
+                goto out_free_token;
+        }
+        *print_arg = field;
+out_free_token:
+        free_token(token);
+        return ret;
+}
 static char *arg_eval (struct print_arg *arg);
 static unsigned long long
@@ -2486,49 +2531,46 @@ out_free:
 static enum event_type
 process_hex(struct event_format *event, struct print_arg *arg, char **tok)
 {
-        struct print_arg *field;
-        enum event_type type;
-        char *token = NULL;
        memset(arg, 0, sizeof(*arg));
        arg->type = PRINT_HEX;
-        field = alloc_arg();
+        if (alloc_and_process_delim(event, ",", &arg->hex.field))
-        if (!field) {
+                goto out;
-                do_warning_event(event, "%s: not enough memory!", __func__);
-                goto out_free;
-        }
-        type = process_arg(event, field, &token);
-        if (test_type_token(type, token, EVENT_DELIM, ","))
+        if (alloc_and_process_delim(event, ")", &arg->hex.size))
-                goto out_free;
+                goto free_field;
-        arg->hex.field = field;
+        return read_token_item(tok);
-        free_token(token);
+free_field:
+        free_arg(arg->hex.field);
+out:
+        *tok = NULL;
+        return EVENT_ERROR;
+}
-        field = alloc_arg();
+static enum event_type
-        if (!field) {
+process_int_array(struct event_format *event, struct print_arg *arg, char **tok)
-                do_warning_event(event, "%s: not enough memory!", __func__);
+{
-                *tok = NULL;
+        memset(arg, 0, sizeof(*arg));
-                return EVENT_ERROR;
+        arg->type = PRINT_INT_ARRAY;
-        }
-        type = process_arg(event, field, &token);
+        if (alloc_and_process_delim(event, ",", &arg->int_array.field))
+                goto out;
-        if (test_type_token(type, token, EVENT_DELIM, ")"))
+        if (alloc_and_process_delim(event, ",", &arg->int_array.count))
-                goto out_free;
+                goto free_field;
-        arg->hex.size = field;
+        if (alloc_and_process_delim(event, ")", &arg->int_array.el_size))
+                goto free_size;
-        free_token(token);
+        return read_token_item(tok);
-        type = read_token_item(tok);
-        return type;
- out_free:
+free_size:
-        free_arg(field);
+        free_arg(arg->int_array.count);
-        free_token(token);
+free_field:
+        free_arg(arg->int_array.field);
+out:
        *tok = NULL;
        return EVENT_ERROR;
 }
@@ -2828,6 +2870,10 @@ process_function(struct event_format *event, struct print_arg *arg,
                free_token(token);
                return process_hex(event, arg, tok);
        }
+        if (strcmp(token, "__print_array") == 0) {
+                free_token(token);
+                return process_int_array(event, arg, tok);
+        }
        if (strcmp(token, "__get_str") == 0) {
                free_token(token);
                return process_str(event, arg, tok);
@@ -3356,6 +3402,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                break;
        case PRINT_FLAGS:
        case PRINT_SYMBOL:
+        case PRINT_INT_ARRAY:
        case PRINT_HEX:
                break;
        case PRINT_TYPE:
@@ -3568,7 +3615,7 @@ static const struct flag flags[] = {
        { "HRTIMER_RESTART", 1 },
 };
-static unsigned long long eval_flag(const char *flag)
+static long long eval_flag(const char *flag)
 {
        int i;
@@ -3584,7 +3631,7 @@ static unsigned long long eval_flag(const char *flag)
                if (strcmp(flags[i].name, flag) == 0)
                        return flags[i].value;
-        return 0;
+        return -1LL;
 }
 static void print_str_to_seq(struct trace_seq *s, const char *format,
@@ -3658,7 +3705,7 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
        struct print_flag_sym *flag;
        struct format_field *field;
        struct printk_map *printk;
-        unsigned long long val, fval;
+        long long val, fval;
        unsigned long addr;
        char *str;
        unsigned char *hex;
@@ -3717,11 +3764,11 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                print = 0;
                for (flag = arg->flags.flags; flag; flag = flag->next) {
                        fval = eval_flag(flag->value);
-                        if (!val && !fval) {
+                        if (!val && fval < 0) {
                                print_str_to_seq(s, format, len_arg, flag->str);
                                break;
                        }
-                        if (fval && (val & fval) == fval) {
+                        if (fval > 0 && (val & fval) == fval) {
                                if (print && arg->flags.delim)
                                        trace_seq_puts(s, arg->flags.delim);
                                print_str_to_seq(s, format, len_arg, flag->str);
@@ -3766,6 +3813,54 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                }
                break;
+        case PRINT_INT_ARRAY: {
+                void *num;
+                int el_size;
+                if (arg->int_array.field->type == PRINT_DYNAMIC_ARRAY) {
+                        unsigned long offset;
+                        struct format_field *field =
+                                arg->int_array.field->dynarray.field;
+                        offset = pevent_read_number(pevent,
+                                                    data + field->offset,
+                                                    field->size);
+                        num = data + (offset & 0xffff);
+                } else {
+                        field = arg->int_array.field->field.field;
+                        if (!field) {
+                                str = arg->int_array.field->field.name;
+                                field = pevent_find_any_field(event, str);
+                                if (!field)
+                                        goto out_warning_field;
+                                arg->int_array.field->field.field = field;
+                        }
+                        num = data + field->offset;
+                }
+                len = eval_num_arg(data, size, event, arg->int_array.count);
+                el_size = eval_num_arg(data, size, event,
+                                       arg->int_array.el_size);
+                for (i = 0; i < len; i++) {
+                        if (i)
+                                trace_seq_putc(s, ' ');
+                        if (el_size == 1) {
+                                trace_seq_printf(s, "%u", *(uint8_t *)num);
+                        } else if (el_size == 2) {
+                                trace_seq_printf(s, "%u", *(uint16_t *)num);
+                        } else if (el_size == 4) {
+                                trace_seq_printf(s, "%u", *(uint32_t *)num);
+                        } else if (el_size == 8) {
+                                trace_seq_printf(s, "%lu", *(uint64_t *)num);
+                        } else {
+                                trace_seq_printf(s, "BAD SIZE:%d 0x%x",
+                                                 el_size, *(uint8_t *)num);
+                                el_size = 1;
+                        }
+                        num += el_size;
+                }
+                break;
+        }
        case PRINT_TYPE:
                break;
        case PRINT_STRING: {
@@ -3997,6 +4092,10 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                                goto process_again;
                        case '.':
                                goto process_again;
+                        case 'z':
+                        case 'Z':
+                                ls = 1;
+                                goto process_again;
                        case 'p':
                                ls = 1;
                                /* fall through */
@@ -4939,6 +5038,96 @@ const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid)
        return comm;
 }
+static struct cmdline *
+pid_from_cmdlist(struct pevent *pevent, const char *comm, struct cmdline *next)
+{
+        struct cmdline_list *cmdlist = (struct cmdline_list *)next;
+        if (cmdlist)
+                cmdlist = cmdlist->next;
+        else
+                cmdlist = pevent->cmdlist;
+        while (cmdlist && strcmp(cmdlist->comm, comm) != 0)
+                cmdlist = cmdlist->next;
+        return (struct cmdline *)cmdlist;
+}
+/**
+ * pevent_data_pid_from_comm - return the pid from a given comm
+ * @pevent: a handle to the pevent
+ * @comm: the cmdline to find the pid from
+ * @next: the cmdline structure to find the next comm
+ *
+ * This returns the cmdline structure that holds a pid for a given
+ * comm, or NULL if none found. As there may be more than one pid for
+ * a given comm, the result of this call can be passed back into
+ * a recurring call in the @next paramater, and then it will find the
+ * next pid.
+ * Also, it does a linear seach, so it may be slow.
+ */
+struct cmdline *pevent_data_pid_from_comm(struct pevent *pevent, const char *comm,
+                                          struct cmdline *next)
+{
+        struct cmdline *cmdline;
+        /*
+         * If the cmdlines have not been converted yet, then use
+         * the list.
+         */
+        if (!pevent->cmdlines)
+                return pid_from_cmdlist(pevent, comm, next);
+        if (next) {
+                /*
+                 * The next pointer could have been still from
+                 * a previous call before cmdlines were created
+                 */
+                if (next < pevent->cmdlines ||
+                    next >= pevent->cmdlines + pevent->cmdline_count)
+                        next = NULL;
+                else
+                        cmdline  = next++;
+        }
+        if (!next)
+                cmdline = pevent->cmdlines;
+        while (cmdline < pevent->cmdlines + pevent->cmdline_count) {
+                if (strcmp(cmdline->comm, comm) == 0)
+                        return cmdline;
+                cmdline++;
+        }
+        return NULL;
+}
+/**
+ * pevent_cmdline_pid - return the pid associated to a given cmdline
+ * @cmdline: The cmdline structure to get the pid from
+ *
+ * Returns the pid for a give cmdline. If @cmdline is NULL, then
+ * -1 is returned.
+ */
+int pevent_cmdline_pid(struct pevent *pevent, struct cmdline *cmdline)
+{
+        struct cmdline_list *cmdlist = (struct cmdline_list *)cmdline;
+        if (!cmdline)
+                return -1;
+        /*
+         * If cmdlines have not been created yet, or cmdline is
+         * not part of the array, then treat it as a cmdlist instead.
+         */
+        if (!pevent->cmdlines ||
+            cmdline < pevent->cmdlines ||
+            cmdline >= pevent->cmdlines + pevent->cmdline_count)
+                return cmdlist->pid;
+        return cmdline->pid;
+}
 /**
 * pevent_data_comm_from_pid - parse the data into the print format
 * @s: the trace_seq to write to
@@ -5256,6 +5445,15 @@ static void print_args(struct print_arg *args)
                print_args(args->hex.size);
                printf(")");
                break;
+        case PRINT_INT_ARRAY:
+                printf("__print_array(");
+                print_args(args->int_array.field);
+                printf(", ");
+                print_args(args->int_array.count);
+                printf(", ");
+                print_args(args->int_array.el_size);
+                printf(")");
+                break;
        case PRINT_STRING:
        case PRINT_BSTRING:
                printf("__get_str(%s)", args->string.string);
@@ -6228,15 +6426,20 @@ void pevent_ref(struct pevent *pevent)
        pevent->ref_count++;
 }
+void pevent_free_format_field(struct format_field *field)
+{
+        free(field->type);
+        free(field->name);
+        free(field);
+}
 static void free_format_fields(struct format_field *field)
 {
        struct format_field *next;
        while (field) {
                next = field->next;
-                free(field->type);
+                pevent_free_format_field(field);
-                free(field->name);
-                free(field);
                field = next;
        }
 }
@@ -6341,6 +6544,7 @@ void pevent_free(struct pevent *pevent)
                free_handler(handle);
        }
+        free(pevent->trace_clock);
        free(pevent->events);
        free(pevent->sort_events);
diff --git a/tools/lib/traceevent/event-parse.h b/tools/lib/traceevent/event-parse.h
index 7a3873ff9a4f..86a5839fb048 100644
--- a/tools/lib/traceevent/event-parse.h
+++ b/tools/lib/traceevent/event-parse.h
@@ -22,6 +22,7 @@
 #include <stdbool.h>
 #include <stdarg.h>
+#include <stdio.h>
 #include <regex.h>
 #include <string.h>
@@ -91,6 +92,7 @@ extern int trace_seq_putc(struct trace_seq *s, unsigned char c);
 extern void trace_seq_terminate(struct trace_seq *s);
+extern int trace_seq_do_fprintf(struct trace_seq *s, FILE *fp);
 extern int trace_seq_do_printf(struct trace_seq *s);
@@ -114,7 +116,7 @@ struct pevent_plugin_option {
        char                            *name;
        char                            *plugin_alias;
        char                            *description;
-        char                            *value;
+        const char                      *value;
        void                            *priv;
        int                             set;
 };
@@ -152,6 +154,10 @@ struct pevent_plugin_option {
 *   .plugin_alias is used to give a shorter name to access
 *   the vairable. Useful if a plugin handles more than one event.
 *
+ *   If .value is not set, then it is considered a boolean and only
+ *   .set will be processed. If .value is defined, then it is considered
+ *   a string option and .set will be ignored.
+ *
 * PEVENT_PLUGIN_ALIAS: (optional)
 *   The name to use for finding options (uses filename if not defined)
 */
@@ -245,6 +251,12 @@ struct print_arg_hex {
        struct print_arg        *size;
 };
+struct print_arg_int_array {
+        struct print_arg        *field;
+        struct print_arg        *count;
+        struct print_arg        *el_size;
+};
 struct print_arg_dynarray {
        struct format_field     *field;
        struct print_arg        *index;
@@ -273,6 +285,7 @@ enum print_arg_type {
        PRINT_FLAGS,
        PRINT_SYMBOL,
        PRINT_HEX,
+        PRINT_INT_ARRAY,
        PRINT_TYPE,
        PRINT_STRING,
        PRINT_BSTRING,
@@ -292,6 +305,7 @@ struct print_arg {
                struct print_arg_flags          flags;
                struct print_arg_symbol         symbol;
                struct print_arg_hex            hex;
+                struct print_arg_int_array      int_array;
                struct print_arg_func           func;
                struct print_arg_string         string;
                struct print_arg_bitmask        bitmask;
@@ -597,7 +611,7 @@ enum trace_flag_type {
 };
 int pevent_register_comm(struct pevent *pevent, const char *comm, int pid);
-void pevent_register_trace_clock(struct pevent *pevent, char *trace_clock);
+int pevent_register_trace_clock(struct pevent *pevent, const char *trace_clock);
 int pevent_register_function(struct pevent *pevent, char *name,
                             unsigned long long addr, char *mod);
 int pevent_register_print_string(struct pevent *pevent, const char *fmt,
@@ -617,6 +631,7 @@ enum pevent_errno pevent_parse_format(struct pevent *pevent,
                                      const char *buf,
                                      unsigned long size, const char *sys);
 void pevent_free_format(struct event_format *event);
+void pevent_free_format_field(struct format_field *field);
 void *pevent_get_field_raw(struct trace_seq *s, struct event_format *event,
                           const char *name, struct pevent_record *record,
@@ -675,6 +690,11 @@ int pevent_data_type(struct pevent *pevent, struct pevent_record *rec);
 struct event_format *pevent_data_event_from_type(struct pevent *pevent, int type);
 int pevent_data_pid(struct pevent *pevent, struct pevent_record *rec);
 const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid);
+struct cmdline;
+struct cmdline *pevent_data_pid_from_comm(struct pevent *pevent, const char *comm,
+                                          struct cmdline *next);
+int pevent_cmdline_pid(struct pevent *pevent, struct cmdline *cmdline);
 void pevent_event_info(struct trace_seq *s, struct event_format *event,
                       struct pevent_record *record);
 int pevent_strerror(struct pevent *pevent, enum pevent_errno errnum,
diff --git a/tools/lib/traceevent/event-plugin.c b/tools/lib/traceevent/event-plugin.c
index 136162c03af1..a16756ae3526 100644
--- a/tools/lib/traceevent/event-plugin.c
+++ b/tools/lib/traceevent/event-plugin.c
@@ -18,6 +18,7 @@
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */
+#include <ctype.h>
 #include <stdio.h>
 #include <string.h>
 #include <dlfcn.h>
@@ -49,6 +50,52 @@ struct plugin_list {
        void                    *handle;
 };
+static void lower_case(char *str)
+{
+        if (!str)
+                return;
+        for (; *str; str++)
+                *str = tolower(*str);
+}
+static int update_option_value(struct pevent_plugin_option *op, const char *val)
+{
+        char *op_val;
+        if (!val) {
+                /* toggle, only if option is boolean */
+                if (op->value)
+                        /* Warn? */
+                        return 0;
+                op->set ^= 1;
+                return 0;
+        }
+        /*
+         * If the option has a value then it takes a string
+         * otherwise the option is a boolean.
+         */
+        if (op->value) {
+                op->value = val;
+                return 0;
+        }
+        /* Option is boolean, must be either "1", "0", "true" or "false" */
+        op_val = strdup(val);
+        if (!op_val)
+                return -1;
+        lower_case(op_val);
+        if (strcmp(val, "1") == 0 || strcmp(val, "true") == 0)
+                op->set = 1;
+        else if (strcmp(val, "0") == 0 || strcmp(val, "false") == 0)
+                op->set = 0;
+        free(op_val);
+        return 0;
+}
 /**
 * traceevent_plugin_list_options - get list of plugin options
 *
@@ -120,6 +167,7 @@ update_option(const char *file, struct pevent_plugin_option *option)
 {
        struct trace_plugin_options *op;
        char *plugin;
+        int ret = 0;
        if (option->plugin_alias) {
                plugin = strdup(option->plugin_alias);
@@ -144,9 +192,10 @@ update_option(const char *file, struct pevent_plugin_option *option)
                if (strcmp(op->option, option->name) != 0)
                        continue;
-                option->value = op->value;
+                ret = update_option_value(option, op->value);
-                option->set ^= 1;
+                if (ret)
-                goto out;
+                        goto out;
+                break;
        }
        /* first look for unnamed options */
@@ -156,14 +205,13 @@ update_option(const char *file, struct pevent_plugin_option *option)
                if (strcmp(op->option, option->name) != 0)
                        continue;
-                option->value = op->value;
+                ret = update_option_value(option, op->value);
-                option->set ^= 1;
                break;
        }
 out:
        free(plugin);
-        return 0;
+        return ret;
 }
 /**
diff --git a/tools/lib/traceevent/kbuffer-parse.c b/tools/lib/traceevent/kbuffer-parse.c
index dcc665228c71..3bcada3ae05a 100644
--- a/tools/lib/traceevent/kbuffer-parse.c
+++ b/tools/lib/traceevent/kbuffer-parse.c
@@ -372,7 +372,6 @@ translate_data(struct kbuffer *kbuf, void *data, void **rptr,
        switch (type_len) {
        case KBUFFER_TYPE_PADDING:
                *length = read_4(kbuf, data);
-                data += *length;
                break;
        case KBUFFER_TYPE_TIME_EXTEND:
@@ -730,3 +729,14 @@ void kbuffer_set_old_format(struct kbuffer *kbuf)
        kbuf->next_event = __old_next_event;
 }
+/**
+ * kbuffer_start_of_data - return offset of where data starts on subbuffer
+ * @kbuf:       The kbuffer
+ *
+ * Returns the location on the subbuffer where the data starts.
+ */
+int kbuffer_start_of_data(struct kbuffer *kbuf)
+{
+        return kbuf->start;
+}
diff --git a/tools/lib/traceevent/kbuffer.h b/tools/lib/traceevent/kbuffer.h
index c831f64b17a0..03dce757553f 100644
--- a/tools/lib/traceevent/kbuffer.h
+++ b/tools/lib/traceevent/kbuffer.h
@@ -63,5 +63,6 @@ int kbuffer_missed_events(struct kbuffer *kbuf);
 int kbuffer_subbuffer_size(struct kbuffer *kbuf);
 void kbuffer_set_old_format(struct kbuffer *kbuf);
+int kbuffer_start_of_data(struct kbuffer *kbuf);
 #endif /* _K_BUFFER_H */
diff --git a/tools/lib/traceevent/parse-filter.c b/tools/lib/traceevent/parse-filter.c
index b50234402fc2..0144b3d1bb77 100644
--- a/tools/lib/traceevent/parse-filter.c
+++ b/tools/lib/traceevent/parse-filter.c
@@ -1058,6 +1058,7 @@ process_filter(struct event_format *event, struct filter_arg **parg,
                                        *parg = current_op;
                                else
                                        *parg = current_exp;
+                                free(token);
                                return PEVENT_ERRNO__UNBALANCED_PAREN;
                        }
                        break;
@@ -1168,6 +1169,7 @@ process_filter(struct event_format *event, struct filter_arg **parg,
        *parg = current_op;
+        free(token);
        return 0;
 fail_alloc:
diff --git a/tools/lib/traceevent/trace-seq.c b/tools/lib/traceevent/trace-seq.c
index ec3bd16a5488..292dc9f1d233 100644
--- a/tools/lib/traceevent/trace-seq.c
+++ b/tools/lib/traceevent/trace-seq.c
@@ -231,19 +231,24 @@ void trace_seq_terminate(struct trace_seq *s)
        s->buffer[s->len] = 0;
 }
-int trace_seq_do_printf(struct trace_seq *s)
+int trace_seq_do_fprintf(struct trace_seq *s, FILE *fp)
 {
        TRACE_SEQ_CHECK(s);
        switch (s->state) {
        case TRACE_SEQ__GOOD:
-                return printf("%.*s", s->len, s->buffer);
+                return fprintf(fp, "%.*s", s->len, s->buffer);
        case TRACE_SEQ__BUFFER_POISONED:
-                puts("Usage of trace_seq after it was destroyed");
+                fprintf(fp, "%s\n", "Usage of trace_seq after it was destroyed");
                break;
        case TRACE_SEQ__MEM_ALLOC_FAILED:
-                puts("Can't allocate trace_seq buffer memory");
+                fprintf(fp, "%s\n", "Can't allocate trace_seq buffer memory");
                break;
        }
        return -1;
 }
+int trace_seq_do_printf(struct trace_seq *s)
+{
+        return trace_seq_do_fprintf(s, stdout);
+}
diff --git a/tools/perf/.gitignore b/tools/perf/.gitignore
index 40399c3d97d6..812f904193e8 100644
--- a/tools/perf/.gitignore
+++ b/tools/perf/.gitignore
@@ -1,6 +1,7 @@
 PERF-CFLAGS
 PERF-GUI-VARS
 PERF-VERSION-FILE
+FEATURE-DUMP
 perf
 perf-read-vdso32
 perf-read-vdsox32
diff --git a/tools/perf/Build b/tools/perf/Build
new file mode 100644
index 000000000000..b77370ef7005
--- /dev/null
+++ b/tools/perf/Build
@@ -0,0 +1,44 @@
+perf-y += builtin-bench.o
+perf-y += builtin-annotate.o
+perf-y += builtin-diff.o
+perf-y += builtin-evlist.o
+perf-y += builtin-help.o
+perf-y += builtin-sched.o
+perf-y += builtin-buildid-list.o
+perf-y += builtin-buildid-cache.o
+perf-y += builtin-list.o
+perf-y += builtin-record.o
+perf-y += builtin-report.o
+perf-y += builtin-stat.o
+perf-y += builtin-timechart.o
+perf-y += builtin-top.o
+perf-y += builtin-script.o
+perf-y += builtin-kmem.o
+perf-y += builtin-lock.o
+perf-y += builtin-kvm.o
+perf-y += builtin-inject.o
+perf-y += builtin-mem.o
+perf-y += builtin-data.o
+perf-$(CONFIG_AUDIT) += builtin-trace.o
+perf-$(CONFIG_LIBELF) += builtin-probe.o
+perf-y += bench/
+perf-y += tests/
+perf-y += perf.o
+paths += -DPERF_HTML_PATH="BUILD_STR($(htmldir_SQ))"
+paths += -DPERF_INFO_PATH="BUILD_STR($(infodir_SQ))"
+paths += -DPERF_MAN_PATH="BUILD_STR($(mandir_SQ))"
+CFLAGS_builtin-help.o      += $(paths)
+CFLAGS_builtin-timechart.o += $(paths)
+CFLAGS_perf.o              += -DPERF_HTML_PATH="BUILD_STR($(htmldir_SQ))" -include $(OUTPUT)PERF-VERSION-FILE
+libperf-y += util/
+libperf-y += arch/
+libperf-y += ui/
+libperf-y += scripts/
+gtk-y += ui/gtk/
diff --git a/tools/perf/Documentation/Build.txt b/tools/perf/Documentation/Build.txt
new file mode 100644
index 000000000000..f6fc6507ba55
--- /dev/null
+++ b/tools/perf/Documentation/Build.txt
@@ -0,0 +1,49 @@
+1) perf build
+=============
+The perf build process consists of several separated building blocks,
+which are linked together to form the perf binary:
+  - libperf library (static)
+  - perf builtin commands
+  - traceevent library (static)
+  - GTK ui library
+Several makefiles govern the perf build:
+  - Makefile
+    top level Makefile working as a wrapper that calls the main
+    Makefile.perf with a -j option to do parallel builds.
+  - Makefile.perf
+    main makefile that triggers build of all perf objects including
+    installation and documentation processing.
+  - tools/build/Makefile.build
+    main makefile of the build framework
+  - tools/build/Build.include
+    build framework generic definitions
+  - Build makefiles
+    makefiles that defines build objects
+Please refer to tools/build/Documentation/Build.txt for more
+information about build framework.
+2) perf build
+=============
+The Makefile.perf triggers the build framework for build objects:
+   perf, libperf, gtk
+resulting in following objects:
+  $ ls  *-in.o
+  gtk-in.o  libperf-in.o  perf-in.o
+Those objects are then used in final linking:
+  libperf-gtk.so <- gtk-in.o  libperf-in.o
+  perf           <- perf-in.o libperf-in.o
+NOTE this description is omitting other libraries involved, only
+     focusing on build framework outcomes
diff --git a/tools/perf/Documentation/perf-buildid-cache.txt b/tools/perf/Documentation/perf-buildid-cache.txt
index 0294c57b1f5e..dd07b55f58d8 100644
--- a/tools/perf/Documentation/perf-buildid-cache.txt
+++ b/tools/perf/Documentation/perf-buildid-cache.txt
@@ -12,9 +12,9 @@ SYNOPSIS
 DESCRIPTION
 -----------
-This command manages the build-id cache. It can add and remove files to/from
+This command manages the build-id cache. It can add, remove, update and purge
-the cache. In the future it should as well purge older entries, set upper
+files to/from the cache. In the future it should as well set upper limits for
-limits for the space used by the cache, etc.
+the space used by the cache, etc.
 OPTIONS
 -------
@@ -36,14 +36,24 @@ OPTIONS
        actually made.
 -r::
 --remove=::
-        Remove specified file from the cache.
+        Remove a cached binary which has same build-id of specified file
+        from the cache.
+-p::
+--purge=::
+        Purge all cached binaries including older caches which have specified
+        path from the cache.
 -M::
 --missing=::
        List missing build ids in the cache for the specified file.
 -u::
--update::
+--update=::
-        Update specified file of the cache. It can be used to update kallsyms
+        Update specified file of the cache. Note that this doesn't remove
-        kernel dso to vmlinux in order to support annotation.
+        older entires since those may be still needed for annotating old
+        (or remote) perf.data. Only if there is already a cache which has
+        exactly same build-id, that is replaced by new one. It can be used
+        to update kallsyms and kernel dso to vmlinux in order to support
+        annotation.
 -v::
 --verbose::
        Be more verbose.
diff --git a/tools/perf/Documentation/perf-data.txt b/tools/perf/Documentation/perf-data.txt
new file mode 100644
index 000000000000..be8fa1a0a97e
--- /dev/null
+++ b/tools/perf/Documentation/perf-data.txt
@@ -0,0 +1,40 @@
+perf-data(1)
+==============
+NAME
+----
+perf-data - Data file related processing
+SYNOPSIS
+--------
+[verse]
+'perf data' [<common options>] <command> [<options>]",
+DESCRIPTION
+-----------
+Data file related processing.
+COMMANDS
+--------
+convert::
+        Converts perf data file into another format (only CTF [1] format is support by now).
+        It's possible to set data-convert debug variable to get debug messages from conversion,
+        like:
+          perf --debug data-convert data convert ...
+OPTIONS for 'convert'
+---------------------
+--to-ctf::
+        Triggers the CTF conversion, specify the path of CTF data directory.
+-i::
+        Specify input perf data file path.
+-v::
+--verbose::
+        Be more verbose (show counter open errors, etc).
+SEE ALSO
+--------
+linkperf:perf[1]
+[1] Common Trace Format - http://www.efficios.com/ctf
diff --git a/tools/perf/Documentation/perf-diff.txt b/tools/perf/Documentation/perf-diff.txt
index e463caa3eb49..d1deb573877f 100644
--- a/tools/perf/Documentation/perf-diff.txt
+++ b/tools/perf/Documentation/perf-diff.txt
@@ -20,12 +20,20 @@ If no parameters are passed it will assume perf.data.old and perf.data.
 The differential profile is displayed only for events matching both
 specified perf.data files.
+If no parameters are passed the samples will be sorted by dso and symbol.
+As the perf.data files could come from different binaries, the symbols addresses
+could vary. So perf diff is based on the comparison of the files and
+symbols name.
 OPTIONS
 -------
 -D::
 --dump-raw-trace::
        Dump raw trace in ASCII.
+--kallsyms=<file>::
+        kallsyms pathname
 -m::
 --modules::
        Load module symbols. WARNING: use only with -k and LIVE kernel
diff --git a/tools/perf/Documentation/perf-kmem.txt b/tools/perf/Documentation/perf-kmem.txt
index 7c8fbbf3f61c..150253cc3c97 100644
--- a/tools/perf/Documentation/perf-kmem.txt
+++ b/tools/perf/Documentation/perf-kmem.txt
@@ -25,6 +25,10 @@ OPTIONS
 --input=<file>::
        Select the input file (default: perf.data unless stdin is a fifo)
+-v::
+--verbose::
+        Be more verbose. (show symbol address, etc)
 --caller::
        Show per-callsite statistics
diff --git a/tools/perf/Documentation/perf-list.txt b/tools/perf/Documentation/perf-list.txt
index 3e2aec94f806..4692d277980b 100644
--- a/tools/perf/Documentation/perf-list.txt
+++ b/tools/perf/Documentation/perf-list.txt
@@ -127,6 +127,12 @@ To limit the list use:
 One or more types can be used at the same time, listing the events for the
 types specified.
+Support raw format:
+. '--raw-dump', shows the raw-dump of all the events.
+. '--raw-dump [hw|sw|cache|tracepoint|pmu|event_glob]', shows the raw-dump of
+  a certain kind of events.
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-top[1],
diff --git a/tools/perf/Documentation/perf-probe.txt b/tools/perf/Documentation/perf-probe.txt
index aaa869be3dc1..239609c09f83 100644
--- a/tools/perf/Documentation/perf-probe.txt
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -47,6 +47,12 @@ OPTIONS
 -v::
 --verbose::
        Be more verbose (show parsed arguments, etc).
+        Can not use with -q.
+-q::
+--quiet::
+        Be quiet (do not show any messages including errors).
+        Can not use with -v.
 -a::
 --add=::
@@ -96,7 +102,7 @@ OPTIONS
        Dry run. With this option, --add and --del doesn't execute actual
        adding and removal operations.
--max-probes::
+--max-probes=NUM::
        Set the maximum number of probe points for an event. Default is 128.
 -x::
@@ -104,8 +110,13 @@ OPTIONS
        Specify path to the executable or shared library file for user
        space tracing. Can also be used with --funcs option.
+--demangle::
+        Demangle application symbols. --no-demangle is also available
+        for disabling demangling.
 --demangle-kernel::
-        Demangle kernel symbols.
+        Demangle kernel symbols. --no-demangle-kernel is also available
+        for disabling kernel demangling.
 In absence of -m/-x options, perf probe checks if the first argument after
 the options is an absolute path name. If its an absolute path, perf probe
@@ -137,6 +148,7 @@ Each probe argument follows below syntax.
 [NAME=]LOCALVAR|$retval|%REG|@SYMBOL[:TYPE]
 'NAME' specifies the name of this argument (optional). You can use the name of local variable, local data structure member (e.g. var->field, var.field2), local array with fixed index (e.g. array[1], var->array[0], var->pointer[2]), or kprobe-tracer argument format (e.g. $retval, %ax, etc). Note that the name of this argument will be set as the last member name if you specify a local data structure member (e.g. field2 for 'var->field1.field2'.)
+'$vars' special argument is also available for NAME, it is expanded to the local variables which can access at given probe point.
 'TYPE' casts the type of this argument (optional). If omitted, perf probe automatically set the type based on debuginfo. You can specify 'string' type only for the local variable or structure member which is an array of or a pointer to 'char' or 'unsigned char' type.
 On x86 systems %REG is always the short form of the register: for example %AX. %RAX or %EAX is not valid.
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index 31e977459c51..355c4f5569b5 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -55,6 +55,11 @@ OPTIONS
          If you want to profile write accesses in [0x1000~1008), just set
          'mem:0x1000/8:w'.
+        - a group of events surrounded by a pair of brace ("{event1,event2,...}").
+          Each event is separated by commas and the group should be quoted to
+          prevent the shell interpretation.  You also need to use --group on
+          "perf report" to view group events together.
 --filter=<filter>::
        Event filter.
@@ -62,9 +67,6 @@ OPTIONS
 --all-cpus::
        System-wide collection from all CPUs.
-l::
-        Scale counter values.
 -p::
 --pid=::
        Record events on existing process ID (comma separated list).
@@ -107,6 +109,10 @@ OPTIONS
        specification with appended unit character - B/K/M/G. The
        size is rounded up to have nearest pages power of two value.
+--group::
+        Put all events in a single event group.  This precedes the --event
+        option and remains only for backward compatibility.  See --event.
 -g::
        Enables call-graph (stack chain/backtrace) recording.
@@ -115,13 +121,19 @@ OPTIONS
        implies -g.
        Allows specifying "fp" (frame pointer) or "dwarf"
-        (DWARF's CFI - Call Frame Information) as the method to collect
+        (DWARF's CFI - Call Frame Information) or "lbr"
+        (Hardware Last Branch Record facility) as the method to collect
        the information used to show the call graphs.
        In some systems, where binaries are build with gcc
        --fomit-frame-pointer, using the "fp" method will produce bogus
        call graphs, using "dwarf", if available (perf tools linked to
        the libunwind library) should be used instead.
+        Using the "lbr" method doesn't require any compiler options. It
+        will produce call graphs from the hardware LBR registers. The
+        main limition is that it is only available on new Intel
+        platforms, such as Haswell. It can only get user call chain. It
+        doesn't work with branch stack sampling at the same time.
 -q::
 --quiet::
@@ -235,6 +247,9 @@ Capture machine state (registers) at interrupt, i.e., on counter overflows for
 each sample. List of captured registers depends on the architecture. This option
 is off by default.
+--running-time::
+Record running and enabled time for read events (:S)
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-list[1]
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index dd7cccdde498..4879cf638824 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -40,6 +40,11 @@ OPTIONS
        Only consider symbols in these comms. CSV that understands
        file://filename entries.  This option will affect the percentage of
        the overhead column.  See --percentage for more info.
+--pid=::
+        Only show events for given process ID (comma separated list).
+--tid=::
+        Only show events for given thread ID (comma separated list).
 -d::
 --dsos=::
        Only consider symbols in these dsos. CSV that understands
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index a21eec05bc42..79445750fcb3 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -193,6 +193,12 @@ OPTIONS
        Only display events for these comms. CSV that understands
        file://filename entries.
+--pid=::
+        Only show events for given process ID (comma separated list).
+--tid=::
+        Only show events for given thread ID (comma separated list).
 -I::
 --show-info::
        Display extended information about the perf.data file. This adds
diff --git a/tools/perf/Documentation/perf-trace.txt b/tools/perf/Documentation/perf-trace.txt
index 7e1b1f2bb83c..ba03fd5d1a54 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -55,6 +55,9 @@ OPTIONS
 --uid=::
        Record events in threads owned by uid. Name or number.
+--filter-pids=::
+        Filter out events for these pids and for 'trace' itself (comma separated list).
 -v::
 --verbose=::
        Verbosity level.
@@ -115,6 +118,9 @@ the thread executes on the designated CPUs. Default is to monitor all CPUs.
 --syscalls::
        Trace system calls. This options is enabled by default.
+--event::
+        Trace other events, see 'perf list' for a complete list.
 PAGEFAULTS
 ----------
diff --git a/tools/perf/Documentation/perf.txt b/tools/perf/Documentation/perf.txt
index 1e8e400b4493..2b131776363e 100644
--- a/tools/perf/Documentation/perf.txt
+++ b/tools/perf/Documentation/perf.txt
@@ -13,11 +13,16 @@ SYNOPSIS
 OPTIONS
 -------
 --debug::
-        Setup debug variable (just verbose for now) in value
+        Setup debug variable (see list below) in value
        range (0, 10). Use like:
          --debug verbose   # sets verbose = 1
          --debug verbose=2 # sets verbose = 2
+        List of debug variables allowed to set:
+          verbose          - general debug messages
+          ordered-events   - ordered events object debug messages
+          data-convert     - data convert command debug messages
 --buildid-dir::
        Setup buildid cache directory. It has higher priority than
        buildid.dir config file option.
diff --git a/tools/perf/MANIFEST b/tools/perf/MANIFEST
index fbbfdc39271d..11ccbb22ea2b 100644
--- a/tools/perf/MANIFEST
+++ b/tools/perf/MANIFEST
@@ -1,5 +1,6 @@
 tools/perf
 tools/scripts
+tools/build
 tools/lib/traceevent
 tools/lib/api
 tools/lib/symbol/kallsyms.c
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index cb2e5868c8e8..c699dc35eef9 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -24,8 +24,8 @@ unexport MAKEFLAGS
 # (To override it, run 'make JOBS=1' and similar.)
 #
 ifeq ($(JOBS),)
-  JOBS := $(shell grep -c ^processor /proc/cpuinfo 2>/dev/null)
+  JOBS := $(shell egrep -c '^processor|^CPU' /proc/cpuinfo 2>/dev/null)
-  ifeq ($(JOBS),)
+  ifeq ($(JOBS),0)
    JOBS := 1
  endif
 endif
diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf
index aa6a50447c32..e9925e6ad1d0 100644
--- a/tools/perf/Makefile.perf
+++ b/tools/perf/Makefile.perf
@@ -68,7 +68,11 @@ include config/utilities.mak
 # for reading the x32 mode 32-bit compatibility VDSO in 64-bit mode
 #
 # Define NO_ZLIB if you do not want to support compressed kernel modules
+#
+# Define NO_LIBBABELTRACE if you do not want libbabeltrace support
+# for CTF data format.
+#
+# Define NO_LZMA if you do not want to support compressed (xz) kernel modules
 ifeq ($(srctree),)
 srctree := $(patsubst %/,%,$(dir $(shell pwd)))
@@ -82,13 +86,29 @@ endif
 ifneq ($(OUTPUT),)
 #$(info Determined 'OUTPUT' to be $(OUTPUT))
+# Adding $(OUTPUT) as a directory to look for source files,
+# because use generated output files as sources dependency
+# for flex/bison parsers.
+VPATH += $(OUTPUT)
+export VPATH
 endif
+ifeq ($(V),1)
+  Q =
+else
+  Q = @
+endif
+# Do not use make's built-in rules
+# (this improves performance and avoids hard-to-debug behaviour);
+MAKEFLAGS += -r
 $(OUTPUT)PERF-VERSION-FILE: ../../.git/HEAD
-        @$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
+        $(Q)$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
-        @touch $(OUTPUT)PERF-VERSION-FILE
+        $(Q)touch $(OUTPUT)PERF-VERSION-FILE
 CC = $(CROSS_COMPILE)gcc
+LD = $(CROSS_COMPILE)ld
 AR = $(CROSS_COMPILE)ar
 PKG_CONFIG = $(CROSS_COMPILE)pkg-config
@@ -127,10 +147,6 @@ export prefix bindir sharedir sysconfdir DESTDIR
 SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
 # Guard against environment variables
-BUILTIN_OBJS =
-LIB_H =
-LIB_OBJS =
-GTK_OBJS =
 PYRF_OBJS =
 SCRIPT_SH =
@@ -155,8 +171,8 @@ endif
 LIBTRACEEVENT = $(TE_PATH)libtraceevent.a
 export LIBTRACEEVENT
-LIBAPIKFS = $(LIB_PATH)libapikfs.a
+LIBAPI = $(LIB_PATH)libapi.a
-export LIBAPIKFS
+export LIBAPI
 # python extension build directories
 PYTHON_EXTBUILD     := $(OUTPUT)python_ext_build/
@@ -167,7 +183,7 @@ export PYTHON_EXTBUILD_LIB PYTHON_EXTBUILD_TMP
 python-clean := $(call QUIET_CLEAN, python) $(RM) -r $(PYTHON_EXTBUILD) $(OUTPUT)python/perf.so
 PYTHON_EXT_SRCS := $(shell grep -v ^\# util/python-ext-sources)
-PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py $(LIBTRACEEVENT) $(LIBAPIKFS)
+PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py $(LIBTRACEEVENT) $(LIBAPI)
 $(OUTPUT)python/perf.so: $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS)
        $(QUIET_GEN)CFLAGS='$(CFLAGS)' $(PYTHON_WORD) util/setup.py \
@@ -206,297 +222,9 @@ endif
 export PERL_PATH
-$(OUTPUT)util/parse-events-flex.c: util/parse-events.l $(OUTPUT)util/parse-events-bison.c
-        $(QUIET_FLEX)$(FLEX) -o $@ --header-file=$(OUTPUT)util/parse-events-flex.h $(PARSER_DEBUG_FLEX) util/parse-events.l
-$(OUTPUT)util/parse-events-bison.c: util/parse-events.y
-        $(QUIET_BISON)$(BISON) -v util/parse-events.y -d $(PARSER_DEBUG_BISON) -o $(OUTPUT)util/parse-events-bison.c -p parse_events_
-$(OUTPUT)util/pmu-flex.c: util/pmu.l $(OUTPUT)util/pmu-bison.c
-        $(QUIET_FLEX)$(FLEX) -o $@ --header-file=$(OUTPUT)util/pmu-flex.h util/pmu.l
-$(OUTPUT)util/pmu-bison.c: util/pmu.y
-        $(QUIET_BISON)$(BISON) -v util/pmu.y -d -o $(OUTPUT)util/pmu-bison.c -p perf_pmu_
-$(OUTPUT)util/parse-events.o: $(OUTPUT)util/parse-events-flex.c $(OUTPUT)util/parse-events-bison.c
-$(OUTPUT)util/pmu.o: $(OUTPUT)util/pmu-flex.c $(OUTPUT)util/pmu-bison.c
 LIB_FILE=$(OUTPUT)libperf.a
-LIB_H += ../lib/symbol/kallsyms.h
+PERFLIBS = $(LIB_FILE) $(LIBAPI) $(LIBTRACEEVENT)
-LIB_H += ../../include/uapi/linux/perf_event.h
-LIB_H += ../../include/linux/rbtree.h
-LIB_H += ../../include/linux/list.h
-LIB_H += ../../include/uapi/linux/const.h
-LIB_H += ../include/linux/hash.h
-LIB_H += ../../include/linux/stringify.h
-LIB_H += util/include/linux/bitmap.h
-LIB_H += ../include/linux/bitops.h
-LIB_H += ../include/asm-generic/bitops/arch_hweight.h
-LIB_H += ../include/asm-generic/bitops/atomic.h
-LIB_H += ../include/asm-generic/bitops/const_hweight.h
-LIB_H += ../include/asm-generic/bitops/find.h
-LIB_H += ../include/asm-generic/bitops/fls64.h
-LIB_H += ../include/asm-generic/bitops/fls.h
-LIB_H += ../include/asm-generic/bitops/__ffs.h
-LIB_H += ../include/asm-generic/bitops/__fls.h
-LIB_H += ../include/asm-generic/bitops/hweight.h
-LIB_H += ../include/asm-generic/bitops.h
-LIB_H += ../include/linux/compiler.h
-LIB_H += ../include/linux/log2.h
-LIB_H += util/include/linux/const.h
-LIB_H += util/include/linux/ctype.h
-LIB_H += util/include/linux/kernel.h
-LIB_H += util/include/linux/list.h
-LIB_H += ../include/linux/export.h
-LIB_H += util/include/linux/poison.h
-LIB_H += util/include/linux/rbtree.h
-LIB_H += util/include/linux/rbtree_augmented.h
-LIB_H += util/include/linux/string.h
-LIB_H += ../include/linux/types.h
-LIB_H += util/include/linux/linkage.h
-LIB_H += util/include/asm/asm-offsets.h
-LIB_H += ../include/asm/bug.h
-LIB_H += util/include/asm/byteorder.h
-LIB_H += util/include/asm/swab.h
-LIB_H += util/include/asm/system.h
-LIB_H += util/include/asm/uaccess.h
-LIB_H += util/include/dwarf-regs.h
-LIB_H += util/include/asm/dwarf2.h
-LIB_H += util/include/asm/cpufeature.h
-LIB_H += util/include/asm/unistd_32.h
-LIB_H += util/include/asm/unistd_64.h
-LIB_H += perf.h
-LIB_H += util/annotate.h
-LIB_H += util/cache.h
-LIB_H += util/callchain.h
-LIB_H += util/build-id.h
-LIB_H += util/db-export.h
-LIB_H += util/debug.h
-LIB_H += util/pmu.h
-LIB_H += util/event.h
-LIB_H += util/evsel.h
-LIB_H += util/evlist.h
-LIB_H += util/exec_cmd.h
-LIB_H += util/find-vdso-map.c
-LIB_H += util/levenshtein.h
-LIB_H += util/machine.h
-LIB_H += util/map.h
-LIB_H += util/parse-options.h
-LIB_H += util/parse-events.h
-LIB_H += util/quote.h
-LIB_H += util/util.h
-LIB_H += util/xyarray.h
-LIB_H += util/header.h
-LIB_H += util/help.h
-LIB_H += util/session.h
-LIB_H += util/ordered-events.h
-LIB_H += util/strbuf.h
-LIB_H += util/strlist.h
-LIB_H += util/strfilter.h
-LIB_H += util/svghelper.h
-LIB_H += util/tool.h
-LIB_H += util/run-command.h
-LIB_H += util/sigchain.h
-LIB_H += util/dso.h
-LIB_H += util/symbol.h
-LIB_H += util/color.h
-LIB_H += util/values.h
-LIB_H += util/sort.h
-LIB_H += util/hist.h
-LIB_H += util/comm.h
-LIB_H += util/thread.h
-LIB_H += util/thread_map.h
-LIB_H += util/trace-event.h
-LIB_H += util/probe-finder.h
-LIB_H += util/dwarf-aux.h
-LIB_H += util/probe-event.h
-LIB_H += util/pstack.h
-LIB_H += util/cpumap.h
-LIB_H += util/top.h
-LIB_H += $(ARCH_INCLUDE)
-LIB_H += util/cgroup.h
-LIB_H += $(LIB_INCLUDE)traceevent/event-parse.h
-LIB_H += util/target.h
-LIB_H += util/rblist.h
-LIB_H += util/intlist.h
-LIB_H += util/perf_regs.h
-LIB_H += util/unwind.h
-LIB_H += util/vdso.h
-LIB_H += util/tsc.h
-LIB_H += ui/helpline.h
-LIB_H += ui/progress.h
-LIB_H += ui/util.h
-LIB_H += ui/ui.h
-LIB_H += util/data.h
-LIB_H += util/kvm-stat.h
-LIB_H += util/thread-stack.h
-LIB_OBJS += $(OUTPUT)util/abspath.o
-LIB_OBJS += $(OUTPUT)util/alias.o
-LIB_OBJS += $(OUTPUT)util/annotate.o
-LIB_OBJS += $(OUTPUT)util/build-id.o
-LIB_OBJS += $(OUTPUT)util/config.o
-LIB_OBJS += $(OUTPUT)util/ctype.o
-LIB_OBJS += $(OUTPUT)util/db-export.o
-LIB_OBJS += $(OUTPUT)util/pmu.o
-LIB_OBJS += $(OUTPUT)util/environment.o
-LIB_OBJS += $(OUTPUT)util/event.o
-LIB_OBJS += $(OUTPUT)util/evlist.o
-LIB_OBJS += $(OUTPUT)util/evsel.o
-LIB_OBJS += $(OUTPUT)util/exec_cmd.o
-LIB_OBJS += $(OUTPUT)util/find_next_bit.o
-LIB_OBJS += $(OUTPUT)util/help.o
-LIB_OBJS += $(OUTPUT)util/kallsyms.o
-LIB_OBJS += $(OUTPUT)util/levenshtein.o
-LIB_OBJS += $(OUTPUT)util/parse-options.o
-LIB_OBJS += $(OUTPUT)util/parse-events.o
-LIB_OBJS += $(OUTPUT)util/path.o
-LIB_OBJS += $(OUTPUT)util/rbtree.o
-LIB_OBJS += $(OUTPUT)util/bitmap.o
-LIB_OBJS += $(OUTPUT)util/hweight.o
-LIB_OBJS += $(OUTPUT)util/run-command.o
-LIB_OBJS += $(OUTPUT)util/quote.o
-LIB_OBJS += $(OUTPUT)util/strbuf.o
-LIB_OBJS += $(OUTPUT)util/string.o
-LIB_OBJS += $(OUTPUT)util/strlist.o
-LIB_OBJS += $(OUTPUT)util/strfilter.o
-LIB_OBJS += $(OUTPUT)util/top.o
-LIB_OBJS += $(OUTPUT)util/usage.o
-LIB_OBJS += $(OUTPUT)util/wrapper.o
-LIB_OBJS += $(OUTPUT)util/sigchain.o
-LIB_OBJS += $(OUTPUT)util/dso.o
-LIB_OBJS += $(OUTPUT)util/symbol.o
-LIB_OBJS += $(OUTPUT)util/symbol-elf.o
-LIB_OBJS += $(OUTPUT)util/color.o
-LIB_OBJS += $(OUTPUT)util/pager.o
-LIB_OBJS += $(OUTPUT)util/header.o
-LIB_OBJS += $(OUTPUT)util/callchain.o
-LIB_OBJS += $(OUTPUT)util/values.o
-LIB_OBJS += $(OUTPUT)util/debug.o
-LIB_OBJS += $(OUTPUT)util/machine.o
-LIB_OBJS += $(OUTPUT)util/map.o
-LIB_OBJS += $(OUTPUT)util/pstack.o
-LIB_OBJS += $(OUTPUT)util/session.o
-LIB_OBJS += $(OUTPUT)util/ordered-events.o
-LIB_OBJS += $(OUTPUT)util/comm.o
-LIB_OBJS += $(OUTPUT)util/thread.o
-LIB_OBJS += $(OUTPUT)util/thread_map.o
-LIB_OBJS += $(OUTPUT)util/trace-event-parse.o
-LIB_OBJS += $(OUTPUT)util/parse-events-flex.o
-LIB_OBJS += $(OUTPUT)util/parse-events-bison.o
-LIB_OBJS += $(OUTPUT)util/pmu-flex.o
-LIB_OBJS += $(OUTPUT)util/pmu-bison.o
-LIB_OBJS += $(OUTPUT)util/trace-event-read.o
-LIB_OBJS += $(OUTPUT)util/trace-event-info.o
-LIB_OBJS += $(OUTPUT)util/trace-event-scripting.o
-LIB_OBJS += $(OUTPUT)util/trace-event.o
-LIB_OBJS += $(OUTPUT)util/svghelper.o
-LIB_OBJS += $(OUTPUT)util/sort.o
-LIB_OBJS += $(OUTPUT)util/hist.o
-LIB_OBJS += $(OUTPUT)util/probe-event.o
-LIB_OBJS += $(OUTPUT)util/util.o
-LIB_OBJS += $(OUTPUT)util/xyarray.o
-LIB_OBJS += $(OUTPUT)util/cpumap.o
-LIB_OBJS += $(OUTPUT)util/cgroup.o
-LIB_OBJS += $(OUTPUT)util/target.o
-LIB_OBJS += $(OUTPUT)util/rblist.o
-LIB_OBJS += $(OUTPUT)util/intlist.o
-LIB_OBJS += $(OUTPUT)util/vdso.o
-LIB_OBJS += $(OUTPUT)util/stat.o
-LIB_OBJS += $(OUTPUT)util/record.o
-LIB_OBJS += $(OUTPUT)util/srcline.o
-LIB_OBJS += $(OUTPUT)util/data.o
-LIB_OBJS += $(OUTPUT)util/tsc.o
-LIB_OBJS += $(OUTPUT)util/cloexec.o
-LIB_OBJS += $(OUTPUT)util/thread-stack.o
-LIB_OBJS += $(OUTPUT)ui/setup.o
-LIB_OBJS += $(OUTPUT)ui/helpline.o
-LIB_OBJS += $(OUTPUT)ui/progress.o
-LIB_OBJS += $(OUTPUT)ui/util.o
-LIB_OBJS += $(OUTPUT)ui/hist.o
-LIB_OBJS += $(OUTPUT)ui/stdio/hist.o
-LIB_OBJS += $(OUTPUT)arch/common.o
-LIB_OBJS += $(OUTPUT)tests/parse-events.o
-LIB_OBJS += $(OUTPUT)tests/dso-data.o
-LIB_OBJS += $(OUTPUT)tests/attr.o
-LIB_OBJS += $(OUTPUT)tests/vmlinux-kallsyms.o
-LIB_OBJS += $(OUTPUT)tests/open-syscall.o
-LIB_OBJS += $(OUTPUT)tests/open-syscall-all-cpus.o
-LIB_OBJS += $(OUTPUT)tests/open-syscall-tp-fields.o
-LIB_OBJS += $(OUTPUT)tests/mmap-basic.o
-LIB_OBJS += $(OUTPUT)tests/perf-record.o
-LIB_OBJS += $(OUTPUT)tests/rdpmc.o
-LIB_OBJS += $(OUTPUT)tests/evsel-roundtrip-name.o
-LIB_OBJS += $(OUTPUT)tests/evsel-tp-sched.o
-LIB_OBJS += $(OUTPUT)tests/fdarray.o
-LIB_OBJS += $(OUTPUT)tests/pmu.o
-LIB_OBJS += $(OUTPUT)tests/hists_common.o
-LIB_OBJS += $(OUTPUT)tests/hists_link.o
-LIB_OBJS += $(OUTPUT)tests/hists_filter.o
-LIB_OBJS += $(OUTPUT)tests/hists_output.o
-LIB_OBJS += $(OUTPUT)tests/hists_cumulate.o
-LIB_OBJS += $(OUTPUT)tests/python-use.o
-LIB_OBJS += $(OUTPUT)tests/bp_signal.o
-LIB_OBJS += $(OUTPUT)tests/bp_signal_overflow.o
-LIB_OBJS += $(OUTPUT)tests/task-exit.o
-LIB_OBJS += $(OUTPUT)tests/sw-clock.o
-ifeq ($(ARCH),x86)
-LIB_OBJS += $(OUTPUT)tests/perf-time-to-tsc.o
-endif
-LIB_OBJS += $(OUTPUT)tests/code-reading.o
-LIB_OBJS += $(OUTPUT)tests/sample-parsing.o
-LIB_OBJS += $(OUTPUT)tests/parse-no-sample-id-all.o
-ifndef NO_DWARF_UNWIND
-ifeq ($(ARCH),$(filter $(ARCH),x86 arm))
-LIB_OBJS += $(OUTPUT)tests/dwarf-unwind.o
-endif
-endif
-LIB_OBJS += $(OUTPUT)tests/mmap-thread-lookup.o
-LIB_OBJS += $(OUTPUT)tests/thread-mg-share.o
-LIB_OBJS += $(OUTPUT)tests/switch-tracking.o
-BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
-BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
-# Benchmark modules
-BUILTIN_OBJS += $(OUTPUT)bench/sched-messaging.o
-BUILTIN_OBJS += $(OUTPUT)bench/sched-pipe.o
-ifeq ($(ARCH), x86)
-ifeq ($(IS_64_BIT), 1)
-BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy-x86-64-asm.o
-BUILTIN_OBJS += $(OUTPUT)bench/mem-memset-x86-64-asm.o
-endif
-endif
-BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy.o
-BUILTIN_OBJS += $(OUTPUT)bench/futex-hash.o
-BUILTIN_OBJS += $(OUTPUT)bench/futex-wake.o
-BUILTIN_OBJS += $(OUTPUT)bench/futex-requeue.o
-BUILTIN_OBJS += $(OUTPUT)builtin-diff.o
-BUILTIN_OBJS += $(OUTPUT)builtin-evlist.o
-BUILTIN_OBJS += $(OUTPUT)builtin-help.o
-BUILTIN_OBJS += $(OUTPUT)builtin-sched.o
-BUILTIN_OBJS += $(OUTPUT)builtin-buildid-list.o
-BUILTIN_OBJS += $(OUTPUT)builtin-buildid-cache.o
-BUILTIN_OBJS += $(OUTPUT)builtin-list.o
-BUILTIN_OBJS += $(OUTPUT)builtin-record.o
-BUILTIN_OBJS += $(OUTPUT)builtin-report.o
-BUILTIN_OBJS += $(OUTPUT)builtin-stat.o
-BUILTIN_OBJS += $(OUTPUT)builtin-timechart.o
-BUILTIN_OBJS += $(OUTPUT)builtin-top.o
-BUILTIN_OBJS += $(OUTPUT)builtin-script.o
-BUILTIN_OBJS += $(OUTPUT)builtin-probe.o
-BUILTIN_OBJS += $(OUTPUT)builtin-kmem.o
-BUILTIN_OBJS += $(OUTPUT)builtin-lock.o
-BUILTIN_OBJS += $(OUTPUT)builtin-kvm.o
-BUILTIN_OBJS += $(OUTPUT)builtin-inject.o
-BUILTIN_OBJS += $(OUTPUT)tests/builtin-test.o
-BUILTIN_OBJS += $(OUTPUT)builtin-mem.o
-PERFLIBS = $(LIB_FILE) $(LIBAPIKFS) $(LIBTRACEEVENT)
 # We choose to avoid "if .. else if .. else .. endif endif"
 # because maintaining the nesting to match is a pain.  If
@@ -508,67 +236,9 @@ ifneq ($(OUTPUT),)
  CFLAGS += -I$(OUTPUT)
 endif
-ifdef NO_LIBELF
-# Remove ELF/DWARF dependent codes
-LIB_OBJS := $(filter-out $(OUTPUT)util/symbol-elf.o,$(LIB_OBJS))
-LIB_OBJS := $(filter-out $(OUTPUT)util/dwarf-aux.o,$(LIB_OBJS))
-LIB_OBJS := $(filter-out $(OUTPUT)util/probe-event.o,$(LIB_OBJS))
-LIB_OBJS := $(filter-out $(OUTPUT)util/probe-finder.o,$(LIB_OBJS))
-BUILTIN_OBJS := $(filter-out $(OUTPUT)builtin-probe.o,$(BUILTIN_OBJS))
-# Use minimal symbol handling
-LIB_OBJS += $(OUTPUT)util/symbol-minimal.o
-else # NO_LIBELF
-ifndef NO_DWARF
-  LIB_OBJS += $(OUTPUT)util/probe-finder.o
-  LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
-endif # NO_DWARF
-endif # NO_LIBELF
-ifndef NO_LIBDW_DWARF_UNWIND
-  LIB_OBJS += $(OUTPUT)util/unwind-libdw.o
-  LIB_H += util/unwind-libdw.h
-endif
-ifndef NO_LIBUNWIND
-  LIB_OBJS += $(OUTPUT)util/unwind-libunwind.o
-endif
-LIB_OBJS += $(OUTPUT)tests/keep-tracking.o
-ifndef NO_LIBAUDIT
-  BUILTIN_OBJS += $(OUTPUT)builtin-trace.o
-endif
-ifndef NO_SLANG
-  LIB_OBJS += $(OUTPUT)ui/browser.o
-  LIB_OBJS += $(OUTPUT)ui/browsers/annotate.o
-  LIB_OBJS += $(OUTPUT)ui/browsers/hists.o
-  LIB_OBJS += $(OUTPUT)ui/browsers/map.o
-  LIB_OBJS += $(OUTPUT)ui/browsers/scripts.o
-  LIB_OBJS += $(OUTPUT)ui/browsers/header.o
-  LIB_OBJS += $(OUTPUT)ui/tui/setup.o
-  LIB_OBJS += $(OUTPUT)ui/tui/util.o
-  LIB_OBJS += $(OUTPUT)ui/tui/helpline.o
-  LIB_OBJS += $(OUTPUT)ui/tui/progress.o
-  LIB_H += ui/tui/tui.h
-  LIB_H += ui/browser.h
-  LIB_H += ui/browsers/map.h
-  LIB_H += ui/keysyms.h
-  LIB_H += ui/libslang.h
-endif
 ifndef NO_GTK2
  ALL_PROGRAMS += $(OUTPUT)libperf-gtk.so
+  GTK_IN := $(OUTPUT)gtk-in.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/browser.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/hists.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/setup.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/util.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/helpline.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/progress.o
-  GTK_OBJS += $(OUTPUT)ui/gtk/annotate.o
 install-gtk: $(OUTPUT)libperf-gtk.so
        $(call QUIET_INSTALL, 'GTK UI') \
@@ -576,31 +246,6 @@ install-gtk: $(OUTPUT)libperf-gtk.so
                $(INSTALL) $(OUTPUT)libperf-gtk.so '$(DESTDIR_SQ)$(libdir_SQ)'
 endif
-ifndef NO_LIBPERL
-  LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-perl.o
-  LIB_OBJS += $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o
-endif
-ifndef NO_LIBPYTHON
-  LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-python.o
-  LIB_OBJS += $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o
-endif
-ifeq ($(NO_PERF_REGS),0)
-  ifeq ($(ARCH),x86)
-    LIB_H += arch/x86/include/perf_regs.h
-  endif
-  LIB_OBJS += $(OUTPUT)util/perf_regs.o
-endif
-ifndef NO_LIBNUMA
-  BUILTIN_OBJS += $(OUTPUT)bench/numa.o
-endif
-ifndef NO_ZLIB
-  LIB_OBJS += $(OUTPUT)util/zlib.o
-endif
 ifdef ASCIIDOC8
  export ASCIIDOC8
 endif
@@ -616,39 +261,29 @@ SHELL = $(SHELL_PATH)
 all: shell_compatibility_test $(ALL_PROGRAMS) $(LANG_BINDINGS) $(OTHER_PROGRAMS)
 please_set_SHELL_PATH_to_a_more_modern_shell:
-        @$$(:)
+        $(Q)$$(:)
 shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell
 strip: $(PROGRAMS) $(OUTPUT)perf
        $(STRIP) $(STRIP_OPTS) $(PROGRAMS) $(OUTPUT)perf
-$(OUTPUT)perf.o: perf.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
+PERF_IN := $(OUTPUT)perf-in.o
-        $(QUIET_CC)$(CC) -include $(OUTPUT)PERF-VERSION-FILE \
-                '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
-                $(CFLAGS) -c $(filter %.c,$^) -o $@
-$(OUTPUT)perf: $(OUTPUT)perf.o $(BUILTIN_OBJS) $(PERFLIBS)
+export srctree OUTPUT RM CC LD AR CFLAGS V BISON FLEX
-        $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $(OUTPUT)perf.o \
+build := -f $(srctree)/tools/build/Makefile.build dir=. obj
-               $(BUILTIN_OBJS) $(LIBS) -o $@
-$(GTK_OBJS): $(OUTPUT)%.o: %.c $(LIB_H)
+$(PERF_IN): $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h FORCE
-        $(QUIET_CC)$(CC) -o $@ -c -fPIC $(CFLAGS) $(GTK_CFLAGS) $<
+        $(Q)$(MAKE) $(build)=perf
-$(OUTPUT)libperf-gtk.so: $(GTK_OBJS) $(PERFLIBS)
+$(OUTPUT)perf: $(PERFLIBS) $(PERF_IN)
-        $(QUIET_LINK)$(CC) -o $@ -shared $(LDFLAGS) $(filter %.o,$^) $(GTK_LIBS)
+        $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $(PERF_IN) $(LIBS) -o $@
-$(OUTPUT)builtin-help.o: builtin-help.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
+$(GTK_IN): FORCE
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
+        $(Q)$(MAKE) $(build)=gtk
-                '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
-                '-DPERF_MAN_PATH="$(mandir_SQ)"' \
-                '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
-$(OUTPUT)builtin-timechart.o: builtin-timechart.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)libperf-gtk.so: $(GTK_IN) $(PERFLIBS)
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
+        $(QUIET_LINK)$(CC) -o $@ -shared $(LDFLAGS) $(filter %.o,$^) $(GTK_LIBS)
-                '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
-                '-DPERF_MAN_PATH="$(mandir_SQ)"' \
-                '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
 $(OUTPUT)common-cmds.h: util/generate-cmdlist.sh command-list.txt
@@ -659,8 +294,7 @@ $(SCRIPTS) : % : %.sh
        $(QUIET_GEN)$(INSTALL) '$@.sh' '$(OUTPUT)$@'
 # These can record PERF_VERSION
-$(OUTPUT)perf.o perf.spec \
+perf.spec $(SCRIPTS) \
-        $(SCRIPTS) \
        : $(OUTPUT)PERF-VERSION-FILE
 .SUFFIXES:
@@ -683,90 +317,33 @@ endif
 # These two need to be here so that when O= is not used they take precedence
 # over the general rule for .o
-$(OUTPUT)util/%-flex.o: $(OUTPUT)util/%-flex.c $(OUTPUT)PERF-CFLAGS
+# get relative building directory (to $(OUTPUT))
-        $(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(CFLAGS) -w $<
+# and '.' if it's $(OUTPUT) itself
+__build-dir = $(subst $(OUTPUT),,$(dir $@))
-$(OUTPUT)util/%-bison.o: $(OUTPUT)util/%-bison.c $(OUTPUT)PERF-CFLAGS
+build-dir   = $(if $(__build-dir),$(__build-dir),.)
-        $(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(CFLAGS) -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w $<
-$(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
-$(OUTPUT)%.i: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
-$(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -S $(CFLAGS) $<
-$(OUTPUT)%.o: %.S
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
-$(OUTPUT)%.s: %.S
-        $(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
-$(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
-                '-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
-                '-DPREFIX="$(prefix_SQ)"' \
-                $<
-$(OUTPUT)tests/attr.o: tests/attr.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
-                '-DBINDIR="$(bindir_SQ)"' -DPYTHON='"$(PYTHON_WORD)"' \
-                $<
-$(OUTPUT)tests/python-use.o: tests/python-use.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
-                -DPYTHONPATH='"$(OUTPUT)python"' \
-                -DPYTHON='"$(PYTHON_WORD)"' \
-                $<
-$(OUTPUT)tests/dwarf-unwind.o: tests/dwarf-unwind.c
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -fno-optimize-sibling-calls $<
-$(OUTPUT)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
+single_dep: $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
-$(OUTPUT)ui/setup.o: ui/setup.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)%.o: %.c single_dep FORCE
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DLIBDIR='"$(libdir_SQ)"' $<
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
-$(OUTPUT)ui/browser.o: ui/browser.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)%.i: %.c single_dep FORCE
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
-$(OUTPUT)ui/browsers/annotate.o: ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)%.s: %.c single_dep FORCE
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
-$(OUTPUT)ui/browsers/hists.o: ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)%-bison.o: %.c single_dep FORCE
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
-$(OUTPUT)ui/browsers/map.o: ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)%-flex.o: %.c single_dep FORCE
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
-$(OUTPUT)ui/browsers/scripts.o: ui/browsers/scripts.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)%.o: %.S single_dep FORCE
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
-$(OUTPUT)util/kallsyms.o: ../lib/symbol/kallsyms.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)%.i: %.S single_dep FORCE
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=$(build-dir) $@
-$(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
-$(OUTPUT)util/hweight.o: ../../lib/hweight.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
-$(OUTPUT)util/find_next_bit.o: ../lib/util/find_next_bit.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
-$(OUTPUT)util/parse-events.o: util/parse-events.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-redundant-decls $<
-$(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow -Wno-undef -Wno-switch-default $<
-$(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs -Wno-undef -Wno-switch-default $<
-$(OUTPUT)util/scripting-engines/trace-event-python.o: util/scripting-engines/trace-event-python.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
-$(OUTPUT)scripts/python/Perf-Trace-Util/Context.o: scripts/python/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 $(OUTPUT)perf-%: %.o $(PERFLIBS)
        $(QUIET_LINK)$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $(filter %.o,$^) $(LIBS)
@@ -781,58 +358,34 @@ $(OUTPUT)perf-read-vdsox32: perf-read-vdso.c util/find-vdso-map.c
        $(QUIET_CC)$(CC) -mx32 $(filter -static,$(LDFLAGS)) -Wall -Werror -o $@ perf-read-vdso.c
 endif
-$(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
+$(patsubst perf-%,%.o,$(PROGRAMS)): $(wildcard */*.h)
-$(patsubst perf-%,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.h)
-# we compile into subdirectories. if the target directory is not the source directory, they might not exists. So
+LIBPERF_IN := $(OUTPUT)libperf-in.o
-# we depend the various files onto their directories.
-DIRECTORY_DEPS = $(LIB_OBJS) $(BUILTIN_OBJS) $(GTK_OBJS)
-DIRECTORY_DEPS += $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h
-# no need to add flex objects, because they depend on bison ones
-DIRECTORY_DEPS += $(OUTPUT)util/parse-events-bison.c
-DIRECTORY_DEPS += $(OUTPUT)util/pmu-bison.c
-OUTPUT_DIRECTORIES := $(sort $(dir $(DIRECTORY_DEPS)))
+$(LIBPERF_IN): FORCE
+        $(Q)$(MAKE) $(build)=libperf
-$(DIRECTORY_DEPS): | $(OUTPUT_DIRECTORIES)
+$(LIB_FILE): $(LIBPERF_IN)
-# In the second step, we make a rule to actually create these directories
+        $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIBPERF_IN) $(LIB_OBJS)
-$(OUTPUT_DIRECTORIES):
-        $(QUIET_MKDIR)$(MKDIR) -p $@ 2>/dev/null
-$(LIB_FILE): $(LIB_OBJS)
-        $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS)
-# libtraceevent.a
-TE_SOURCES = $(wildcard $(TRACE_EVENT_DIR)*.[ch])
-LIBTRACEEVENT_FLAGS  = $(QUIET_SUBDIR1) O=$(OUTPUT)
-LIBTRACEEVENT_FLAGS += CFLAGS="-g -Wall $(EXTRA_CFLAGS)"
 LIBTRACEEVENT_FLAGS += plugin_dir=$(plugindir_SQ)
-$(LIBTRACEEVENT): $(TE_SOURCES) $(OUTPUT)PERF-CFLAGS
+$(LIBTRACEEVENT): FORCE
-        $(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) libtraceevent.a plugins
+        $(Q)$(MAKE) -C $(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) O=$(OUTPUT) $(OUTPUT)libtraceevent.a plugins
 $(LIBTRACEEVENT)-clean:
        $(call QUIET_CLEAN, libtraceevent)
-        @$(MAKE) -C $(TRACE_EVENT_DIR) O=$(OUTPUT) clean >/dev/null
+        $(Q)$(MAKE) -C $(TRACE_EVENT_DIR) O=$(OUTPUT) clean >/dev/null
 install-traceevent-plugins: $(LIBTRACEEVENT)
-        $(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) install_plugins
+        $(Q)$(MAKE) -C $(TRACE_EVENT_DIR) $(LIBTRACEEVENT_FLAGS) O=$(OUTPUT) install_plugins
-LIBAPIKFS_SOURCES = $(wildcard $(LIB_PATH)fs/*.[ch] $(LIB_PATH)fd/*.[ch])
+$(LIBAPI): FORCE
+        $(Q)$(MAKE) -C $(LIB_DIR) O=$(OUTPUT) $(OUTPUT)libapi.a
-# if subdir is set, we've been called from above so target has been built
-# already
-$(LIBAPIKFS): $(LIBAPIKFS_SOURCES)
-ifeq ($(subdir),)
-        $(QUIET_SUBDIR0)$(LIB_DIR) $(QUIET_SUBDIR1) O=$(OUTPUT) libapikfs.a
-endif
-$(LIBAPIKFS)-clean:
+$(LIBAPI)-clean:
-ifeq ($(subdir),)
+        $(call QUIET_CLEAN, libapi)
-        $(call QUIET_CLEAN, libapikfs)
+        $(Q)$(MAKE) -C $(LIB_DIR) O=$(OUTPUT) clean >/dev/null
-        @$(MAKE) -C $(LIB_DIR) O=$(OUTPUT) clean >/dev/null
-endif
 help:
        @echo 'Perf make targets:'
@@ -888,17 +441,6 @@ cscope:
        $(QUIET_GEN)$(RM) cscope*; \
        $(FIND) $(TAG_FOLDERS) -name '*.[hcS]' -print | xargs cscope -b $(TAG_FILES)
-### Detect prefix changes
-TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):\
-             $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ):$(plugindir_SQ)
-$(OUTPUT)PERF-CFLAGS: .FORCE-PERF-CFLAGS
-        @FLAGS='$(TRACK_CFLAGS)'; \
-            if test x"$$FLAGS" != x"`cat $(OUTPUT)PERF-CFLAGS 2>/dev/null`" ; then \
-                echo 1>&2 "  FLAGS:   * new build flags or prefix"; \
-                echo "$$FLAGS" >$(OUTPUT)PERF-CFLAGS; \
-            fi
 ### Testing rules
 # GNU make supports exporting all variables by "export" without parameters.
@@ -981,12 +523,14 @@ $(INSTALL_DOC_TARGETS):
 #
 config-clean:
        $(call QUIET_CLEAN, config)
-        @$(MAKE) -C config/feature-checks clean >/dev/null
+        $(Q)$(MAKE) -C $(srctree)/tools/build/feature/ clean >/dev/null
-clean: $(LIBTRACEEVENT)-clean $(LIBAPIKFS)-clean config-clean
+clean: $(LIBTRACEEVENT)-clean $(LIBAPI)-clean config-clean
-        $(call QUIET_CLEAN, core-objs)  $(RM) $(LIB_OBJS) $(BUILTIN_OBJS) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf-with-kcore $(OUTPUT)perf.o $(LANG_BINDINGS) $(GTK_OBJS)
+        $(call QUIET_CLEAN, core-objs)  $(RM) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf-with-kcore $(LANG_BINDINGS)
+        $(Q)find . -name '*.o' -delete -o -name '\.*.cmd' -delete -o -name '\.*.d' -delete
+        $(Q)$(RM) .config-detected
        $(call QUIET_CLEAN, core-progs) $(RM) $(ALL_PROGRAMS) perf perf-read-vdso32 perf-read-vdsox32
-        $(call QUIET_CLEAN, core-gen)   $(RM)  *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope* $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS $(OUTPUT)PERF-FEATURES $(OUTPUT)util/*-bison* $(OUTPUT)util/*-flex*
+        $(call QUIET_CLEAN, core-gen)   $(RM)  *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope* $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)FEATURE-DUMP $(OUTPUT)util/*-bison* $(OUTPUT)util/*-flex*
        $(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) clean
        $(python-clean)
@@ -1000,7 +544,9 @@ else
    GIT-HEAD-PHONY =
 endif
+FORCE:
 .PHONY: all install clean config-clean strip install-gtk
 .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
-.PHONY: $(GIT-HEAD-PHONY) TAGS tags cscope .FORCE-PERF-CFLAGS
+.PHONY: $(GIT-HEAD-PHONY) TAGS tags cscope FORCE single_dep
diff --git a/tools/perf/arch/Build b/tools/perf/arch/Build
new file mode 100644
index 000000000000..109eb75cf7de
--- /dev/null
+++ b/tools/perf/arch/Build
@@ -0,0 +1,2 @@
+libperf-y += common.o
+libperf-y += $(ARCH)/
diff --git a/tools/perf/arch/arm/Build b/tools/perf/arch/arm/Build
new file mode 100644
index 000000000000..41bf61da476a
--- /dev/null
+++ b/tools/perf/arch/arm/Build
@@ -0,0 +1,2 @@
+libperf-y += util/
+libperf-$(CONFIG_DWARF_UNWIND) += tests/
diff --git a/tools/perf/arch/arm/Makefile b/tools/perf/arch/arm/Makefile
index 09d62153d384..7fbca175099e 100644
--- a/tools/perf/arch/arm/Makefile
+++ b/tools/perf/arch/arm/Makefile
@@ -1,14 +1,3 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
-endif
-ifndef NO_LIBUNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind-libunwind.o
-endif
-ifndef NO_LIBDW_DWARF_UNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind-libdw.o
-endif
-ifndef NO_DWARF_UNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/tests/regs_load.o
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/tests/dwarf-unwind.o
 endif
diff --git a/tools/perf/arch/arm/tests/Build b/tools/perf/arch/arm/tests/Build
new file mode 100644
index 000000000000..b30eff9bcc83
--- /dev/null
+++ b/tools/perf/arch/arm/tests/Build
@@ -0,0 +1,2 @@
+libperf-y += regs_load.o
+libperf-y += dwarf-unwind.o
diff --git a/tools/perf/arch/arm/util/Build b/tools/perf/arch/arm/util/Build
new file mode 100644
index 000000000000..d22e3d07de3d
--- /dev/null
+++ b/tools/perf/arch/arm/util/Build
@@ -0,0 +1,4 @@
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
+libperf-$(CONFIG_LIBUNWIND)          += unwind-libunwind.o
+libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
diff --git a/tools/perf/arch/arm64/Build b/tools/perf/arch/arm64/Build
new file mode 100644
index 000000000000..54afe4a467e7
--- /dev/null
+++ b/tools/perf/arch/arm64/Build
@@ -0,0 +1 @@
+libperf-y += util/
diff --git a/tools/perf/arch/arm64/Makefile b/tools/perf/arch/arm64/Makefile
index 67e9b3d38e89..7fbca175099e 100644
--- a/tools/perf/arch/arm64/Makefile
+++ b/tools/perf/arch/arm64/Makefile
@@ -1,7 +1,3 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
-endif
-ifndef NO_LIBUNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind-libunwind.o
 endif
diff --git a/tools/perf/arch/arm64/util/Build b/tools/perf/arch/arm64/util/Build
new file mode 100644
index 000000000000..e58123a8912b
--- /dev/null
+++ b/tools/perf/arch/arm64/util/Build
@@ -0,0 +1,2 @@
+libperf-$(CONFIG_DWARF)     += dwarf-regs.o
+libperf-$(CONFIG_LIBUNWIND) += unwind-libunwind.o
diff --git a/tools/perf/arch/powerpc/Build b/tools/perf/arch/powerpc/Build
new file mode 100644
index 000000000000..54afe4a467e7
--- /dev/null
+++ b/tools/perf/arch/powerpc/Build
@@ -0,0 +1 @@
+libperf-y += util/
diff --git a/tools/perf/arch/powerpc/Makefile b/tools/perf/arch/powerpc/Makefile
index 6f7782bea5dd..7fbca175099e 100644
--- a/tools/perf/arch/powerpc/Makefile
+++ b/tools/perf/arch/powerpc/Makefile
@@ -1,6 +1,3 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/skip-callchain-idx.o
 endif
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
diff --git a/tools/perf/arch/powerpc/util/Build b/tools/perf/arch/powerpc/util/Build
new file mode 100644
index 000000000000..0af6e9b3f728
--- /dev/null
+++ b/tools/perf/arch/powerpc/util/Build
@@ -0,0 +1,4 @@
+libperf-y += header.o
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
+libperf-$(CONFIG_DWARF) += skip-callchain-idx.o
diff --git a/tools/perf/arch/s390/Build b/tools/perf/arch/s390/Build
new file mode 100644
index 000000000000..54afe4a467e7
--- /dev/null
+++ b/tools/perf/arch/s390/Build
@@ -0,0 +1 @@
+libperf-y += util/
diff --git a/tools/perf/arch/s390/Makefile b/tools/perf/arch/s390/Makefile
index 798ac7379c5f..21322e0385b8 100644
--- a/tools/perf/arch/s390/Makefile
+++ b/tools/perf/arch/s390/Makefile
@@ -1,7 +1,4 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
 HAVE_KVM_STAT_SUPPORT := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/kvm-stat.o
diff --git a/tools/perf/arch/s390/util/Build b/tools/perf/arch/s390/util/Build
new file mode 100644
index 000000000000..8a61372bb47a
--- /dev/null
+++ b/tools/perf/arch/s390/util/Build
@@ -0,0 +1,4 @@
+libperf-y += header.o
+libperf-y += kvm-stat.o
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
diff --git a/tools/perf/arch/sh/Build b/tools/perf/arch/sh/Build
new file mode 100644
index 000000000000..54afe4a467e7
--- /dev/null
+++ b/tools/perf/arch/sh/Build
@@ -0,0 +1 @@
+libperf-y += util/
diff --git a/tools/perf/arch/sh/Makefile b/tools/perf/arch/sh/Makefile
index 15130b50dfe3..7fbca175099e 100644
--- a/tools/perf/arch/sh/Makefile
+++ b/tools/perf/arch/sh/Makefile
@@ -1,4 +1,3 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
diff --git a/tools/perf/arch/sh/util/Build b/tools/perf/arch/sh/util/Build
new file mode 100644
index 000000000000..954e287bbb89
--- /dev/null
+++ b/tools/perf/arch/sh/util/Build
@@ -0,0 +1 @@
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
diff --git a/tools/perf/arch/sparc/Build b/tools/perf/arch/sparc/Build
new file mode 100644
index 000000000000..54afe4a467e7
--- /dev/null
+++ b/tools/perf/arch/sparc/Build
@@ -0,0 +1 @@
+libperf-y += util/
diff --git a/tools/perf/arch/sparc/Makefile b/tools/perf/arch/sparc/Makefile
index 15130b50dfe3..7fbca175099e 100644
--- a/tools/perf/arch/sparc/Makefile
+++ b/tools/perf/arch/sparc/Makefile
@@ -1,4 +1,3 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
diff --git a/tools/perf/arch/sparc/util/Build b/tools/perf/arch/sparc/util/Build
new file mode 100644
index 000000000000..954e287bbb89
--- /dev/null
+++ b/tools/perf/arch/sparc/util/Build
@@ -0,0 +1 @@
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
diff --git a/tools/perf/arch/x86/Build b/tools/perf/arch/x86/Build
new file mode 100644
index 000000000000..41bf61da476a
--- /dev/null
+++ b/tools/perf/arch/x86/Build
@@ -0,0 +1,2 @@
+libperf-y += util/
+libperf-$(CONFIG_DWARF_UNWIND) += tests/
diff --git a/tools/perf/arch/x86/Makefile b/tools/perf/arch/x86/Makefile
index 9b21881db52f..21322e0385b8 100644
--- a/tools/perf/arch/x86/Makefile
+++ b/tools/perf/arch/x86/Makefile
@@ -1,19 +1,4 @@
 ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
-ifndef NO_LIBUNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind-libunwind.o
-endif
-ifndef NO_LIBDW_DWARF_UNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind-libdw.o
-endif
-ifndef NO_DWARF_UNWIND
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/tests/regs_load.o
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/tests/dwarf-unwind.o
-endif
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/tsc.o
-LIB_H += arch/$(ARCH)/util/tsc.h
 HAVE_KVM_STAT_SUPPORT := 1
-LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/kvm-stat.o
diff --git a/tools/perf/arch/x86/tests/Build b/tools/perf/arch/x86/tests/Build
new file mode 100644
index 000000000000..b30eff9bcc83
--- /dev/null
+++ b/tools/perf/arch/x86/tests/Build
@@ -0,0 +1,2 @@
+libperf-y += regs_load.o
+libperf-y += dwarf-unwind.o
diff --git a/tools/perf/arch/x86/util/Build b/tools/perf/arch/x86/util/Build
new file mode 100644
index 000000000000..cfbccc4e3187
--- /dev/null
+++ b/tools/perf/arch/x86/util/Build
@@ -0,0 +1,8 @@
+libperf-y += header.o
+libperf-y += tsc.o
+libperf-y += kvm-stat.o
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
+libperf-$(CONFIG_LIBUNWIND)          += unwind-libunwind.o
+libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
diff --git a/tools/perf/bench/Build b/tools/perf/bench/Build
new file mode 100644
index 000000000000..5ce98023d518
--- /dev/null
+++ b/tools/perf/bench/Build
@@ -0,0 +1,11 @@
+perf-y += sched-messaging.o
+perf-y += sched-pipe.o
+perf-y += mem-memcpy.o
+perf-y += futex-hash.o
+perf-y += futex-wake.o
+perf-y += futex-requeue.o
+perf-$(CONFIG_X86_64) += mem-memcpy-x86-64-asm.o
+perf-$(CONFIG_X86_64) += mem-memset-x86-64-asm.o
+perf-$(CONFIG_NUMA) += numa.o
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 747f86103599..71bf7451c0ca 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -208,7 +208,7 @@ static int __cmd_annotate(struct perf_annotate *ann)
                        goto out;
        }
-        ret = perf_session__process_events(session, &ann->tool);
+        ret = perf_session__process_events(session);
        if (ret)
                goto out;
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
index 50e6b66aea1f..d47a0cdc71c9 100644
--- a/tools/perf/builtin-buildid-cache.c
+++ b/tools/perf/builtin-buildid-cache.c
@@ -125,8 +125,7 @@ static int build_id_cache__kcore_existing(const char *from_dir, char *to_dir,
        return ret;
 }
-static int build_id_cache__add_kcore(const char *filename, const char *debugdir,
+static int build_id_cache__add_kcore(const char *filename, bool force)
-                                     bool force)
 {
        char dir[32], sbuildid[BUILD_ID_SIZE * 2 + 1];
        char from_dir[PATH_MAX], to_dir[PATH_MAX];
@@ -143,7 +142,7 @@ static int build_id_cache__add_kcore(const char *filename, const char *debugdir,
                return -1;
        scnprintf(to_dir, sizeof(to_dir), "%s/[kernel.kcore]/%s",
-                  debugdir, sbuildid);
+                  buildid_dir, sbuildid);
        if (!force &&
            !build_id_cache__kcore_existing(from_dir, to_dir, sizeof(to_dir))) {
@@ -155,7 +154,7 @@ static int build_id_cache__add_kcore(const char *filename, const char *debugdir,
                return -1;
        scnprintf(to_dir, sizeof(to_dir), "%s/[kernel.kcore]/%s/%s",
-                  debugdir, sbuildid, dir);
+                  buildid_dir, sbuildid, dir);
        if (mkdir_p(to_dir, 0755))
                return -1;
@@ -183,7 +182,7 @@ static int build_id_cache__add_kcore(const char *filename, const char *debugdir,
        return 0;
 }
-static int build_id_cache__add_file(const char *filename, const char *debugdir)
+static int build_id_cache__add_file(const char *filename)
 {
        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
        u8 build_id[BUILD_ID_SIZE];
@@ -195,16 +194,14 @@ static int build_id_cache__add_file(const char *filename, const char *debugdir)
        }
        build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
-        err = build_id_cache__add_s(sbuild_id, debugdir, filename,
+        err = build_id_cache__add_s(sbuild_id, filename,
                                    false, false);
-        if (verbose)
+        pr_debug("Adding %s %s: %s\n", sbuild_id, filename,
-                pr_info("Adding %s %s: %s\n", sbuild_id, filename,
+                 err ? "FAIL" : "Ok");
-                        err ? "FAIL" : "Ok");
        return err;
 }
-static int build_id_cache__remove_file(const char *filename,
+static int build_id_cache__remove_file(const char *filename)
-                                       const char *debugdir)
 {
        u8 build_id[BUILD_ID_SIZE];
        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
@@ -217,10 +214,34 @@ static int build_id_cache__remove_file(const char *filename,
        }
        build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
-        err = build_id_cache__remove_s(sbuild_id, debugdir);
+        err = build_id_cache__remove_s(sbuild_id);
-        if (verbose)
+        pr_debug("Removing %s %s: %s\n", sbuild_id, filename,
-                pr_info("Removing %s %s: %s\n", sbuild_id, filename,
+                 err ? "FAIL" : "Ok");
-                        err ? "FAIL" : "Ok");
+        return err;
+}
+static int build_id_cache__purge_path(const char *pathname)
+{
+        struct strlist *list;
+        struct str_node *pos;
+        int err;
+        err = build_id_cache__list_build_ids(pathname, &list);
+        if (err)
+                goto out;
+        strlist__for_each(pos, list) {
+                err = build_id_cache__remove_s(pos->s);
+                pr_debug("Removing %s %s: %s\n", pos->s, pathname,
+                         err ? "FAIL" : "Ok");
+                if (err)
+                        break;
+        }
+        strlist__delete(list);
+out:
+        pr_debug("Purging %s: %s\n", pathname, err ? "FAIL" : "Ok");
        return err;
 }
@@ -252,13 +273,12 @@ static int build_id_cache__fprintf_missing(struct perf_session *session, FILE *f
        return 0;
 }
-static int build_id_cache__update_file(const char *filename,
+static int build_id_cache__update_file(const char *filename)
-                                       const char *debugdir)
 {
        u8 build_id[BUILD_ID_SIZE];
        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
-        int err;
+        int err = 0;
        if (filename__read_build_id(filename, &build_id, sizeof(build_id)) < 0) {
                pr_debug("Couldn't read a build-id in %s\n", filename);
@@ -266,14 +286,14 @@ static int build_id_cache__update_file(const char *filename,
        }
        build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
-        err = build_id_cache__remove_s(sbuild_id, debugdir);
+        if (build_id_cache__cached(sbuild_id))
-        if (!err) {
+                err = build_id_cache__remove_s(sbuild_id);
-                err = build_id_cache__add_s(sbuild_id, debugdir, filename,
-                                            false, false);
+        if (!err)
-        }
+                err = build_id_cache__add_s(sbuild_id, filename, false, false);
-        if (verbose)
-                pr_info("Updating %s %s: %s\n", sbuild_id, filename,
+        pr_debug("Updating %s %s: %s\n", sbuild_id, filename,
-                        err ? "FAIL" : "Ok");
+                 err ? "FAIL" : "Ok");
        return err;
 }
@@ -287,6 +307,7 @@ int cmd_buildid_cache(int argc, const char **argv,
        bool force = false;
        char const *add_name_list_str = NULL,
                   *remove_name_list_str = NULL,
+                   *purge_name_list_str = NULL,
                   *missing_filename = NULL,
                   *update_name_list_str = NULL,
                   *kcore_filename = NULL;
@@ -304,6 +325,8 @@ int cmd_buildid_cache(int argc, const char **argv,
                   "file", "kcore file to add"),
        OPT_STRING('r', "remove", &remove_name_list_str, "file list",
                    "file(s) to remove"),
+        OPT_STRING('p', "purge", &purge_name_list_str, "path list",
+                    "path(s) to remove (remove old caches too)"),
        OPT_STRING('M', "missing", &missing_filename, "file",
                   "to find missing build ids in the cache"),
        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
@@ -320,6 +343,11 @@ int cmd_buildid_cache(int argc, const char **argv,
        argc = parse_options(argc, argv, buildid_cache_options,
                             buildid_cache_usage, 0);
+        if (argc || (!add_name_list_str && !kcore_filename &&
+                     !remove_name_list_str && !purge_name_list_str &&
+                     !missing_filename && !update_name_list_str))
+                usage_with_options(buildid_cache_usage, buildid_cache_options);
        if (missing_filename) {
                file.path = missing_filename;
                file.force = force;
@@ -338,7 +366,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                list = strlist__new(true, add_name_list_str);
                if (list) {
                        strlist__for_each(pos, list)
-                                if (build_id_cache__add_file(pos->s, buildid_dir)) {
+                                if (build_id_cache__add_file(pos->s)) {
                                        if (errno == EEXIST) {
                                                pr_debug("%s already in the cache\n",
                                                         pos->s);
@@ -356,7 +384,25 @@ int cmd_buildid_cache(int argc, const char **argv,
                list = strlist__new(true, remove_name_list_str);
                if (list) {
                        strlist__for_each(pos, list)
-                                if (build_id_cache__remove_file(pos->s, buildid_dir)) {
+                                if (build_id_cache__remove_file(pos->s)) {
+                                        if (errno == ENOENT) {
+                                                pr_debug("%s wasn't in the cache\n",
+                                                         pos->s);
+                                                continue;
+                                        }
+                                        pr_warning("Couldn't remove %s: %s\n",
+                                                   pos->s, strerror_r(errno, sbuf, sizeof(sbuf)));
+                                }
+                        strlist__delete(list);
+                }
+        }
+        if (purge_name_list_str) {
+                list = strlist__new(true, purge_name_list_str);
+                if (list) {
+                        strlist__for_each(pos, list)
+                                if (build_id_cache__purge_path(pos->s)) {
                                        if (errno == ENOENT) {
                                                pr_debug("%s wasn't in the cache\n",
                                                         pos->s);
@@ -377,7 +423,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                list = strlist__new(true, update_name_list_str);
                if (list) {
                        strlist__for_each(pos, list)
-                                if (build_id_cache__update_file(pos->s, buildid_dir)) {
+                                if (build_id_cache__update_file(pos->s)) {
                                        if (errno == ENOENT) {
                                                pr_debug("%s wasn't in the cache\n",
                                                         pos->s);
@@ -391,8 +437,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                }
        }
-        if (kcore_filename &&
+        if (kcore_filename && build_id_cache__add_kcore(kcore_filename, force))
-            build_id_cache__add_kcore(kcore_filename, buildid_dir, force))
                pr_warning("Couldn't add %s\n", kcore_filename);
 out:
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
index ed3873b3e238..feb420f74c2d 100644
--- a/tools/perf/builtin-buildid-list.c
+++ b/tools/perf/builtin-buildid-list.c
@@ -74,7 +74,7 @@ static int perf_session__list_build_ids(bool force, bool with_hits)
         * the record stream. Buildids are stored as RECORD_HEADER_BUILD_ID
         */
        if (with_hits || perf_data_file__is_pipe(&file))
-                perf_session__process_events(session, &build_id__mark_dso_hit_ops);
+                perf_session__process_events(session);
        perf_session__fprintf_dsos_buildid(session, stdout, dso__skip_buildid, with_hits);
        perf_session__delete(session);
diff --git a/tools/perf/builtin-data.c b/tools/perf/builtin-data.c
new file mode 100644
index 000000000000..709152a7b408
--- /dev/null
+++ b/tools/perf/builtin-data.c
@@ -0,0 +1,121 @@
+#include <linux/compiler.h>
+#include "builtin.h"
+#include "perf.h"
+#include "debug.h"
+#include "parse-options.h"
+#include "data-convert-bt.h"
+typedef int (*data_cmd_fn_t)(int argc, const char **argv, const char *prefix);
+struct data_cmd {
+        const char      *name;
+        const char      *summary;
+        data_cmd_fn_t   fn;
+};
+static struct data_cmd data_cmds[];
+#define for_each_cmd(cmd) \
+        for (cmd = data_cmds; cmd && cmd->name; cmd++)
+static const struct option data_options[] = {
+        OPT_END()
+};
+static const char * const data_subcommands[] = { "convert", NULL };
+static const char *data_usage[] = {
+        "perf data [<common options>] <command> [<options>]",
+        NULL
+};
+static void print_usage(void)
+{
+        struct data_cmd *cmd;
+        printf("Usage:\n");
+        printf("\t%s\n\n", data_usage[0]);
+        printf("\tAvailable commands:\n");
+        for_each_cmd(cmd) {
+                printf("\t %s\t- %s\n", cmd->name, cmd->summary);
+        }
+        printf("\n");
+}
+static const char * const data_convert_usage[] = {
+        "perf data convert [<options>]",
+        NULL
+};
+static int cmd_data_convert(int argc, const char **argv,
+                            const char *prefix __maybe_unused)
+{
+        const char *to_ctf     = NULL;
+        const struct option options[] = {
+                OPT_INCR('v', "verbose", &verbose, "be more verbose"),
+                OPT_STRING('i', "input", &input_name, "file", "input file name"),
+#ifdef HAVE_LIBBABELTRACE_SUPPORT
+                OPT_STRING(0, "to-ctf", &to_ctf, NULL, "Convert to CTF format"),
+#endif
+                OPT_END()
+        };
+#ifndef HAVE_LIBBABELTRACE_SUPPORT
+        pr_err("No conversion support compiled in.\n");
+        return -1;
+#endif
+        argc = parse_options(argc, argv, options,
+                             data_convert_usage, 0);
+        if (argc) {
+                usage_with_options(data_convert_usage, options);
+                return -1;
+        }
+        if (to_ctf) {
+#ifdef HAVE_LIBBABELTRACE_SUPPORT
+                return bt_convert__perf2ctf(input_name, to_ctf);
+#else
+                pr_err("The libbabeltrace support is not compiled in.\n");
+                return -1;
+#endif
+        }
+        return 0;
+}
+static struct data_cmd data_cmds[] = {
+        { "convert", "converts data file between formats", cmd_data_convert },
+        { .name = NULL, },
+};
+int cmd_data(int argc, const char **argv, const char *prefix)
+{
+        struct data_cmd *cmd;
+        const char *cmdstr;
+        /* No command specified. */
+        if (argc < 2)
+                goto usage;
+        argc = parse_options_subcommand(argc, argv, data_options, data_subcommands, data_usage,
+                             PARSE_OPT_STOP_AT_NON_OPTION);
+        if (argc < 1)
+                goto usage;
+        cmdstr = argv[0];
+        for_each_cmd(cmd) {
+                if (strcmp(cmd->name, cmdstr))
+                        continue;
+                return cmd->fn(argc, argv, prefix);
+        }
+        pr_err("Unknown command: %s\n", cmdstr);
+usage:
+        print_usage();
+        return -1;
+}
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index 74aada554b12..df6307b4050a 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -747,7 +747,7 @@ static int __cmd_diff(void)
                        goto out_delete;
                }
-                ret = perf_session__process_events(d->session, &tool);
+                ret = perf_session__process_events(d->session);
                if (ret) {
                        pr_err("Failed to process %s\n", d->file.path);
                        goto out_delete;
@@ -791,6 +791,8 @@ static const struct option options[] = {
        OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                    "dump raw trace in ASCII"),
        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
+        OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
+                   "file", "kallsyms pathname"),
        OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
                    "load module symbols - WARNING: use only with -k and LIVE kernel"),
        OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
@@ -802,7 +804,7 @@ static const struct option options[] = {
        OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
                   "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..."
                   " Please refer the man page for the complete list."),
-        OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
+        OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator",
                   "separator for columns, no spaces will be added between "
                   "columns '.' is reserved."),
        OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index 25d20628212e..36486eade1ef 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -437,7 +437,18 @@ int cmd_help(int argc, const char **argv, const char *prefix __maybe_unused)
                        HELP_FORMAT_INFO),
        OPT_END(),
        };
-        const char * const builtin_help_usage[] = {
+        const char * const builtin_help_subcommands[] = {
+                "buildid-cache", "buildid-list", "diff", "evlist", "help", "list",
+                "record", "report", "bench", "stat", "timechart", "top", "annotate",
+                "script", "sched", "kmem", "lock", "kvm", "test", "inject", "mem", "data",
+#ifdef HAVE_LIBELF_SUPPORT
+                "probe",
+#endif
+#ifdef HAVE_LIBAUDIT_SUPPORT
+                "trace",
+#endif
+        NULL };
+        const char *builtin_help_usage[] = {
                "perf help [--all] [--man|--web|--info] [command]",
                NULL
        };
@@ -448,8 +459,8 @@ int cmd_help(int argc, const char **argv, const char *prefix __maybe_unused)
        perf_config(perf_help_config, &help_format);
-        argc = parse_options(argc, argv, builtin_help_options,
+        argc = parse_options_subcommand(argc, argv, builtin_help_options,
-                        builtin_help_usage, 0);
+                        builtin_help_subcommands, builtin_help_usage, 0);
        if (show_all) {
                printf("\n usage: %s\n\n", perf_usage_string);
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index a13641e066f5..ea46df25368c 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -53,6 +53,13 @@ static int perf_event__repipe_synth(struct perf_tool *tool,
        return 0;
 }
+static int perf_event__repipe_oe_synth(struct perf_tool *tool,
+                                       union perf_event *event,
+                                       struct ordered_events *oe __maybe_unused)
+{
+        return perf_event__repipe_synth(tool, event);
+}
 static int perf_event__repipe_op2_synth(struct perf_tool *tool,
                                        union perf_event *event,
                                        struct perf_session *session
@@ -359,8 +366,6 @@ static int __cmd_inject(struct perf_inject *inject)
        } else if (inject->sched_stat) {
                struct perf_evsel *evsel;
-                inject->tool.ordered_events = true;
                evlist__for_each(session->evlist, evsel) {
                        const char *name = perf_evsel__name(evsel);
@@ -379,7 +384,7 @@ static int __cmd_inject(struct perf_inject *inject)
        if (!file_out->is_pipe)
                lseek(fd, session->header.data_offset, SEEK_SET);
-        ret = perf_session__process_events(session, &inject->tool);
+        ret = perf_session__process_events(session);
        if (!file_out->is_pipe) {
                if (inject->build_ids)
@@ -408,7 +413,7 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                        .unthrottle     = perf_event__repipe,
                        .attr           = perf_event__repipe_attr,
                        .tracing_data   = perf_event__repipe_op2_synth,
-                        .finished_round = perf_event__repipe_op2_synth,
+                        .finished_round = perf_event__repipe_oe_synth,
                        .build_id       = perf_event__repipe_op2_synth,
                        .id_index       = perf_event__repipe_op2_synth,
                },
@@ -458,6 +463,8 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                return -1;
        }
+        inject.tool.ordered_events = inject.sched_stat;
        file.path = inject.input_name;
        inject.session = perf_session__new(&file, true, &inject.tool);
        if (inject.session == NULL)
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index f295141025bc..64d3623d45a0 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -20,6 +20,7 @@
 #include <linux/rbtree.h>
 #include <linux/string.h>
+#include <locale.h>
 struct alloc_stat;
 typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);
@@ -275,10 +276,10 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
        struct rb_node *next;
        struct machine *machine = &session->machines.host;
-        printf("%.102s\n", graph_dotted_line);
+        printf("%.105s\n", graph_dotted_line);
        printf(" %-34s |",  is_caller ? "Callsite": "Alloc Ptr");
        printf(" Total_alloc/Per | Total_req/Per   | Hit      | Ping-pong | Frag\n");
-        printf("%.102s\n", graph_dotted_line);
+        printf("%.105s\n", graph_dotted_line);
        next = rb_first(root);
@@ -304,7 +305,7 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
                        snprintf(buf, sizeof(buf), "%#" PRIx64 "", addr);
                printf(" %-34s |", buf);
-                printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %8lu | %6.3f%%\n",
+                printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %9lu | %6.3f%%\n",
                       (unsigned long long)data->bytes_alloc,
                       (unsigned long)data->bytes_alloc / data->hit,
                       (unsigned long long)data->bytes_req,
@@ -317,21 +318,21 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
        }
        if (n_lines == -1)
-                printf(" ...                                | ...             | ...             | ...    | ...      | ...   \n");
+                printf(" ...                                | ...             | ...             | ...      | ...       | ...   \n");
-        printf("%.102s\n", graph_dotted_line);
+        printf("%.105s\n", graph_dotted_line);
 }
 static void print_summary(void)
 {
        printf("\nSUMMARY\n=======\n");
-        printf("Total bytes requested: %lu\n", total_requested);
+        printf("Total bytes requested: %'lu\n", total_requested);
-        printf("Total bytes allocated: %lu\n", total_allocated);
+        printf("Total bytes allocated: %'lu\n", total_allocated);
-        printf("Total bytes wasted on internal fragmentation: %lu\n",
+        printf("Total bytes wasted on internal fragmentation: %'lu\n",
               total_allocated - total_requested);
        printf("Internal fragmentation: %f%%\n",
               fragmentation(total_requested, total_allocated));
-        printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
+        printf("Cross CPU allocations: %'lu/%'lu\n", nr_cross_allocs, nr_allocs);
 }
 static void print_result(struct perf_session *session)
@@ -426,7 +427,7 @@ static int __cmd_kmem(struct perf_session *session)
        }
        setup_pager();
-        err = perf_session__process_events(session, &perf_kmem);
+        err = perf_session__process_events(session);
        if (err != 0)
                goto out;
        sort_result();
@@ -559,6 +560,7 @@ static int setup_sorting(struct list_head *sort_list, const char *arg)
 {
        char *tok;
        char *str = strdup(arg);
+        char *pos = str;
        if (!str) {
                pr_err("%s: strdup failed\n", __func__);
@@ -566,7 +568,7 @@ static int setup_sorting(struct list_head *sort_list, const char *arg)
        }
        while (true) {
-                tok = strsep(&str, ",");
+                tok = strsep(&pos, ",");
                if (!tok)
                        break;
                if (sort_dimension__add(tok, sort_list) < 0) {
@@ -662,6 +664,8 @@ int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused)
        const char * const default_sort_order = "frag,hit,bytes";
        const struct option kmem_options[] = {
        OPT_STRING('i', "input", &input_name, "file", "input file name"),
+        OPT_INCR('v', "verbose", &verbose,
+                    "be more verbose (show symbol address, etc)"),
        OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
                           "show per-callsite statistics", parse_caller_opt),
        OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
@@ -703,6 +707,8 @@ int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused)
        symbol__init(&session->header.env);
        if (!strcmp(argv[0], "stat")) {
+                setlocale(LC_ALL, "");
                if (cpu__setup_cpunode_map())
                        goto out_delete;
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 0894a817f67e..643722f40075 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -18,6 +18,7 @@
 #include "util/stat.h"
 #include "util/top.h"
 #include "util/data.h"
+#include "util/ordered-events.h"
 #include <sys/prctl.h>
 #ifdef HAVE_TIMERFD_SUPPORT
@@ -730,9 +731,9 @@ static s64 perf_kvm__mmap_read_idx(struct perf_kvm_stat *kvm, int idx,
                        return -1;
                }
-                err = perf_session_queue_event(kvm->session, event, &kvm->tool, &sample, 0);
+                err = perf_session__queue_event(kvm->session, event, &sample, 0);
                /*
-                 * FIXME: Here we can't consume the event, as perf_session_queue_event will
+                 * FIXME: Here we can't consume the event, as perf_session__queue_event will
                 *        point to it, and it'll get possibly overwritten by the kernel.
                 */
                perf_evlist__mmap_consume(kvm->evlist, idx);
@@ -783,8 +784,10 @@ static int perf_kvm__mmap_read(struct perf_kvm_stat *kvm)
        /* flush queue after each round in which we processed events */
        if (ntotal) {
-                kvm->session->ordered_events.next_flush = flush_time;
+                struct ordered_events *oe = &kvm->session->ordered_events;
-                err = kvm->tool.finished_round(&kvm->tool, NULL, kvm->session);
+                oe->next_flush = flush_time;
+                err = ordered_events__flush(oe, OE_FLUSH__ROUND);
                if (err) {
                        if (kvm->lost_events)
                                pr_info("\nLost events: %" PRIu64 "\n\n",
@@ -1066,7 +1069,7 @@ static int read_events(struct perf_kvm_stat *kvm)
        if (ret < 0)
                return ret;
-        return perf_session__process_events(kvm->session, &kvm->tool);
+        return perf_session__process_events(kvm->session);
 }
 static int parse_target_str(struct perf_kvm_stat *kvm)
diff --git a/tools/perf/builtin-list.c b/tools/perf/builtin-list.c
index 198f3c3aff95..af5bd0514108 100644
--- a/tools/perf/builtin-list.c
+++ b/tools/perf/builtin-list.c
@@ -36,38 +36,36 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
        setup_pager();
-        if (raw_dump) {
+        if (!raw_dump)
-                print_events(NULL, true);
+                printf("\nList of pre-defined events (to be used in -e):\n\n");
-                return 0;
-        }
        if (argc == 0) {
-                print_events(NULL, false);
+                print_events(NULL, raw_dump);
                return 0;
        }
        for (i = 0; i < argc; ++i) {
-                if (i)
+                if (strcmp(argv[i], "tracepoint") == 0)
-                        putchar('\n');
+                        print_tracepoint_events(NULL, NULL, raw_dump);
-                if (strncmp(argv[i], "tracepoint", 10) == 0)
-                        print_tracepoint_events(NULL, NULL, false);
                else if (strcmp(argv[i], "hw") == 0 ||
                         strcmp(argv[i], "hardware") == 0)
-                        print_events_type(PERF_TYPE_HARDWARE);
+                        print_symbol_events(NULL, PERF_TYPE_HARDWARE,
+                                        event_symbols_hw, PERF_COUNT_HW_MAX, raw_dump);
                else if (strcmp(argv[i], "sw") == 0 ||
                         strcmp(argv[i], "software") == 0)
-                        print_events_type(PERF_TYPE_SOFTWARE);
+                        print_symbol_events(NULL, PERF_TYPE_SOFTWARE,
+                                        event_symbols_sw, PERF_COUNT_SW_MAX, raw_dump);
                else if (strcmp(argv[i], "cache") == 0 ||
                         strcmp(argv[i], "hwcache") == 0)
-                        print_hwcache_events(NULL, false);
+                        print_hwcache_events(NULL, raw_dump);
                else if (strcmp(argv[i], "pmu") == 0)
-                        print_pmu_events(NULL, false);
+                        print_pmu_events(NULL, raw_dump);
                else {
                        char *sep = strchr(argv[i], ':'), *s;
                        int sep_idx;
                        if (sep == NULL) {
-                                print_events(argv[i], false);
+                                print_events(argv[i], raw_dump);
                                continue;
                        }
                        sep_idx = sep - argv[i];
@@ -76,7 +74,7 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                                return -1;
                        s[sep_idx] = '\0';
-                        print_tracepoint_events(s, s + sep_idx + 1, false);
+                        print_tracepoint_events(s, s + sep_idx + 1, raw_dump);
                        free(s);
                }
        }
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index e7ec71589da6..7893a9bba2a7 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -878,7 +878,7 @@ static int __cmd_report(bool display_info)
        if (select_key())
                goto out_delete;
-        err = perf_session__process_events(session, &eops);
+        err = perf_session__process_events(session);
        if (err)
                goto out_delete;
diff --git a/tools/perf/builtin-mem.c b/tools/perf/builtin-mem.c
index 9b5663950a4d..b4dcf0bfc029 100644
--- a/tools/perf/builtin-mem.c
+++ b/tools/perf/builtin-mem.c
@@ -141,7 +141,7 @@ static int report_raw_events(struct perf_mem *mem)
        printf("# PID, TID, IP, ADDR, LOCAL WEIGHT, DSRC, SYMBOL\n");
-        err = perf_session__process_events(session, &mem->tool);
+        err = perf_session__process_events(session);
        if (err)
                return err;
@@ -286,7 +286,7 @@ int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
                   "input file name"),
        OPT_STRING('C', "cpu", &mem.cpu_list, "cpu",
                   "list of cpus to profile"),
-        OPT_STRING('x', "field-separator", &symbol_conf.field_sep,
+        OPT_STRING_NOEMPTY('x', "field-separator", &symbol_conf.field_sep,
                   "separator",
                   "separator for columns, no spaces will be added"
                   " between columns '.' is reserved."),
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 404ab3434052..18aad239b401 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -161,8 +161,9 @@ try_again:
                }
        }
-        if (perf_evlist__apply_filters(evlist)) {
+        if (perf_evlist__apply_filters(evlist, &pos)) {
-                error("failed to set filter with %d (%s)\n", errno,
+                error("failed to set filter \"%s\" on event %s with %d (%s)\n",
+                        pos->filter, perf_evsel__name(pos), errno,
                        strerror_r(errno, msg, sizeof(msg)));
                rc = -1;
                goto out;
@@ -225,7 +226,7 @@ static int process_buildids(struct record *rec)
         */
        symbol_conf.ignore_vmlinux_buildid = true;
-        return perf_session__process_events(session, &rec->tool);
+        return perf_session__process_events(session);
 }
 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
@@ -343,7 +344,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
        signal(SIGINT, sig_handler);
        signal(SIGTERM, sig_handler);
-        session = perf_session__new(file, false, NULL);
+        session = perf_session__new(file, false, tool);
        if (session == NULL) {
                pr_err("Perf session creation failed.\n");
                return -1;
@@ -658,7 +659,7 @@ error:
 static void callchain_debug(void)
 {
-        static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF" };
+        static const char *str[CALLCHAIN_MAX] = { "NONE", "FP", "DWARF", "LBR" };
        pr_debug("callchain: type %s\n", str[callchain_param.record_mode]);
@@ -751,9 +752,9 @@ static struct record record = {
 #define CALLCHAIN_HELP "setup and enables call-graph (stack chain/backtrace) recording: "
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
-const char record_callchain_help[] = CALLCHAIN_HELP "fp dwarf";
+const char record_callchain_help[] = CALLCHAIN_HELP "fp dwarf lbr";
 #else
-const char record_callchain_help[] = CALLCHAIN_HELP "fp";
+const char record_callchain_help[] = CALLCHAIN_HELP "fp lbr";
 #endif
 /*
@@ -839,6 +840,8 @@ struct option __record_options[] = {
                    "use per-thread mmaps"),
        OPT_BOOLEAN('I', "intr-regs", &record.opts.sample_intr_regs,
                    "Sample machine registers on interrupt"),
+        OPT_BOOLEAN(0, "running-time", &record.opts.running_time,
+                    "Record running/enabled time of read (:S) events"),
        OPT_END()
 };
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 2f91094e228b..b5b2ad4ca9c4 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -249,6 +249,8 @@ static int report__setup_sample_type(struct report *rep)
                if ((sample_type & PERF_SAMPLE_REGS_USER) &&
                    (sample_type & PERF_SAMPLE_STACK_USER))
                        callchain_param.record_mode = CALLCHAIN_DWARF;
+                else if (sample_type & PERF_SAMPLE_BRANCH_STACK)
+                        callchain_param.record_mode = CALLCHAIN_LBR;
                else
                        callchain_param.record_mode = CALLCHAIN_FP;
        }
@@ -302,7 +304,7 @@ static size_t hists__fprintf_nr_sample_events(struct hists *hists, struct report
        if (rep->mem_mode) {
                ret += fprintf(fp, "\n# Total weight : %" PRIu64, nr_events);
-                ret += fprintf(fp, "\n# Sort order   : %s", sort_order);
+                ret += fprintf(fp, "\n# Sort order   : %s", sort_order ? : default_mem_sort_order);
        } else
                ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events);
        return ret + fprintf(fp, "\n#\n");
@@ -480,7 +482,7 @@ static int __cmd_report(struct report *rep)
        if (ret)
                return ret;
-        ret = perf_session__process_events(session, &rep->tool);
+        ret = perf_session__process_events(session);
        if (ret)
                return ret;
@@ -667,6 +669,10 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                   "only consider symbols in these dsos"),
        OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
                   "only consider symbols in these comms"),
+        OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
+                   "only consider symbols in these pids"),
+        OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
+                   "only consider symbols in these tids"),
        OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
                   "only consider these symbols"),
        OPT_STRING(0, "symbol-filter", &report.symbol_filter_str, "filter",
@@ -674,7 +680,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
        OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
                   "width[,width...]",
                   "don't try to adjust column width, use these fixed values"),
-        OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
+        OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator",
                   "separator for columns, no spaces will be added between "
                   "columns '.' is reserved."),
        OPT_BOOLEAN('U', "hide-unresolved", &report.hide_unresolved,
@@ -766,7 +772,7 @@ repeat:
         * 0/1 means the user chose a mode.
         */
        if (((branch_mode == -1 && has_br_stack) || branch_mode == 1) &&
-            branch_call_mode == -1) {
+            !branch_call_mode) {
                sort__mode = SORT_MODE__BRANCH;
                symbol_conf.cumulate_callchain = false;
        }
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index 891c3930080e..3b3a5bb97059 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -831,7 +831,7 @@ static int thread_atoms_insert(struct perf_sched *sched, struct thread *thread)
                return -1;
        }
-        atoms->thread = thread;
+        atoms->thread = thread__get(thread);
        INIT_LIST_HEAD(&atoms->work_list);
        __thread_latency_insert(&sched->atom_root, atoms, &sched->cmp_pid);
        return 0;
@@ -1439,8 +1439,7 @@ static int perf_sched__process_tracepoint_sample(struct perf_tool *tool __maybe_
        return err;
 }
-static int perf_sched__read_events(struct perf_sched *sched,
+static int perf_sched__read_events(struct perf_sched *sched)
-                                   struct perf_session **psession)
 {
        const struct perf_evsel_str_handler handlers[] = {
                { "sched:sched_switch",       process_sched_switch_event, },
@@ -1454,6 +1453,7 @@ static int perf_sched__read_events(struct perf_sched *sched,
                .path = input_name,
                .mode = PERF_DATA_MODE_READ,
        };
+        int rc = -1;
        session = perf_session__new(&file, false, &sched->tool);
        if (session == NULL) {
@@ -1467,27 +1467,21 @@ static int perf_sched__read_events(struct perf_sched *sched,
                goto out_delete;
        if (perf_session__has_traces(session, "record -R")) {
-                int err = perf_session__process_events(session, &sched->tool);
+                int err = perf_session__process_events(session);
                if (err) {
                        pr_err("Failed to process events, error %d", err);
                        goto out_delete;
                }
-                sched->nr_events      = session->stats.nr_events[0];
+                sched->nr_events      = session->evlist->stats.nr_events[0];
-                sched->nr_lost_events = session->stats.total_lost;
+                sched->nr_lost_events = session->evlist->stats.total_lost;
-                sched->nr_lost_chunks = session->stats.nr_events[PERF_RECORD_LOST];
+                sched->nr_lost_chunks = session->evlist->stats.nr_events[PERF_RECORD_LOST];
        }
-        if (psession)
+        rc = 0;
-                *psession = session;
-        else
-                perf_session__delete(session);
-        return 0;
 out_delete:
        perf_session__delete(session);
-        return -1;
+        return rc;
 }
 static void print_bad_events(struct perf_sched *sched)
@@ -1515,12 +1509,10 @@ static void print_bad_events(struct perf_sched *sched)
 static int perf_sched__lat(struct perf_sched *sched)
 {
        struct rb_node *next;
-        struct perf_session *session;
        setup_pager();
-        /* save session -- references to threads are held in work_list */
+        if (perf_sched__read_events(sched))
-        if (perf_sched__read_events(sched, &session))
                return -1;
        perf_sched__sort_lat(sched);
@@ -1537,6 +1529,7 @@ static int perf_sched__lat(struct perf_sched *sched)
                work_list = rb_entry(next, struct work_atoms, node);
                output_lat_thread(sched, work_list);
                next = rb_next(next);
+                thread__zput(work_list->thread);
        }
        printf(" -----------------------------------------------------------------------------------------------------------------\n");
@@ -1548,7 +1541,6 @@ static int perf_sched__lat(struct perf_sched *sched)
        print_bad_events(sched);
        printf("\n");
-        perf_session__delete(session);
        return 0;
 }
@@ -1557,7 +1549,7 @@ static int perf_sched__map(struct perf_sched *sched)
        sched->max_cpu = sysconf(_SC_NPROCESSORS_CONF);
        setup_pager();
-        if (perf_sched__read_events(sched, NULL))
+        if (perf_sched__read_events(sched))
                return -1;
        print_bad_events(sched);
        return 0;
@@ -1572,7 +1564,7 @@ static int perf_sched__replay(struct perf_sched *sched)
        test_calibrations(sched);
-        if (perf_sched__read_events(sched, NULL))
+        if (perf_sched__read_events(sched))
                return -1;
        printf("nr_run_events:        %ld\n", sched->nr_run_events);
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index ce304dfd962a..662366ceb572 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -800,7 +800,7 @@ static int __cmd_script(struct perf_script *script)
                script->tool.mmap2 = process_mmap2_event;
        }
-        ret = perf_session__process_events(script->session, &script->tool);
+        ret = perf_session__process_events(script->session);
        if (debug_mode)
                pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
@@ -1562,6 +1562,10 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
        OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
        OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
                   "only display events for these comms"),
+        OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
+                   "only consider symbols in these pids"),
+        OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
+                   "only consider symbols in these tids"),
        OPT_BOOLEAN('I', "show-info", &show_full_info,
                    "display extended information from perf.data file"),
        OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
@@ -1572,7 +1576,8 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                    "Show the mmap events"),
        OPT_END()
        };
-        const char * const script_usage[] = {
+        const char * const script_subcommands[] = { "record", "report", NULL };
+        const char *script_usage[] = {
                "perf script [<options>]",
                "perf script [<options>] record <script> [<record-options>] <command>",
                "perf script [<options>] report <script> [script-args]",
@@ -1586,7 +1591,7 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
        setup_scripting();
-        argc = parse_options(argc, argv, options, script_usage,
+        argc = parse_options_subcommand(argc, argv, options, script_subcommands, script_usage,
                             PARSE_OPT_STOP_AT_NON_OPTION);
        file.path = input_name;
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index e598e4e98170..f7b8218785f6 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -353,39 +353,40 @@ static struct perf_evsel *nth_evsel(int n)
 * more semantic information such as miss/hit ratios,
 * instruction rates, etc:
 */
-static void update_shadow_stats(struct perf_evsel *counter, u64 *count)
+static void update_shadow_stats(struct perf_evsel *counter, u64 *count,
+                                int cpu)
 {
        if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
-                update_stats(&runtime_nsecs_stats[0], count[0]);
+                update_stats(&runtime_nsecs_stats[cpu], count[0]);
        else if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
-                update_stats(&runtime_cycles_stats[0], count[0]);
+                update_stats(&runtime_cycles_stats[cpu], count[0]);
        else if (transaction_run &&
                 perf_evsel__cmp(counter, nth_evsel(T_CYCLES_IN_TX)))
-                update_stats(&runtime_cycles_in_tx_stats[0], count[0]);
+                update_stats(&runtime_cycles_in_tx_stats[cpu], count[0]);
        else if (transaction_run &&
                 perf_evsel__cmp(counter, nth_evsel(T_TRANSACTION_START)))
-                update_stats(&runtime_transaction_stats[0], count[0]);
+                update_stats(&runtime_transaction_stats[cpu], count[0]);
        else if (transaction_run &&
                 perf_evsel__cmp(counter, nth_evsel(T_ELISION_START)))
-                update_stats(&runtime_elision_stats[0], count[0]);
+                update_stats(&runtime_elision_stats[cpu], count[0]);
        else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND))
-                update_stats(&runtime_stalled_cycles_front_stats[0], count[0]);
+                update_stats(&runtime_stalled_cycles_front_stats[cpu], count[0]);
        else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND))
-                update_stats(&runtime_stalled_cycles_back_stats[0], count[0]);
+                update_stats(&runtime_stalled_cycles_back_stats[cpu], count[0]);
        else if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
-                update_stats(&runtime_branches_stats[0], count[0]);
+                update_stats(&runtime_branches_stats[cpu], count[0]);
        else if (perf_evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES))
-                update_stats(&runtime_cacherefs_stats[0], count[0]);
+                update_stats(&runtime_cacherefs_stats[cpu], count[0]);
        else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1D))
-                update_stats(&runtime_l1_dcache_stats[0], count[0]);
+                update_stats(&runtime_l1_dcache_stats[cpu], count[0]);
        else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1I))
-                update_stats(&runtime_l1_icache_stats[0], count[0]);
+                update_stats(&runtime_l1_icache_stats[cpu], count[0]);
        else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_LL))
-                update_stats(&runtime_ll_cache_stats[0], count[0]);
+                update_stats(&runtime_ll_cache_stats[cpu], count[0]);
        else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_DTLB))
-                update_stats(&runtime_dtlb_cache_stats[0], count[0]);
+                update_stats(&runtime_dtlb_cache_stats[cpu], count[0]);
        else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB))
-                update_stats(&runtime_itlb_cache_stats[0], count[0]);
+                update_stats(&runtime_itlb_cache_stats[cpu], count[0]);
 }
 static void zero_per_pkg(struct perf_evsel *counter)
@@ -447,7 +448,8 @@ static int read_cb(struct perf_evsel *evsel, int cpu, int thread __maybe_unused,
                        perf_evsel__compute_deltas(evsel, cpu, count);
                perf_counts_values__scale(count, scale, NULL);
                evsel->counts->cpu[cpu] = *count;
-                update_shadow_stats(evsel, count->values);
+                if (aggr_mode == AGGR_NONE)
+                        update_shadow_stats(evsel, count->values, cpu);
                break;
        case AGGR_GLOBAL:
                aggr->val += count->val;
@@ -495,7 +497,7 @@ static int read_counter_aggr(struct perf_evsel *counter)
        /*
         * Save the full runtime - to allow normalization during printout:
         */
-        update_shadow_stats(counter, count);
+        update_shadow_stats(counter, count, 0);
        return 0;
 }
@@ -510,6 +512,9 @@ static int read_counter(struct perf_evsel *counter)
        int ncpus = perf_evsel__nr_cpus(counter);
        int cpu, thread;
+        if (!counter->supported)
+                return -ENOENT;
        if (counter->system_wide)
                nthreads = 1;
@@ -679,8 +684,9 @@ static int __run_perf_stat(int argc, const char **argv)
                        unit_width = l;
        }
-        if (perf_evlist__apply_filters(evsel_list)) {
+        if (perf_evlist__apply_filters(evsel_list, &counter)) {
-                error("failed to set filter with %d (%s)\n", errno,
+                error("failed to set filter \"%s\" on event %s with %d (%s)\n",
+                        counter->filter, perf_evsel__name(counter), errno,
                        strerror_r(errno, msg, sizeof(msg)));
                return -1;
        }
@@ -766,6 +772,19 @@ static int run_perf_stat(int argc, const char **argv)
        return ret;
 }
+static void print_running(u64 run, u64 ena)
+{
+        if (csv_output) {
+                fprintf(output, "%s%" PRIu64 "%s%.2f",
+                                        csv_sep,
+                                        run,
+                                        csv_sep,
+                                        ena ? 100.0 * run / ena : 100.0);
+        } else if (run != ena) {
+                fprintf(output, "  (%.2f%%)", 100.0 * run / ena);
+        }
+}
 static void print_noise_pct(double total, double avg)
 {
        double pct = rel_stddev_stats(total, avg);
@@ -1076,6 +1095,8 @@ static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
                if (total) {
                        ratio = avg / total;
                        fprintf(output, " #   %5.2f  insns per cycle        ", ratio);
+                } else {
+                        fprintf(output, "                                   ");
                }
                total = avg_stats(&runtime_stalled_cycles_front_stats[cpu]);
                total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[cpu]));
@@ -1145,6 +1166,8 @@ static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
                if (total) {
                        ratio = avg / total;
                        fprintf(output, " # %8.3f GHz                    ", ratio);
+                } else {
+                        fprintf(output, "                                   ");
                }
        } else if (transaction_run &&
                   perf_evsel__cmp(evsel, nth_evsel(T_CYCLES_IN_TX))) {
@@ -1249,6 +1272,7 @@ static void print_aggr(char *prefix)
                                        fprintf(output, "%s%s",
                                                csv_sep, counter->cgrp->name);
+                                print_running(run, ena);
                                fputc('\n', output);
                                continue;
                        }
@@ -1259,13 +1283,10 @@ static void print_aggr(char *prefix)
                        else
                                abs_printout(id, nr, counter, uval);
-                        if (!csv_output) {
+                        if (!csv_output)
                                print_noise(counter, 1.0);
-                                if (run != ena)
+                        print_running(run, ena);
-                                        fprintf(output, "  (%.2f%%)",
-                                                100.0 * run / ena);
-                        }
                        fputc('\n', output);
                }
        }
@@ -1281,11 +1302,15 @@ static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
        double avg = avg_stats(&ps->res_stats[0]);
        int scaled = counter->counts->scaled;
        double uval;
+        double avg_enabled, avg_running;
+        avg_enabled = avg_stats(&ps->res_stats[1]);
+        avg_running = avg_stats(&ps->res_stats[2]);
        if (prefix)
                fprintf(output, "%s", prefix);
-        if (scaled == -1) {
+        if (scaled == -1 || !counter->supported) {
                fprintf(output, "%*s%s",
                        csv_output ? 0 : 18,
                        counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
@@ -1300,6 +1325,7 @@ static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
                if (counter->cgrp)
                        fprintf(output, "%s%s", csv_sep, counter->cgrp->name);
+                print_running(avg_running, avg_enabled);
                fputc('\n', output);
                return;
        }
@@ -1313,19 +1339,7 @@ static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
        print_noise(counter, avg);
-        if (csv_output) {
+        print_running(avg_running, avg_enabled);
-                fputc('\n', output);
-                return;
-        }
-        if (scaled) {
-                double avg_enabled, avg_running;
-                avg_enabled = avg_stats(&ps->res_stats[1]);
-                avg_running = avg_stats(&ps->res_stats[2]);
-                fprintf(output, " [%5.2f%%]", 100 * avg_running / avg_enabled);
-        }
        fprintf(output, "\n");
 }
@@ -1367,6 +1381,7 @@ static void print_counter(struct perf_evsel *counter, char *prefix)
                                fprintf(output, "%s%s",
                                        csv_sep, counter->cgrp->name);
+                        print_running(run, ena);
                        fputc('\n', output);
                        continue;
                }
@@ -1378,13 +1393,10 @@ static void print_counter(struct perf_evsel *counter, char *prefix)
                else
                        abs_printout(cpu, 0, counter, uval);
-                if (!csv_output) {
+                if (!csv_output)
                        print_noise(counter, 1.0);
+                print_running(run, ena);
-                        if (run != ena)
-                                fprintf(output, "  (%.2f%%)",
-                                        100.0 * run / ena);
-                }
                fputc('\n', output);
        }
 }
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index f3bb1a4bf060..494b3bbe5ea4 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -1623,7 +1623,7 @@ static int __cmd_timechart(struct timechart *tchart, const char *output_name)
                goto out_delete;
        }
-        ret = perf_session__process_events(session, &tchart->tool);
+        ret = perf_session__process_events(session);
        if (ret)
                goto out_delete;
@@ -1958,7 +1958,8 @@ int cmd_timechart(int argc, const char **argv,
                     parse_time),
        OPT_END()
        };
-        const char * const timechart_usage[] = {
+        const char * const timechart_subcommands[] = { "record", NULL };
+        const char *timechart_usage[] = {
                "perf timechart [<options>] {record}",
                NULL
        };
@@ -1976,8 +1977,8 @@ int cmd_timechart(int argc, const char **argv,
                "perf timechart record [<options>]",
                NULL
        };
-        argc = parse_options(argc, argv, timechart_options, timechart_usage,
+        argc = parse_options_subcommand(argc, argv, timechart_options, timechart_subcommands,
-                        PARSE_OPT_STOP_AT_NON_OPTION);
+                        timechart_usage, PARSE_OPT_STOP_AT_NON_OPTION);
        if (tchart.power_only && tchart.tasks_only) {
                pr_err("-P and -T options cannot be used at the same time.\n");
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index c4c7eac69de4..1cb3436276d1 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -716,7 +716,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
        if (!machine) {
                pr_err("%u unprocessable samples recorded.\r",
-                       top->session->stats.nr_unprocessable_samples++);
+                       top->session->evlist->stats.nr_unprocessable_samples++);
                return;
        }
@@ -757,8 +757,10 @@ static void perf_event__process_sample(struct perf_tool *tool,
                    al.map == machine->vmlinux_maps[MAP__FUNCTION] &&
                    RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) {
                        if (symbol_conf.vmlinux_name) {
-                                ui__warning("The %s file can't be used.\n%s",
+                                char serr[256];
-                                            symbol_conf.vmlinux_name, msg);
+                                dso__strerror_load(al.map->dso, serr, sizeof(serr));
+                                ui__warning("The %s file can't be used: %s\n%s",
+                                            symbol_conf.vmlinux_name, serr, msg);
                        } else {
                                ui__warning("A vmlinux file was not found.\n%s",
                                            msg);
@@ -856,7 +858,7 @@ static void perf_top__mmap_read_idx(struct perf_top *top, int idx)
                        hists__inc_nr_events(evsel__hists(evsel), event->header.type);
                        machine__process_event(machine, event, &sample);
                } else
-                        ++session->stats.nr_unknown_events;
+                        ++session->evlist->stats.nr_unknown_events;
 next_event:
                perf_evlist__mmap_consume(top->evlist, idx);
        }
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 7e935f1083ec..bcc98ce3e5b8 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -52,7 +52,9 @@ struct tp_field {
 #define TP_UINT_FIELD(bits) \
 static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
 { \
-        return *(u##bits *)(sample->raw_data + field->offset); \
+        u##bits value; \
+        memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
+        return value;  \
 }
 TP_UINT_FIELD(8);
@@ -63,7 +65,8 @@ TP_UINT_FIELD(64);
 #define TP_UINT_FIELD__SWAPPED(bits) \
 static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
 { \
-        u##bits value = *(u##bits *)(sample->raw_data + field->offset); \
+        u##bits value; \
+        memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
        return bswap_##bits(value);\
 }
@@ -1132,6 +1135,8 @@ static struct syscall_fmt *syscall_fmt__find(const char *name)
 struct syscall {
        struct event_format *tp_format;
+        int                 nr_args;
+        struct format_field *args;
        const char          *name;
        bool                filtered;
        bool                is_exit;
@@ -1219,7 +1224,9 @@ struct trace {
                struct syscall  *table;
        } syscalls;
        struct record_opts      opts;
+        struct perf_evlist      *evlist;
        struct machine          *host;
+        struct thread           *current;
        u64                     base_time;
        FILE                    *output;
        unsigned long           nr_events;
@@ -1227,6 +1234,10 @@ struct trace {
        const char              *last_vfs_getname;
        struct intlist          *tid_list;
        struct intlist          *pid_list;
+        struct {
+                size_t          nr;
+                pid_t           *entries;
+        }                       filter_pids;
        double                  duration_filter;
        double                  runtime_ms;
        struct {
@@ -1433,14 +1444,14 @@ static int syscall__set_arg_fmts(struct syscall *sc)
        struct format_field *field;
        int idx = 0;
-        sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
+        sc->arg_scnprintf = calloc(sc->nr_args, sizeof(void *));
        if (sc->arg_scnprintf == NULL)
                return -1;
        if (sc->fmt)
                sc->arg_parm = sc->fmt->arg_parm;
-        for (field = sc->tp_format->format.fields->next; field; field = field->next) {
+        for (field = sc->args; field; field = field->next) {
                if (sc->fmt && sc->fmt->arg_scnprintf[idx])
                        sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
                else if (field->flags & FIELD_IS_POINTER)
@@ -1506,18 +1517,37 @@ static int trace__read_syscall_info(struct trace *trace, int id)
        if (sc->tp_format == NULL)
                return -1;
+        sc->args = sc->tp_format->format.fields;
+        sc->nr_args = sc->tp_format->format.nr_fields;
+        /* drop nr field - not relevant here; does not exist on older kernels */
+        if (sc->args && strcmp(sc->args->name, "nr") == 0) {
+                sc->args = sc->args->next;
+                --sc->nr_args;
+        }
        sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
        return syscall__set_arg_fmts(sc);
 }
+/*
+ * args is to be interpreted as a series of longs but we need to handle
+ * 8-byte unaligned accesses. args points to raw_data within the event
+ * and raw_data is guaranteed to be 8-byte unaligned because it is
+ * preceded by raw_size which is a u32. So we need to copy args to a temp
+ * variable to read it. Most notably this avoids extended load instructions
+ * on unaligned addresses
+ */
 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
-                                      unsigned long *args, struct trace *trace,
+                                      unsigned char *args, struct trace *trace,
                                      struct thread *thread)
 {
        size_t printed = 0;
+        unsigned char *p;
+        unsigned long val;
-        if (sc->tp_format != NULL) {
+        if (sc->args != NULL) {
                struct format_field *field;
                u8 bit = 1;
                struct syscall_arg arg = {
@@ -1527,16 +1557,21 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                        .thread = thread,
                };
-                for (field = sc->tp_format->format.fields->next; field;
+                for (field = sc->args; field;
                     field = field->next, ++arg.idx, bit <<= 1) {
                        if (arg.mask & bit)
                                continue;
+                        /* special care for unaligned accesses */
+                        p = args + sizeof(unsigned long) * arg.idx;
+                        memcpy(&val, p, sizeof(val));
                        /*
                         * Suppress this argument if its value is zero and
                         * and we don't have a string associated in an
                         * strarray for it.
                         */
-                        if (args[arg.idx] == 0 &&
+                        if (val == 0 &&
                            !(sc->arg_scnprintf &&
                              sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
                              sc->arg_parm[arg.idx]))
@@ -1545,23 +1580,26 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
                        printed += scnprintf(bf + printed, size - printed,
                                             "%s%s: ", printed ? ", " : "", field->name);
                        if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
-                                arg.val = args[arg.idx];
+                                arg.val = val;
                                if (sc->arg_parm)
                                        arg.parm = sc->arg_parm[arg.idx];
                                printed += sc->arg_scnprintf[arg.idx](bf + printed,
                                                                      size - printed, &arg);
                        } else {
                                printed += scnprintf(bf + printed, size - printed,
-                                                     "%ld", args[arg.idx]);
+                                                     "%ld", val);
                        }
                }
        } else {
                int i = 0;
                while (i < 6) {
+                        /* special care for unaligned accesses */
+                        p = args + sizeof(unsigned long) * i;
+                        memcpy(&val, p, sizeof(val));
                        printed += scnprintf(bf + printed, size - printed,
                                             "%sarg%d: %ld",
-                                             printed ? ", " : "", i, args[i]);
+                                             printed ? ", " : "", i, val);
                        ++i;
                }
        }
@@ -1642,6 +1680,29 @@ static void thread__update_stats(struct thread_trace *ttrace,
        update_stats(stats, duration);
 }
+static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
+{
+        struct thread_trace *ttrace;
+        u64 duration;
+        size_t printed;
+        if (trace->current == NULL)
+                return 0;
+        ttrace = thread__priv(trace->current);
+        if (!ttrace->entry_pending)
+                return 0;
+        duration = sample->time - ttrace->entry_time;
+        printed  = trace__fprintf_entry_head(trace, trace->current, duration, sample->time, trace->output);
+        printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
+        ttrace->entry_pending = false;
+        return printed;
+}
 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
                            union perf_event *event __maybe_unused,
                            struct perf_sample *sample)
@@ -1673,6 +1734,9 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
                        return -1;
        }
+        if (!trace->summary_only)
+                trace__printf_interrupted_entry(trace, sample);
        ttrace->entry_time = sample->time;
        msg = ttrace->entry_str;
        printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
@@ -1688,6 +1752,11 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
        } else
                ttrace->entry_pending = true;
+        if (trace->current != thread) {
+                thread__put(trace->current);
+                trace->current = thread__get(thread);
+        }
        return 0;
 }
@@ -1805,6 +1874,28 @@ out_dump:
        return 0;
 }
+static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
+                                union perf_event *event __maybe_unused,
+                                struct perf_sample *sample)
+{
+        trace__printf_interrupted_entry(trace, sample);
+        trace__fprintf_tstamp(trace, sample->time, trace->output);
+        if (trace->trace_syscalls)
+                fprintf(trace->output, "(         ): ");
+        fprintf(trace->output, "%s:", evsel->name);
+        if (evsel->tp_format) {
+                event_format__fprintf(evsel->tp_format, sample->cpu,
+                                      sample->raw_data, sample->raw_size,
+                                      trace->output);
+        }
+        fprintf(trace->output, ")\n");
+        return 0;
+}
 static void print_location(FILE *f, struct perf_sample *sample,
                           struct addr_location *al,
                           bool print_dso, bool print_sym)
@@ -2037,10 +2128,39 @@ static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
        return 0;
 }
-static int trace__run(struct trace *trace, int argc, const char **argv)
+static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
 {
-        struct perf_evlist *evlist = perf_evlist__new();
+        const u32 type = event->header.type;
        struct perf_evsel *evsel;
+        if (!trace->full_time && trace->base_time == 0)
+                trace->base_time = sample->time;
+        if (type != PERF_RECORD_SAMPLE) {
+                trace__process_event(trace, trace->host, event, sample);
+                return;
+        }
+        evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
+        if (evsel == NULL) {
+                fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
+                return;
+        }
+        if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
+            sample->raw_data == NULL) {
+                fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
+                       perf_evsel__name(evsel), sample->tid,
+                       sample->cpu, sample->raw_size);
+        } else {
+                tracepoint_handler handler = evsel->handler;
+                handler(trace, evsel, event, sample);
+        }
+}
+static int trace__run(struct trace *trace, int argc, const char **argv)
+{
+        struct perf_evlist *evlist = trace->evlist;
        int err = -1, i;
        unsigned long before;
        const bool forks = argc > 0;
@@ -2048,11 +2168,6 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
        trace->live = true;
-        if (evlist == NULL) {
-                fprintf(trace->output, "Not enough memory to run!\n");
-                goto out;
-        }
        if (trace->trace_syscalls &&
            perf_evlist__add_syscall_newtp(evlist, trace__sys_enter,
                                           trace__sys_exit))
@@ -2105,16 +2220,34 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
        if (err < 0)
                goto out_error_open;
+        /*
+         * Better not use !target__has_task() here because we need to cover the
+         * case where no threads were specified in the command line, but a
+         * workload was, and in that case we will fill in the thread_map when
+         * we fork the workload in perf_evlist__prepare_workload.
+         */
+        if (trace->filter_pids.nr > 0)
+                err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
+        else if (evlist->threads->map[0] == -1)
+                err = perf_evlist__set_filter_pid(evlist, getpid());
+        if (err < 0) {
+                printf("err=%d,%s\n", -err, strerror(-err));
+                exit(1);
+        }
        err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
        if (err < 0)
                goto out_error_mmap;
-        perf_evlist__enable(evlist);
        if (forks)
                perf_evlist__start_workload(evlist);
+        else
+                perf_evlist__enable(evlist);
-        trace->multiple_threads = evlist->threads->map[0] == -1 || evlist->threads->nr > 1;
+        trace->multiple_threads = evlist->threads->map[0] == -1 ||
+                                  evlist->threads->nr > 1 ||
+                                  perf_evlist__first(evlist)->attr.inherit;
 again:
        before = trace->nr_events;
@@ -2122,8 +2255,6 @@ again:
                union perf_event *event;
                while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
-                        const u32 type = event->header.type;
-                        tracepoint_handler handler;
                        struct perf_sample sample;
                        ++trace->nr_events;
@@ -2134,30 +2265,7 @@ again:
                                goto next_event;
                        }
-                        if (!trace->full_time && trace->base_time == 0)
+                        trace__handle_event(trace, event, &sample);
-                                trace->base_time = sample.time;
-                        if (type != PERF_RECORD_SAMPLE) {
-                                trace__process_event(trace, trace->host, event, &sample);
-                                continue;
-                        }
-                        evsel = perf_evlist__id2evsel(evlist, sample.id);
-                        if (evsel == NULL) {
-                                fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
-                                goto next_event;
-                        }
-                        if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
-                            sample.raw_data == NULL) {
-                                fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
-                                       perf_evsel__name(evsel), sample.tid,
-                                       sample.cpu, sample.raw_size);
-                                goto next_event;
-                        }
-                        handler = evsel->handler;
-                        handler(trace, evsel, event, &sample);
 next_event:
                        perf_evlist__mmap_consume(evlist, i);
@@ -2180,6 +2288,8 @@ next_event:
        }
 out_disable:
+        thread__zput(trace->current);
        perf_evlist__disable(evlist);
        if (!err) {
@@ -2197,7 +2307,7 @@ out_disable:
 out_delete_evlist:
        perf_evlist__delete(evlist);
-out:
+        trace->evlist = NULL;
        trace->live = false;
        return err;
 {
@@ -2309,7 +2419,7 @@ static int trace__replay(struct trace *trace)
        setup_pager();
-        err = perf_session__process_events(session, &trace->tool);
+        err = perf_session__process_events(session);
        if (err)
                pr_err("Failed to process events, error %d", err);
@@ -2434,6 +2544,38 @@ static int trace__set_duration(const struct option *opt, const char *str,
        return 0;
 }
+static int trace__set_filter_pids(const struct option *opt, const char *str,
+                                  int unset __maybe_unused)
+{
+        int ret = -1;
+        size_t i;
+        struct trace *trace = opt->value;
+        /*
+         * FIXME: introduce a intarray class, plain parse csv and create a
+         * { int nr, int entries[] } struct...
+         */
+        struct intlist *list = intlist__new(str);
+        if (list == NULL)
+                return -1;
+        i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
+        trace->filter_pids.entries = calloc(i, sizeof(pid_t));
+        if (trace->filter_pids.entries == NULL)
+                goto out;
+        trace->filter_pids.entries[0] = getpid();
+        for (i = 1; i < trace->filter_pids.nr; ++i)
+                trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
+        intlist__delete(list);
+        ret = 0;
+out:
+        return ret;
+}
 static int trace__open_output(struct trace *trace, const char *filename)
 {
        struct stat st;
@@ -2468,9 +2610,17 @@ static int parse_pagefaults(const struct option *opt, const char *str,
        return 0;
 }
+static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
+{
+        struct perf_evsel *evsel;
+        evlist__for_each(evlist, evsel)
+                evsel->handler = handler;
+}
 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
 {
-        const char * const trace_usage[] = {
+        const char *trace_usage[] = {
                "perf trace [<options>] [<command>]",
                "perf trace [<options>] -- <command> [<options>]",
                "perf trace record [<options>] [<command>]",
@@ -2502,6 +2652,9 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
        const char *output_name = NULL;
        const char *ev_qualifier_str = NULL;
        const struct option trace_options[] = {
+        OPT_CALLBACK(0, "event", &trace.evlist, "event",
+                     "event selector. use 'perf list' to list available events",
+                     parse_events_option),
        OPT_BOOLEAN(0, "comm", &trace.show_comm,
                    "show the thread COMM next to its id"),
        OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
@@ -2513,6 +2666,8 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
                    "trace events on existing process id"),
        OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
                    "trace events on existing thread id"),
+        OPT_CALLBACK(0, "filter-pids", &trace, "float",
+                     "show only events with duration > N.M ms", trace__set_filter_pids),
        OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
                    "system-wide collection from all CPUs"),
        OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
@@ -2540,17 +2695,33 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
        OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
        OPT_END()
        };
+        const char * const trace_subcommands[] = { "record", NULL };
        int err;
        char bf[BUFSIZ];
-        argc = parse_options(argc, argv, trace_options, trace_usage,
+        signal(SIGSEGV, sighandler_dump_stack);
-                             PARSE_OPT_STOP_AT_NON_OPTION);
+        signal(SIGFPE, sighandler_dump_stack);
+        trace.evlist = perf_evlist__new();
+        if (trace.evlist == NULL)
+                return -ENOMEM;
+        if (trace.evlist == NULL) {
+                pr_err("Not enough memory to run!\n");
+                goto out;
+        }
+        argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
+                                 trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
        if (trace.trace_pgfaults) {
                trace.opts.sample_address = true;
                trace.opts.sample_time = true;
        }
+        if (trace.evlist->nr_entries > 0)
+                evlist__set_evsel_handler(trace.evlist, trace__event_handler);
        if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
                return trace__record(&trace, argc-1, &argv[1]);
@@ -2558,7 +2729,8 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
        if (trace.summary_only)
                trace.summary = trace.summary_only;
-        if (!trace.trace_syscalls && !trace.trace_pgfaults) {
+        if (!trace.trace_syscalls && !trace.trace_pgfaults &&
+            trace.evlist->nr_entries == 0 /* Was --events used? */) {
                pr_err("Please specify something to trace.\n");
                return -1;
        }
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index b210d62907e4..3688ad29085f 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -37,6 +37,7 @@ extern int cmd_test(int argc, const char **argv, const char *prefix);
 extern int cmd_trace(int argc, const char **argv, const char *prefix);
 extern int cmd_inject(int argc, const char **argv, const char *prefix);
 extern int cmd_mem(int argc, const char **argv, const char *prefix);
+extern int cmd_data(int argc, const char **argv, const char *prefix);
 extern int find_scripts(char **scripts_array, char **scripts_path_array);
 #endif
diff --git a/tools/perf/command-list.txt b/tools/perf/command-list.txt
index 0906fc401c52..00fcaf8a5b8d 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -7,6 +7,7 @@ perf-archive			mainporcelain common
 perf-bench                      mainporcelain common
 perf-buildid-cache              mainporcelain common
 perf-buildid-list               mainporcelain common
+perf-data                       mainporcelain common
 perf-diff                       mainporcelain common
 perf-evlist                     mainporcelain common
 perf-inject                     mainporcelain common
diff --git a/tools/perf/config/Makefile b/tools/perf/config/Makefile
index cc224080b525..cd121dfc4de9 100644
--- a/tools/perf/config/Makefile
+++ b/tools/perf/config/Makefile
@@ -11,19 +11,26 @@ ifneq ($(obj-perf),)
 obj-perf := $(abspath $(obj-perf))/
 endif
-LIB_INCLUDE := $(srctree)/tools/lib/
+$(shell echo -n > .config-detected)
+detected     = $(shell echo "$(1)=y"       >> .config-detected)
+detected_var = $(shell echo "$(1)=$($(1))" >> .config-detected)
 CFLAGS := $(EXTRA_CFLAGS) $(EXTRA_WARNINGS)
 include $(src-perf)/config/Makefile.arch
+$(call detected_var,ARCH)
 NO_PERF_REGS := 1
 # Additional ARCH settings for x86
 ifeq ($(ARCH),x86)
+  $(call detected,CONFIG_X86)
  ifeq (${IS_64_BIT}, 1)
    CFLAGS += -DHAVE_ARCH_X86_64_SUPPORT
    ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S ../../arch/x86/lib/memset_64.S
    LIBUNWIND_LIBS = -lunwind -lunwind-x86_64
+    $(call detected,CONFIG_X86_64)
  else
    LIBUNWIND_LIBS = -lunwind -lunwind-x86
  endif
@@ -40,6 +47,10 @@ ifeq ($(ARCH),arm64)
  LIBUNWIND_LIBS = -lunwind -lunwind-aarch64
 endif
+ifeq ($(NO_PERF_REGS),0)
+  $(call detected,CONFIG_PERF_REGS)
+endif
 # So far there's only x86 and arm libdw unwind support merged in perf.
 # Disable it on all other architectures in case libdw unwind
 # support is detected in system. Add supported architectures
@@ -84,6 +95,17 @@ ifndef NO_LIBELF
  FEATURE_CHECK_LDFLAGS-libdw-dwarf-unwind := $(LIBDW_LDFLAGS) -ldw
 endif
+ifndef NO_LIBBABELTRACE
+  # for linking with debug library, run like:
+  # make DEBUG=1 LIBBABELTRACE_DIR=/opt/libbabeltrace/
+  ifdef LIBBABELTRACE_DIR
+    LIBBABELTRACE_CFLAGS  := -I$(LIBBABELTRACE_DIR)/include
+    LIBBABELTRACE_LDFLAGS := -L$(LIBBABELTRACE_DIR)/lib
+  endif
+  FEATURE_CHECK_CFLAGS-libbabeltrace := $(LIBBABELTRACE_CFLAGS)
+  FEATURE_CHECK_LDFLAGS-libbabeltrace := $(LIBBABELTRACE_LDFLAGS) -lbabeltrace-ctf
+endif
 # include ARCH specific config
 -include $(src-perf)/arch/$(ARCH)/Makefile
@@ -114,6 +136,8 @@ ifdef PARSER_DEBUG
  PARSER_DEBUG_BISON := -t
  PARSER_DEBUG_FLEX  := -d
  CFLAGS             += -DPARSER_DEBUG
+  $(call detected_var,PARSER_DEBUG_BISON)
+  $(call detected_var,PARSER_DEBUG_FLEX)
 endif
 ifndef NO_LIBPYTHON
@@ -152,121 +176,7 @@ LDFLAGS += -Wl,-z,noexecstack
 EXTLIBS = -lpthread -lrt -lm -ldl
-ifneq ($(OUTPUT),)
+include $(srctree)/tools/build/Makefile.feature
-  OUTPUT_FEATURES = $(OUTPUT)config/feature-checks/
-  $(shell mkdir -p $(OUTPUT_FEATURES))
-endif
-feature_check = $(eval $(feature_check_code))
-define feature_check_code
-  feature-$(1) := $(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS) $(FEATURE_CHECK_CFLAGS-$(1))" LDFLAGS="$(LDFLAGS) $(FEATURE_CHECK_LDFLAGS-$(1))" -C config/feature-checks test-$1.bin >/dev/null 2>/dev/null && echo 1 || echo 0)
-endef
-feature_set = $(eval $(feature_set_code))
-define feature_set_code
-  feature-$(1) := 1
-endef
-#
-# Build the feature check binaries in parallel, ignore errors, ignore return value and suppress output:
-#
-#
-# Note that this is not a complete list of all feature tests, just
-# those that are typically built on a fully configured system.
-#
-# [ Feature tests not mentioned here have to be built explicitly in
-#   the rule that uses them - an example for that is the 'bionic'
-#   feature check. ]
-#
-CORE_FEATURE_TESTS =                    \
-        backtrace                       \
-        dwarf                           \
-        fortify-source                  \
-        sync-compare-and-swap           \
-        glibc                           \
-        gtk2                            \
-        gtk2-infobar                    \
-        libaudit                        \
-        libbfd                          \
-        libelf                          \
-        libelf-getphdrnum               \
-        libelf-mmap                     \
-        libnuma                         \
-        libperl                         \
-        libpython                       \
-        libpython-version               \
-        libslang                        \
-        libunwind                       \
-        pthread-attr-setaffinity-np     \
-        stackprotector-all              \
-        timerfd                         \
-        libdw-dwarf-unwind              \
-        zlib
-LIB_FEATURE_TESTS =                     \
-        dwarf                           \
-        glibc                           \
-        gtk2                            \
-        libaudit                        \
-        libbfd                          \
-        libelf                          \
-        libnuma                         \
-        libperl                         \
-        libpython                       \
-        libslang                        \
-        libunwind                       \
-        libdw-dwarf-unwind              \
-        zlib
-VF_FEATURE_TESTS =                      \
-        backtrace                       \
-        fortify-source                  \
-        sync-compare-and-swap           \
-        gtk2-infobar                    \
-        libelf-getphdrnum               \
-        libelf-mmap                     \
-        libpython-version               \
-        pthread-attr-setaffinity-np     \
-        stackprotector-all              \
-        timerfd                         \
-        libunwind-debug-frame           \
-        bionic                          \
-        liberty                         \
-        liberty-z                       \
-        cplus-demangle                  \
-        compile-32                      \
-        compile-x32
-# Set FEATURE_CHECK_(C|LD)FLAGS-all for all CORE_FEATURE_TESTS features.
-# If in the future we need per-feature checks/flags for features not
-# mentioned in this list we need to refactor this ;-).
-set_test_all_flags = $(eval $(set_test_all_flags_code))
-define set_test_all_flags_code
-  FEATURE_CHECK_CFLAGS-all  += $(FEATURE_CHECK_CFLAGS-$(1))
-  FEATURE_CHECK_LDFLAGS-all += $(FEATURE_CHECK_LDFLAGS-$(1))
-endef
-$(foreach feat,$(CORE_FEATURE_TESTS),$(call set_test_all_flags,$(feat)))
-#
-# Special fast-path for the 'all features are available' case:
-#
-$(call feature_check,all,$(MSG))
-#
-# Just in case the build freshly failed, make sure we print the
-# feature matrix:
-#
-ifeq ($(feature-all), 1)
-  #
-  # test-all.c passed - just set all the core feature flags to 1:
-  #
-  $(foreach feat,$(CORE_FEATURE_TESTS),$(call feature_set,$(feat)))
-else
-  $(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS)" LDFLAGS=$(LDFLAGS) -i -j -C config/feature-checks $(addsuffix .bin,$(CORE_FEATURE_TESTS)) >/dev/null 2>&1)
-  $(foreach feat,$(CORE_FEATURE_TESTS),$(call feature_check,$(feat)))
-endif
 ifeq ($(feature-stackprotector-all), 1)
  CFLAGS += -fstack-protector-all
@@ -295,7 +205,7 @@ endif
 CFLAGS += -I$(src-perf)/util
 CFLAGS += -I$(src-perf)
-CFLAGS += -I$(LIB_INCLUDE)
+CFLAGS += -I$(srctree)/tools/lib/
 CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
@@ -361,6 +271,7 @@ endif # NO_LIBELF
 ifndef NO_LIBELF
  CFLAGS += -DHAVE_LIBELF_SUPPORT
  EXTLIBS += -lelf
+  $(call detected,CONFIG_LIBELF)
  ifeq ($(feature-libelf-mmap), 1)
    CFLAGS += -DHAVE_LIBELF_MMAP_SUPPORT
@@ -381,6 +292,7 @@ ifndef NO_LIBELF
      CFLAGS += -DHAVE_DWARF_SUPPORT $(LIBDW_CFLAGS)
      LDFLAGS += $(LIBDW_LDFLAGS)
      EXTLIBS += -ldw
+      $(call detected,CONFIG_DWARF)
    endif # PERF_HAVE_DWARF_REGS
  endif # NO_DWARF
 endif # NO_LIBELF
@@ -408,9 +320,11 @@ ifdef NO_LIBUNWIND
    dwarf-post-unwind := 0
  else
    dwarf-post-unwind-text := libdw
+    $(call detected,CONFIG_LIBDW_DWARF_UNWIND)
  endif
 else
  dwarf-post-unwind-text := libunwind
+  $(call detected,CONFIG_LIBUNWIND)
  # Enable libunwind support by default.
  ifndef NO_LIBDW_DWARF_UNWIND
    NO_LIBDW_DWARF_UNWIND := 1
@@ -419,6 +333,7 @@ endif
 ifeq ($(dwarf-post-unwind),1)
  CFLAGS += -DHAVE_DWARF_UNWIND_SUPPORT
+  $(call detected,CONFIG_DWARF_UNWIND)
 else
  NO_DWARF_UNWIND := 1
 endif
@@ -447,6 +362,7 @@ ifndef NO_LIBAUDIT
  else
    CFLAGS += -DHAVE_LIBAUDIT_SUPPORT
    EXTLIBS += -laudit
+    $(call detected,CONFIG_AUDIT)
  endif
 endif
@@ -463,6 +379,7 @@ ifndef NO_SLANG
    CFLAGS += -I/usr/include/slang
    CFLAGS += -DHAVE_SLANG_SUPPORT
    EXTLIBS += -lslang
+    $(call detected,CONFIG_SLANG)
  endif
 endif
@@ -497,10 +414,11 @@ else
  ifneq ($(feature-libperl), 1)
    CFLAGS += -DNO_LIBPERL
    NO_LIBPERL := 1
-    msg := $(warning Missing perl devel files. Disabling perl scripting support, consider installing perl-ExtUtils-Embed);
+    msg := $(warning Missing perl devel files. Disabling perl scripting support, please install perl-ExtUtils-Embed/libperl-dev);
  else
    LDFLAGS += $(PERL_EMBED_LDFLAGS)
    EXTLIBS += $(PERL_EMBED_LIBADD)
+    $(call detected,CONFIG_LIBPERL)
  endif
 endif
@@ -513,22 +431,21 @@ endif
 disable-python = $(eval $(disable-python_code))
 define disable-python_code
  CFLAGS += -DNO_LIBPYTHON
-  $(if $(1),$(warning No $(1) was found))
+  $(warning $1)
-  $(warning Python support will not be built)
  NO_LIBPYTHON := 1
 endef
 ifdef NO_LIBPYTHON
-  $(call disable-python)
+  $(call disable-python,Python support disabled by user)
 else
  ifndef PYTHON
-    $(call disable-python,python interpreter)
+    $(call disable-python,No python interpreter was found: disables Python support - please install python-devel/python-dev)
  else
    PYTHON_WORD := $(call shell-wordify,$(PYTHON))
    ifndef PYTHON_CONFIG
-      $(call disable-python,python-config tool)
+      $(call disable-python,No 'python-config' tool was found: disables Python support - please install python-devel/python-dev)
    else
      PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
@@ -540,7 +457,7 @@ else
      FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
      ifneq ($(feature-libpython), 1)
-        $(call disable-python,Python.h (for Python 2.x))
+        $(call disable-python,No 'Python.h' (for Python 2.x support) was found: disables Python support - please install python-devel/python-dev)
      else
        ifneq ($(feature-libpython-version), 1)
@@ -560,6 +477,7 @@ else
          LDFLAGS += $(PYTHON_EMBED_LDFLAGS)
          EXTLIBS += $(PYTHON_EMBED_LIBADD)
          LANG_BINDINGS += $(obj-perf)python/perf.so
+          $(call detected,CONFIG_LIBPYTHON)
        endif
      endif
    endif
@@ -600,7 +518,7 @@ else
            EXTLIBS += -liberty
            CFLAGS += -DHAVE_CPLUS_DEMANGLE_SUPPORT
          else
-            msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
+            msg := $(warning No bfd.h/libbfd found, please install binutils-dev[el]/zlib-static/libiberty-dev to gain symbol demangling)
            CFLAGS += -DNO_DEMANGLE
          endif
        endif
@@ -617,11 +535,23 @@ ifndef NO_ZLIB
  ifeq ($(feature-zlib), 1)
    CFLAGS += -DHAVE_ZLIB_SUPPORT
    EXTLIBS += -lz
+    $(call detected,CONFIG_ZLIB)
  else
    NO_ZLIB := 1
  endif
 endif
+ifndef NO_LZMA
+  ifeq ($(feature-lzma), 1)
+    CFLAGS += -DHAVE_LZMA_SUPPORT
+    EXTLIBS += -llzma
+    $(call detected,CONFIG_LZMA)
+  else
+    msg := $(warning No liblzma found, disables xz kernel module decompression, please install xz-devel/liblzma-dev);
+    NO_LZMA := 1
+  endif
+endif
 ifndef NO_BACKTRACE
  ifeq ($(feature-backtrace), 1)
    CFLAGS += -DHAVE_BACKTRACE_SUPPORT
@@ -635,6 +565,7 @@ ifndef NO_LIBNUMA
  else
    CFLAGS += -DHAVE_LIBNUMA_SUPPORT
    EXTLIBS += -lnuma
+    $(call detected,CONFIG_NUMA)
  endif
 endif
@@ -651,7 +582,7 @@ ifeq (${IS_64_BIT}, 1)
      NO_PERF_READ_VDSO32 := 1
    endif
  endif
-  ifneq (${IS_X86_64}, 1)
+  ifneq ($(ARCH), x86)
    NO_PERF_READ_VDSOX32 := 1
  endif
  ifndef NO_PERF_READ_VDSOX32
@@ -667,6 +598,19 @@ else
  NO_PERF_READ_VDSOX32 := 1
 endif
+ifndef NO_LIBBABELTRACE
+  $(call feature_check,libbabeltrace)
+  ifeq ($(feature-libbabeltrace), 1)
+    CFLAGS += -DHAVE_LIBBABELTRACE_SUPPORT $(LIBBABELTRACE_CFLAGS)
+    LDFLAGS += $(LIBBABELTRACE_LDFLAGS)
+    EXTLIBS += -lbabeltrace-ctf
+    $(call detected,CONFIG_LIBBABELTRACE)
+  else
+    msg := $(warning No libbabeltrace found, disables 'perf data' CTF format support, please install libbabeltrace-dev[el]/libbabeltrace-ctf-dev);
+    NO_LIBBABELTRACE := 1
+  endif
+endif
 # Among the variables below, these:
 #   perfexecdir
 #   template_dir
@@ -699,7 +643,7 @@ sysconfdir = $(prefix)/etc
 ETC_PERFCONFIG = etc/perfconfig
 endif
 ifndef lib
-ifeq ($(IS_X86_64),1)
+ifeq ($(ARCH)$(IS_64_BIT), x861)
 lib = lib64
 else
 lib = lib
@@ -735,83 +679,33 @@ plugindir=$(libdir)/traceevent/plugins
 plugindir_SQ= $(subst ','\'',$(plugindir))
 endif
-#
+print_var = $(eval $(print_var_code)) $(info $(MSG))
-# Print the result of the feature test:
+define print_var_code
-#
-feature_print_status = $(eval $(feature_print_status_code)) $(info $(MSG))
-define feature_print_status_code
-  ifeq ($(feature-$(1)), 1)
-    MSG = $(shell printf '...%30s: [ \033[32mon\033[m  ]' $(1))
-  else
-    MSG = $(shell printf '...%30s: [ \033[31mOFF\033[m ]' $(1))
-  endif
-endef
-feature_print_var = $(eval $(feature_print_var_code)) $(info $(MSG))
-define feature_print_var_code
    MSG = $(shell printf '...%30s: %s' $(1) $($(1)))
 endef
-feature_print_text = $(eval $(feature_print_text_code)) $(info $(MSG))
-define feature_print_text_code
-    MSG = $(shell printf '...%30s: %s' $(1) $(2))
-endef
-PERF_FEATURES := $(foreach feat,$(LIB_FEATURE_TESTS),feature-$(feat)($(feature-$(feat))))
-PERF_FEATURES_FILE := $(shell touch $(OUTPUT)PERF-FEATURES; cat $(OUTPUT)PERF-FEATURES)
-ifeq ($(dwarf-post-unwind),1)
-  PERF_FEATURES += dwarf-post-unwind($(dwarf-post-unwind-text))
-endif
-# The $(display_lib) controls the default detection message
-# output. It's set if:
-# - detected features differes from stored features from
-#   last build (in PERF-FEATURES file)
-# - one of the $(LIB_FEATURE_TESTS) is not detected
-# - VF is enabled
-ifneq ("$(PERF_FEATURES)","$(PERF_FEATURES_FILE)")
-  $(shell echo "$(PERF_FEATURES)" > $(OUTPUT)PERF-FEATURES)
-  display_lib := 1
-endif
-feature_check = $(eval $(feature_check_code))
-define feature_check_code
-  ifneq ($(feature-$(1)), 1)
-    display_lib := 1
-  endif
-endef
-$(foreach feat,$(LIB_FEATURE_TESTS),$(call feature_check,$(feat)))
 ifeq ($(VF),1)
-  display_lib := 1
+  $(call print_var,prefix)
-  display_vf := 1
+  $(call print_var,bindir)
-endif
+  $(call print_var,libdir)
+  $(call print_var,sysconfdir)
-ifeq ($(display_lib),1)
+  $(call print_var,LIBUNWIND_DIR)
+  $(call print_var,LIBDW_DIR)
  $(info )
-  $(info Auto-detecting system features:)
-  $(foreach feat,$(LIB_FEATURE_TESTS),$(call feature_print_status,$(feat),))
-  ifeq ($(dwarf-post-unwind),1)
-    $(call feature_print_text,"DWARF post unwind library", $(dwarf-post-unwind-text))
-  endif
-endif
-ifeq ($(display_vf),1)
-  $(foreach feat,$(VF_FEATURE_TESTS),$(call feature_print_status,$(feat),))
-  $(info )
-  $(call feature_print_var,prefix)
-  $(call feature_print_var,bindir)
-  $(call feature_print_var,libdir)
-  $(call feature_print_var,sysconfdir)
-  $(call feature_print_var,LIBUNWIND_DIR)
-  $(call feature_print_var,LIBDW_DIR)
 endif
-ifeq ($(display_lib),1)
+$(call detected_var,bindir_SQ)
-  $(info )
+$(call detected_var,PYTHON_WORD)
-endif
+ifneq ($(OUTPUT),)
+$(call detected_var,OUTPUT)
+endif
+$(call detected_var,htmldir_SQ)
+$(call detected_var,infodir_SQ)
+$(call detected_var,mandir_SQ)
+$(call detected_var,ETC_PERFCONFIG_SQ)
+$(call detected_var,prefix_SQ)
+$(call detected_var,perfexecdir_SQ)
+$(call detected_var,LIBDIR)
+$(call detected_var,GTK_CFLAGS)
+$(call detected_var,PERL_EMBED_CCOPTS)
+$(call detected_var,PYTHON_EMBED_CCOPTS)
diff --git a/tools/perf/config/Makefile.arch b/tools/perf/config/Makefile.arch
index ac8721ffa6c8..e11fbd6fae78 100644
--- a/tools/perf/config/Makefile.arch
+++ b/tools/perf/config/Makefile.arch
@@ -1,32 +1,15 @@
+ifndef ARCH
+ARCH := $(shell uname -m 2>/dev/null || echo not)
+endif
-uname_M := $(shell uname -m 2>/dev/null || echo not)
+ARCH := $(shell echo $(ARCH) | sed -e s/i.86/x86/ -e s/x86_64/x86/ \
+                                  -e s/sun4u/sparc/ -e s/sparc64/sparc/ \
-RAW_ARCH := $(shell echo $(uname_M) | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
+                                  -e /arm64/!s/arm.*/arm/ -e s/sa110/arm/ \
-                                  -e s/arm.*/arm/ -e s/sa110/arm/ \
                                  -e s/s390x/s390/ -e s/parisc64/parisc/ \
                                  -e s/ppc.*/powerpc/ -e s/mips.*/mips/ \
                                  -e s/sh[234].*/sh/ -e s/aarch64.*/arm64/ \
                                  -e s/tile.*/tile/ )
-# Additional ARCH settings for x86
-ifeq ($(RAW_ARCH),i386)
-  ARCH ?= x86
-endif
-ifeq ($(RAW_ARCH),x86_64)
-  ARCH ?= x86
-  ifneq (, $(findstring m32,$(CFLAGS)))
-    RAW_ARCH := x86_32
-  endif
-endif
-ifeq ($(RAW_ARCH),sparc64)
-  ARCH ?= sparc
-endif
-ARCH ?= $(RAW_ARCH)
 LP64 := $(shell echo __LP64__ | ${CC} ${CFLAGS} -E -x c - | tail -n 1)
 ifeq ($(LP64), 1)
  IS_64_BIT := 1
diff --git a/tools/perf/config/utilities.mak b/tools/perf/config/utilities.mak
index 7076a62d0ff7..c16ce833079c 100644
--- a/tools/perf/config/utilities.mak
+++ b/tools/perf/config/utilities.mak
@@ -175,6 +175,5 @@ _ge-abspath = $(if $(is-executable),$(1))
 define get-executable-or-default
 $(if $($(1)),$(call _ge_attempt,$($(1)),$(1)),$(call _ge_attempt,$(2)))
 endef
-_ge_attempt = $(if $(get-executable),$(get-executable),$(_gea_warn)$(call _gea_err,$(2)))
+_ge_attempt = $(if $(get-executable),$(get-executable),$(call _gea_err,$(2)))
-_gea_warn = $(warning The path '$(1)' is not executable.)
 _gea_err  = $(if $(1),$(error Please set '$(1)' appropriately))
diff --git a/tools/perf/perf-completion.sh b/tools/perf/perf-completion.sh
index 33569847fdcc..3ba80b2359cc 100644
--- a/tools/perf/perf-completion.sh
+++ b/tools/perf/perf-completion.sh
@@ -47,8 +47,16 @@ __my_reassemble_comp_words_by_ref()
        done
 }
-type _get_comp_words_by_ref &>/dev/null ||
+# Define preload_get_comp_words_by_ref="false", if the function
-_get_comp_words_by_ref()
+# __perf_get_comp_words_by_ref() is required instead.
+preload_get_comp_words_by_ref="true"
+if [ $preload_get_comp_words_by_ref = "true" ]; then
+        type _get_comp_words_by_ref &>/dev/null ||
+        preload_get_comp_words_by_ref="false"
+fi
+[ $preload_get_comp_words_by_ref = "true" ] ||
+__perf_get_comp_words_by_ref()
 {
        local exclude cur_ words_ cword_
        if [ "$1" = "-n" ]; then
@@ -76,8 +84,16 @@ _get_comp_words_by_ref()
        done
 }
-type __ltrim_colon_completions &>/dev/null ||
+# Define preload__ltrim_colon_completions="false", if the function
-__ltrim_colon_completions()
+# __perf__ltrim_colon_completions() is required instead.
+preload__ltrim_colon_completions="true"
+if [ $preload__ltrim_colon_completions = "true" ]; then
+        type __ltrim_colon_completions &>/dev/null ||
+        preload__ltrim_colon_completions="false"
+fi
+[ $preload__ltrim_colon_completions = "true" ] ||
+__perf__ltrim_colon_completions()
 {
        if [[ "$1" == *:* && "$COMP_WORDBREAKS" == *:* ]]; then
                # Remove colon-word prefix from COMPREPLY items
@@ -97,7 +113,32 @@ __perfcomp ()
 __perfcomp_colon ()
 {
        __perfcomp "$1" "$2"
-        __ltrim_colon_completions $cur
+        if [ $preload__ltrim_colon_completions = "true" ]; then
+                __ltrim_colon_completions $cur
+        else
+                __perf__ltrim_colon_completions $cur
+        fi
+}
+__perf_prev_skip_opts ()
+{
+        local i cmd_ cmds_
+        let i=cword-1
+        cmds_=$($cmd $1 --list-cmds)
+        prev_skip_opts=()
+        while [ $i -ge 0 ]; do
+                if [[ ${words[i]} == $1 ]]; then
+                        return
+                fi
+                for cmd_ in $cmds_; do
+                        if [[ ${words[i]} == $cmd_ ]]; then
+                                prev_skip_opts=${words[i]}
+                                return
+                        fi
+                done
+                ((i--))
+        done
 }
 __perf_main ()
@@ -107,29 +148,36 @@ __perf_main ()
        cmd=${words[0]}
        COMPREPLY=()
+        # Skip options backward and find the last perf command
+        __perf_prev_skip_opts
        # List perf subcommands or long options
-        if [ $cword -eq 1 ]; then
+        if [ -z $prev_skip_opts ]; then
                if [[ $cur == --* ]]; then
-                        __perfcomp '--help --version \
+                        cmds=$($cmd --list-opts)
-                        --exec-path --html-path --paginate --no-pager \
-                        --perf-dir --work-tree --debugfs-dir' -- "$cur"
                else
                        cmds=$($cmd --list-cmds)
-                        __perfcomp "$cmds" "$cur"
                fi
+                __perfcomp "$cmds" "$cur"
        # List possible events for -e option
-        elif [[ $prev == "-e" && "${words[1]}" == @(record|stat|top) ]]; then
+        elif [[ $prev == @("-e"|"--event") &&
+                $prev_skip_opts == @(record|stat|top) ]]; then
                evts=$($cmd list --raw-dump)
                __perfcomp_colon "$evts" "$cur"
-        # List subcommands for perf commands
+        else
-        elif [[ $prev == @(kvm|kmem|mem|lock|sched) ]]; then
+                # List subcommands for perf commands
-                subcmds=$($cmd $prev --list-cmds)
+                if [[ $prev_skip_opts == @(kvm|kmem|mem|lock|sched|
-                __perfcomp_colon "$subcmds" "$cur"
+                        |data|help|script|test|timechart|trace) ]]; then
-        # List long option names
+                        subcmds=$($cmd $prev_skip_opts --list-cmds)
-        elif [[ $cur == --* ]];  then
+                        __perfcomp_colon "$subcmds" "$cur"
-                subcmd=${words[1]}
+                fi
-                opts=$($cmd $subcmd --list-opts)
+                # List long option names
-                __perfcomp "$opts" "$cur"
+                if [[ $cur == --* ]];  then
+                        subcmd=$prev_skip_opts
+                        __perf_prev_skip_opts $subcmd
+                        subcmd=$subcmd" "$prev_skip_opts
+                        opts=$($cmd $subcmd --list-opts)
+                        __perfcomp "$opts" "$cur"
+                fi
        fi
 }
@@ -198,7 +246,11 @@ type perf &>/dev/null &&
 _perf()
 {
        local cur words cword prev
-        _get_comp_words_by_ref -n =: cur words cword prev
+        if [ $preload_get_comp_words_by_ref = "true" ]; then
+                _get_comp_words_by_ref -n =: cur words cword prev
+        else
+                __perf_get_comp_words_by_ref -n =: cur words cword prev
+        fi
        __perf_main
 } &&
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 3700a7faca6c..b857fcbd00cf 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -13,6 +13,7 @@
 #include "util/quote.h"
 #include "util/run-command.h"
 #include "util/parse-events.h"
+#include "util/parse-options.h"
 #include "util/debug.h"
 #include <api/fs/debugfs.h>
 #include <pthread.h>
@@ -62,6 +63,7 @@ static struct cmd_struct commands[] = {
 #endif
        { "inject",     cmd_inject,     0 },
        { "mem",        cmd_mem,        0 },
+        { "data",       cmd_data,       0 },
 };
 struct pager_config {
@@ -124,6 +126,23 @@ static void commit_pager_choice(void)
        }
 }
+struct option options[] = {
+        OPT_ARGUMENT("help", "help"),
+        OPT_ARGUMENT("version", "version"),
+        OPT_ARGUMENT("exec-path", "exec-path"),
+        OPT_ARGUMENT("html-path", "html-path"),
+        OPT_ARGUMENT("paginate", "paginate"),
+        OPT_ARGUMENT("no-pager", "no-pager"),
+        OPT_ARGUMENT("perf-dir", "perf-dir"),
+        OPT_ARGUMENT("work-tree", "work-tree"),
+        OPT_ARGUMENT("debugfs-dir", "debugfs-dir"),
+        OPT_ARGUMENT("buildid-dir", "buildid-dir"),
+        OPT_ARGUMENT("list-cmds", "list-cmds"),
+        OPT_ARGUMENT("list-opts", "list-opts"),
+        OPT_ARGUMENT("debug", "debug"),
+        OPT_END()
+};
 static int handle_options(const char ***argv, int *argc, int *envchanged)
 {
        int handled = 0;
@@ -222,6 +241,16 @@ static int handle_options(const char ***argv, int *argc, int *envchanged)
                                struct cmd_struct *p = commands+i;
                                printf("%s ", p->cmd);
                        }
+                        putchar('\n');
+                        exit(0);
+                } else if (!strcmp(cmd, "--list-opts")) {
+                        unsigned int i;
+                        for (i = 0; i < ARRAY_SIZE(options)-1; i++) {
+                                struct option *p = options+i;
+                                printf("--%s ", p->long_name);
+                        }
+                        putchar('\n');
                        exit(0);
                } else if (!strcmp(cmd, "--debug")) {
                        if (*argc < 2) {
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 1dabb8553499..c38a085a5571 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -29,7 +29,7 @@ static inline unsigned long long rdclock(void)
        return ts.tv_sec * 1000000000ULL + ts.tv_nsec;
 }
-#define MAX_NR_CPUS                     256
+#define MAX_NR_CPUS                     1024
 extern const char *input_name;
 extern bool perf_host, perf_guest;
@@ -53,6 +53,7 @@ struct record_opts {
        bool         sample_time;
        bool         period;
        bool         sample_intr_regs;
+        bool         running_time;
        unsigned int freq;
        unsigned int mmap_pages;
        unsigned int user_freq;
diff --git a/tools/perf/scripts/Build b/tools/perf/scripts/Build
new file mode 100644
index 000000000000..41efd7e368b3
--- /dev/null
+++ b/tools/perf/scripts/Build
@@ -0,0 +1,2 @@
+libperf-$(CONFIG_LIBPERL)   += perl/Perf-Trace-Util/
+libperf-$(CONFIG_LIBPYTHON) += python/Perf-Trace-Util/
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Build b/tools/perf/scripts/perl/Perf-Trace-Util/Build
new file mode 100644
index 000000000000..928e110179cb
--- /dev/null
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Build
@@ -0,0 +1,3 @@
+libperf-y += Context.o
+CFLAGS_Context.o += $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs -Wno-undef -Wno-switch-default
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/Build b/tools/perf/scripts/python/Perf-Trace-Util/Build
new file mode 100644
index 000000000000..aefc15c9444a
--- /dev/null
+++ b/tools/perf/scripts/python/Perf-Trace-Util/Build
@@ -0,0 +1,3 @@
+libperf-y += Context.o
+CFLAGS_Context.o += $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs
diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
new file mode 100644
index 000000000000..6a8801b32017
--- /dev/null
+++ b/tools/perf/tests/Build
@@ -0,0 +1,43 @@
+perf-y += builtin-test.o
+perf-y += parse-events.o
+perf-y += dso-data.o
+perf-y += attr.o
+perf-y += vmlinux-kallsyms.o
+perf-y += open-syscall.o
+perf-y += open-syscall-all-cpus.o
+perf-y += open-syscall-tp-fields.o
+perf-y += mmap-basic.o
+perf-y += perf-record.o
+perf-y += rdpmc.o
+perf-y += evsel-roundtrip-name.o
+perf-y += evsel-tp-sched.o
+perf-y += fdarray.o
+perf-y += pmu.o
+perf-y += hists_common.o
+perf-y += hists_link.o
+perf-y += hists_filter.o
+perf-y += hists_output.o
+perf-y += hists_cumulate.o
+perf-y += python-use.o
+perf-y += bp_signal.o
+perf-y += bp_signal_overflow.o
+perf-y += task-exit.o
+perf-y += sw-clock.o
+perf-y += mmap-thread-lookup.o
+perf-y += thread-mg-share.o
+perf-y += switch-tracking.o
+perf-y += keep-tracking.o
+perf-y += code-reading.o
+perf-y += sample-parsing.o
+perf-y += parse-no-sample-id-all.o
+perf-y += kmod-path.o
+perf-$(CONFIG_X86) += perf-time-to-tsc.o
+ifeq ($(ARCH),$(filter $(ARCH),x86 arm))
+perf-$(CONFIG_DWARF_UNWIND) += dwarf-unwind.o
+endif
+CFLAGS_attr.o         += -DBINDIR="BUILD_STR($(bindir_SQ))" -DPYTHON="BUILD_STR($(PYTHON_WORD))"
+CFLAGS_python-use.o   += -DPYTHONPATH="BUILD_STR($(OUTPUT)python)" -DPYTHON="BUILD_STR($(PYTHON_WORD))"
+CFLAGS_dwarf-unwind.o += -fno-optimize-sibling-calls
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 4b7d9ab0f049..4f4098167112 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -167,6 +167,10 @@ static struct test {
                .func = test__fdarray__add,
        },
        {
+                .desc = "Test kmod_path__parse function",
+                .func = test__kmod_path__parse,
+        },
+        {
                .func = NULL,
        },
 };
@@ -291,7 +295,7 @@ static int perf_test__list(int argc, const char **argv)
 int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
 {
-        const char * const test_usage[] = {
+        const char *test_usage[] = {
        "perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]",
        NULL,
        };
@@ -302,13 +306,14 @@ int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
                    "be more verbose (show symbol address, etc)"),
        OPT_END()
        };
+        const char * const test_subcommands[] = { "list", NULL };
        struct intlist *skiplist = NULL;
        int ret = hists__init();
        if (ret < 0)
                return ret;
-        argc = parse_options(argc, argv, test_options, test_usage, 0);
+        argc = parse_options_subcommand(argc, argv, test_options, test_subcommands, test_usage, 0);
        if (argc >= 1 && !strcmp(argv[0], "list"))
                return perf_test__list(argc, argv);
diff --git a/tools/perf/tests/dso-data.c b/tools/perf/tests/dso-data.c
index caaf37f079b1..513e5febbe5a 100644
--- a/tools/perf/tests/dso-data.c
+++ b/tools/perf/tests/dso-data.c
@@ -112,6 +112,9 @@ int test__dso_data(void)
        dso = dso__new((const char *)file);
+        TEST_ASSERT_VAL("Failed to access to dso",
+                        dso__data_fd(dso, &machine) >= 0);
        /* Basic 10 bytes tests. */
        for (i = 0; i < ARRAY_SIZE(offsets); i++) {
                struct test_data_offset *data = &offsets[i];
@@ -243,8 +246,8 @@ int test__dso_data_cache(void)
        limit = nr * 4;
        TEST_ASSERT_VAL("failed to set file limit", !set_fd_limit(limit));
-        /* and this is now our dso open FDs limit + 1 extra */
+        /* and this is now our dso open FDs limit */
-        dso_cnt = limit / 2 + 1;
+        dso_cnt = limit / 2;
        TEST_ASSERT_VAL("failed to create dsos\n",
                !dsos__create(dso_cnt, TEST_FILE_SIZE));
@@ -252,13 +255,13 @@ int test__dso_data_cache(void)
                struct dso *dso = dsos[i];
                /*
-                 * Open dsos via dso__data_fd or dso__data_read_offset.
+                 * Open dsos via dso__data_fd(), it opens the data
-                 * Both opens the data file and keep it open.
+                 * file and keep it open (unless open file limit).
                 */
+                fd = dso__data_fd(dso, &machine);
+                TEST_ASSERT_VAL("failed to get fd", fd > 0);
                if (i % 2) {
-                        fd = dso__data_fd(dso, &machine);
-                        TEST_ASSERT_VAL("failed to get fd", fd > 0);
-                } else {
                        #define BUFSIZE 10
                        u8 buf[BUFSIZE];
                        ssize_t n;
@@ -268,7 +271,10 @@ int test__dso_data_cache(void)
                }
        }
-        /* open +1 dso over the allowed limit */
+        /* verify the first one is already open */
+        TEST_ASSERT_VAL("dsos[0] is not open", dsos[0]->data.fd != -1);
+        /* open +1 dso to reach the allowed limit */
        fd = dso__data_fd(dsos[i], &machine);
        TEST_ASSERT_VAL("failed to get fd", fd > 0);
diff --git a/tools/perf/tests/kmod-path.c b/tools/perf/tests/kmod-path.c
new file mode 100644
index 000000000000..e8d7cbb9320c
--- /dev/null
+++ b/tools/perf/tests/kmod-path.c
@@ -0,0 +1,73 @@
+#include <stdbool.h>
+#include "tests.h"
+#include "dso.h"
+#include "debug.h"
+static int test(const char *path, bool alloc_name, bool alloc_ext,
+                bool kmod, bool comp, const char *name, const char *ext)
+{
+        struct kmod_path m;
+        memset(&m, 0x0, sizeof(m));
+        TEST_ASSERT_VAL("kmod_path__parse",
+                        !__kmod_path__parse(&m, path, alloc_name, alloc_ext));
+        pr_debug("%s - alloc name %d, alloc ext %d, kmod %d, comp %d, name '%s', ext '%s'\n",
+                 path, alloc_name, alloc_ext, m.kmod, m.comp, m.name, m.ext);
+        TEST_ASSERT_VAL("wrong kmod", m.kmod == kmod);
+        TEST_ASSERT_VAL("wrong comp", m.comp == comp);
+        if (ext)
+                TEST_ASSERT_VAL("wrong ext", m.ext && !strcmp(ext, m.ext));
+        else
+                TEST_ASSERT_VAL("wrong ext", !m.ext);
+        if (name)
+                TEST_ASSERT_VAL("wrong name", m.name && !strcmp(name, m.name));
+        else
+                TEST_ASSERT_VAL("wrong name", !m.name);
+        free(m.name);
+        free(m.ext);
+        return 0;
+}
+#define T(path, an, ae, k, c, n, e) \
+        TEST_ASSERT_VAL("failed", !test(path, an, ae, k, c, n, e))
+int test__kmod_path__parse(void)
+{
+        /* path                alloc_name  alloc_ext   kmod  comp   name     ext */
+        T("/xxxx/xxxx/x-x.ko", true      , true      , true, false, "[x_x]", NULL);
+        T("/xxxx/xxxx/x-x.ko", false     , true      , true, false, NULL   , NULL);
+        T("/xxxx/xxxx/x-x.ko", true      , false     , true, false, "[x_x]", NULL);
+        T("/xxxx/xxxx/x-x.ko", false     , false     , true, false, NULL   , NULL);
+        /* path                alloc_name  alloc_ext   kmod  comp  name   ext */
+        T("/xxxx/xxxx/x.ko.gz", true     , true      , true, true, "[x]", "gz");
+        T("/xxxx/xxxx/x.ko.gz", false    , true      , true, true, NULL , "gz");
+        T("/xxxx/xxxx/x.ko.gz", true     , false     , true, true, "[x]", NULL);
+        T("/xxxx/xxxx/x.ko.gz", false    , false     , true, true, NULL , NULL);
+        /* path              alloc_name  alloc_ext  kmod   comp  name    ext */
+        T("/xxxx/xxxx/x.gz", true      , true     , false, true, "x.gz" ,"gz");
+        T("/xxxx/xxxx/x.gz", false     , true     , false, true, NULL   ,"gz");
+        T("/xxxx/xxxx/x.gz", true      , false    , false, true, "x.gz" , NULL);
+        T("/xxxx/xxxx/x.gz", false     , false    , false, true, NULL   , NULL);
+        /* path   alloc_name  alloc_ext  kmod   comp  name     ext */
+        T("x.gz", true      , true     , false, true, "x.gz", "gz");
+        T("x.gz", false     , true     , false, true, NULL  , "gz");
+        T("x.gz", true      , false    , false, true, "x.gz", NULL);
+        T("x.gz", false     , false    , false, true, NULL  , NULL);
+        /* path      alloc_name  alloc_ext  kmod  comp  name  ext */
+        T("x.ko.gz", true      , true     , true, true, "[x]", "gz");
+        T("x.ko.gz", false     , true     , true, true, NULL , "gz");
+        T("x.ko.gz", true      , false    , true, true, "[x]", NULL);
+        T("x.ko.gz", false     , false    , true, true, NULL , NULL);
+        return 0;
+}
diff --git a/tools/perf/tests/make b/tools/perf/tests/make
index 75709d2b17b4..bff85324f799 100644
--- a/tools/perf/tests/make
+++ b/tools/perf/tests/make
@@ -5,7 +5,7 @@ include config/Makefile.arch
 # FIXME looks like x86 is the only arch running tests ;-)
 # we need some IS_(32/64) flag to make this generic
-ifeq ($(IS_X86_64),1)
+ifeq ($(ARCH)$(IS_64_BIT), x861)
 lib = lib64
 else
 lib = lib
diff --git a/tools/perf/tests/open-syscall-all-cpus.c b/tools/perf/tests/open-syscall-all-cpus.c
index 8fa82d1700c7..3ec885c48f8f 100644
--- a/tools/perf/tests/open-syscall-all-cpus.c
+++ b/tools/perf/tests/open-syscall-all-cpus.c
@@ -29,7 +29,12 @@ int test__open_syscall_event_on_all_cpus(void)
        evsel = perf_evsel__newtp("syscalls", "sys_enter_open");
        if (evsel == NULL) {
-                pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
+                if (tracefs_configured())
+                        pr_debug("is tracefs mounted on /sys/kernel/tracing?\n");
+                else if (debugfs_configured())
+                        pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
+                else
+                        pr_debug("Neither tracefs or debugfs is enabled in this kernel\n");
                goto out_thread_map_delete;
        }
diff --git a/tools/perf/tests/open-syscall.c b/tools/perf/tests/open-syscall.c
index a33b2daae40f..07aa319bf334 100644
--- a/tools/perf/tests/open-syscall.c
+++ b/tools/perf/tests/open-syscall.c
@@ -18,7 +18,12 @@ int test__open_syscall_event(void)
        evsel = perf_evsel__newtp("syscalls", "sys_enter_open");
        if (evsel == NULL) {
-                pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
+                if (tracefs_configured())
+                        pr_debug("is tracefs mounted on /sys/kernel/tracing?\n");
+                else if (debugfs_configured())
+                        pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
+                else
+                        pr_debug("Neither tracefs or debugfs is enabled in this kernel\n");
                goto out_thread_map_delete;
        }
diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index 1cdab0ce00e2..ac243ebcb20a 100644
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -3,6 +3,7 @@
 #include "evsel.h"
 #include "evlist.h"
 #include <api/fs/fs.h>
+#include <api/fs/tracefs.h>
 #include <api/fs/debugfs.h>
 #include "tests.h"
 #include "debug.h"
@@ -1192,11 +1193,19 @@ static int count_tracepoints(void)
 {
        char events_path[PATH_MAX];
        struct dirent *events_ent;
+        const char *mountpoint;
        DIR *events_dir;
        int cnt = 0;
-        scnprintf(events_path, PATH_MAX, "%s/tracing/events",
+        mountpoint = tracefs_find_mountpoint();
-                  debugfs_find_mountpoint());
+        if (mountpoint) {
+                scnprintf(events_path, PATH_MAX, "%s/events",
+                          mountpoint);
+        } else {
+                mountpoint = debugfs_find_mountpoint();
+                scnprintf(events_path, PATH_MAX, "%s/tracing/events",
+                          mountpoint);
+        }
        events_dir = opendir(events_path);
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index 00e776a87a9c..52758a33f64c 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -51,6 +51,7 @@ int test__hists_cumulate(void);
 int test__switch_tracking(void);
 int test__fdarray__filter(void);
 int test__fdarray__add(void);
+int test__kmod_path__parse(void);
 #if defined(__x86_64__) || defined(__i386__) || defined(__arm__)
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
diff --git a/tools/perf/ui/Build b/tools/perf/ui/Build
new file mode 100644
index 000000000000..0a73538c0441
--- /dev/null
+++ b/tools/perf/ui/Build
@@ -0,0 +1,14 @@
+libperf-y += setup.o
+libperf-y += helpline.o
+libperf-y += progress.o
+libperf-y += util.o
+libperf-y += hist.o
+libperf-y += stdio/hist.o
+CFLAGS_setup.o += -DLIBDIR="BUILD_STR($(LIBDIR))"
+libperf-$(CONFIG_SLANG) += browser.o
+libperf-$(CONFIG_SLANG) += browsers/
+libperf-$(CONFIG_SLANG) += tui/
+CFLAGS_browser.o += -DENABLE_SLFUTURE_CONST
diff --git a/tools/perf/ui/browsers/Build b/tools/perf/ui/browsers/Build
new file mode 100644
index 000000000000..de223f5bed58
--- /dev/null
+++ b/tools/perf/ui/browsers/Build
@@ -0,0 +1,10 @@
+libperf-y += annotate.o
+libperf-y += hists.o
+libperf-y += map.o
+libperf-y += scripts.o
+libperf-y += header.o
+CFLAGS_annotate.o += -DENABLE_SLFUTURE_CONST
+CFLAGS_hists.o    += -DENABLE_SLFUTURE_CONST
+CFLAGS_map.o      += -DENABLE_SLFUTURE_CONST
+CFLAGS_scripts.o  += -DENABLE_SLFUTURE_CONST
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
index 9d32e3c0cfee..e5250eb2dd57 100644
--- a/tools/perf/ui/browsers/annotate.c
+++ b/tools/perf/ui/browsers/annotate.c
@@ -829,10 +829,16 @@ out:
        return key;
 }
+int map_symbol__tui_annotate(struct map_symbol *ms, struct perf_evsel *evsel,
+                             struct hist_browser_timer *hbt)
+{
+        return symbol__tui_annotate(ms->sym, ms->map, evsel, hbt);
+}
 int hist_entry__tui_annotate(struct hist_entry *he, struct perf_evsel *evsel,
                             struct hist_browser_timer *hbt)
 {
-        return symbol__tui_annotate(he->ms.sym, he->ms.map, evsel, hbt);
+        return map_symbol__tui_annotate(&he->ms, evsel, hbt);
 }
 static void annotate_browser__mark_jump_targets(struct annotate_browser *browser,
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index 788506eef567..995b7a8596b1 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -48,6 +48,24 @@ static bool hist_browser__has_filter(struct hist_browser *hb)
        return hists__has_filter(hb->hists) || hb->min_pcnt;
 }
+static int hist_browser__get_folding(struct hist_browser *browser)
+{
+        struct rb_node *nd;
+        struct hists *hists = browser->hists;
+        int unfolded_rows = 0;
+        for (nd = rb_first(&hists->entries);
+             (nd = hists__filter_entries(nd, browser->min_pcnt)) != NULL;
+             nd = rb_next(nd)) {
+                struct hist_entry *he =
+                        rb_entry(nd, struct hist_entry, rb_node);
+                if (he->ms.unfolded)
+                        unfolded_rows += he->nr_rows;
+        }
+        return unfolded_rows;
+}
 static u32 hist_browser__nr_entries(struct hist_browser *hb)
 {
        u32 nr_entries;
@@ -57,6 +75,7 @@ static u32 hist_browser__nr_entries(struct hist_browser *hb)
        else
                nr_entries = hb->hists->nr_entries;
+        hb->nr_callchain_rows = hist_browser__get_folding(hb);
        return nr_entries + hb->nr_callchain_rows;
 }
@@ -492,6 +511,7 @@ static void hist_browser__show_callchain_entry(struct hist_browser *browser,
 {
        int color, width;
        char folded_sign = callchain_list__folded(chain);
+        bool show_annotated = browser->show_dso && chain->ms.sym && symbol__annotation(chain->ms.sym)->src;
        color = HE_COLORSET_NORMAL;
        width = browser->b.width - (offset + 2);
@@ -504,7 +524,8 @@ static void hist_browser__show_callchain_entry(struct hist_browser *browser,
        ui_browser__set_color(&browser->b, color);
        hist_browser__gotorc(browser, row, 0);
        slsmg_write_nstring(" ", offset);
-        slsmg_printf("%c ", folded_sign);
+        slsmg_printf("%c", folded_sign);
+        ui_browser__write_graph(&browser->b, show_annotated ? SLSMG_RARROW_CHAR : ' ');
        slsmg_write_nstring(str, width);
 }
@@ -1467,7 +1488,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                perf_hpp__set_user_width(symbol_conf.col_width_list_str);
        while (1) {
-                const struct thread *thread = NULL;
+                struct thread *thread = NULL;
                const struct dso *dso = NULL;
                int choice = 0,
                    annotate = -2, zoom_dso = -2, zoom_thread = -2,
@@ -1593,28 +1614,30 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                if (!sort__has_sym)
                        goto add_exit_option;
+                if (browser->selection == NULL)
+                        goto skip_annotation;
                if (sort__mode == SORT_MODE__BRANCH) {
                        bi = browser->he_selection->branch_info;
-                        if (browser->selection != NULL &&
-                            bi &&
+                        if (bi == NULL)
-                            bi->from.sym != NULL &&
+                                goto skip_annotation;
+                        if (bi->from.sym != NULL &&
                            !bi->from.map->dso->annotate_warned &&
-                                asprintf(&options[nr_options], "Annotate %s",
+                            asprintf(&options[nr_options], "Annotate %s", bi->from.sym->name) > 0) {
-                                         bi->from.sym->name) > 0)
                                annotate_f = nr_options++;
+                        }
-                        if (browser->selection != NULL &&
+                        if (bi->to.sym != NULL &&
-                            bi &&
-                            bi->to.sym != NULL &&
                            !bi->to.map->dso->annotate_warned &&
                            (bi->to.sym != bi->from.sym ||
                             bi->to.map->dso != bi->from.map->dso) &&
-                                asprintf(&options[nr_options], "Annotate %s",
+                            asprintf(&options[nr_options], "Annotate %s", bi->to.sym->name) > 0) {
-                                         bi->to.sym->name) > 0)
                                annotate_t = nr_options++;
+                        }
                } else {
-                        if (browser->selection != NULL &&
+                        if (browser->selection->sym != NULL &&
-                            browser->selection->sym != NULL &&
                            !browser->selection->map->dso->annotate_warned) {
                                struct annotation *notes;
@@ -1622,11 +1645,12 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                                if (notes->src &&
                                    asprintf(&options[nr_options], "Annotate %s",
-                                                 browser->selection->sym->name) > 0)
+                                                 browser->selection->sym->name) > 0) {
                                        annotate = nr_options++;
+                                }
                        }
                }
+skip_annotation:
                if (thread != NULL &&
                    asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
                             (browser->hists->thread_filter ? "out of" : "into"),
@@ -1682,6 +1706,7 @@ retry_popup_menu:
                if (choice == annotate || choice == annotate_t || choice == annotate_f) {
                        struct hist_entry *he;
                        struct annotation *notes;
+                        struct map_symbol ms;
                        int err;
 do_annotate:
                        if (!objdump_path && perf_session_env__lookup_objdump(env))
@@ -1691,30 +1716,21 @@ do_annotate:
                        if (he == NULL)
                                continue;
-                        /*
-                         * we stash the branch_info symbol + map into the
-                         * the ms so we don't have to rewrite all the annotation
-                         * code to use branch_info.
-                         * in branch mode, the ms struct is not used
-                         */
                        if (choice == annotate_f) {
-                                he->ms.sym = he->branch_info->from.sym;
+                                ms.map = he->branch_info->from.map;
-                                he->ms.map = he->branch_info->from.map;
+                                ms.sym = he->branch_info->from.sym;
-                        }  else if (choice == annotate_t) {
+                        } else if (choice == annotate_t) {
-                                he->ms.sym = he->branch_info->to.sym;
+                                ms.map = he->branch_info->to.map;
-                                he->ms.map = he->branch_info->to.map;
+                                ms.sym = he->branch_info->to.sym;
+                        } else {
+                                ms = *browser->selection;
                        }
-                        notes = symbol__annotation(he->ms.sym);
+                        notes = symbol__annotation(ms.sym);
                        if (!notes->src)
                                continue;
-                        /*
+                        err = map_symbol__tui_annotate(&ms, evsel, hbt);
-                         * Don't let this be freed, say, by hists__decay_entry.
-                         */
-                        he->used = true;
-                        err = hist_entry__tui_annotate(he, evsel, hbt);
-                        he->used = false;
                        /*
                         * offer option to annotate the other branch source or target
                         * (if they exists) when returning from annotate
@@ -1754,13 +1770,13 @@ zoom_thread:
                                pstack__remove(fstack, &browser->hists->thread_filter);
 zoom_out_thread:
                                ui_helpline__pop();
-                                browser->hists->thread_filter = NULL;
+                                thread__zput(browser->hists->thread_filter);
                                perf_hpp__set_elide(HISTC_THREAD, false);
                        } else {
                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
                                                   thread->comm_set ? thread__comm_str(thread) : "",
                                                   thread->tid);
-                                browser->hists->thread_filter = thread;
+                                browser->hists->thread_filter = thread__get(thread);
                                perf_hpp__set_elide(HISTC_THREAD, false);
                                pstack__push(fstack, &browser->hists->thread_filter);
                        }
diff --git a/tools/perf/ui/gtk/Build b/tools/perf/ui/gtk/Build
new file mode 100644
index 000000000000..ec22e899a224
--- /dev/null
+++ b/tools/perf/ui/gtk/Build
@@ -0,0 +1,9 @@
+CFLAGS_gtk += -fPIC $(GTK_CFLAGS)
+gtk-y += browser.o
+gtk-y += hists.o
+gtk-y += setup.o
+gtk-y += util.o
+gtk-y += helpline.o
+gtk-y += progress.o
+gtk-y += annotate.o
diff --git a/tools/perf/ui/tui/Build b/tools/perf/ui/tui/Build
new file mode 100644
index 000000000000..9e4c6ca41a9f
--- /dev/null
+++ b/tools/perf/ui/tui/Build
@@ -0,0 +1,4 @@
+libperf-y += setup.o
+libperf-y += util.o
+libperf-y += helpline.o
+libperf-y += progress.o
diff --git a/tools/perf/util/Build b/tools/perf/util/Build
new file mode 100644
index 000000000000..797490a40075
--- /dev/null
+++ b/tools/perf/util/Build
@@ -0,0 +1,145 @@
+libperf-y += abspath.o
+libperf-y += alias.o
+libperf-y += annotate.o
+libperf-y += build-id.o
+libperf-y += config.o
+libperf-y += ctype.o
+libperf-y += db-export.o
+libperf-y += environment.o
+libperf-y += event.o
+libperf-y += evlist.o
+libperf-y += evsel.o
+libperf-y += exec_cmd.o
+libperf-y += find_next_bit.o
+libperf-y += help.o
+libperf-y += kallsyms.o
+libperf-y += levenshtein.o
+libperf-y += parse-options.o
+libperf-y += parse-events.o
+libperf-y += path.o
+libperf-y += rbtree.o
+libperf-y += bitmap.o
+libperf-y += hweight.o
+libperf-y += run-command.o
+libperf-y += quote.o
+libperf-y += strbuf.o
+libperf-y += string.o
+libperf-y += strlist.o
+libperf-y += strfilter.o
+libperf-y += top.o
+libperf-y += usage.o
+libperf-y += wrapper.o
+libperf-y += sigchain.o
+libperf-y += dso.o
+libperf-y += symbol.o
+libperf-y += color.o
+libperf-y += pager.o
+libperf-y += header.o
+libperf-y += callchain.o
+libperf-y += values.o
+libperf-y += debug.o
+libperf-y += machine.o
+libperf-y += map.o
+libperf-y += pstack.o
+libperf-y += session.o
+libperf-y += ordered-events.o
+libperf-y += comm.o
+libperf-y += thread.o
+libperf-y += thread_map.o
+libperf-y += trace-event-parse.o
+libperf-y += parse-events-flex.o
+libperf-y += parse-events-bison.o
+libperf-y += pmu.o
+libperf-y += pmu-flex.o
+libperf-y += pmu-bison.o
+libperf-y += trace-event-read.o
+libperf-y += trace-event-info.o
+libperf-y += trace-event-scripting.o
+libperf-y += trace-event.o
+libperf-y += svghelper.o
+libperf-y += sort.o
+libperf-y += hist.o
+libperf-y += util.o
+libperf-y += xyarray.o
+libperf-y += cpumap.o
+libperf-y += cgroup.o
+libperf-y += target.o
+libperf-y += rblist.o
+libperf-y += intlist.o
+libperf-y += vdso.o
+libperf-y += stat.o
+libperf-y += record.o
+libperf-y += srcline.o
+libperf-y += data.o
+libperf-$(CONFIG_X86) += tsc.o
+libperf-y += cloexec.o
+libperf-y += thread-stack.o
+libperf-$(CONFIG_LIBELF) += symbol-elf.o
+libperf-$(CONFIG_LIBELF) += probe-event.o
+ifndef CONFIG_LIBELF
+libperf-y += symbol-minimal.o
+endif
+libperf-$(CONFIG_DWARF) += probe-finder.o
+libperf-$(CONFIG_DWARF) += dwarf-aux.o
+libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
+libperf-$(CONFIG_LIBUNWIND)          += unwind-libunwind.o
+libperf-$(CONFIG_LIBBABELTRACE) += data-convert-bt.o
+libperf-y += scripting-engines/
+libperf-$(CONFIG_PERF_REGS) += perf_regs.o
+libperf-$(CONFIG_ZLIB) += zlib.o
+libperf-$(CONFIG_LZMA) += lzma.o
+CFLAGS_config.o   += -DETC_PERFCONFIG="BUILD_STR($(ETC_PERFCONFIG_SQ))"
+CFLAGS_exec_cmd.o += -DPERF_EXEC_PATH="BUILD_STR($(perfexecdir_SQ))" -DPREFIX="BUILD_STR($(prefix_SQ))"
+$(OUTPUT)util/parse-events-flex.c: util/parse-events.l $(OUTPUT)util/parse-events-bison.c
+        $(call rule_mkdir)
+        @$(call echo-cmd,flex)$(FLEX) -o $@ --header-file=$(OUTPUT)util/parse-events-flex.h $(PARSER_DEBUG_FLEX) util/parse-events.l
+$(OUTPUT)util/parse-events-bison.c: util/parse-events.y
+        $(call rule_mkdir)
+        @$(call echo-cmd,bison)$(BISON) -v util/parse-events.y -d $(PARSER_DEBUG_BISON) -o $@ -p parse_events_
+$(OUTPUT)util/pmu-flex.c: util/pmu.l $(OUTPUT)util/pmu-bison.c
+        $(call rule_mkdir)
+        @$(call echo-cmd,flex)$(FLEX) -o $@ --header-file=$(OUTPUT)util/pmu-flex.h util/pmu.l
+$(OUTPUT)util/pmu-bison.c: util/pmu.y
+        $(call rule_mkdir)
+        @$(call echo-cmd,bison)$(BISON) -v util/pmu.y -d -o $@ -p perf_pmu_
+CFLAGS_parse-events-flex.o  += -w
+CFLAGS_pmu-flex.o           += -w
+CFLAGS_parse-events-bison.o += -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w
+CFLAGS_pmu-bison.o          += -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w
+$(OUTPUT)util/parse-events.o: $(OUTPUT)util/parse-events-flex.c $(OUTPUT)util/parse-events-bison.c
+$(OUTPUT)util/pmu.o: $(OUTPUT)util/pmu-flex.c $(OUTPUT)util/pmu-bison.c
+CFLAGS_find_next_bit.o += -Wno-unused-parameter -DETC_PERFCONFIG="BUILD_STR($(ETC_PERFCONFIG_SQ))"
+CFLAGS_rbtree.o        += -Wno-unused-parameter -DETC_PERFCONFIG="BUILD_STR($(ETC_PERFCONFIG_SQ))"
+CFLAGS_hweight.o       += -Wno-unused-parameter -DETC_PERFCONFIG="BUILD_STR($(ETC_PERFCONFIG_SQ))"
+CFLAGS_parse-events.o  += -Wno-redundant-decls
+$(OUTPUT)util/kallsyms.o: ../lib/symbol/kallsyms.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
+$(OUTPUT)util/find_next_bit.o: ../lib/util/find_next_bit.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
+$(OUTPUT)util/rbtree.o: ../../lib/rbtree.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
+$(OUTPUT)util/hweight.o: ../../lib/hweight.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 9d9db3b296dd..7f5bdfc9bc87 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -1010,6 +1010,32 @@ fallback:
                        }
                        filename = symfs_filename;
                }
+        } else if (dso__needs_decompress(dso)) {
+                char tmp[PATH_MAX];
+                struct kmod_path m;
+                int fd;
+                bool ret;
+                if (kmod_path__parse_ext(&m, symfs_filename))
+                        goto out_free_filename;
+                snprintf(tmp, PATH_MAX, "/tmp/perf-kmod-XXXXXX");
+                fd = mkstemp(tmp);
+                if (fd < 0) {
+                        free(m.ext);
+                        goto out_free_filename;
+                }
+                ret = decompress_to_file(m.ext, symfs_filename, fd);
+                free(m.ext);
+                close(fd);
+                if (!ret)
+                        goto out_free_filename;
+                strcpy(symfs_filename, tmp);
        }
        snprintf(command, sizeof(command),
@@ -1029,7 +1055,7 @@ fallback:
        file = popen(command, "r");
        if (!file)
-                goto out_free_filename;
+                goto out_remove_tmp;
        while (!feof(file))
                if (symbol__parse_objdump_line(sym, map, file, privsize,
@@ -1044,6 +1070,10 @@ fallback:
                delete_last_nop(sym);
        pclose(file);
+out_remove_tmp:
+        if (dso__needs_decompress(dso))
+                unlink(symfs_filename);
 out_free_filename:
        if (delete_extract)
                kcore_extract__delete(&kce);
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 0c72680a977f..f7fb2587df69 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -61,8 +61,9 @@ static int perf_event__exit_del_thread(struct perf_tool *tool __maybe_unused,
        if (thread) {
                rb_erase(&thread->rb_node, &machine->threads);
-                machine->last_match = NULL;
+                if (machine->last_match == thread)
-                thread__delete(thread);
+                        thread__zput(machine->last_match);
+                thread__put(thread);
        }
        return 0;
@@ -93,6 +94,35 @@ int build_id__sprintf(const u8 *build_id, int len, char *bf)
        return raw - build_id;
 }
+/* asnprintf consolidates asprintf and snprintf */
+static int asnprintf(char **strp, size_t size, const char *fmt, ...)
+{
+        va_list ap;
+        int ret;
+        if (!strp)
+                return -EINVAL;
+        va_start(ap, fmt);
+        if (*strp)
+                ret = vsnprintf(*strp, size, fmt, ap);
+        else
+                ret = vasprintf(strp, fmt, ap);
+        va_end(ap);
+        return ret;
+}
+static char *build_id__filename(const char *sbuild_id, char *bf, size_t size)
+{
+        char *tmp = bf;
+        int ret = asnprintf(&bf, size, "%s/.build-id/%.2s/%s", buildid_dir,
+                            sbuild_id, sbuild_id + 2);
+        if (ret < 0 || (tmp && size < (unsigned int)ret))
+                return NULL;
+        return bf;
+}
 char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size)
 {
        char build_id_hex[BUILD_ID_SIZE * 2 + 1];
@@ -101,14 +131,7 @@ char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size)
                return NULL;
        build_id__sprintf(dso->build_id, sizeof(dso->build_id), build_id_hex);
-        if (bf == NULL) {
+        return build_id__filename(build_id_hex, bf, size);
-                if (asprintf(&bf, "%s/.build-id/%.2s/%s", buildid_dir,
-                             build_id_hex, build_id_hex + 2) < 0)
-                        return NULL;
-        } else
-                snprintf(bf, size, "%s/.build-id/%.2s/%s", buildid_dir,
-                         build_id_hex, build_id_hex + 2);
-        return bf;
 }
 #define dsos__for_each_with_build_id(pos, head) \
@@ -259,52 +282,113 @@ void disable_buildid_cache(void)
        no_buildid_cache = true;
 }
-int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
+static char *build_id_cache__dirname_from_path(const char *name,
-                          const char *name, bool is_kallsyms, bool is_vdso)
+                                               bool is_kallsyms, bool is_vdso)
 {
-        const size_t size = PATH_MAX;
+        char *realname = (char *)name, *filename;
-        char *realname, *filename = zalloc(size),
-             *linkname = zalloc(size), *targetname;
-        int len, err = -1;
        bool slash = is_kallsyms || is_vdso;
-        if (is_kallsyms) {
+        if (!slash) {
-                if (symbol_conf.kptr_restrict) {
+                realname = realpath(name, NULL);
-                        pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
+                if (!realname)
-                        err = 0;
+                        return NULL;
-                        goto out_free;
+        }
-                }
-                realname = (char *) name;
+        if (asprintf(&filename, "%s%s%s", buildid_dir, slash ? "/" : "",
-        } else
+                     is_vdso ? DSO__NAME_VDSO : realname) < 0)
+                filename = NULL;
+        if (!slash)
+                free(realname);
+        return filename;
+}
+int build_id_cache__list_build_ids(const char *pathname,
+                                   struct strlist **result)
+{
+        struct strlist *list;
+        char *dir_name;
+        DIR *dir;
+        struct dirent *d;
+        int ret = 0;
+        list = strlist__new(true, NULL);
+        dir_name = build_id_cache__dirname_from_path(pathname, false, false);
+        if (!list || !dir_name) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        /* List up all dirents */
+        dir = opendir(dir_name);
+        if (!dir) {
+                ret = -errno;
+                goto out;
+        }
+        while ((d = readdir(dir)) != NULL) {
+                if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
+                        continue;
+                strlist__add(list, d->d_name);
+        }
+        closedir(dir);
+out:
+        free(dir_name);
+        if (ret)
+                strlist__delete(list);
+        else
+                *result = list;
+        return ret;
+}
+int build_id_cache__add_s(const char *sbuild_id, const char *name,
+                          bool is_kallsyms, bool is_vdso)
+{
+        const size_t size = PATH_MAX;
+        char *realname = NULL, *filename = NULL, *dir_name = NULL,
+             *linkname = zalloc(size), *targetname, *tmp;
+        int err = -1;
+        if (!is_kallsyms) {
                realname = realpath(name, NULL);
+                if (!realname)
+                        goto out_free;
+        }
-        if (realname == NULL || filename == NULL || linkname == NULL)
+        dir_name = build_id_cache__dirname_from_path(name, is_kallsyms, is_vdso);
+        if (!dir_name)
                goto out_free;
-        len = scnprintf(filename, size, "%s%s%s",
+        if (mkdir_p(dir_name, 0755))
-                       debugdir, slash ? "/" : "",
-                       is_vdso ? DSO__NAME_VDSO : realname);
-        if (mkdir_p(filename, 0755))
                goto out_free;
-        snprintf(filename + len, size - len, "/%s", sbuild_id);
+        if (asprintf(&filename, "%s/%s", dir_name, sbuild_id) < 0) {
+                filename = NULL;
+                goto out_free;
+        }
        if (access(filename, F_OK)) {
                if (is_kallsyms) {
                         if (copyfile("/proc/kallsyms", filename))
                                goto out_free;
-                } else if (link(realname, filename) && copyfile(name, filename))
+                } else if (link(realname, filename) && errno != EEXIST &&
+                                copyfile(name, filename))
                        goto out_free;
        }
-        len = scnprintf(linkname, size, "%s/.build-id/%.2s",
+        if (!build_id__filename(sbuild_id, linkname, size))
-                       debugdir, sbuild_id);
+                goto out_free;
+        tmp = strrchr(linkname, '/');
+        *tmp = '\0';
        if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
                goto out_free;
-        snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
+        *tmp = '/';
-        targetname = filename + strlen(debugdir) - 5;
+        targetname = filename + strlen(buildid_dir) - 5;
        memcpy(targetname, "../..", 5);
        if (symlink(targetname, linkname) == 0)
@@ -313,34 +397,46 @@ out_free:
        if (!is_kallsyms)
                free(realname);
        free(filename);
+        free(dir_name);
        free(linkname);
        return err;
 }
 static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
-                                 const char *name, const char *debugdir,
+                                 const char *name, bool is_kallsyms,
-                                 bool is_kallsyms, bool is_vdso)
+                                 bool is_vdso)
 {
        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
        build_id__sprintf(build_id, build_id_size, sbuild_id);
-        return build_id_cache__add_s(sbuild_id, debugdir, name,
+        return build_id_cache__add_s(sbuild_id, name, is_kallsyms, is_vdso);
-                                     is_kallsyms, is_vdso);
+}
+bool build_id_cache__cached(const char *sbuild_id)
+{
+        bool ret = false;
+        char *filename = build_id__filename(sbuild_id, NULL, 0);
+        if (filename && !access(filename, F_OK))
+                ret = true;
+        free(filename);
+        return ret;
 }
-int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
+int build_id_cache__remove_s(const char *sbuild_id)
 {
        const size_t size = PATH_MAX;
        char *filename = zalloc(size),
-             *linkname = zalloc(size);
+             *linkname = zalloc(size), *tmp;
        int err = -1;
        if (filename == NULL || linkname == NULL)
                goto out_free;
-        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
+        if (!build_id__filename(sbuild_id, linkname, size))
-                 debugdir, sbuild_id, sbuild_id + 2);
+                goto out_free;
        if (access(linkname, F_OK))
                goto out_free;
@@ -354,8 +450,8 @@ int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
        /*
         * Since the link is relative, we must make it absolute:
         */
-        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
+        tmp = strrchr(linkname, '/') + 1;
-                 debugdir, sbuild_id, filename);
+        snprintf(tmp, size - (tmp - linkname), "%s", filename);
        if (unlink(linkname))
                goto out_free;
@@ -367,8 +463,7 @@ out_free:
        return err;
 }
-static int dso__cache_build_id(struct dso *dso, struct machine *machine,
+static int dso__cache_build_id(struct dso *dso, struct machine *machine)
-                               const char *debugdir)
 {
        bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
        bool is_vdso = dso__is_vdso(dso);
@@ -381,28 +476,26 @@ static int dso__cache_build_id(struct dso *dso, struct machine *machine,
                name = nm;
        }
        return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id), name,
-                                     debugdir, is_kallsyms, is_vdso);
+                                     is_kallsyms, is_vdso);
 }
 static int __dsos__cache_build_ids(struct list_head *head,
-                                   struct machine *machine, const char *debugdir)
+                                   struct machine *machine)
 {
        struct dso *pos;
        int err = 0;
        dsos__for_each_with_build_id(pos, head)
-                if (dso__cache_build_id(pos, machine, debugdir))
+                if (dso__cache_build_id(pos, machine))
                        err = -1;
        return err;
 }
-static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
+static int machine__cache_build_ids(struct machine *machine)
 {
-        int ret = __dsos__cache_build_ids(&machine->kernel_dsos.head, machine,
+        int ret = __dsos__cache_build_ids(&machine->kernel_dsos.head, machine);
-                                          debugdir);
+        ret |= __dsos__cache_build_ids(&machine->user_dsos.head, machine);
-        ret |= __dsos__cache_build_ids(&machine->user_dsos.head, machine,
-                                       debugdir);
        return ret;
 }
@@ -417,11 +510,11 @@ int perf_session__cache_build_ids(struct perf_session *session)
        if (mkdir(buildid_dir, 0755) != 0 && errno != EEXIST)
                return -1;
-        ret = machine__cache_build_ids(&session->machines.host, buildid_dir);
+        ret = machine__cache_build_ids(&session->machines.host);
        for (nd = rb_first(&session->machines.guests); nd; nd = rb_next(nd)) {
                struct machine *pos = rb_entry(nd, struct machine, rb_node);
-                ret |= machine__cache_build_ids(pos, buildid_dir);
+                ret |= machine__cache_build_ids(pos);
        }
        return ret ? -1 : 0;
 }
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
index 8236319514d5..85011222cc14 100644
--- a/tools/perf/util/build-id.h
+++ b/tools/perf/util/build-id.h
@@ -4,6 +4,7 @@
 #define BUILD_ID_SIZE 20
 #include "tool.h"
+#include "strlist.h"
 #include <linux/types.h>
 extern struct perf_tool build_id__mark_dso_hit_ops;
@@ -22,9 +23,12 @@ bool perf_session__read_build_ids(struct perf_session *session, bool with_hits);
 int perf_session__write_buildid_table(struct perf_session *session, int fd);
 int perf_session__cache_build_ids(struct perf_session *session);
-int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
+int build_id_cache__list_build_ids(const char *pathname,
+                                   struct strlist **result);
+bool build_id_cache__cached(const char *sbuild_id);
+int build_id_cache__add_s(const char *sbuild_id,
                          const char *name, bool is_kallsyms, bool is_vdso);
-int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir);
+int build_id_cache__remove_s(const char *sbuild_id);
 void disable_buildid_cache(void);
 #endif
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index d04d770d90f6..fbcca21d66ab 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -17,6 +17,7 @@
 #define EXEC_PATH_ENVIRONMENT "PERF_EXEC_PATH"
 #define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
 #define PERF_DEBUGFS_ENVIRONMENT "PERF_DEBUGFS_DIR"
+#define PERF_TRACEFS_ENVIRONMENT "PERF_TRACEFS_DIR"
 typedef int (*config_fn_t)(const char *, const char *, void *);
 extern int perf_default_config(const char *, const char *, void *);
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 14e7a123d43b..9f643ee77001 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -97,6 +97,14 @@ int parse_callchain_record_opt(const char *arg)
                                callchain_param.dump_size = size;
                        }
 #endif /* HAVE_DWARF_UNWIND_SUPPORT */
+                } else if (!strncmp(name, "lbr", sizeof("lbr"))) {
+                        if (!strtok_r(NULL, ",", &saveptr)) {
+                                callchain_param.record_mode = CALLCHAIN_LBR;
+                                ret = 0;
+                        } else
+                                pr_err("callchain: No more arguments "
+                                        "needed for --call-graph lbr\n");
+                        break;
                } else {
                        pr_err("callchain: Unknown --call-graph option "
                               "value: %s\n", arg);
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index c0ec1acc38e4..6033a0a212ca 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -11,6 +11,7 @@ enum perf_call_graph_mode {
        CALLCHAIN_NONE,
        CALLCHAIN_FP,
        CALLCHAIN_DWARF,
+        CALLCHAIN_LBR,
        CALLCHAIN_MAX
 };
diff --git a/tools/perf/util/cloexec.c b/tools/perf/util/cloexec.c
index 6da965bdbc2c..85b523885f9d 100644
--- a/tools/perf/util/cloexec.c
+++ b/tools/perf/util/cloexec.c
@@ -7,6 +7,12 @@
 static unsigned long flag = PERF_FLAG_FD_CLOEXEC;
+int __weak sched_getcpu(void)
+{
+        errno = ENOSYS;
+        return -1;
+}
 static int perf_flag_probe(void)
 {
        /* use 'safest' configuration as used in perf_evsel__fallback() */
diff --git a/tools/perf/util/cloexec.h b/tools/perf/util/cloexec.h
index 94a5a7d829d5..68888c29b04a 100644
--- a/tools/perf/util/cloexec.h
+++ b/tools/perf/util/cloexec.h
@@ -3,4 +3,10 @@
 unsigned long perf_event_open_cloexec_flag(void);
+#ifdef __GLIBC_PREREQ
+#if !__GLIBC_PREREQ(2, 6)
+extern int sched_getcpu(void) __THROW;
+#endif
+#endif
 #endif /* __PERF_CLOEXEC_H */
diff --git a/tools/perf/util/data-convert-bt.c b/tools/perf/util/data-convert-bt.c
new file mode 100644
index 000000000000..c6d62268cc2a
--- /dev/null
+++ b/tools/perf/util/data-convert-bt.c
@@ -0,0 +1,856 @@
+/*
+ * CTF writing support via babeltrace.
+ *
+ * Copyright (C) 2014, Jiri Olsa <jolsa@redhat.com>
+ * Copyright (C) 2014, Sebastian Andrzej Siewior <bigeasy@linutronix.de>
+ *
+ * Released under the GPL v2. (and only v2, not any later version)
+ */
+#include <linux/compiler.h>
+#include <babeltrace/ctf-writer/writer.h>
+#include <babeltrace/ctf-writer/clock.h>
+#include <babeltrace/ctf-writer/stream.h>
+#include <babeltrace/ctf-writer/event.h>
+#include <babeltrace/ctf-writer/event-types.h>
+#include <babeltrace/ctf-writer/event-fields.h>
+#include <babeltrace/ctf/events.h>
+#include <traceevent/event-parse.h>
+#include "asm/bug.h"
+#include "data-convert-bt.h"
+#include "session.h"
+#include "util.h"
+#include "debug.h"
+#include "tool.h"
+#include "evlist.h"
+#include "evsel.h"
+#include "machine.h"
+#define pr_N(n, fmt, ...) \
+        eprintf(n, debug_data_convert, fmt, ##__VA_ARGS__)
+#define pr(fmt, ...)  pr_N(1, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr2(fmt, ...) pr_N(2, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_time2(t, fmt, ...) pr_time_N(2, debug_data_convert, t, pr_fmt(fmt), ##__VA_ARGS__)
+struct evsel_priv {
+        struct bt_ctf_event_class *event_class;
+};
+struct ctf_writer {
+        /* writer primitives */
+        struct bt_ctf_writer            *writer;
+        struct bt_ctf_stream            *stream;
+        struct bt_ctf_stream_class      *stream_class;
+        struct bt_ctf_clock             *clock;
+        /* data types */
+        union {
+                struct {
+                        struct bt_ctf_field_type        *s64;
+                        struct bt_ctf_field_type        *u64;
+                        struct bt_ctf_field_type        *s32;
+                        struct bt_ctf_field_type        *u32;
+                        struct bt_ctf_field_type        *string;
+                        struct bt_ctf_field_type        *u64_hex;
+                };
+                struct bt_ctf_field_type *array[6];
+        } data;
+};
+struct convert {
+        struct perf_tool        tool;
+        struct ctf_writer       writer;
+        u64                     events_size;
+        u64                     events_count;
+};
+static int value_set(struct bt_ctf_field_type *type,
+                     struct bt_ctf_event *event,
+                     const char *name, u64 val)
+{
+        struct bt_ctf_field *field;
+        bool sign = bt_ctf_field_type_integer_get_signed(type);
+        int ret;
+        field = bt_ctf_field_create(type);
+        if (!field) {
+                pr_err("failed to create a field %s\n", name);
+                return -1;
+        }
+        if (sign) {
+                ret = bt_ctf_field_signed_integer_set_value(field, val);
+                if (ret) {
+                        pr_err("failed to set field value %s\n", name);
+                        goto err;
+                }
+        } else {
+                ret = bt_ctf_field_unsigned_integer_set_value(field, val);
+                if (ret) {
+                        pr_err("failed to set field value %s\n", name);
+                        goto err;
+                }
+        }
+        ret = bt_ctf_event_set_payload(event, name, field);
+        if (ret) {
+                pr_err("failed to set payload %s\n", name);
+                goto err;
+        }
+        pr2("  SET [%s = %" PRIu64 "]\n", name, val);
+err:
+        bt_ctf_field_put(field);
+        return ret;
+}
+#define __FUNC_VALUE_SET(_name, _val_type)                              \
+static __maybe_unused int value_set_##_name(struct ctf_writer *cw,      \
+                             struct bt_ctf_event *event,                \
+                             const char *name,                          \
+                             _val_type val)                             \
+{                                                                       \
+        struct bt_ctf_field_type *type = cw->data._name;                \
+        return value_set(type, event, name, (u64) val);                 \
+}
+#define FUNC_VALUE_SET(_name) __FUNC_VALUE_SET(_name, _name)
+FUNC_VALUE_SET(s32)
+FUNC_VALUE_SET(u32)
+FUNC_VALUE_SET(s64)
+FUNC_VALUE_SET(u64)
+__FUNC_VALUE_SET(u64_hex, u64)
+static struct bt_ctf_field_type*
+get_tracepoint_field_type(struct ctf_writer *cw, struct format_field *field)
+{
+        unsigned long flags = field->flags;
+        if (flags & FIELD_IS_STRING)
+                return cw->data.string;
+        if (!(flags & FIELD_IS_SIGNED)) {
+                /* unsigned long are mostly pointers */
+                if (flags & FIELD_IS_LONG || flags & FIELD_IS_POINTER)
+                        return cw->data.u64_hex;
+        }
+        if (flags & FIELD_IS_SIGNED) {
+                if (field->size == 8)
+                        return cw->data.s64;
+                else
+                        return cw->data.s32;
+        }
+        if (field->size == 8)
+                return cw->data.u64;
+        else
+                return cw->data.u32;
+}
+static int add_tracepoint_field_value(struct ctf_writer *cw,
+                                      struct bt_ctf_event_class *event_class,
+                                      struct bt_ctf_event *event,
+                                      struct perf_sample *sample,
+                                      struct format_field *fmtf)
+{
+        struct bt_ctf_field_type *type;
+        struct bt_ctf_field *array_field;
+        struct bt_ctf_field *field;
+        const char *name = fmtf->name;
+        void *data = sample->raw_data;
+        unsigned long long value_int;
+        unsigned long flags = fmtf->flags;
+        unsigned int n_items;
+        unsigned int i;
+        unsigned int offset;
+        unsigned int len;
+        int ret;
+        offset = fmtf->offset;
+        len = fmtf->size;
+        if (flags & FIELD_IS_STRING)
+                flags &= ~FIELD_IS_ARRAY;
+        if (flags & FIELD_IS_DYNAMIC) {
+                unsigned long long tmp_val;
+                tmp_val = pevent_read_number(fmtf->event->pevent,
+                                data + offset, len);
+                offset = tmp_val;
+                len = offset >> 16;
+                offset &= 0xffff;
+        }
+        if (flags & FIELD_IS_ARRAY) {
+                type = bt_ctf_event_class_get_field_by_name(
+                                event_class, name);
+                array_field = bt_ctf_field_create(type);
+                bt_ctf_field_type_put(type);
+                if (!array_field) {
+                        pr_err("Failed to create array type %s\n", name);
+                        return -1;
+                }
+                len = fmtf->size / fmtf->arraylen;
+                n_items = fmtf->arraylen;
+        } else {
+                n_items = 1;
+                array_field = NULL;
+        }
+        type = get_tracepoint_field_type(cw, fmtf);
+        for (i = 0; i < n_items; i++) {
+                if (!(flags & FIELD_IS_STRING))
+                        value_int = pevent_read_number(
+                                        fmtf->event->pevent,
+                                        data + offset + i * len, len);
+                if (flags & FIELD_IS_ARRAY)
+                        field = bt_ctf_field_array_get_field(array_field, i);
+                else
+                        field = bt_ctf_field_create(type);
+                if (!field) {
+                        pr_err("failed to create a field %s\n", name);
+                        return -1;
+                }
+                if (flags & FIELD_IS_STRING)
+                        ret = bt_ctf_field_string_set_value(field,
+                                        data + offset + i * len);
+                else if (!(flags & FIELD_IS_SIGNED))
+                        ret = bt_ctf_field_unsigned_integer_set_value(
+                                        field, value_int);
+                else
+                        ret = bt_ctf_field_signed_integer_set_value(
+                                        field, value_int);
+                if (ret) {
+                        pr_err("failed to set file value %s\n", name);
+                        goto err_put_field;
+                }
+                if (!(flags & FIELD_IS_ARRAY)) {
+                        ret = bt_ctf_event_set_payload(event, name, field);
+                        if (ret) {
+                                pr_err("failed to set payload %s\n", name);
+                                goto err_put_field;
+                        }
+                }
+                bt_ctf_field_put(field);
+        }
+        if (flags & FIELD_IS_ARRAY) {
+                ret = bt_ctf_event_set_payload(event, name, array_field);
+                if (ret) {
+                        pr_err("Failed add payload array %s\n", name);
+                        return -1;
+                }
+                bt_ctf_field_put(array_field);
+        }
+        return 0;
+err_put_field:
+        bt_ctf_field_put(field);
+        return -1;
+}
+static int add_tracepoint_fields_values(struct ctf_writer *cw,
+                                        struct bt_ctf_event_class *event_class,
+                                        struct bt_ctf_event *event,
+                                        struct format_field *fields,
+                                        struct perf_sample *sample)
+{
+        struct format_field *field;
+        int ret;
+        for (field = fields; field; field = field->next) {
+                ret = add_tracepoint_field_value(cw, event_class, event, sample,
+                                field);
+                if (ret)
+                        return -1;
+        }
+        return 0;
+}
+static int add_tracepoint_values(struct ctf_writer *cw,
+                                 struct bt_ctf_event_class *event_class,
+                                 struct bt_ctf_event *event,
+                                 struct perf_evsel *evsel,
+                                 struct perf_sample *sample)
+{
+        struct format_field *common_fields = evsel->tp_format->format.common_fields;
+        struct format_field *fields        = evsel->tp_format->format.fields;
+        int ret;
+        ret = add_tracepoint_fields_values(cw, event_class, event,
+                                           common_fields, sample);
+        if (!ret)
+                ret = add_tracepoint_fields_values(cw, event_class, event,
+                                                   fields, sample);
+        return ret;
+}
+static int add_generic_values(struct ctf_writer *cw,
+                              struct bt_ctf_event *event,
+                              struct perf_evsel *evsel,
+                              struct perf_sample *sample)
+{
+        u64 type = evsel->attr.sample_type;
+        int ret;
+        /*
+         * missing:
+         *   PERF_SAMPLE_TIME         - not needed as we have it in
+         *                              ctf event header
+         *   PERF_SAMPLE_READ         - TODO
+         *   PERF_SAMPLE_CALLCHAIN    - TODO
+         *   PERF_SAMPLE_RAW          - tracepoint fields are handled separately
+         *   PERF_SAMPLE_BRANCH_STACK - TODO
+         *   PERF_SAMPLE_REGS_USER    - TODO
+         *   PERF_SAMPLE_STACK_USER   - TODO
+         */
+        if (type & PERF_SAMPLE_IP) {
+                ret = value_set_u64_hex(cw, event, "perf_ip", sample->ip);
+                if (ret)
+                        return -1;
+        }
+        if (type & PERF_SAMPLE_TID) {
+                ret = value_set_s32(cw, event, "perf_tid", sample->tid);
+                if (ret)
+                        return -1;
+                ret = value_set_s32(cw, event, "perf_pid", sample->pid);
+                if (ret)
+                        return -1;
+        }
+        if ((type & PERF_SAMPLE_ID) ||
+            (type & PERF_SAMPLE_IDENTIFIER)) {
+                ret = value_set_u64(cw, event, "perf_id", sample->id);
+                if (ret)
+                        return -1;
+        }
+        if (type & PERF_SAMPLE_STREAM_ID) {
+                ret = value_set_u64(cw, event, "perf_stream_id", sample->stream_id);
+                if (ret)
+                        return -1;
+        }
+        if (type & PERF_SAMPLE_CPU) {
+                ret = value_set_u32(cw, event, "perf_cpu", sample->cpu);
+                if (ret)
+                        return -1;
+        }
+        if (type & PERF_SAMPLE_PERIOD) {
+                ret = value_set_u64(cw, event, "perf_period", sample->period);
+                if (ret)
+                        return -1;
+        }
+        if (type & PERF_SAMPLE_WEIGHT) {
+                ret = value_set_u64(cw, event, "perf_weight", sample->weight);
+                if (ret)
+                        return -1;
+        }
+        if (type & PERF_SAMPLE_DATA_SRC) {
+                ret = value_set_u64(cw, event, "perf_data_src",
+                                sample->data_src);
+                if (ret)
+                        return -1;
+        }
+        if (type & PERF_SAMPLE_TRANSACTION) {
+                ret = value_set_u64(cw, event, "perf_transaction",
+                                sample->transaction);
+                if (ret)
+                        return -1;
+        }
+        return 0;
+}
+static int process_sample_event(struct perf_tool *tool,
+                                union perf_event *_event __maybe_unused,
+                                struct perf_sample *sample,
+                                struct perf_evsel *evsel,
+                                struct machine *machine __maybe_unused)
+{
+        struct convert *c = container_of(tool, struct convert, tool);
+        struct evsel_priv *priv = evsel->priv;
+        struct ctf_writer *cw = &c->writer;
+        struct bt_ctf_event_class *event_class;
+        struct bt_ctf_event *event;
+        int ret;
+        if (WARN_ONCE(!priv, "Failed to setup all events.\n"))
+                return 0;
+        event_class = priv->event_class;
+        /* update stats */
+        c->events_count++;
+        c->events_size += _event->header.size;
+        pr_time2(sample->time, "sample %" PRIu64 "\n", c->events_count);
+        event = bt_ctf_event_create(event_class);
+        if (!event) {
+                pr_err("Failed to create an CTF event\n");
+                return -1;
+        }
+        bt_ctf_clock_set_time(cw->clock, sample->time);
+        ret = add_generic_values(cw, event, evsel, sample);
+        if (ret)
+                return -1;
+        if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
+                ret = add_tracepoint_values(cw, event_class, event,
+                                            evsel, sample);
+                if (ret)
+                        return -1;
+        }
+        bt_ctf_stream_append_event(cw->stream, event);
+        bt_ctf_event_put(event);
+        return 0;
+}
+static int add_tracepoint_fields_types(struct ctf_writer *cw,
+                                       struct format_field *fields,
+                                       struct bt_ctf_event_class *event_class)
+{
+        struct format_field *field;
+        int ret;
+        for (field = fields; field; field = field->next) {
+                struct bt_ctf_field_type *type;
+                unsigned long flags = field->flags;
+                pr2("  field '%s'\n", field->name);
+                type = get_tracepoint_field_type(cw, field);
+                if (!type)
+                        return -1;
+                /*
+                 * A string is an array of chars. For this we use the string
+                 * type and don't care that it is an array. What we don't
+                 * support is an array of strings.
+                 */
+                if (flags & FIELD_IS_STRING)
+                        flags &= ~FIELD_IS_ARRAY;
+                if (flags & FIELD_IS_ARRAY)
+                        type = bt_ctf_field_type_array_create(type, field->arraylen);
+                ret = bt_ctf_event_class_add_field(event_class, type,
+                                field->name);
+                if (flags & FIELD_IS_ARRAY)
+                        bt_ctf_field_type_put(type);
+                if (ret) {
+                        pr_err("Failed to add field '%s\n", field->name);
+                        return -1;
+                }
+        }
+        return 0;
+}
+static int add_tracepoint_types(struct ctf_writer *cw,
+                                struct perf_evsel *evsel,
+                                struct bt_ctf_event_class *class)
+{
+        struct format_field *common_fields = evsel->tp_format->format.common_fields;
+        struct format_field *fields        = evsel->tp_format->format.fields;
+        int ret;
+        ret = add_tracepoint_fields_types(cw, common_fields, class);
+        if (!ret)
+                ret = add_tracepoint_fields_types(cw, fields, class);
+        return ret;
+}
+static int add_generic_types(struct ctf_writer *cw, struct perf_evsel *evsel,
+                             struct bt_ctf_event_class *event_class)
+{
+        u64 type = evsel->attr.sample_type;
+        /*
+         * missing:
+         *   PERF_SAMPLE_TIME         - not needed as we have it in
+         *                              ctf event header
+         *   PERF_SAMPLE_READ         - TODO
+         *   PERF_SAMPLE_CALLCHAIN    - TODO
+         *   PERF_SAMPLE_RAW          - tracepoint fields are handled separately
+         *   PERF_SAMPLE_BRANCH_STACK - TODO
+         *   PERF_SAMPLE_REGS_USER    - TODO
+         *   PERF_SAMPLE_STACK_USER   - TODO
+         */
+#define ADD_FIELD(cl, t, n)                                             \
+        do {                                                            \
+                pr2("  field '%s'\n", n);                               \
+                if (bt_ctf_event_class_add_field(cl, t, n)) {           \
+                        pr_err("Failed to add field '%s;\n", n);        \
+                        return -1;                                      \
+                }                                                       \
+        } while (0)
+        if (type & PERF_SAMPLE_IP)
+                ADD_FIELD(event_class, cw->data.u64_hex, "perf_ip");
+        if (type & PERF_SAMPLE_TID) {
+                ADD_FIELD(event_class, cw->data.s32, "perf_tid");
+                ADD_FIELD(event_class, cw->data.s32, "perf_pid");
+        }
+        if ((type & PERF_SAMPLE_ID) ||
+            (type & PERF_SAMPLE_IDENTIFIER))
+                ADD_FIELD(event_class, cw->data.u64, "perf_id");
+        if (type & PERF_SAMPLE_STREAM_ID)
+                ADD_FIELD(event_class, cw->data.u64, "perf_stream_id");
+        if (type & PERF_SAMPLE_CPU)
+                ADD_FIELD(event_class, cw->data.u32, "perf_cpu");
+        if (type & PERF_SAMPLE_PERIOD)
+                ADD_FIELD(event_class, cw->data.u64, "perf_period");
+        if (type & PERF_SAMPLE_WEIGHT)
+                ADD_FIELD(event_class, cw->data.u64, "perf_weight");
+        if (type & PERF_SAMPLE_DATA_SRC)
+                ADD_FIELD(event_class, cw->data.u64, "perf_data_src");
+        if (type & PERF_SAMPLE_TRANSACTION)
+                ADD_FIELD(event_class, cw->data.u64, "perf_transaction");
+#undef ADD_FIELD
+        return 0;
+}
+static int add_event(struct ctf_writer *cw, struct perf_evsel *evsel)
+{
+        struct bt_ctf_event_class *event_class;
+        struct evsel_priv *priv;
+        const char *name = perf_evsel__name(evsel);
+        int ret;
+        pr("Adding event '%s' (type %d)\n", name, evsel->attr.type);
+        event_class = bt_ctf_event_class_create(name);
+        if (!event_class)
+                return -1;
+        ret = add_generic_types(cw, evsel, event_class);
+        if (ret)
+                goto err;
+        if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
+                ret = add_tracepoint_types(cw, evsel, event_class);
+                if (ret)
+                        goto err;
+        }
+        ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);
+        if (ret) {
+                pr("Failed to add event class into stream.\n");
+                goto err;
+        }
+        priv = malloc(sizeof(*priv));
+        if (!priv)
+                goto err;
+        priv->event_class = event_class;
+        evsel->priv       = priv;
+        return 0;
+err:
+        bt_ctf_event_class_put(event_class);
+        pr_err("Failed to add event '%s'.\n", name);
+        return -1;
+}
+static int setup_events(struct ctf_writer *cw, struct perf_session *session)
+{
+        struct perf_evlist *evlist = session->evlist;
+        struct perf_evsel *evsel;
+        int ret;
+        evlist__for_each(evlist, evsel) {
+                ret = add_event(cw, evsel);
+                if (ret)
+                        return ret;
+        }
+        return 0;
+}
+static int ctf_writer__setup_env(struct ctf_writer *cw,
+                                 struct perf_session *session)
+{
+        struct perf_header *header = &session->header;
+        struct bt_ctf_writer *writer = cw->writer;
+#define ADD(__n, __v)                                                   \
+do {                                                                    \
+        if (bt_ctf_writer_add_environment_field(writer, __n, __v))      \
+                return -1;                                              \
+} while (0)
+        ADD("host",    header->env.hostname);
+        ADD("sysname", "Linux");
+        ADD("release", header->env.os_release);
+        ADD("version", header->env.version);
+        ADD("machine", header->env.arch);
+        ADD("domain", "kernel");
+        ADD("tracer_name", "perf");
+#undef ADD
+        return 0;
+}
+static int ctf_writer__setup_clock(struct ctf_writer *cw)
+{
+        struct bt_ctf_clock *clock = cw->clock;
+        bt_ctf_clock_set_description(clock, "perf clock");
+#define SET(__n, __v)                           \
+do {                                            \
+        if (bt_ctf_clock_set_##__n(clock, __v)) \
+                return -1;                      \
+} while (0)
+        SET(frequency,   1000000000);
+        SET(offset_s,    0);
+        SET(offset,      0);
+        SET(precision,   10);
+        SET(is_absolute, 0);
+#undef SET
+        return 0;
+}
+static struct bt_ctf_field_type *create_int_type(int size, bool sign, bool hex)
+{
+        struct bt_ctf_field_type *type;
+        type = bt_ctf_field_type_integer_create(size);
+        if (!type)
+                return NULL;
+        if (sign &&
+            bt_ctf_field_type_integer_set_signed(type, 1))
+                goto err;
+        if (hex &&
+            bt_ctf_field_type_integer_set_base(type, BT_CTF_INTEGER_BASE_HEXADECIMAL))
+                goto err;
+        pr2("Created type: INTEGER %d-bit %ssigned %s\n",
+            size, sign ? "un" : "", hex ? "hex" : "");
+        return type;
+err:
+        bt_ctf_field_type_put(type);
+        return NULL;
+}
+static void ctf_writer__cleanup_data(struct ctf_writer *cw)
+{
+        unsigned int i;
+        for (i = 0; i < ARRAY_SIZE(cw->data.array); i++)
+                bt_ctf_field_type_put(cw->data.array[i]);
+}
+static int ctf_writer__init_data(struct ctf_writer *cw)
+{
+#define CREATE_INT_TYPE(type, size, sign, hex)          \
+do {                                                    \
+        (type) = create_int_type(size, sign, hex);      \
+        if (!(type))                                    \
+                goto err;                               \
+} while (0)
+        CREATE_INT_TYPE(cw->data.s64, 64, true,  false);
+        CREATE_INT_TYPE(cw->data.u64, 64, false, false);
+        CREATE_INT_TYPE(cw->data.s32, 32, true,  false);
+        CREATE_INT_TYPE(cw->data.u32, 32, false, false);
+        CREATE_INT_TYPE(cw->data.u64_hex, 64, false, true);
+        cw->data.string  = bt_ctf_field_type_string_create();
+        if (cw->data.string)
+                return 0;
+err:
+        ctf_writer__cleanup_data(cw);
+        pr_err("Failed to create data types.\n");
+        return -1;
+}
+static void ctf_writer__cleanup(struct ctf_writer *cw)
+{
+        ctf_writer__cleanup_data(cw);
+        bt_ctf_clock_put(cw->clock);
+        bt_ctf_stream_put(cw->stream);
+        bt_ctf_stream_class_put(cw->stream_class);
+        bt_ctf_writer_put(cw->writer);
+        /* and NULL all the pointers */
+        memset(cw, 0, sizeof(*cw));
+}
+static int ctf_writer__init(struct ctf_writer *cw, const char *path)
+{
+        struct bt_ctf_writer            *writer;
+        struct bt_ctf_stream_class      *stream_class;
+        struct bt_ctf_stream            *stream;
+        struct bt_ctf_clock             *clock;
+        /* CTF writer */
+        writer = bt_ctf_writer_create(path);
+        if (!writer)
+                goto err;
+        cw->writer = writer;
+        /* CTF clock */
+        clock = bt_ctf_clock_create("perf_clock");
+        if (!clock) {
+                pr("Failed to create CTF clock.\n");
+                goto err_cleanup;
+        }
+        cw->clock = clock;
+        if (ctf_writer__setup_clock(cw)) {
+                pr("Failed to setup CTF clock.\n");
+                goto err_cleanup;
+        }
+        /* CTF stream class */
+        stream_class = bt_ctf_stream_class_create("perf_stream");
+        if (!stream_class) {
+                pr("Failed to create CTF stream class.\n");
+                goto err_cleanup;
+        }
+        cw->stream_class = stream_class;
+        /* CTF clock stream setup */
+        if (bt_ctf_stream_class_set_clock(stream_class, clock)) {
+                pr("Failed to assign CTF clock to stream class.\n");
+                goto err_cleanup;
+        }
+        if (ctf_writer__init_data(cw))
+                goto err_cleanup;
+        /* CTF stream instance */
+        stream = bt_ctf_writer_create_stream(writer, stream_class);
+        if (!stream) {
+                pr("Failed to create CTF stream.\n");
+                goto err_cleanup;
+        }
+        cw->stream = stream;
+        /* CTF clock writer setup */
+        if (bt_ctf_writer_add_clock(writer, clock)) {
+                pr("Failed to assign CTF clock to writer.\n");
+                goto err_cleanup;
+        }
+        return 0;
+err_cleanup:
+        ctf_writer__cleanup(cw);
+err:
+        pr_err("Failed to setup CTF writer.\n");
+        return -1;
+}
+int bt_convert__perf2ctf(const char *input, const char *path)
+{
+        struct perf_session *session;
+        struct perf_data_file file = {
+                .path = input,
+                .mode = PERF_DATA_MODE_READ,
+        };
+        struct convert c = {
+                .tool = {
+                        .sample          = process_sample_event,
+                        .mmap            = perf_event__process_mmap,
+                        .mmap2           = perf_event__process_mmap2,
+                        .comm            = perf_event__process_comm,
+                        .exit            = perf_event__process_exit,
+                        .fork            = perf_event__process_fork,
+                        .lost            = perf_event__process_lost,
+                        .tracing_data    = perf_event__process_tracing_data,
+                        .build_id        = perf_event__process_build_id,
+                        .ordered_events  = true,
+                        .ordering_requires_timestamps = true,
+                },
+        };
+        struct ctf_writer *cw = &c.writer;
+        int err = -1;
+        /* CTF writer */
+        if (ctf_writer__init(cw, path))
+                return -1;
+        /* perf.data session */
+        session = perf_session__new(&file, 0, &c.tool);
+        if (!session)
+                goto free_writer;
+        /* CTF writer env/clock setup  */
+        if (ctf_writer__setup_env(cw, session))
+                goto free_session;
+        /* CTF events setup */
+        if (setup_events(cw, session))
+                goto free_session;
+        err = perf_session__process_events(session);
+        if (!err)
+                err = bt_ctf_stream_flush(cw->stream);
+        fprintf(stderr,
+                "[ perf data convert: Converted '%s' into CTF data '%s' ]\n",
+                file.path, path);
+        fprintf(stderr,
+                "[ perf data convert: Converted and wrote %.3f MB (%" PRIu64 " samples) ]\n",
+                (double) c.events_size / 1024.0 / 1024.0,
+                c.events_count);
+        /* its all good */
+free_session:
+        perf_session__delete(session);
+free_writer:
+        ctf_writer__cleanup(cw);
+        return err;
+}
diff --git a/tools/perf/util/data-convert-bt.h b/tools/perf/util/data-convert-bt.h
new file mode 100644
index 000000000000..dda30c5d0792
--- /dev/null
+++ b/tools/perf/util/data-convert-bt.h
@@ -0,0 +1,8 @@
+#ifndef __DATA_CONVERT_BT_H
+#define __DATA_CONVERT_BT_H
+#ifdef HAVE_LIBBABELTRACE_SUPPORT
+int bt_convert__perf2ctf(const char *input_name, const char *to_ctf);
+#endif /* HAVE_LIBBABELTRACE_SUPPORT */
+#endif /* __DATA_CONVERT_BT_H */
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index ad60b2f20258..2da5581ec74d 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -20,6 +20,7 @@ int verbose;
 bool dump_trace = false, quiet = false;
 int debug_ordered_events;
 static int redirect_to_stderr;
+int debug_data_convert;
 static int _eprintf(int level, int var, const char *fmt, va_list args)
 {
@@ -147,6 +148,7 @@ static struct debug_variable {
        { .name = "verbose",            .ptr = &verbose },
        { .name = "ordered-events",     .ptr = &debug_ordered_events},
        { .name = "stderr",             .ptr = &redirect_to_stderr},
+        { .name = "data-convert",       .ptr = &debug_data_convert },
        { .name = NULL, }
 };
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index be264d6f3b30..caac2fdc6105 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -12,6 +12,7 @@
 extern int verbose;
 extern bool quiet, dump_trace;
 extern int debug_ordered_events;
+extern int debug_data_convert;
 #ifndef pr_fmt
 #define pr_fmt(fmt) fmt
diff --git a/tools/perf/util/dso.c b/tools/perf/util/dso.c
index c2f7d3b90966..fc0ddd5792a9 100644
--- a/tools/perf/util/dso.c
+++ b/tools/perf/util/dso.c
@@ -45,13 +45,13 @@ int dso__read_binary_type_filename(const struct dso *dso,
        case DSO_BINARY_TYPE__DEBUGLINK: {
                char *debuglink;
-                strncpy(filename, dso->long_name, size);
+                len = __symbol__join_symfs(filename, size, dso->long_name);
-                debuglink = filename + dso->long_name_len;
+                debuglink = filename + len;
                while (debuglink != filename && *debuglink != '/')
                        debuglink--;
                if (*debuglink == '/')
                        debuglink++;
-                ret = filename__read_debuglink(dso->long_name, debuglink,
+                ret = filename__read_debuglink(filename, debuglink,
                                               size - (debuglink - filename));
                }
                break;
@@ -148,6 +148,9 @@ static const struct {
 #ifdef HAVE_ZLIB_SUPPORT
        { "gz", gzip_decompress_to_file },
 #endif
+#ifdef HAVE_LZMA_SUPPORT
+        { "xz", lzma_decompress_to_file },
+#endif
        { NULL, NULL },
 };
@@ -162,32 +165,14 @@ bool is_supported_compression(const char *ext)
        return false;
 }
-bool is_kmodule_extension(const char *ext)
+bool is_kernel_module(const char *pathname)
-{
-        if (strncmp(ext, "ko", 2))
-                return false;
-        if (ext[2] == '\0' || (ext[2] == '.' && is_supported_compression(ext+3)))
-                return true;
-        return false;
-}
-bool is_kernel_module(const char *pathname, bool *compressed)
 {
-        const char *ext = strrchr(pathname, '.');
+        struct kmod_path m;
-        if (ext == NULL)
+        if (kmod_path__parse(&m, pathname))
-                return false;
+                return NULL;
-        if (is_supported_compression(ext + 1)) {
-                if (compressed)
-                        *compressed = true;
-                ext -= 3;
-        } else if (compressed)
-                *compressed = false;
-        return is_kmodule_extension(ext + 1);
+        return m.kmod;
 }
 bool decompress_to_file(const char *ext, const char *filename, int output_fd)
@@ -209,6 +194,72 @@ bool dso__needs_decompress(struct dso *dso)
 }
 /*
+ * Parses kernel module specified in @path and updates
+ * @m argument like:
+ *
+ *    @comp - true if @path contains supported compression suffix,
+ *            false otherwise
+ *    @kmod - true if @path contains '.ko' suffix in right position,
+ *            false otherwise
+ *    @name - if (@alloc_name && @kmod) is true, it contains strdup-ed base name
+ *            of the kernel module without suffixes, otherwise strudup-ed
+ *            base name of @path
+ *    @ext  - if (@alloc_ext && @comp) is true, it contains strdup-ed string
+ *            the compression suffix
+ *
+ * Returns 0 if there's no strdup error, -ENOMEM otherwise.
+ */
+int __kmod_path__parse(struct kmod_path *m, const char *path,
+                       bool alloc_name, bool alloc_ext)
+{
+        const char *name = strrchr(path, '/');
+        const char *ext  = strrchr(path, '.');
+        memset(m, 0x0, sizeof(*m));
+        name = name ? name + 1 : path;
+        /* No extension, just return name. */
+        if (ext == NULL) {
+                if (alloc_name) {
+                        m->name = strdup(name);
+                        return m->name ? 0 : -ENOMEM;
+                }
+                return 0;
+        }
+        if (is_supported_compression(ext + 1)) {
+                m->comp = true;
+                ext -= 3;
+        }
+        /* Check .ko extension only if there's enough name left. */
+        if (ext > name)
+                m->kmod = !strncmp(ext, ".ko", 3);
+        if (alloc_name) {
+                if (m->kmod) {
+                        if (asprintf(&m->name, "[%.*s]", (int) (ext - name), name) == -1)
+                                return -ENOMEM;
+                } else {
+                        if (asprintf(&m->name, "%s", name) == -1)
+                                return -ENOMEM;
+                }
+                strxfrchar(m->name, '-', '_');
+        }
+        if (alloc_ext && m->comp) {
+                m->ext = strdup(ext + 4);
+                if (!m->ext) {
+                        free((void *) m->name);
+                        return -ENOMEM;
+                }
+        }
+        return 0;
+}
+/*
 * Global list of open DSOs and the counter.
 */
 static LIST_HEAD(dso__data_open);
@@ -240,7 +291,7 @@ static int do_open(char *name)
                if (fd >= 0)
                        return fd;
-                pr_debug("dso open failed, mmap: %s\n",
+                pr_debug("dso open failed: %s\n",
                         strerror_r(errno, sbuf, sizeof(sbuf)));
                if (!dso__data_open_cnt || errno != EMFILE)
                        break;
@@ -1002,21 +1053,24 @@ struct dso *dsos__find(const struct dsos *dsos, const char *name,
        return dso__find_by_longname(&dsos->root, name);
 }
-struct dso *__dsos__findnew(struct dsos *dsos, const char *name)
+struct dso *dsos__addnew(struct dsos *dsos, const char *name)
 {
-        struct dso *dso = dsos__find(dsos, name, false);
+        struct dso *dso = dso__new(name);
-        if (!dso) {
+        if (dso != NULL) {
-                dso = dso__new(name);
+                dsos__add(dsos, dso);
-                if (dso != NULL) {
+                dso__set_basename(dso);
-                        dsos__add(dsos, dso);
-                        dso__set_basename(dso);
-                }
        }
        return dso;
 }
+struct dso *__dsos__findnew(struct dsos *dsos, const char *name)
+{
+        struct dso *dso = dsos__find(dsos, name, false);
+        return dso ? dso : dsos__addnew(dsos, name);
+}
 size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
                               bool (skip)(struct dso *dso, int parm), int parm)
 {
@@ -1083,3 +1137,36 @@ enum dso_type dso__type(struct dso *dso, struct machine *machine)
        return dso__type_fd(fd);
 }
+int dso__strerror_load(struct dso *dso, char *buf, size_t buflen)
+{
+        int idx, errnum = dso->load_errno;
+        /*
+         * This must have a same ordering as the enum dso_load_errno.
+         */
+        static const char *dso_load__error_str[] = {
+        "Internal tools/perf/ library error",
+        "Invalid ELF file",
+        "Can not read build id",
+        "Mismatching build id",
+        "Decompression failure",
+        };
+        BUG_ON(buflen == 0);
+        if (errnum >= 0) {
+                const char *err = strerror_r(errnum, buf, buflen);
+                if (err != buf)
+                        scnprintf(buf, buflen, "%s", err);
+                return 0;
+        }
+        if (errnum <  __DSO_LOAD_ERRNO__START || errnum >= __DSO_LOAD_ERRNO__END)
+                return -1;
+        idx = errnum - __DSO_LOAD_ERRNO__START;
+        scnprintf(buf, buflen, "%s", dso_load__error_str[idx]);
+        return 0;
+}
diff --git a/tools/perf/util/dso.h b/tools/perf/util/dso.h
index ced92841ff97..e0901b4ed8de 100644
--- a/tools/perf/util/dso.h
+++ b/tools/perf/util/dso.h
@@ -60,6 +60,31 @@ enum dso_type {
        DSO__TYPE_X32BIT,
 };
+enum dso_load_errno {
+        DSO_LOAD_ERRNO__SUCCESS         = 0,
+        /*
+         * Choose an arbitrary negative big number not to clash with standard
+         * errno since SUS requires the errno has distinct positive values.
+         * See 'Issue 6' in the link below.
+         *
+         * http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html
+         */
+        __DSO_LOAD_ERRNO__START         = -10000,
+        DSO_LOAD_ERRNO__INTERNAL_ERROR  = __DSO_LOAD_ERRNO__START,
+        /* for symsrc__init() */
+        DSO_LOAD_ERRNO__INVALID_ELF,
+        DSO_LOAD_ERRNO__CANNOT_READ_BUILDID,
+        DSO_LOAD_ERRNO__MISMATCHING_BUILDID,
+        /* for decompress_kmodule */
+        DSO_LOAD_ERRNO__DECOMPRESSION_FAILURE,
+        __DSO_LOAD_ERRNO__END,
+};
 #define DSO__SWAP(dso, type, val)                       \
 ({                                                      \
        type ____r = val;                               \
@@ -113,6 +138,7 @@ struct dso {
        enum dso_swap_type      needs_swap;
        enum dso_binary_type    symtab_type;
        enum dso_binary_type    binary_type;
+        enum dso_load_errno     load_errno;
        u8               adjust_symbols:1;
        u8               has_build_id:1;
        u8               has_srcline:1;
@@ -139,7 +165,8 @@ struct dso {
                u32              status_seen;
                size_t           file_size;
                struct list_head open_entry;
-                u64              frame_offset;
+                u64              debug_frame_offset;
+                u64              eh_frame_hdr_offset;
        } data;
        union { /* Tool specific area */
@@ -189,11 +216,24 @@ char dso__symtab_origin(const struct dso *dso);
 int dso__read_binary_type_filename(const struct dso *dso, enum dso_binary_type type,
                                   char *root_dir, char *filename, size_t size);
 bool is_supported_compression(const char *ext);
-bool is_kmodule_extension(const char *ext);
+bool is_kernel_module(const char *pathname);
-bool is_kernel_module(const char *pathname, bool *compressed);
 bool decompress_to_file(const char *ext, const char *filename, int output_fd);
 bool dso__needs_decompress(struct dso *dso);
+struct kmod_path {
+        char *name;
+        char *ext;
+        bool  comp;
+        bool  kmod;
+};
+int __kmod_path__parse(struct kmod_path *m, const char *path,
+                     bool alloc_name, bool alloc_ext);
+#define kmod_path__parse(__m, __p)      __kmod_path__parse(__m, __p, false, false)
+#define kmod_path__parse_name(__m, __p) __kmod_path__parse(__m, __p, true , false)
+#define kmod_path__parse_ext(__m, __p)  __kmod_path__parse(__m, __p, false, true)
 /*
 * The dso__data_* external interface provides following functions:
 *   dso__data_fd
@@ -249,6 +289,7 @@ struct dso *dso__kernel_findnew(struct machine *machine, const char *name,
                                const char *short_name, int dso_type);
 void dsos__add(struct dsos *dsos, struct dso *dso);
+struct dso *dsos__addnew(struct dsos *dsos, const char *name);
 struct dso *dsos__find(const struct dsos *dsos, const char *name,
                       bool cmp_short);
 struct dso *__dsos__findnew(struct dsos *dsos, const char *name);
@@ -279,4 +320,6 @@ void dso__free_a2l(struct dso *dso);
 enum dso_type dso__type(struct dso *dso, struct machine *machine);
+int dso__strerror_load(struct dso *dso, char *buf, size_t buflen);
 #endif /* __PERF_DSO */
diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c
index cc66c4049e09..780b2bc11128 100644
--- a/tools/perf/util/dwarf-aux.c
+++ b/tools/perf/util/dwarf-aux.c
@@ -278,6 +278,21 @@ bool die_is_func_def(Dwarf_Die *dw_die)
 }
 /**
+ * die_is_func_instance - Ensure that this DIE is an instance of a subprogram
+ * @dw_die: a DIE
+ *
+ * Ensure that this DIE is an instance (which has an entry address).
+ * This returns true if @dw_die is a function instance. If not, you need to
+ * call die_walk_instances() to find actual instances.
+ **/
+bool die_is_func_instance(Dwarf_Die *dw_die)
+{
+        Dwarf_Addr tmp;
+        /* Actually gcc optimizes non-inline as like as inlined */
+        return !dwarf_func_inline(dw_die) && dwarf_entrypc(dw_die, &tmp) == 0;
+}
+/**
 * die_get_data_member_location - Get the data-member offset
 * @mb_die: a DIE of a member of a data structure
 * @offs: The offset of the member in the data structure
diff --git a/tools/perf/util/dwarf-aux.h b/tools/perf/util/dwarf-aux.h
index b4fe90c6cb2d..af7dbcd5f929 100644
--- a/tools/perf/util/dwarf-aux.h
+++ b/tools/perf/util/dwarf-aux.h
@@ -41,6 +41,9 @@ extern int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
 /* Ensure that this DIE is a subprogram and definition (not declaration) */
 extern bool die_is_func_def(Dwarf_Die *dw_die);
+/* Ensure that this DIE is an instance of a subprogram */
+extern bool die_is_func_instance(Dwarf_Die *dw_die);
 /* Compare diename and tname */
 extern bool die_compare_name(Dwarf_Die *dw_die, const char *tname);
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 6c6d044e959a..d5efa5092ce6 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -95,9 +95,7 @@ static pid_t perf_event__get_comm_tgid(pid_t pid, char *comm, size_t len)
        return tgid;
 }
-static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
+static pid_t perf_event__prepare_comm(union perf_event *event, pid_t pid,
-                                         union perf_event *event, pid_t pid,
-                                         perf_event__handler_t process,
                                         struct machine *machine)
 {
        size_t size;
@@ -124,6 +122,19 @@ static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
                                (sizeof(event->comm.comm) - size) +
                                machine->id_hdr_size);
        event->comm.tid = pid;
+out:
+        return tgid;
+}
+static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
+                                         union perf_event *event, pid_t pid,
+                                         perf_event__handler_t process,
+                                         struct machine *machine)
+{
+        pid_t tgid = perf_event__prepare_comm(event, pid, machine);
+        if (tgid == -1)
+                goto out;
        if (process(tool, event, &synth_sample, machine) != 0)
                return -1;
@@ -139,7 +150,6 @@ static int perf_event__synthesize_fork(struct perf_tool *tool,
 {
        memset(&event->fork, 0, sizeof(event->fork) + machine->id_hdr_size);
-        /* this is really a clone event but we use fork to synthesize it */
        event->fork.ppid = tgid;
        event->fork.ptid = tgid;
        event->fork.pid  = tgid;
@@ -368,19 +378,23 @@ static int __event__synthesize_thread(union perf_event *comm_event,
                if (*end)
                        continue;
-                tgid = perf_event__synthesize_comm(tool, comm_event, _pid,
+                tgid = perf_event__prepare_comm(comm_event, _pid, machine);
-                                                   process, machine);
                if (tgid == -1)
                        return -1;
+                if (perf_event__synthesize_fork(tool, fork_event, _pid, tgid,
+                                                process, machine) < 0)
+                        return -1;
+                /*
+                 * Send the prepared comm event
+                 */
+                if (process(tool, comm_event, &synth_sample, machine) != 0)
+                        return -1;
                if (_pid == pid) {
                        /* process the parent's maps too */
                        rc = perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid,
                                                process, machine, mmap_data);
-                } else {
-                        /* only fork the tid's map, to save time */
-                        rc = perf_event__synthesize_fork(tool, fork_event, _pid, tgid,
-                                                 process, machine);
                }
                if (rc)
@@ -615,7 +629,7 @@ size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp)
        else
                s = "";
-        return fprintf(fp, "%s: %s:%d\n", s, event->comm.comm, event->comm.tid);
+        return fprintf(fp, "%s: %s:%d/%d\n", s, event->comm.comm, event->comm.pid, event->comm.tid);
 }
 int perf_event__process_comm(struct perf_tool *tool __maybe_unused,
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 28b8ce86bf12..82bf224bbee9 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -7,7 +7,6 @@
 * Released under the GPL v2. (and only v2, not any later version)
 */
 #include "util.h"
-#include <api/fs/debugfs.h>
 #include <api/fs/fs.h>
 #include <poll.h>
 #include "cpumap.h"
@@ -1051,7 +1050,7 @@ out_delete_threads:
        return -1;
 }
-int perf_evlist__apply_filters(struct perf_evlist *evlist)
+int perf_evlist__apply_filters(struct perf_evlist *evlist, struct perf_evsel **err_evsel)
 {
        struct perf_evsel *evsel;
        int err = 0;
@@ -1063,8 +1062,10 @@ int perf_evlist__apply_filters(struct perf_evlist *evlist)
                        continue;
                err = perf_evsel__set_filter(evsel, ncpus, nthreads, evsel->filter);
-                if (err)
+                if (err) {
+                        *err_evsel = evsel;
                        break;
+                }
        }
        return err;
@@ -1086,6 +1087,38 @@ int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
        return err;
 }
+int perf_evlist__set_filter_pids(struct perf_evlist *evlist, size_t npids, pid_t *pids)
+{
+        char *filter;
+        int ret = -1;
+        size_t i;
+        for (i = 0; i < npids; ++i) {
+                if (i == 0) {
+                        if (asprintf(&filter, "common_pid != %d", pids[i]) < 0)
+                                return -1;
+                } else {
+                        char *tmp;
+                        if (asprintf(&tmp, "%s && common_pid != %d", filter, pids[i]) < 0)
+                                goto out_free;
+                        free(filter);
+                        filter = tmp;
+                }
+        }
+        ret = perf_evlist__set_filter(evlist, filter);
+out_free:
+        free(filter);
+        return ret;
+}
+int perf_evlist__set_filter_pid(struct perf_evlist *evlist, pid_t pid)
+{
+        return perf_evlist__set_filter_pids(evlist, 1, &pid);
+}
 bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
 {
        struct perf_evsel *pos;
@@ -1329,7 +1362,7 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *tar
                 * writing exactly one byte, in workload.cork_fd, usually via
                 * perf_evlist__start_workload().
                 *
-                 * For cancelling the workload without actuallin running it,
+                 * For cancelling the workload without actually running it,
                 * the parent will just close workload.cork_fd, without writing
                 * anything, i.e. read will return zero and we just exit()
                 * here.
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index e99a67632831..fb19c47b8aac 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -51,6 +51,7 @@ struct perf_evlist {
        struct thread_map *threads;
        struct cpu_map    *cpus;
        struct perf_evsel *selected;
+        struct events_stats stats;
 };
 struct perf_evsel_str_handler {
@@ -77,6 +78,8 @@ int perf_evlist__add_newtp(struct perf_evlist *evlist,
                           const char *sys, const char *name, void *handler);
 int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter);
+int perf_evlist__set_filter_pid(struct perf_evlist *evlist, pid_t pid);
+int perf_evlist__set_filter_pids(struct perf_evlist *evlist, size_t npids, pid_t *pids);
 struct perf_evsel *
 perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id);
@@ -149,7 +152,7 @@ static inline void perf_evlist__set_maps(struct perf_evlist *evlist,
 }
 int perf_evlist__create_maps(struct perf_evlist *evlist, struct target *target);
-int perf_evlist__apply_filters(struct perf_evlist *evlist);
+int perf_evlist__apply_filters(struct perf_evlist *evlist, struct perf_evsel **err_evsel);
 void __perf_evlist__set_leader(struct list_head *list);
 void perf_evlist__set_leader(struct perf_evlist *evlist);
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index ea51a90e20a0..358e5954baa8 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -537,13 +537,30 @@ int perf_evsel__group_desc(struct perf_evsel *evsel, char *buf, size_t size)
 }
 static void
-perf_evsel__config_callgraph(struct perf_evsel *evsel)
+perf_evsel__config_callgraph(struct perf_evsel *evsel,
+                             struct record_opts *opts)
 {
        bool function = perf_evsel__is_function_event(evsel);
        struct perf_event_attr *attr = &evsel->attr;
        perf_evsel__set_sample_bit(evsel, CALLCHAIN);
+        if (callchain_param.record_mode == CALLCHAIN_LBR) {
+                if (!opts->branch_stack) {
+                        if (attr->exclude_user) {
+                                pr_warning("LBR callstack option is only available "
+                                           "to get user callchain information. "
+                                           "Falling back to framepointers.\n");
+                        } else {
+                                perf_evsel__set_sample_bit(evsel, BRANCH_STACK);
+                                attr->branch_sample_type = PERF_SAMPLE_BRANCH_USER |
+                                                        PERF_SAMPLE_BRANCH_CALL_STACK;
+                        }
+                } else
+                         pr_warning("Cannot use LBR callstack with branch stack. "
+                                    "Falling back to framepointers.\n");
+        }
        if (callchain_param.record_mode == CALLCHAIN_DWARF) {
                if (!function) {
                        perf_evsel__set_sample_bit(evsel, REGS_USER);
@@ -667,7 +684,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
                evsel->attr.exclude_callchain_user = 1;
        if (callchain_param.enabled && !evsel->no_aux_samples)
-                perf_evsel__config_callgraph(evsel);
+                perf_evsel__config_callgraph(evsel, opts);
        if (opts->sample_intr_regs) {
                attr->sample_regs_intr = PERF_REGS_MASK;
@@ -717,6 +734,12 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
        if (opts->sample_transaction)
                perf_evsel__set_sample_bit(evsel, TRANSACTION);
+        if (opts->running_time) {
+                evsel->attr.read_format |=
+                        PERF_FORMAT_TOTAL_TIME_ENABLED |
+                        PERF_FORMAT_TOTAL_TIME_RUNNING;
+        }
        /*
         * XXX see the function comment above
         *
@@ -1892,7 +1915,7 @@ u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
                value = *(u32 *)ptr;
                break;
        case 8:
-                value = *(u64 *)ptr;
+                memcpy(&value, ptr, sizeof(u64));
                break;
        default:
                return 0;
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 38622747d130..dcf202aebe9f 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -355,4 +355,8 @@ for ((_evsel) = list_entry((_leader)->node.next, struct perf_evsel, node); 	\
     (_evsel) && (_evsel)->leader == (_leader);                                 \
     (_evsel) = list_entry((_evsel)->node.next, struct perf_evsel, node))
+static inline bool has_branch_callstack(struct perf_evsel *evsel)
+{
+        return evsel->attr.branch_sample_type & PERF_SAMPLE_BRANCH_CALL_STACK;
+}
 #endif /* __PERF_EVSEL_H */
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 1f407f7352a7..fb432153e2aa 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -1266,7 +1266,7 @@ static int __event_process_build_id(struct build_id_event *bev,
                dso__set_build_id(dso, &bev->build_id);
-                if (!is_kernel_module(filename, NULL))
+                if (!is_kernel_module(filename))
                        dso->kernel = dso_type;
                build_id__sprintf(dso->build_id, sizeof(dso->build_id),
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 70b48a65064c..cc22b9158b93 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -263,15 +263,9 @@ void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
        while (next) {
                n = rb_entry(next, struct hist_entry, rb_node);
                next = rb_next(&n->rb_node);
-                /*
-                 * We may be annotating this, for instance, so keep it here in
-                 * case some it gets new samples, we'll eventually free it when
-                 * the user stops browsing and it agains gets fully decayed.
-                 */
                if (((zap_user && n->level == '.') ||
                     (zap_kernel && n->level != '.') ||
-                     hists__decay_entry(hists, n)) &&
+                     hists__decay_entry(hists, n))) {
-                    !n->used) {
                        hists__delete_entry(hists, n);
                }
        }
@@ -355,6 +349,7 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template,
                        callchain_init(he->callchain);
                INIT_LIST_HEAD(&he->pairs.node);
+                thread__get(he->thread);
        }
        return he;
@@ -941,6 +936,7 @@ hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
 void hist_entry__delete(struct hist_entry *he)
 {
+        thread__zput(he->thread);
        zfree(&he->branch_info);
        zfree(&he->mem_info);
        zfree(&he->stat_acc);
@@ -1169,6 +1165,7 @@ static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h
        /* force fold unfiltered entry for simplicity */
        h->ms.unfolded = false;
        h->row_offset = 0;
+        h->nr_rows = 0;
        hists->stats.nr_non_filtered_samples += h->stat.nr_events;
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 2b690d028907..9f31b89a527a 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -60,7 +60,7 @@ struct hists {
        struct rb_root          entries_collapsed;
        u64                     nr_entries;
        u64                     nr_non_filtered_entries;
-        const struct thread     *thread_filter;
+        struct thread           *thread_filter;
        const struct dso        *dso_filter;
        const char              *uid_filter_str;
        const char              *symbol_filter_str;
@@ -303,6 +303,9 @@ struct hist_browser_timer {
 #ifdef HAVE_SLANG_SUPPORT
 #include "../ui/keysyms.h"
+int map_symbol__tui_annotate(struct map_symbol *ms, struct perf_evsel *evsel,
+                             struct hist_browser_timer *hbt);
 int hist_entry__tui_annotate(struct hist_entry *he, struct perf_evsel *evsel,
                             struct hist_browser_timer *hbt);
@@ -321,6 +324,12 @@ int perf_evlist__tui_browse_hists(struct perf_evlist *evlist __maybe_unused,
 {
        return 0;
 }
+static inline int map_symbol__tui_annotate(struct map_symbol *ms __maybe_unused,
+                                           struct perf_evsel *evsel __maybe_unused,
+                                           struct hist_browser_timer *hbt __maybe_unused)
+{
+        return 0;
+}
 static inline int hist_entry__tui_annotate(struct hist_entry *he __maybe_unused,
                                           struct perf_evsel *evsel __maybe_unused,
diff --git a/tools/perf/util/lzma.c b/tools/perf/util/lzma.c
new file mode 100644
index 000000000000..95a1acb61245
--- /dev/null
+++ b/tools/perf/util/lzma.c
@@ -0,0 +1,95 @@
+#include <lzma.h>
+#include <stdio.h>
+#include <linux/compiler.h>
+#include "util.h"
+#include "debug.h"
+#define BUFSIZE 8192
+static const char *lzma_strerror(lzma_ret ret)
+{
+        switch ((int) ret) {
+        case LZMA_MEM_ERROR:
+                return "Memory allocation failed";
+        case LZMA_OPTIONS_ERROR:
+                return "Unsupported decompressor flags";
+        case LZMA_FORMAT_ERROR:
+                return "The input is not in the .xz format";
+        case LZMA_DATA_ERROR:
+                return "Compressed file is corrupt";
+        case LZMA_BUF_ERROR:
+                return "Compressed file is truncated or otherwise corrupt";
+        default:
+                return "Unknown error, possibly a bug";
+        }
+}
+int lzma_decompress_to_file(const char *input, int output_fd)
+{
+        lzma_action action = LZMA_RUN;
+        lzma_stream strm   = LZMA_STREAM_INIT;
+        lzma_ret ret;
+        u8 buf_in[BUFSIZE];
+        u8 buf_out[BUFSIZE];
+        FILE *infile;
+        infile = fopen(input, "rb");
+        if (!infile) {
+                pr_err("lzma: fopen failed on %s: '%s'\n",
+                       input, strerror(errno));
+                return -1;
+        }
+        ret = lzma_stream_decoder(&strm, UINT64_MAX, LZMA_CONCATENATED);
+        if (ret != LZMA_OK) {
+                pr_err("lzma: lzma_stream_decoder failed %s (%d)\n",
+                        lzma_strerror(ret), ret);
+                return -1;
+        }
+        strm.next_in   = NULL;
+        strm.avail_in  = 0;
+        strm.next_out  = buf_out;
+        strm.avail_out = sizeof(buf_out);
+        while (1) {
+                if (strm.avail_in == 0 && !feof(infile)) {
+                        strm.next_in  = buf_in;
+                        strm.avail_in = fread(buf_in, 1, sizeof(buf_in), infile);
+                        if (ferror(infile)) {
+                                pr_err("lzma: read error: %s\n", strerror(errno));
+                                return -1;
+                        }
+                        if (feof(infile))
+                                action = LZMA_FINISH;
+                }
+                ret = lzma_code(&strm, action);
+                if (strm.avail_out == 0 || ret == LZMA_STREAM_END) {
+                        ssize_t write_size = sizeof(buf_out) - strm.avail_out;
+                        if (writen(output_fd, buf_out, write_size) != write_size) {
+                                pr_err("lzma: write error: %s\n", strerror(errno));
+                                return -1;
+                        }
+                        strm.next_out  = buf_out;
+                        strm.avail_out = sizeof(buf_out);
+                }
+                if (ret != LZMA_OK) {
+                        if (ret == LZMA_STREAM_END)
+                                return 0;
+                        pr_err("lzma: failed %s\n", lzma_strerror(ret));
+                        return -1;
+                }
+        }
+        fclose(infile);
+        return 0;
+}
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 1bca3a9f2b16..e3353307330c 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -14,6 +14,8 @@
 #include "unwind.h"
 #include "linux/hash.h"
+static void machine__remove_thread(struct machine *machine, struct thread *th);
 static void dsos__init(struct dsos *dsos)
 {
        INIT_LIST_HEAD(&dsos->head);
@@ -89,16 +91,6 @@ static void dsos__delete(struct dsos *dsos)
        }
 }
-void machine__delete_dead_threads(struct machine *machine)
-{
-        struct thread *n, *t;
-        list_for_each_entry_safe(t, n, &machine->dead_threads, node) {
-                list_del(&t->node);
-                thread__delete(t);
-        }
-}
 void machine__delete_threads(struct machine *machine)
 {
        struct rb_node *nd = rb_first(&machine->threads);
@@ -106,9 +98,8 @@ void machine__delete_threads(struct machine *machine)
        while (nd) {
                struct thread *t = rb_entry(nd, struct thread, rb_node);
-                rb_erase(&t->rb_node, &machine->threads);
                nd = rb_next(nd);
-                thread__delete(t);
+                machine__remove_thread(machine, t);
        }
 }
@@ -361,9 +352,13 @@ static struct thread *__machine__findnew_thread(struct machine *machine,
         * the full rbtree:
         */
        th = machine->last_match;
-        if (th && th->tid == tid) {
+        if (th != NULL) {
-                machine__update_thread_pid(machine, th, pid);
+                if (th->tid == tid) {
-                return th;
+                        machine__update_thread_pid(machine, th, pid);
+                        return th;
+                }
+                thread__zput(machine->last_match);
        }
        while (*p != NULL) {
@@ -371,7 +366,7 @@ static struct thread *__machine__findnew_thread(struct machine *machine,
                th = rb_entry(parent, struct thread, rb_node);
                if (th->tid == tid) {
-                        machine->last_match = th;
+                        machine->last_match = thread__get(th);
                        machine__update_thread_pid(machine, th, pid);
                        return th;
                }
@@ -403,8 +398,11 @@ static struct thread *__machine__findnew_thread(struct machine *machine,
                        thread__delete(th);
                        return NULL;
                }
+                /*
-                machine->last_match = th;
+                 * It is now in the rbtree, get a ref
+                 */
+                thread__get(th);
+                machine->last_match = thread__get(th);
        }
        return th;
@@ -462,30 +460,61 @@ int machine__process_lost_event(struct machine *machine __maybe_unused,
        return 0;
 }
+static struct dso*
+machine__module_dso(struct machine *machine, struct kmod_path *m,
+                    const char *filename)
+{
+        struct dso *dso;
+        dso = dsos__find(&machine->kernel_dsos, m->name, true);
+        if (!dso) {
+                dso = dsos__addnew(&machine->kernel_dsos, m->name);
+                if (dso == NULL)
+                        return NULL;
+                if (machine__is_host(machine))
+                        dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
+                else
+                        dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
+                /* _KMODULE_COMP should be next to _KMODULE */
+                if (m->kmod && m->comp)
+                        dso->symtab_type++;
+                dso__set_short_name(dso, strdup(m->name), true);
+                dso__set_long_name(dso, strdup(filename), true);
+        }
+        return dso;
+}
 struct map *machine__new_module(struct machine *machine, u64 start,
                                const char *filename)
 {
-        struct map *map;
+        struct map *map = NULL;
-        struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
+        struct dso *dso;
-        bool compressed;
+        struct kmod_path m;
-        if (dso == NULL)
+        if (kmod_path__parse_name(&m, filename))
                return NULL;
-        map = map__new2(start, dso, MAP__FUNCTION);
+        map = map_groups__find_by_name(&machine->kmaps, MAP__FUNCTION,
-        if (map == NULL)
+                                       m.name);
-                return NULL;
+        if (map)
+                goto out;
-        if (machine__is_host(machine))
+        dso = machine__module_dso(machine, &m, filename);
-                dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
+        if (dso == NULL)
-        else
+                goto out;
-                dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
-        /* _KMODULE_COMP should be next to _KMODULE */
+        map = map__new2(start, dso, MAP__FUNCTION);
-        if (is_kernel_module(filename, &compressed) && compressed)
+        if (map == NULL)
-                dso->symtab_type++;
+                goto out;
        map_groups__insert(&machine->kmaps, map);
+out:
+        free(m.name);
        return map;
 }
@@ -827,6 +856,39 @@ static char *get_kernel_version(const char *root_dir)
        return strdup(name);
 }
+static bool is_kmod_dso(struct dso *dso)
+{
+        return dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
+               dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE;
+}
+static int map_groups__set_module_path(struct map_groups *mg, const char *path,
+                                       struct kmod_path *m)
+{
+        struct map *map;
+        char *long_name;
+        map = map_groups__find_by_name(mg, MAP__FUNCTION, m->name);
+        if (map == NULL)
+                return 0;
+        long_name = strdup(path);
+        if (long_name == NULL)
+                return -ENOMEM;
+        dso__set_long_name(map->dso, long_name, true);
+        dso__kernel_module_get_build_id(map->dso, "");
+        /*
+         * Full name could reveal us kmod compression, so
+         * we need to update the symtab_type if needed.
+         */
+        if (m->comp && is_kmod_dso(map->dso))
+                map->dso->symtab_type++;
+        return 0;
+}
 static int map_groups__set_modules_path_dir(struct map_groups *mg,
                                const char *dir_name, int depth)
 {
@@ -865,35 +927,19 @@ static int map_groups__set_modules_path_dir(struct map_groups *mg,
                        if (ret < 0)
                                goto out;
                } else {
-                        char *dot = strrchr(dent->d_name, '.'),
+                        struct kmod_path m;
-                             dso_name[PATH_MAX];
-                        struct map *map;
-                        char *long_name;
-                        if (dot == NULL)
+                        ret = kmod_path__parse_name(&m, dent->d_name);
-                                continue;
+                        if (ret)
+                                goto out;
-                        /* On some system, modules are compressed like .ko.gz */
+                        if (m.kmod)
-                        if (is_supported_compression(dot + 1) &&
+                                ret = map_groups__set_module_path(mg, path, &m);
-                            is_kmodule_extension(dot - 2))
-                                dot -= 3;
-                        snprintf(dso_name, sizeof(dso_name), "[%.*s]",
+                        free(m.name);
-                                 (int)(dot - dent->d_name), dent->d_name);
-                        strxfrchar(dso_name, '-', '_');
+                        if (ret)
-                        map = map_groups__find_by_name(mg, MAP__FUNCTION,
-                                                       dso_name);
-                        if (map == NULL)
-                                continue;
-                        long_name = strdup(path);
-                        if (long_name == NULL) {
-                                ret = -1;
                                goto out;
-                        }
-                        dso__set_long_name(map->dso, long_name, true);
-                        dso__kernel_module_get_build_id(map->dso, "");
                }
        }
@@ -1046,40 +1092,11 @@ static int machine__process_kernel_mmap_event(struct machine *machine,
                                strlen(kmmap_prefix) - 1) == 0;
        if (event->mmap.filename[0] == '/' ||
            (!is_kernel_mmap && event->mmap.filename[0] == '[')) {
-                char short_module_name[1024];
-                char *name, *dot;
-                if (event->mmap.filename[0] == '/') {
-                        name = strrchr(event->mmap.filename, '/');
-                        if (name == NULL)
-                                goto out_problem;
-                        ++name; /* skip / */
-                        dot = strrchr(name, '.');
-                        if (dot == NULL)
-                                goto out_problem;
-                        /* On some system, modules are compressed like .ko.gz */
-                        if (is_supported_compression(dot + 1))
-                                dot -= 3;
-                        if (!is_kmodule_extension(dot + 1))
-                                goto out_problem;
-                        snprintf(short_module_name, sizeof(short_module_name),
-                                        "[%.*s]", (int)(dot - name), name);
-                        strxfrchar(short_module_name, '-', '_');
-                } else
-                        strcpy(short_module_name, event->mmap.filename);
                map = machine__new_module(machine, event->mmap.start,
                                          event->mmap.filename);
                if (map == NULL)
                        goto out_problem;
-                name = strdup(short_module_name);
-                if (name == NULL)
-                        goto out_problem;
-                dso__set_short_name(map->dso, name, true);
                map->end = map->start + event->mmap.len;
        } else if (is_kernel_mmap) {
                const char *symbol_name = (event->mmap.filename +
@@ -1092,7 +1109,7 @@ static int machine__process_kernel_mmap_event(struct machine *machine,
                struct dso *dso;
                list_for_each_entry(dso, &machine->kernel_dsos.head, node) {
-                        if (is_kernel_module(dso->long_name, NULL))
+                        if (is_kernel_module(dso->long_name))
                                continue;
                        kernel = dso;
@@ -1238,13 +1255,17 @@ out_problem:
 static void machine__remove_thread(struct machine *machine, struct thread *th)
 {
-        machine->last_match = NULL;
+        if (machine->last_match == th)
+                thread__zput(machine->last_match);
        rb_erase(&th->rb_node, &machine->threads);
        /*
-         * We may have references to this thread, for instance in some hist_entry
+         * Move it first to the dead_threads list, then drop the reference,
-         * instances, so just move them to a separate list.
+         * if this is the last reference, then the thread__delete destructor
+         * will be called and we will remove it from the dead_threads list.
         */
        list_add_tail(&th->node, &machine->dead_threads);
+        thread__put(th);
 }
 int machine__process_fork_event(struct machine *machine, union perf_event *event,
@@ -1502,18 +1523,100 @@ static int remove_loops(struct branch_entry *l, int nr)
        return nr;
 }
-static int thread__resolve_callchain_sample(struct thread *thread,
+/*
-                                             struct ip_callchain *chain,
+ * Recolve LBR callstack chain sample
-                                             struct branch_stack *branch,
+ * Return:
-                                             struct symbol **parent,
+ * 1 on success get LBR callchain information
-                                             struct addr_location *root_al,
+ * 0 no available LBR callchain information, should try fp
-                                             int max_stack)
+ * negative error code on other errors.
+ */
+static int resolve_lbr_callchain_sample(struct thread *thread,
+                                        struct perf_sample *sample,
+                                        struct symbol **parent,
+                                        struct addr_location *root_al,
+                                        int max_stack)
 {
+        struct ip_callchain *chain = sample->callchain;
+        int chain_nr = min(max_stack, (int)chain->nr);
+        int i, j, err;
+        u64 ip;
+        for (i = 0; i < chain_nr; i++) {
+                if (chain->ips[i] == PERF_CONTEXT_USER)
+                        break;
+        }
+        /* LBR only affects the user callchain */
+        if (i != chain_nr) {
+                struct branch_stack *lbr_stack = sample->branch_stack;
+                int lbr_nr = lbr_stack->nr;
+                /*
+                 * LBR callstack can only get user call chain.
+                 * The mix_chain_nr is kernel call chain
+                 * number plus LBR user call chain number.
+                 * i is kernel call chain number,
+                 * 1 is PERF_CONTEXT_USER,
+                 * lbr_nr + 1 is the user call chain number.
+                 * For details, please refer to the comments
+                 * in callchain__printf
+                 */
+                int mix_chain_nr = i + 1 + lbr_nr + 1;
+                if (mix_chain_nr > PERF_MAX_STACK_DEPTH + PERF_MAX_BRANCH_DEPTH) {
+                        pr_warning("corrupted callchain. skipping...\n");
+                        return 0;
+                }
+                for (j = 0; j < mix_chain_nr; j++) {
+                        if (callchain_param.order == ORDER_CALLEE) {
+                                if (j < i + 1)
+                                        ip = chain->ips[j];
+                                else if (j > i + 1)
+                                        ip = lbr_stack->entries[j - i - 2].from;
+                                else
+                                        ip = lbr_stack->entries[0].to;
+                        } else {
+                                if (j < lbr_nr)
+                                        ip = lbr_stack->entries[lbr_nr - j - 1].from;
+                                else if (j > lbr_nr)
+                                        ip = chain->ips[i + 1 - (j - lbr_nr)];
+                                else
+                                        ip = lbr_stack->entries[0].to;
+                        }
+                        err = add_callchain_ip(thread, parent, root_al, false, ip);
+                        if (err)
+                                return (err < 0) ? err : 0;
+                }
+                return 1;
+        }
+        return 0;
+}
+static int thread__resolve_callchain_sample(struct thread *thread,
+                                            struct perf_evsel *evsel,
+                                            struct perf_sample *sample,
+                                            struct symbol **parent,
+                                            struct addr_location *root_al,
+                                            int max_stack)
+{
+        struct branch_stack *branch = sample->branch_stack;
+        struct ip_callchain *chain = sample->callchain;
        int chain_nr = min(max_stack, (int)chain->nr);
        int i, j, err;
        int skip_idx = -1;
        int first_call = 0;
+        callchain_cursor_reset(&callchain_cursor);
+        if (has_branch_callstack(evsel)) {
+                err = resolve_lbr_callchain_sample(thread, sample, parent,
+                                                   root_al, max_stack);
+                if (err)
+                        return (err < 0) ? err : 0;
+        }
        /*
         * Based on DWARF debug information, some architectures skip
         * a callchain entry saved by the kernel.
@@ -1521,8 +1624,6 @@ static int thread__resolve_callchain_sample(struct thread *thread,
        if (chain->nr < PERF_MAX_STACK_DEPTH)
                skip_idx = arch_skip_callchain_idx(thread, chain);
-        callchain_cursor_reset(&callchain_cursor);
        /*
         * Add branches to call stack for easier browsing. This gives
         * more context for a sample than just the callers.
@@ -1623,9 +1724,9 @@ int thread__resolve_callchain(struct thread *thread,
                              struct addr_location *root_al,
                              int max_stack)
 {
-        int ret = thread__resolve_callchain_sample(thread, sample->callchain,
+        int ret = thread__resolve_callchain_sample(thread, evsel,
-                                                   sample->branch_stack,
+                                                   sample, parent,
-                                                   parent, root_al, max_stack);
+                                                   root_al, max_stack);
        if (ret)
                return ret;
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index e8b7779a0a3f..e2faf3b47e7b 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -118,7 +118,6 @@ void machines__set_comm_exec(struct machines *machines, bool comm_exec);
 struct machine *machine__new_host(void);
 int machine__init(struct machine *machine, const char *root_dir, pid_t pid);
 void machine__exit(struct machine *machine);
-void machine__delete_dead_threads(struct machine *machine);
 void machine__delete_threads(struct machine *machine);
 void machine__delete(struct machine *machine);
diff --git a/tools/perf/util/ordered-events.c b/tools/perf/util/ordered-events.c
index fd4be94125fb..6002fa3fcf77 100644
--- a/tools/perf/util/ordered-events.c
+++ b/tools/perf/util/ordered-events.c
@@ -131,8 +131,8 @@ static struct ordered_event *alloc_event(struct ordered_events *oe,
        return new;
 }
-struct ordered_event *
+static struct ordered_event *
-ordered_events__new(struct ordered_events *oe, u64 timestamp,
+ordered_events__new_event(struct ordered_events *oe, u64 timestamp,
                    union perf_event *event)
 {
        struct ordered_event *new;
@@ -153,10 +153,38 @@ void ordered_events__delete(struct ordered_events *oe, struct ordered_event *eve
        free_dup_event(oe, event->event);
 }
-static int __ordered_events__flush(struct perf_session *s,
+int ordered_events__queue(struct ordered_events *oe, union perf_event *event,
-                                   struct perf_tool *tool)
+                          struct perf_sample *sample, u64 file_offset)
+{
+        u64 timestamp = sample->time;
+        struct ordered_event *oevent;
+        if (!timestamp || timestamp == ~0ULL)
+                return -ETIME;
+        if (timestamp < oe->last_flush) {
+                pr_oe_time(timestamp,      "out of order event\n");
+                pr_oe_time(oe->last_flush, "last flush, last_flush_type %d\n",
+                           oe->last_flush_type);
+                oe->evlist->stats.nr_unordered_events++;
+        }
+        oevent = ordered_events__new_event(oe, timestamp, event);
+        if (!oevent) {
+                ordered_events__flush(oe, OE_FLUSH__HALF);
+                oevent = ordered_events__new_event(oe, timestamp, event);
+        }
+        if (!oevent)
+                return -ENOMEM;
+        oevent->file_offset = file_offset;
+        return 0;
+}
+static int __ordered_events__flush(struct ordered_events *oe)
 {
-        struct ordered_events *oe = &s->ordered_events;
        struct list_head *head = &oe->events;
        struct ordered_event *tmp, *iter;
        struct perf_sample sample;
@@ -166,7 +194,7 @@ static int __ordered_events__flush(struct perf_session *s,
        struct ui_progress prog;
        int ret;
-        if (!tool->ordered_events || !limit)
+        if (!limit)
                return 0;
        if (show_progress)
@@ -179,12 +207,11 @@ static int __ordered_events__flush(struct perf_session *s,
                if (iter->timestamp > limit)
                        break;
-                ret = perf_evlist__parse_sample(s->evlist, iter->event, &sample);
+                ret = perf_evlist__parse_sample(oe->evlist, iter->event, &sample);
                if (ret)
                        pr_err("Can't parse sample, err = %d\n", ret);
                else {
-                        ret = perf_session__deliver_event(s, iter->event, &sample, tool,
+                        ret = oe->deliver(oe, iter, &sample);
-                                                          iter->file_offset);
                        if (ret)
                                return ret;
                }
@@ -204,10 +231,8 @@ static int __ordered_events__flush(struct perf_session *s,
        return 0;
 }
-int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
+int ordered_events__flush(struct ordered_events *oe, enum oe_flush how)
-                          enum oe_flush how)
 {
-        struct ordered_events *oe = &s->ordered_events;
        static const char * const str[] = {
                "NONE",
                "FINAL",
@@ -216,6 +241,9 @@ int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
        };
        int err;
+        if (oe->nr_events == 0)
+                return 0;
        switch (how) {
        case OE_FLUSH__FINAL:
                oe->next_flush = ULLONG_MAX;
@@ -248,7 +276,7 @@ int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
                   str[how], oe->nr_events);
        pr_oe_time(oe->max_timestamp, "max_timestamp\n");
-        err = __ordered_events__flush(s, tool);
+        err = __ordered_events__flush(oe);
        if (!err) {
                if (how == OE_FLUSH__ROUND)
@@ -264,13 +292,19 @@ int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
        return err;
 }
-void ordered_events__init(struct ordered_events *oe)
+void ordered_events__init(struct ordered_events *oe, struct machines *machines,
+                          struct perf_evlist *evlist, struct perf_tool *tool,
+                          ordered_events__deliver_t deliver)
 {
        INIT_LIST_HEAD(&oe->events);
        INIT_LIST_HEAD(&oe->cache);
        INIT_LIST_HEAD(&oe->to_free);
        oe->max_alloc_size = (u64) -1;
        oe->cur_alloc_size = 0;
+        oe->evlist         = evlist;
+        oe->machines       = machines;
+        oe->tool           = tool;
+        oe->deliver        = deliver;
 }
 void ordered_events__free(struct ordered_events *oe)
diff --git a/tools/perf/util/ordered-events.h b/tools/perf/util/ordered-events.h
index 7b8f9b011f38..173e13f28c08 100644
--- a/tools/perf/util/ordered-events.h
+++ b/tools/perf/util/ordered-events.h
@@ -2,9 +2,11 @@
 #define __ORDERED_EVENTS_H
 #include <linux/types.h>
-#include "tool.h"
-struct perf_session;
+struct perf_tool;
+struct perf_evlist;
+struct perf_sample;
+struct machines;
 struct ordered_event {
        u64                     timestamp;
@@ -20,6 +22,12 @@ enum oe_flush {
        OE_FLUSH__HALF,
 };
+struct ordered_events;
+typedef int (*ordered_events__deliver_t)(struct ordered_events *oe,
+                                         struct ordered_event *event,
+                                         struct perf_sample *sample);
 struct ordered_events {
        u64                     last_flush;
        u64                     next_flush;
@@ -31,18 +39,23 @@ struct ordered_events {
        struct list_head        to_free;
        struct ordered_event    *buffer;
        struct ordered_event    *last;
+        struct machines         *machines;
+        struct perf_evlist      *evlist;
+        struct perf_tool        *tool;
+        ordered_events__deliver_t deliver;
        int                     buffer_idx;
        unsigned int            nr_events;
        enum oe_flush           last_flush_type;
        bool                    copy_on_queue;
 };
-struct ordered_event *ordered_events__new(struct ordered_events *oe, u64 timestamp,
+int ordered_events__queue(struct ordered_events *oe, union perf_event *event,
-                                          union perf_event *event);
+                          struct perf_sample *sample, u64 file_offset);
 void ordered_events__delete(struct ordered_events *oe, struct ordered_event *event);
-int ordered_events__flush(struct perf_session *s, struct perf_tool *tool,
+int ordered_events__flush(struct ordered_events *oe, enum oe_flush how);
-                          enum oe_flush how);
+void ordered_events__init(struct ordered_events *oe, struct machines *machines,
-void ordered_events__init(struct ordered_events *oe);
+                          struct perf_evlist *evlsit, struct perf_tool *tool,
+                          ordered_events__deliver_t deliver);
 void ordered_events__free(struct ordered_events *oe);
 static inline
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 7f8ec6ce2823..fe07573d5ed4 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -20,11 +20,6 @@
 #define MAX_NAME_LEN 100
-struct event_symbol {
-        const char      *symbol;
-        const char      *alias;
-};
 #ifdef PARSER_DEBUG
 extern int parse_events_debug;
 #endif
@@ -39,7 +34,7 @@ static struct perf_pmu_event_symbol *perf_pmu_events_list;
 */
 static int perf_pmu_events_list_num;
-static struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
+struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
        [PERF_COUNT_HW_CPU_CYCLES] = {
                .symbol = "cpu-cycles",
                .alias  = "cycles",
@@ -82,7 +77,7 @@ static struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
        },
 };
-static struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
+struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
        [PERF_COUNT_SW_CPU_CLOCK] = {
                .symbol = "cpu-clock",
                .alias  = "",
@@ -175,9 +170,6 @@ struct tracepoint_path *tracepoint_id_to_path(u64 config)
        char evt_path[MAXPATHLEN];
        char dir_path[MAXPATHLEN];
-        if (debugfs_valid_mountpoint(tracing_events_path))
-                return NULL;
        sys_dir = opendir(tracing_events_path);
        if (!sys_dir)
                return NULL;
@@ -473,12 +465,6 @@ static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
 int parse_events_add_tracepoint(struct list_head *list, int *idx,
                                char *sys, char *event)
 {
-        int ret;
-        ret = debugfs_valid_mountpoint(tracing_events_path);
-        if (ret)
-                return ret;
        if (strpbrk(sys, "*?"))
                return add_tracepoint_multi_sys(list, idx, sys, event);
        else
@@ -1098,6 +1084,14 @@ static const char * const event_type_descriptors[] = {
        "Hardware breakpoint",
 };
+static int cmp_string(const void *a, const void *b)
+{
+        const char * const *as = a;
+        const char * const *bs = b;
+        return strcmp(*as, *bs);
+}
 /*
 * Print the events from <debugfs_mount_point>/tracing/events
 */
@@ -1109,18 +1103,21 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
        struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
        char evt_path[MAXPATHLEN];
        char dir_path[MAXPATHLEN];
-        char sbuf[STRERR_BUFSIZE];
+        char **evt_list = NULL;
+        unsigned int evt_i = 0, evt_num = 0;
-        if (debugfs_valid_mountpoint(tracing_events_path)) {
+        bool evt_num_known = false;
-                printf("  [ Tracepoints not available: %s ]\n",
-                        strerror_r(errno, sbuf, sizeof(sbuf)));
-                return;
-        }
+restart:
        sys_dir = opendir(tracing_events_path);
        if (!sys_dir)
                return;
+        if (evt_num_known) {
+                evt_list = zalloc(sizeof(char *) * evt_num);
+                if (!evt_list)
+                        goto out_close_sys_dir;
+        }
        for_each_subsystem(sys_dir, sys_dirent, sys_next) {
                if (subsys_glob != NULL &&
                    !strglobmatch(sys_dirent.d_name, subsys_glob))
@@ -1137,19 +1134,56 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
                            !strglobmatch(evt_dirent.d_name, event_glob))
                                continue;
-                        if (name_only) {
+                        if (!evt_num_known) {
-                                printf("%s:%s ", sys_dirent.d_name, evt_dirent.d_name);
+                                evt_num++;
                                continue;
                        }
                        snprintf(evt_path, MAXPATHLEN, "%s:%s",
                                 sys_dirent.d_name, evt_dirent.d_name);
-                        printf("  %-50s [%s]\n", evt_path,
-                                event_type_descriptors[PERF_TYPE_TRACEPOINT]);
+                        evt_list[evt_i] = strdup(evt_path);
+                        if (evt_list[evt_i] == NULL)
+                                goto out_close_evt_dir;
+                        evt_i++;
                }
                closedir(evt_dir);
        }
        closedir(sys_dir);
+        if (!evt_num_known) {
+                evt_num_known = true;
+                goto restart;
+        }
+        qsort(evt_list, evt_num, sizeof(char *), cmp_string);
+        evt_i = 0;
+        while (evt_i < evt_num) {
+                if (name_only) {
+                        printf("%s ", evt_list[evt_i++]);
+                        continue;
+                }
+                printf("  %-50s [%s]\n", evt_list[evt_i++],
+                                event_type_descriptors[PERF_TYPE_TRACEPOINT]);
+        }
+        if (evt_num)
+                printf("\n");
+out_free:
+        evt_num = evt_i;
+        for (evt_i = 0; evt_i < evt_num; evt_i++)
+                zfree(&evt_list[evt_i]);
+        zfree(&evt_list);
+        return;
+out_close_evt_dir:
+        closedir(evt_dir);
+out_close_sys_dir:
+        closedir(sys_dir);
+        printf("FATAL: not enough memory to print %s\n",
+                        event_type_descriptors[PERF_TYPE_TRACEPOINT]);
+        if (evt_list)
+                goto out_free;
 }
 /*
@@ -1163,9 +1197,6 @@ int is_valid_tracepoint(const char *event_string)
        char evt_path[MAXPATHLEN];
        char dir_path[MAXPATHLEN];
-        if (debugfs_valid_mountpoint(tracing_events_path))
-                return 0;
        sys_dir = opendir(tracing_events_path);
        if (!sys_dir)
                return 0;
@@ -1233,38 +1264,19 @@ static bool is_event_supported(u8 type, unsigned config)
        return ret;
 }
-static void __print_events_type(u8 type, struct event_symbol *syms,
-                                unsigned max)
-{
-        char name[64];
-        unsigned i;
-        for (i = 0; i < max ; i++, syms++) {
-                if (!is_event_supported(type, i))
-                        continue;
-                if (strlen(syms->alias))
-                        snprintf(name, sizeof(name),  "%s OR %s",
-                                 syms->symbol, syms->alias);
-                else
-                        snprintf(name, sizeof(name), "%s", syms->symbol);
-                printf("  %-50s [%s]\n", name, event_type_descriptors[type]);
-        }
-}
-void print_events_type(u8 type)
-{
-        if (type == PERF_TYPE_SOFTWARE)
-                __print_events_type(type, event_symbols_sw, PERF_COUNT_SW_MAX);
-        else
-                __print_events_type(type, event_symbols_hw, PERF_COUNT_HW_MAX);
-}
 int print_hwcache_events(const char *event_glob, bool name_only)
 {
-        unsigned int type, op, i, printed = 0;
+        unsigned int type, op, i, evt_i = 0, evt_num = 0;
        char name[64];
+        char **evt_list = NULL;
+        bool evt_num_known = false;
+restart:
+        if (evt_num_known) {
+                evt_list = zalloc(sizeof(char *) * evt_num);
+                if (!evt_list)
+                        goto out_enomem;
+        }
        for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
                for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
@@ -1282,27 +1294,66 @@ int print_hwcache_events(const char *event_glob, bool name_only)
                                                        type | (op << 8) | (i << 16)))
                                        continue;
-                                if (name_only)
+                                if (!evt_num_known) {
-                                        printf("%s ", name);
+                                        evt_num++;
-                                else
+                                        continue;
-                                        printf("  %-50s [%s]\n", name,
+                                }
-                                               event_type_descriptors[PERF_TYPE_HW_CACHE]);
-                                ++printed;
+                                evt_list[evt_i] = strdup(name);
+                                if (evt_list[evt_i] == NULL)
+                                        goto out_enomem;
+                                evt_i++;
                        }
                }
        }
-        if (printed)
+        if (!evt_num_known) {
+                evt_num_known = true;
+                goto restart;
+        }
+        qsort(evt_list, evt_num, sizeof(char *), cmp_string);
+        evt_i = 0;
+        while (evt_i < evt_num) {
+                if (name_only) {
+                        printf("%s ", evt_list[evt_i++]);
+                        continue;
+                }
+                printf("  %-50s [%s]\n", evt_list[evt_i++],
+                                event_type_descriptors[PERF_TYPE_HW_CACHE]);
+        }
+        if (evt_num)
                printf("\n");
-        return printed;
+out_free:
+        evt_num = evt_i;
+        for (evt_i = 0; evt_i < evt_num; evt_i++)
+                zfree(&evt_list[evt_i]);
+        zfree(&evt_list);
+        return evt_num;
+out_enomem:
+        printf("FATAL: not enough memory to print %s\n", event_type_descriptors[PERF_TYPE_HW_CACHE]);
+        if (evt_list)
+                goto out_free;
+        return evt_num;
 }
-static void print_symbol_events(const char *event_glob, unsigned type,
+void print_symbol_events(const char *event_glob, unsigned type,
                                struct event_symbol *syms, unsigned max,
                                bool name_only)
 {
-        unsigned i, printed = 0;
+        unsigned int i, evt_i = 0, evt_num = 0;
        char name[MAX_NAME_LEN];
+        char **evt_list = NULL;
+        bool evt_num_known = false;
+restart:
+        if (evt_num_known) {
+                evt_list = zalloc(sizeof(char *) * evt_num);
+                if (!evt_list)
+                        goto out_enomem;
+                syms -= max;
+        }
        for (i = 0; i < max; i++, syms++) {
@@ -1314,23 +1365,49 @@ static void print_symbol_events(const char *event_glob, unsigned type,
                if (!is_event_supported(type, i))
                        continue;
-                if (name_only) {
+                if (!evt_num_known) {
-                        printf("%s ", syms->symbol);
+                        evt_num++;
                        continue;
                }
-                if (strlen(syms->alias))
+                if (!name_only && strlen(syms->alias))
                        snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
                else
                        strncpy(name, syms->symbol, MAX_NAME_LEN);
-                printf("  %-50s [%s]\n", name, event_type_descriptors[type]);
+                evt_list[evt_i] = strdup(name);
+                if (evt_list[evt_i] == NULL)
-                printed++;
+                        goto out_enomem;
+                evt_i++;
        }
-        if (printed)
+        if (!evt_num_known) {
+                evt_num_known = true;
+                goto restart;
+        }
+        qsort(evt_list, evt_num, sizeof(char *), cmp_string);
+        evt_i = 0;
+        while (evt_i < evt_num) {
+                if (name_only) {
+                        printf("%s ", evt_list[evt_i++]);
+                        continue;
+                }
+                printf("  %-50s [%s]\n", evt_list[evt_i++], event_type_descriptors[type]);
+        }
+        if (evt_num)
                printf("\n");
+out_free:
+        evt_num = evt_i;
+        for (evt_i = 0; evt_i < evt_num; evt_i++)
+                zfree(&evt_list[evt_i]);
+        zfree(&evt_list);
+        return;
+out_enomem:
+        printf("FATAL: not enough memory to print %s\n", event_type_descriptors[type]);
+        if (evt_list)
+                goto out_free;
 }
 /*
@@ -1338,11 +1415,6 @@ static void print_symbol_events(const char *event_glob, unsigned type,
 */
 void print_events(const char *event_glob, bool name_only)
 {
-        if (!name_only) {
-                printf("\n");
-                printf("List of pre-defined events (to be used in -e):\n");
-        }
        print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
                            event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index ff6e1fa4111e..52a2dda4f954 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -116,12 +116,21 @@ void parse_events_update_lists(struct list_head *list_event,
 void parse_events_error(void *data, void *scanner, char const *msg);
 void print_events(const char *event_glob, bool name_only);
-void print_events_type(u8 type);
+struct event_symbol {
+        const char      *symbol;
+        const char      *alias;
+};
+extern struct event_symbol event_symbols_hw[];
+extern struct event_symbol event_symbols_sw[];
+void print_symbol_events(const char *event_glob, unsigned type,
+                                struct event_symbol *syms, unsigned max,
+                                bool name_only);
 void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
                             bool name_only);
 int print_hwcache_events(const char *event_glob, bool name_only);
 extern int is_valid_tracepoint(const char *event_string);
-extern int valid_debugfs_mount(const char *debugfs);
+int valid_event_mount(const char *eventfs);
 #endif /* __PERF_PARSE_EVENTS_H */
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
index 4a015f77e2b5..01626be2a8eb 100644
--- a/tools/perf/util/parse-options.c
+++ b/tools/perf/util/parse-options.c
@@ -37,6 +37,7 @@ static int get_value(struct parse_opt_ctx_t *p,
 {
        const char *s, *arg = NULL;
        const int unset = flags & OPT_UNSET;
+        int err;
        if (unset && p->opt)
                return opterror(opt, "takes no value", flags);
@@ -114,13 +115,29 @@ static int get_value(struct parse_opt_ctx_t *p,
                return 0;
        case OPTION_STRING:
+                err = 0;
                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);
+                        err = get_arg(p, opt, flags, (const char **)opt->value);
-                return 0;
+                /* PARSE_OPT_NOEMPTY: Allow NULL but disallow empty string. */
+                if (opt->flags & PARSE_OPT_NOEMPTY) {
+                        const char *val = *(const char **)opt->value;
+                        if (!val)
+                                return err;
+                        /* Similar to unset if we are given an empty string. */
+                        if (val[0] == '\0') {
+                                *(const char **)opt->value = NULL;
+                                return 0;
+                        }
+                }
+                return err;
        case OPTION_CALLBACK:
                if (unset)
@@ -505,13 +522,18 @@ int parse_options_subcommand(int argc, const char **argv, const struct option *o
                break;
        case PARSE_OPT_LIST_OPTS:
                while (options->type != OPTION_END) {
-                        printf("--%s ", options->long_name);
+                        if (options->long_name)
+                                printf("--%s ", options->long_name);
                        options++;
                }
+                putchar('\n');
                exit(130);
        case PARSE_OPT_LIST_SUBCMDS:
-                for (int i = 0; subcommands[i]; i++)
+                if (subcommands) {
-                        printf("%s ", subcommands[i]);
+                        for (int i = 0; subcommands[i]; i++)
+                                printf("%s ", subcommands[i]);
+                }
+                putchar('\n');
                exit(130);
        default: /* PARSE_OPT_UNKNOWN */
                if (ctx.argv[0][1] == '-') {
diff --git a/tools/perf/util/parse-options.h b/tools/perf/util/parse-options.h
index 97b153fb4999..59561fd86278 100644
--- a/tools/perf/util/parse-options.h
+++ b/tools/perf/util/parse-options.h
@@ -40,6 +40,7 @@ enum parse_opt_option_flags {
        PARSE_OPT_LASTARG_DEFAULT = 16,
        PARSE_OPT_DISABLED = 32,
        PARSE_OPT_EXCLUSIVE = 64,
+        PARSE_OPT_NOEMPTY  = 128,
 };
 struct option;
@@ -122,6 +123,7 @@ struct option {
 #define OPT_LONG(s, l, v, h)        { .type = OPTION_LONG, .short_name = (s), .long_name = (l), .value = check_vtype(v, long *), .help = (h) }
 #define OPT_U64(s, l, v, h)         { .type = OPTION_U64, .short_name = (s), .long_name = (l), .value = check_vtype(v, u64 *), .help = (h) }
 #define OPT_STRING(s, l, v, a, h)   { .type = OPTION_STRING,  .short_name = (s), .long_name = (l), .value = check_vtype(v, const char **), (a), .help = (h) }
+#define OPT_STRING_NOEMPTY(s, l, v, a, h)   { .type = OPTION_STRING,  .short_name = (s), .long_name = (l), .value = check_vtype(v, const char **), (a), .help = (h), .flags = PARSE_OPT_NOEMPTY}
 #define OPT_DATE(s, l, v, h) \
        { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), .argh = "time", .help = (h), .callback = parse_opt_approxidate_cb }
 #define OPT_CALLBACK(s, l, v, a, h, f) \
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 919937eb0be2..8feac0774c41 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -41,6 +41,7 @@
 #include "symbol.h"
 #include "thread.h"
 #include <api/fs/debugfs.h>
+#include <api/fs/tracefs.h>
 #include "trace-event.h"        /* For __maybe_unused */
 #include "probe-event.h"
 #include "probe-finder.h"
@@ -79,6 +80,7 @@ static int init_symbol_maps(bool user_only)
        int ret;
        symbol_conf.sort_by_name = true;
+        symbol_conf.allow_aliases = true;
        ret = symbol__init(NULL);
        if (ret < 0) {
                pr_debug("Failed to init symbol map.\n");
@@ -150,7 +152,7 @@ static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc)
                sym = __find_kernel_function_by_name(name, &map);
                if (sym)
                        return map->unmap_ip(map, sym->start) -
-                                (reloc) ? 0 : map->reloc;
+                                ((reloc) ? 0 : map->reloc);
        }
        return 0;
 }
@@ -177,6 +179,25 @@ static struct map *kernel_get_module_map(const char *module)
        return NULL;
 }
+static struct map *get_target_map(const char *target, bool user)
+{
+        /* Init maps of given executable or kernel */
+        if (user)
+                return dso__new_map(target);
+        else
+                return kernel_get_module_map(target);
+}
+static void put_target_map(struct map *map, bool user)
+{
+        if (map && user) {
+                /* Only the user map needs to be released */
+                dso__delete(map->dso);
+                map__delete(map);
+        }
+}
 static struct dso *kernel_get_module_dso(const char *module)
 {
        struct dso *dso;
@@ -248,6 +269,13 @@ out:
        return ret;
 }
+static void clear_perf_probe_point(struct perf_probe_point *pp)
+{
+        free(pp->file);
+        free(pp->function);
+        free(pp->lazy_line);
+}
 static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
 {
        int i;
@@ -257,6 +285,102 @@ static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
 }
 #ifdef HAVE_DWARF_SUPPORT
+/*
+ * Some binaries like glibc have special symbols which are on the symbol
+ * table, but not in the debuginfo. If we can find the address of the
+ * symbol from map, we can translate the address back to the probe point.
+ */
+static int find_alternative_probe_point(struct debuginfo *dinfo,
+                                        struct perf_probe_point *pp,
+                                        struct perf_probe_point *result,
+                                        const char *target, bool uprobes)
+{
+        struct map *map = NULL;
+        struct symbol *sym;
+        u64 address = 0;
+        int ret = -ENOENT;
+        /* This can work only for function-name based one */
+        if (!pp->function || pp->file)
+                return -ENOTSUP;
+        map = get_target_map(target, uprobes);
+        if (!map)
+                return -EINVAL;
+        /* Find the address of given function */
+        map__for_each_symbol_by_name(map, pp->function, sym) {
+                if (uprobes)
+                        address = sym->start;
+                else
+                        address = map->unmap_ip(map, sym->start);
+                break;
+        }
+        if (!address) {
+                ret = -ENOENT;
+                goto out;
+        }
+        pr_debug("Symbol %s address found : %lx\n", pp->function, address);
+        ret = debuginfo__find_probe_point(dinfo, (unsigned long)address,
+                                          result);
+        if (ret <= 0)
+                ret = (!ret) ? -ENOENT : ret;
+        else {
+                result->offset += pp->offset;
+                result->line += pp->line;
+                ret = 0;
+        }
+out:
+        put_target_map(map, uprobes);
+        return ret;
+}
+static int get_alternative_probe_event(struct debuginfo *dinfo,
+                                       struct perf_probe_event *pev,
+                                       struct perf_probe_point *tmp,
+                                       const char *target)
+{
+        int ret;
+        memcpy(tmp, &pev->point, sizeof(*tmp));
+        memset(&pev->point, 0, sizeof(pev->point));
+        ret = find_alternative_probe_point(dinfo, tmp, &pev->point,
+                                           target, pev->uprobes);
+        if (ret < 0)
+                memcpy(&pev->point, tmp, sizeof(*tmp));
+        return ret;
+}
+static int get_alternative_line_range(struct debuginfo *dinfo,
+                                      struct line_range *lr,
+                                      const char *target, bool user)
+{
+        struct perf_probe_point pp = { .function = lr->function,
+                                       .file = lr->file,
+                                       .line = lr->start };
+        struct perf_probe_point result;
+        int ret, len = 0;
+        memset(&result, 0, sizeof(result));
+        if (lr->end != INT_MAX)
+                len = lr->end - lr->start;
+        ret = find_alternative_probe_point(dinfo, &pp, &result,
+                                           target, user);
+        if (!ret) {
+                lr->function = result.function;
+                lr->file = result.file;
+                lr->start = result.line;
+                if (lr->end != INT_MAX)
+                        lr->end = lr->start + len;
+                clear_perf_probe_point(&pp);
+        }
+        return ret;
+}
 /* Open new debuginfo of given module */
 static struct debuginfo *open_debuginfo(const char *module, bool silent)
@@ -465,6 +589,7 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
                                          int max_tevs, const char *target)
 {
        bool need_dwarf = perf_probe_event_need_dwarf(pev);
+        struct perf_probe_point tmp;
        struct debuginfo *dinfo;
        int ntevs, ret = 0;
@@ -481,6 +606,20 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
        /* Searching trace events corresponding to a probe event */
        ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);
+        if (ntevs == 0) {  /* Not found, retry with an alternative */
+                ret = get_alternative_probe_event(dinfo, pev, &tmp, target);
+                if (!ret) {
+                        ntevs = debuginfo__find_trace_events(dinfo, pev,
+                                                             tevs, max_tevs);
+                        /*
+                         * Write back to the original probe_event for
+                         * setting appropriate (user given) event name
+                         */
+                        clear_perf_probe_point(&pev->point);
+                        memcpy(&pev->point, &tmp, sizeof(tmp));
+                }
+        }
        debuginfo__delete(dinfo);
        if (ntevs > 0) {        /* Succeeded to find trace events */
@@ -495,11 +634,9 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
        }
        if (ntevs == 0) {       /* No error but failed to find probe point. */
-                pr_warning("Probe point '%s' not found in debuginfo.\n",
+                pr_warning("Probe point '%s' not found.\n",
                           synthesize_perf_probe_point(&pev->point));
-                if (need_dwarf)
+                return -ENOENT;
-                        return -ENOENT;
-                return 0;
        }
        /* Error path : ntevs < 0 */
        pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
@@ -532,7 +669,7 @@ static int get_real_path(const char *raw_path, const char *comp_dir,
                else {
                        if (access(raw_path, R_OK) == 0) {
                                *new_path = strdup(raw_path);
-                                return 0;
+                                return *new_path ? 0 : -ENOMEM;
                        } else
                                return -errno;
                }
@@ -548,9 +685,11 @@ static int get_real_path(const char *raw_path, const char *comp_dir,
                if (access(*new_path, R_OK) == 0)
                        return 0;
-                if (!symbol_conf.source_prefix)
+                if (!symbol_conf.source_prefix) {
                        /* In case of searching comp_dir, don't retry */
+                        zfree(new_path);
                        return -errno;
+                }
                switch (errno) {
                case ENAMETOOLONG:
@@ -622,7 +761,8 @@ static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
 * Show line-range always requires debuginfo to find source file and
 * line number.
 */
-static int __show_line_range(struct line_range *lr, const char *module)
+static int __show_line_range(struct line_range *lr, const char *module,
+                             bool user)
 {
        int l = 1;
        struct int_node *ln;
@@ -638,6 +778,11 @@ static int __show_line_range(struct line_range *lr, const char *module)
                return -ENOENT;
        ret = debuginfo__find_line_range(dinfo, lr);
+        if (!ret) {     /* Not found, retry with an alternative */
+                ret = get_alternative_line_range(dinfo, lr, module, user);
+                if (!ret)
+                        ret = debuginfo__find_line_range(dinfo, lr);
+        }
        debuginfo__delete(dinfo);
        if (ret == 0 || ret == -ENOENT) {
                pr_warning("Specified source line is not found.\n");
@@ -650,7 +795,11 @@ static int __show_line_range(struct line_range *lr, const char *module)
        /* Convert source file path */
        tmp = lr->path;
        ret = get_real_path(tmp, lr->comp_dir, &lr->path);
-        free(tmp);      /* Free old path */
+        /* Free old path when new path is assigned */
+        if (tmp != lr->path)
+                free(tmp);
        if (ret < 0) {
                pr_warning("Failed to find source file path.\n");
                return ret;
@@ -707,7 +856,7 @@ int show_line_range(struct line_range *lr, const char *module, bool user)
        ret = init_symbol_maps(user);
        if (ret < 0)
                return ret;
-        ret = __show_line_range(lr, module);
+        ret = __show_line_range(lr, module, user);
        exit_symbol_maps();
        return ret;
@@ -716,12 +865,13 @@ int show_line_range(struct line_range *lr, const char *module, bool user)
 static int show_available_vars_at(struct debuginfo *dinfo,
                                  struct perf_probe_event *pev,
                                  int max_vls, struct strfilter *_filter,
-                                  bool externs)
+                                  bool externs, const char *target)
 {
        char *buf;
        int ret, i, nvars;
        struct str_node *node;
        struct variable_list *vls = NULL, *vl;
+        struct perf_probe_point tmp;
        const char *var;
        buf = synthesize_perf_probe_point(&pev->point);
@@ -731,6 +881,15 @@ static int show_available_vars_at(struct debuginfo *dinfo,
        ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,
                                                max_vls, externs);
+        if (!ret) {  /* Not found, retry with an alternative */
+                ret = get_alternative_probe_event(dinfo, pev, &tmp, target);
+                if (!ret) {
+                        ret = debuginfo__find_available_vars_at(dinfo, pev,
+                                                &vls, max_vls, externs);
+                        /* Release the old probe_point */
+                        clear_perf_probe_point(&tmp);
+                }
+        }
        if (ret <= 0) {
                if (ret == 0 || ret == -ENOENT) {
                        pr_err("Failed to find the address of %s\n", buf);
@@ -793,7 +952,7 @@ int show_available_vars(struct perf_probe_event *pevs, int npevs,
        for (i = 0; i < npevs && ret >= 0; i++)
                ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,
-                                             externs);
+                                             externs, module);
        debuginfo__delete(dinfo);
 out:
@@ -1739,15 +1898,12 @@ static int convert_to_perf_probe_event(struct probe_trace_event *tev,
 void clear_perf_probe_event(struct perf_probe_event *pev)
 {
-        struct perf_probe_point *pp = &pev->point;
        struct perf_probe_arg_field *field, *next;
        int i;
        free(pev->event);
        free(pev->group);
-        free(pp->file);
+        clear_perf_probe_point(&pev->point);
-        free(pp->function);
-        free(pp->lazy_line);
        for (i = 0; i < pev->nargs; i++) {
                free(pev->args[i].name);
@@ -1805,7 +1961,7 @@ static void print_open_warning(int err, bool is_kprobe)
                           " - please rebuild kernel with %s.\n",
                           is_kprobe ? 'k' : 'u', config);
        } else if (err == -ENOTSUP)
-                pr_warning("Debugfs is not mounted.\n");
+                pr_warning("Tracefs or debugfs is not mounted.\n");
        else
                pr_warning("Failed to open %cprobe_events: %s\n",
                           is_kprobe ? 'k' : 'u',
@@ -1816,7 +1972,7 @@ static void print_both_open_warning(int kerr, int uerr)
 {
        /* Both kprobes and uprobes are disabled, warn it. */
        if (kerr == -ENOTSUP && uerr == -ENOTSUP)
-                pr_warning("Debugfs is not mounted.\n");
+                pr_warning("Tracefs or debugfs is not mounted.\n");
        else if (kerr == -ENOENT && uerr == -ENOENT)
                pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
                           "or/and CONFIG_UPROBE_EVENTS.\n");
@@ -1833,13 +1989,20 @@ static int open_probe_events(const char *trace_file, bool readwrite)
 {
        char buf[PATH_MAX];
        const char *__debugfs;
+        const char *tracing_dir = "";
        int ret;
-        __debugfs = debugfs_find_mountpoint();
+        __debugfs = tracefs_find_mountpoint();
-        if (__debugfs == NULL)
+        if (__debugfs == NULL) {
-                return -ENOTSUP;
+                tracing_dir = "tracing/";
+                __debugfs = debugfs_find_mountpoint();
+                if (__debugfs == NULL)
+                        return -ENOTSUP;
+        }
-        ret = e_snprintf(buf, PATH_MAX, "%s/%s", __debugfs, trace_file);
+        ret = e_snprintf(buf, PATH_MAX, "%s/%s%s",
+                         __debugfs, tracing_dir, trace_file);
        if (ret >= 0) {
                pr_debug("Opening %s write=%d\n", buf, readwrite);
                if (readwrite && !probe_event_dry_run)
@@ -1855,12 +2018,12 @@ static int open_probe_events(const char *trace_file, bool readwrite)
 static int open_kprobe_events(bool readwrite)
 {
-        return open_probe_events("tracing/kprobe_events", readwrite);
+        return open_probe_events("kprobe_events", readwrite);
 }
 static int open_uprobe_events(bool readwrite)
 {
-        return open_probe_events("tracing/uprobe_events", readwrite);
+        return open_probe_events("uprobe_events", readwrite);
 }
 /* Get raw string list of current kprobe_events  or uprobe_events */
@@ -1895,6 +2058,95 @@ static struct strlist *get_probe_trace_command_rawlist(int fd)
        return sl;
 }
+struct kprobe_blacklist_node {
+        struct list_head list;
+        unsigned long start;
+        unsigned long end;
+        char *symbol;
+};
+static void kprobe_blacklist__delete(struct list_head *blacklist)
+{
+        struct kprobe_blacklist_node *node;
+        while (!list_empty(blacklist)) {
+                node = list_first_entry(blacklist,
+                                        struct kprobe_blacklist_node, list);
+                list_del(&node->list);
+                free(node->symbol);
+                free(node);
+        }
+}
+static int kprobe_blacklist__load(struct list_head *blacklist)
+{
+        struct kprobe_blacklist_node *node;
+        const char *__debugfs = debugfs_find_mountpoint();
+        char buf[PATH_MAX], *p;
+        FILE *fp;
+        int ret;
+        if (__debugfs == NULL)
+                return -ENOTSUP;
+        ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
+        if (ret < 0)
+                return ret;
+        fp = fopen(buf, "r");
+        if (!fp)
+                return -errno;
+        ret = 0;
+        while (fgets(buf, PATH_MAX, fp)) {
+                node = zalloc(sizeof(*node));
+                if (!node) {
+                        ret = -ENOMEM;
+                        break;
+                }
+                INIT_LIST_HEAD(&node->list);
+                list_add_tail(&node->list, blacklist);
+                if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) {
+                        ret = -EINVAL;
+                        break;
+                }
+                p = strchr(buf, '\t');
+                if (p) {
+                        p++;
+                        if (p[strlen(p) - 1] == '\n')
+                                p[strlen(p) - 1] = '\0';
+                } else
+                        p = (char *)"unknown";
+                node->symbol = strdup(p);
+                if (!node->symbol) {
+                        ret = -ENOMEM;
+                        break;
+                }
+                pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n",
+                          node->start, node->end, node->symbol);
+                ret++;
+        }
+        if (ret < 0)
+                kprobe_blacklist__delete(blacklist);
+        fclose(fp);
+        return ret;
+}
+static struct kprobe_blacklist_node *
+kprobe_blacklist__find_by_address(struct list_head *blacklist,
+                                  unsigned long address)
+{
+        struct kprobe_blacklist_node *node;
+        list_for_each_entry(node, blacklist, list) {
+                if (node->start <= address && address <= node->end)
+                        return node;
+        }
+        return NULL;
+}
 /* Show an event */
 static int show_perf_probe_event(struct perf_probe_event *pev,
                                 const char *module)
@@ -2100,6 +2352,27 @@ static int get_new_event_name(char *buf, size_t len, const char *base,
        return ret;
 }
+/* Warn if the current kernel's uprobe implementation is old */
+static void warn_uprobe_event_compat(struct probe_trace_event *tev)
+{
+        int i;
+        char *buf = synthesize_probe_trace_command(tev);
+        /* Old uprobe event doesn't support memory dereference */
+        if (!tev->uprobes || tev->nargs == 0 || !buf)
+                goto out;
+        for (i = 0; i < tev->nargs; i++)
+                if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
+                        pr_warning("Please upgrade your kernel to at least "
+                                   "3.14 to have access to feature %s\n",
+                                   tev->args[i].value);
+                        break;
+                }
+out:
+        free(buf);
+}
 static int __add_probe_trace_events(struct perf_probe_event *pev,
                                     struct probe_trace_event *tevs,
                                     int ntevs, bool allow_suffix)
@@ -2109,6 +2382,8 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
        char buf[64];
        const char *event, *group;
        struct strlist *namelist;
+        LIST_HEAD(blacklist);
+        struct kprobe_blacklist_node *node;
        if (pev->uprobes)
                fd = open_uprobe_events(true);
@@ -2126,11 +2401,25 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
                pr_debug("Failed to get current event list.\n");
                return -EIO;
        }
+        /* Get kprobe blacklist if exists */
+        if (!pev->uprobes) {
+                ret = kprobe_blacklist__load(&blacklist);
+                if (ret < 0)
+                        pr_debug("No kprobe blacklist support, ignored\n");
+        }
        ret = 0;
        pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
        for (i = 0; i < ntevs; i++) {
                tev = &tevs[i];
+                /* Ensure that the address is NOT blacklisted */
+                node = kprobe_blacklist__find_by_address(&blacklist,
+                                                         tev->point.address);
+                if (node) {
+                        pr_warning("Warning: Skipped probing on blacklisted function: %s\n", node->symbol);
+                        continue;
+                }
                if (pev->event)
                        event = pev->event;
                else
@@ -2180,14 +2469,18 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
                 */
                allow_suffix = true;
        }
+        if (ret == -EINVAL && pev->uprobes)
+                warn_uprobe_event_compat(tev);
-        if (ret >= 0) {
+        /* Note that it is possible to skip all events because of blacklist */
+        if (ret >= 0 && tev->event) {
                /* Show how to use the event. */
                pr_info("\nYou can now use it in all perf tools, such as:\n\n");
                pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
                         tev->event);
        }
+        kprobe_blacklist__delete(&blacklist);
        strlist__delete(namelist);
        close(fd);
        return ret;
@@ -2199,8 +2492,7 @@ static int find_probe_functions(struct map *map, char *name)
        struct symbol *sym;
        map__for_each_symbol_by_name(map, name, sym) {
-                if (sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL)
+                found++;
-                        found++;
        }
        return found;
@@ -2218,7 +2510,6 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
                                            int max_tevs, const char *target)
 {
        struct map *map = NULL;
-        struct kmap *kmap = NULL;
        struct ref_reloc_sym *reloc_sym = NULL;
        struct symbol *sym;
        struct probe_trace_event *tev;
@@ -2227,11 +2518,7 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
        int num_matched_functions;
        int ret, i;
-        /* Init maps of given executable or kernel */
+        map = get_target_map(target, pev->uprobes);
-        if (pev->uprobes)
-                map = dso__new_map(target);
-        else
-                map = kernel_get_module_map(target);
        if (!map) {
                ret = -EINVAL;
                goto out;
@@ -2255,8 +2542,7 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
        }
        if (!pev->uprobes && !pp->retprobe) {
-                kmap = map__kmap(map);
+                reloc_sym = kernel_get_ref_reloc_sym();
-                reloc_sym = kmap->ref_reloc_sym;
                if (!reloc_sym) {
                        pr_warning("Relocated base symbol is not found!\n");
                        ret = -EINVAL;
@@ -2324,11 +2610,7 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
        }
 out:
-        if (map && pev->uprobes) {
+        put_target_map(map, pev->uprobes);
-                /* Only when using uprobe(exec) map needs to be released */
-                dso__delete(map->dso);
-                map__delete(map);
-        }
        return ret;
 nomem_out:
@@ -2568,8 +2850,7 @@ static struct strfilter *available_func_filter;
 static int filter_available_functions(struct map *map __maybe_unused,
                                      struct symbol *sym)
 {
-        if ((sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL) &&
+        if (strfilter__compare(available_func_filter, sym->name))
-            strfilter__compare(available_func_filter, sym->name))
                return 0;
        return 1;
 }
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index b5247d777f0e..46f009aa486c 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -915,17 +915,13 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
                dwarf_decl_line(sp_die, &pf->lno);
                pf->lno += pp->line;
                param->retval = find_probe_point_by_line(pf);
-        } else if (!dwarf_func_inline(sp_die)) {
+        } else if (die_is_func_instance(sp_die)) {
+                /* Instances always have the entry address */
+                dwarf_entrypc(sp_die, &pf->addr);
                /* Real function */
                if (pp->lazy_line)
                        param->retval = find_probe_point_lazy(sp_die, pf);
                else {
-                        if (dwarf_entrypc(sp_die, &pf->addr) != 0) {
-                                pr_warning("Failed to get entry address of "
-                                           "%s.\n", dwarf_diename(sp_die));
-                                param->retval = -ENOENT;
-                                return DWARF_CB_ABORT;
-                        }
                        pf->addr += pp->offset;
                        /* TODO: Check the address in this function */
                        param->retval = call_probe_finder(sp_die, pf);
@@ -1349,11 +1345,8 @@ int debuginfo__find_probe_point(struct debuginfo *dbg, unsigned long addr,
        const char *fname = NULL, *func = NULL, *basefunc = NULL, *tmp;
        int baseline = 0, lineno = 0, ret = 0;
-        /* Adjust address with bias */
-        addr += dbg->bias;
        /* Find cu die */
-        if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr - dbg->bias, &cudie)) {
+        if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr, &cudie)) {
                pr_warning("Failed to find debug information for address %lx\n",
                           addr);
                ret = -EINVAL;
@@ -1536,7 +1529,7 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
                pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
                lr->start = lf->lno_s;
                lr->end = lf->lno_e;
-                if (dwarf_func_inline(sp_die))
+                if (!die_is_func_instance(sp_die))
                        param->retval = die_walk_instances(sp_die,
                                                line_range_inline_cb, lf);
                else
diff --git a/tools/perf/util/python-ext-sources b/tools/perf/util/python-ext-sources
index 6c6a6953fa93..4d28624a1eca 100644
--- a/tools/perf/util/python-ext-sources
+++ b/tools/perf/util/python-ext-sources
@@ -17,6 +17,5 @@ util/xyarray.c
 util/cgroup.c
 util/rblist.c
 util/strlist.c
-../lib/api/fs/fs.c
 util/trace-event.c
 ../../lib/rbtree.c
diff --git a/tools/perf/util/scripting-engines/Build b/tools/perf/util/scripting-engines/Build
new file mode 100644
index 000000000000..6516e220c247
--- /dev/null
+++ b/tools/perf/util/scripting-engines/Build
@@ -0,0 +1,6 @@
+libperf-$(CONFIG_LIBPERL)   += trace-event-perl.o
+libperf-$(CONFIG_LIBPYTHON) += trace-event-python.o
+CFLAGS_trace-event-perl.o += $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow -Wno-undef -Wno-switch-default
+CFLAGS_trace-event-python.o += $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 22ebc46226e7..8171fed4136e 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -214,6 +214,11 @@ static void define_event_symbols(struct event_format *event,
                define_event_symbols(event, ev_name, args->hex.field);
                define_event_symbols(event, ev_name, args->hex.size);
                break;
+        case PRINT_INT_ARRAY:
+                define_event_symbols(event, ev_name, args->int_array.field);
+                define_event_symbols(event, ev_name, args->int_array.count);
+                define_event_symbols(event, ev_name, args->int_array.el_size);
+                break;
        case PRINT_BSTRING:
        case PRINT_DYNAMIC_ARRAY:
        case PRINT_STRING:
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 0c815a40a6e8..2ec5dfb5a456 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -231,6 +231,11 @@ static void define_event_symbols(struct event_format *event,
                define_event_symbols(event, ev_name, args->hex.field);
                define_event_symbols(event, ev_name, args->hex.size);
                break;
+        case PRINT_INT_ARRAY:
+                define_event_symbols(event, ev_name, args->int_array.field);
+                define_event_symbols(event, ev_name, args->int_array.count);
+                define_event_symbols(event, ev_name, args->int_array.el_size);
+                break;
        case PRINT_STRING:
                break;
        case PRINT_TYPE:
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 0baf75f12b7c..adf0740c563b 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -16,6 +16,12 @@
 #include "perf_regs.h"
 #include "asm/bug.h"
+static int machines__deliver_event(struct machines *machines,
+                                   struct perf_evlist *evlist,
+                                   union perf_event *event,
+                                   struct perf_sample *sample,
+                                   struct perf_tool *tool, u64 file_offset);
 static int perf_session__open(struct perf_session *session)
 {
        struct perf_data_file *file = session->file;
@@ -86,6 +92,14 @@ static void perf_session__set_comm_exec(struct perf_session *session)
        machines__set_comm_exec(&session->machines, comm_exec);
 }
+static int ordered_events__deliver_event(struct ordered_events *oe,
+                                         struct ordered_event *event,
+                                         struct perf_sample *sample)
+{
+        return machines__deliver_event(oe->machines, oe->evlist, event->event,
+                                       sample, oe->tool, event->file_offset);
+}
 struct perf_session *perf_session__new(struct perf_data_file *file,
                                       bool repipe, struct perf_tool *tool)
 {
@@ -95,7 +109,6 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
                goto out;
        session->repipe = repipe;
-        ordered_events__init(&session->ordered_events);
        machines__init(&session->machines);
        if (file) {
@@ -126,6 +139,9 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
            tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) {
                dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
                tool->ordered_events = false;
+        } else {
+                ordered_events__init(&session->ordered_events, &session->machines,
+                                     session->evlist, tool, ordered_events__deliver_event);
        }
        return session;
@@ -138,11 +154,6 @@ struct perf_session *perf_session__new(struct perf_data_file *file,
        return NULL;
 }
-static void perf_session__delete_dead_threads(struct perf_session *session)
-{
-        machine__delete_dead_threads(&session->machines.host);
-}
 static void perf_session__delete_threads(struct perf_session *session)
 {
        machine__delete_threads(&session->machines.host);
@@ -167,7 +178,6 @@ static void perf_session_env__delete(struct perf_session_env *env)
 void perf_session__delete(struct perf_session *session)
 {
        perf_session__destroy_kernel_maps(session);
-        perf_session__delete_dead_threads(session);
        perf_session__delete_threads(session);
        perf_session_env__delete(&session->header.env);
        machines__exit(&session->machines);
@@ -215,10 +225,17 @@ static int process_event_stub(struct perf_tool *tool __maybe_unused,
        return 0;
 }
+static int process_build_id_stub(struct perf_tool *tool __maybe_unused,
+                                 union perf_event *event __maybe_unused,
+                                 struct perf_session *session __maybe_unused)
+{
+        dump_printf(": unhandled!\n");
+        return 0;
+}
 static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
                                       union perf_event *event __maybe_unused,
-                                       struct perf_session *perf_session
+                                       struct ordered_events *oe __maybe_unused)
-                                       __maybe_unused)
 {
        dump_printf(": unhandled!\n");
        return 0;
@@ -226,7 +243,7 @@ static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
 static int process_finished_round(struct perf_tool *tool,
                                  union perf_event *event,
-                                  struct perf_session *session);
+                                  struct ordered_events *oe);
 static int process_id_index_stub(struct perf_tool *tool __maybe_unused,
                                 union perf_event *event __maybe_unused,
@@ -264,7 +281,7 @@ void perf_tool__fill_defaults(struct perf_tool *tool)
        if (tool->tracing_data == NULL)
                tool->tracing_data = process_event_synth_tracing_data_stub;
        if (tool->build_id == NULL)
-                tool->build_id = process_finished_round_stub;
+                tool->build_id = process_build_id_stub;
        if (tool->finished_round == NULL) {
                if (tool->ordered_events)
                        tool->finished_round = process_finished_round;
@@ -514,54 +531,80 @@ static perf_event__swap_op perf_event__swap_ops[] = {
 *      Flush every events below timestamp 7
 *      etc...
 */
-static int process_finished_round(struct perf_tool *tool,
+static int process_finished_round(struct perf_tool *tool __maybe_unused,
                                  union perf_event *event __maybe_unused,
-                                  struct perf_session *session)
+                                  struct ordered_events *oe)
 {
-        return ordered_events__flush(session, tool, OE_FLUSH__ROUND);
+        return ordered_events__flush(oe, OE_FLUSH__ROUND);
 }
-int perf_session_queue_event(struct perf_session *s, union perf_event *event,
+int perf_session__queue_event(struct perf_session *s, union perf_event *event,
-                             struct perf_tool *tool, struct perf_sample *sample,
+                              struct perf_sample *sample, u64 file_offset)
-                             u64 file_offset)
 {
-        struct ordered_events *oe = &s->ordered_events;
+        return ordered_events__queue(&s->ordered_events, event, sample, file_offset);
-        u64 timestamp = sample->time;
+}
-        struct ordered_event *new;
-        if (!timestamp || timestamp == ~0ULL)
-                return -ETIME;
-        if (timestamp < oe->last_flush) {
+static void callchain__lbr_callstack_printf(struct perf_sample *sample)
-                pr_oe_time(timestamp,      "out of order event\n");
+{
-                pr_oe_time(oe->last_flush, "last flush, last_flush_type %d\n",
+        struct ip_callchain *callchain = sample->callchain;
-                           oe->last_flush_type);
+        struct branch_stack *lbr_stack = sample->branch_stack;
+        u64 kernel_callchain_nr = callchain->nr;
+        unsigned int i;
-                s->stats.nr_unordered_events++;
+        for (i = 0; i < kernel_callchain_nr; i++) {
+                if (callchain->ips[i] == PERF_CONTEXT_USER)
+                        break;
        }
-        new = ordered_events__new(oe, timestamp, event);
+        if ((i != kernel_callchain_nr) && lbr_stack->nr) {
-        if (!new) {
+                u64 total_nr;
-                ordered_events__flush(s, tool, OE_FLUSH__HALF);
+                /*
-                new = ordered_events__new(oe, timestamp, event);
+                 * LBR callstack can only get user call chain,
-        }
+                 * i is kernel call chain number,
+                 * 1 is PERF_CONTEXT_USER.
+                 *
+                 * The user call chain is stored in LBR registers.
+                 * LBR are pair registers. The caller is stored
+                 * in "from" register, while the callee is stored
+                 * in "to" register.
+                 * For example, there is a call stack
+                 * "A"->"B"->"C"->"D".
+                 * The LBR registers will recorde like
+                 * "C"->"D", "B"->"C", "A"->"B".
+                 * So only the first "to" register and all "from"
+                 * registers are needed to construct the whole stack.
+                 */
+                total_nr = i + 1 + lbr_stack->nr + 1;
+                kernel_callchain_nr = i + 1;
-        if (!new)
+                printf("... LBR call chain: nr:%" PRIu64 "\n", total_nr);
-                return -ENOMEM;
-        new->file_offset = file_offset;
+                for (i = 0; i < kernel_callchain_nr; i++)
-        return 0;
+                        printf("..... %2d: %016" PRIx64 "\n",
+                               i, callchain->ips[i]);
+                printf("..... %2d: %016" PRIx64 "\n",
+                       (int)(kernel_callchain_nr), lbr_stack->entries[0].to);
+                for (i = 0; i < lbr_stack->nr; i++)
+                        printf("..... %2d: %016" PRIx64 "\n",
+                               (int)(i + kernel_callchain_nr + 1), lbr_stack->entries[i].from);
+        }
 }
-static void callchain__printf(struct perf_sample *sample)
+static void callchain__printf(struct perf_evsel *evsel,
+                              struct perf_sample *sample)
 {
        unsigned int i;
+        struct ip_callchain *callchain = sample->callchain;
-        printf("... chain: nr:%" PRIu64 "\n", sample->callchain->nr);
+        if (has_branch_callstack(evsel))
+                callchain__lbr_callstack_printf(sample);
-        for (i = 0; i < sample->callchain->nr; i++)
+        printf("... FP chain: nr:%" PRIu64 "\n", callchain->nr);
+        for (i = 0; i < callchain->nr; i++)
                printf("..... %2d: %016" PRIx64 "\n",
-                       i, sample->callchain->ips[i]);
+                       i, callchain->ips[i]);
 }
 static void branch_stack__printf(struct perf_sample *sample)
@@ -636,14 +679,14 @@ static void stack_user__printf(struct stack_dump *dump)
               dump->size, dump->offset);
 }
-static void perf_session__print_tstamp(struct perf_session *session,
+static void perf_evlist__print_tstamp(struct perf_evlist *evlist,
                                       union perf_event *event,
                                       struct perf_sample *sample)
 {
-        u64 sample_type = __perf_evlist__combined_sample_type(session->evlist);
+        u64 sample_type = __perf_evlist__combined_sample_type(evlist);
        if (event->header.type != PERF_RECORD_SAMPLE &&
-            !perf_evlist__sample_id_all(session->evlist)) {
+            !perf_evlist__sample_id_all(evlist)) {
                fputs("-1 -1 ", stdout);
                return;
        }
@@ -685,7 +728,7 @@ static void sample_read__printf(struct perf_sample *sample, u64 read_format)
                        sample->read.one.id, sample->read.one.value);
 }
-static void dump_event(struct perf_session *session, union perf_event *event,
+static void dump_event(struct perf_evlist *evlist, union perf_event *event,
                       u64 file_offset, struct perf_sample *sample)
 {
        if (!dump_trace)
@@ -697,7 +740,7 @@ static void dump_event(struct perf_session *session, union perf_event *event,
        trace_event(event);
        if (sample)
-                perf_session__print_tstamp(session, event, sample);
+                perf_evlist__print_tstamp(evlist, event, sample);
        printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
               event->header.size, perf_event__name(event->header.type));
@@ -718,9 +761,9 @@ static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
        sample_type = evsel->attr.sample_type;
        if (sample_type & PERF_SAMPLE_CALLCHAIN)
-                callchain__printf(sample);
+                callchain__printf(evsel, sample);
-        if (sample_type & PERF_SAMPLE_BRANCH_STACK)
+        if ((sample_type & PERF_SAMPLE_BRANCH_STACK) && !has_branch_callstack(evsel))
                branch_stack__printf(sample);
        if (sample_type & PERF_SAMPLE_REGS_USER)
@@ -745,8 +788,7 @@ static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
                sample_read__printf(sample, evsel->attr.read_format);
 }
-static struct machine *
+static struct machine *machines__find_for_cpumode(struct machines *machines,
-        perf_session__find_machine_for_cpumode(struct perf_session *session,
                                               union perf_event *event,
                                               struct perf_sample *sample)
 {
@@ -764,26 +806,24 @@ static struct machine *
                else
                        pid = sample->pid;
-                machine = perf_session__find_machine(session, pid);
+                machine = machines__find(machines, pid);
                if (!machine)
-                        machine = perf_session__findnew_machine(session,
+                        machine = machines__find(machines, DEFAULT_GUEST_KERNEL_ID);
-                                                DEFAULT_GUEST_KERNEL_ID);
                return machine;
        }
-        return &session->machines.host;
+        return &machines->host;
 }
-static int deliver_sample_value(struct perf_session *session,
+static int deliver_sample_value(struct perf_evlist *evlist,
                                struct perf_tool *tool,
                                union perf_event *event,
                                struct perf_sample *sample,
                                struct sample_read_value *v,
                                struct machine *machine)
 {
-        struct perf_sample_id *sid;
+        struct perf_sample_id *sid = perf_evlist__id2sid(evlist, v->id);
-        sid = perf_evlist__id2sid(session->evlist, v->id);
        if (sid) {
                sample->id     = v->id;
                sample->period = v->value - sid->period;
@@ -791,14 +831,14 @@ static int deliver_sample_value(struct perf_session *session,
        }
        if (!sid || sid->evsel == NULL) {
-                ++session->stats.nr_unknown_id;
+                ++evlist->stats.nr_unknown_id;
                return 0;
        }
        return tool->sample(tool, event, sample, sid->evsel, machine);
 }
-static int deliver_sample_group(struct perf_session *session,
+static int deliver_sample_group(struct perf_evlist *evlist,
                                struct perf_tool *tool,
                                union  perf_event *event,
                                struct perf_sample *sample,
@@ -808,7 +848,7 @@ static int deliver_sample_group(struct perf_session *session,
        u64 i;
        for (i = 0; i < sample->read.group.nr; i++) {
-                ret = deliver_sample_value(session, tool, event, sample,
+                ret = deliver_sample_value(evlist, tool, event, sample,
                                           &sample->read.group.values[i],
                                           machine);
                if (ret)
@@ -819,7 +859,7 @@ static int deliver_sample_group(struct perf_session *session,
 }
 static int
-perf_session__deliver_sample(struct perf_session *session,
+ perf_evlist__deliver_sample(struct perf_evlist *evlist,
                             struct perf_tool *tool,
                             union  perf_event *event,
                             struct perf_sample *sample,
@@ -836,41 +876,40 @@ perf_session__deliver_sample(struct perf_session *session,
        /* For PERF_SAMPLE_READ we have either single or group mode. */
        if (read_format & PERF_FORMAT_GROUP)
-                return deliver_sample_group(session, tool, event, sample,
+                return deliver_sample_group(evlist, tool, event, sample,
                                            machine);
        else
-                return deliver_sample_value(session, tool, event, sample,
+                return deliver_sample_value(evlist, tool, event, sample,
                                            &sample->read.one, machine);
 }
-int perf_session__deliver_event(struct perf_session *session,
+static int machines__deliver_event(struct machines *machines,
-                                union perf_event *event,
+                                   struct perf_evlist *evlist,
-                                struct perf_sample *sample,
+                                   union perf_event *event,
-                                struct perf_tool *tool, u64 file_offset)
+                                   struct perf_sample *sample,
+                                   struct perf_tool *tool, u64 file_offset)
 {
        struct perf_evsel *evsel;
        struct machine *machine;
-        dump_event(session, event, file_offset, sample);
+        dump_event(evlist, event, file_offset, sample);
-        evsel = perf_evlist__id2evsel(session->evlist, sample->id);
+        evsel = perf_evlist__id2evsel(evlist, sample->id);
-        machine = perf_session__find_machine_for_cpumode(session, event,
+        machine = machines__find_for_cpumode(machines, event, sample);
-                                                         sample);
        switch (event->header.type) {
        case PERF_RECORD_SAMPLE:
                dump_sample(evsel, event, sample);
                if (evsel == NULL) {
-                        ++session->stats.nr_unknown_id;
+                        ++evlist->stats.nr_unknown_id;
                        return 0;
                }
                if (machine == NULL) {
-                        ++session->stats.nr_unprocessable_samples;
+                        ++evlist->stats.nr_unprocessable_samples;
                        return 0;
                }
-                return perf_session__deliver_sample(session, tool, event,
+                return perf_evlist__deliver_sample(evlist, tool, event, sample, evsel, machine);
-                                                    sample, evsel, machine);
        case PERF_RECORD_MMAP:
                return tool->mmap(tool, event, sample, machine);
        case PERF_RECORD_MMAP2:
@@ -883,7 +922,7 @@ int perf_session__deliver_event(struct perf_session *session,
                return tool->exit(tool, event, sample, machine);
        case PERF_RECORD_LOST:
                if (tool->lost == perf_event__process_lost)
-                        session->stats.total_lost += event->lost.lost;
+                        evlist->stats.total_lost += event->lost.lost;
                return tool->lost(tool, event, sample, machine);
        case PERF_RECORD_READ:
                return tool->read(tool, event, sample, evsel, machine);
@@ -892,20 +931,21 @@ int perf_session__deliver_event(struct perf_session *session,
        case PERF_RECORD_UNTHROTTLE:
                return tool->unthrottle(tool, event, sample, machine);
        default:
-                ++session->stats.nr_unknown_events;
+                ++evlist->stats.nr_unknown_events;
                return -1;
        }
 }
 static s64 perf_session__process_user_event(struct perf_session *session,
                                            union perf_event *event,
-                                            struct perf_tool *tool,
                                            u64 file_offset)
 {
+        struct ordered_events *oe = &session->ordered_events;
+        struct perf_tool *tool = oe->tool;
        int fd = perf_data_file__fd(session->file);
        int err;
-        dump_event(session, event, file_offset, NULL);
+        dump_event(session->evlist, event, file_offset, NULL);
        /* These events are processed right away */
        switch (event->header.type) {
@@ -929,7 +969,7 @@ static s64 perf_session__process_user_event(struct perf_session *session,
        case PERF_RECORD_HEADER_BUILD_ID:
                return tool->build_id(tool, event, session);
        case PERF_RECORD_FINISHED_ROUND:
-                return tool->finished_round(tool, event, session);
+                return tool->finished_round(tool, event, oe);
        case PERF_RECORD_ID_INDEX:
                return tool->id_index(tool, event, session);
        default:
@@ -939,15 +979,17 @@ static s64 perf_session__process_user_event(struct perf_session *session,
 int perf_session__deliver_synth_event(struct perf_session *session,
                                      union perf_event *event,
-                                      struct perf_sample *sample,
+                                      struct perf_sample *sample)
-                                      struct perf_tool *tool)
 {
-        events_stats__inc(&session->stats, event->header.type);
+        struct perf_evlist *evlist = session->evlist;
+        struct perf_tool *tool = session->ordered_events.tool;
+        events_stats__inc(&evlist->stats, event->header.type);
        if (event->header.type >= PERF_RECORD_USER_TYPE_START)
-                return perf_session__process_user_event(session, event, tool, 0);
+                return perf_session__process_user_event(session, event, 0);
-        return perf_session__deliver_event(session, event, sample, tool, 0);
+        return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0);
 }
 static void event_swap(union perf_event *event, bool sample_id_all)
@@ -1015,40 +1057,39 @@ out_parse_sample:
 }
 static s64 perf_session__process_event(struct perf_session *session,
-                                       union perf_event *event,
+                                       union perf_event *event, u64 file_offset)
-                                       struct perf_tool *tool,
-                                       u64 file_offset)
 {
+        struct perf_evlist *evlist = session->evlist;
+        struct perf_tool *tool = session->ordered_events.tool;
        struct perf_sample sample;
        int ret;
        if (session->header.needs_swap)
-                event_swap(event, perf_evlist__sample_id_all(session->evlist));
+                event_swap(event, perf_evlist__sample_id_all(evlist));
        if (event->header.type >= PERF_RECORD_HEADER_MAX)
                return -EINVAL;
-        events_stats__inc(&session->stats, event->header.type);
+        events_stats__inc(&evlist->stats, event->header.type);
        if (event->header.type >= PERF_RECORD_USER_TYPE_START)
-                return perf_session__process_user_event(session, event, tool, file_offset);
+                return perf_session__process_user_event(session, event, file_offset);
        /*
         * For all kernel events we get the sample data
         */
-        ret = perf_evlist__parse_sample(session->evlist, event, &sample);
+        ret = perf_evlist__parse_sample(evlist, event, &sample);
        if (ret)
                return ret;
        if (tool->ordered_events) {
-                ret = perf_session_queue_event(session, event, tool, &sample,
+                ret = perf_session__queue_event(session, event, &sample, file_offset);
-                                               file_offset);
                if (ret != -ETIME)
                        return ret;
        }
-        return perf_session__deliver_event(session, event, &sample, tool,
+        return machines__deliver_event(&session->machines, evlist, event,
-                                           file_offset);
+                                       &sample, tool, file_offset);
 }
 void perf_event_header__bswap(struct perf_event_header *hdr)
@@ -1076,54 +1117,55 @@ static struct thread *perf_session__register_idle_thread(struct perf_session *se
        return thread;
 }
-static void perf_session__warn_about_errors(const struct perf_session *session,
+static void perf_tool__warn_about_errors(const struct perf_tool *tool,
-                                            const struct perf_tool *tool)
+                                         const struct events_stats *stats)
 {
        if (tool->lost == perf_event__process_lost &&
-            session->stats.nr_events[PERF_RECORD_LOST] != 0) {
+            stats->nr_events[PERF_RECORD_LOST] != 0) {
                ui__warning("Processed %d events and lost %d chunks!\n\n"
                            "Check IO/CPU overload!\n\n",
-                            session->stats.nr_events[0],
+                            stats->nr_events[0],
-                            session->stats.nr_events[PERF_RECORD_LOST]);
+                            stats->nr_events[PERF_RECORD_LOST]);
        }
-        if (session->stats.nr_unknown_events != 0) {
+        if (stats->nr_unknown_events != 0) {
                ui__warning("Found %u unknown events!\n\n"
                            "Is this an older tool processing a perf.data "
                            "file generated by a more recent tool?\n\n"
                            "If that is not the case, consider "
                            "reporting to linux-kernel@vger.kernel.org.\n\n",
-                            session->stats.nr_unknown_events);
+                            stats->nr_unknown_events);
        }
-        if (session->stats.nr_unknown_id != 0) {
+        if (stats->nr_unknown_id != 0) {
                ui__warning("%u samples with id not present in the header\n",
-                            session->stats.nr_unknown_id);
+                            stats->nr_unknown_id);
        }
-        if (session->stats.nr_invalid_chains != 0) {
+        if (stats->nr_invalid_chains != 0) {
-                ui__warning("Found invalid callchains!\n\n"
+                ui__warning("Found invalid callchains!\n\n"
-                            "%u out of %u events were discarded for this reason.\n\n"
+                            "%u out of %u events were discarded for this reason.\n\n"
-                            "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
+                            "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
-                            session->stats.nr_invalid_chains,
+                            stats->nr_invalid_chains,
-                            session->stats.nr_events[PERF_RECORD_SAMPLE]);
+                            stats->nr_events[PERF_RECORD_SAMPLE]);
-        }
+        }
-        if (session->stats.nr_unprocessable_samples != 0) {
+        if (stats->nr_unprocessable_samples != 0) {
                ui__warning("%u unprocessable samples recorded.\n"
                            "Do you have a KVM guest running and not using 'perf kvm'?\n",
-                            session->stats.nr_unprocessable_samples);
+                            stats->nr_unprocessable_samples);
        }
-        if (session->stats.nr_unordered_events != 0)
+        if (stats->nr_unordered_events != 0)
-                ui__warning("%u out of order events recorded.\n", session->stats.nr_unordered_events);
+                ui__warning("%u out of order events recorded.\n", stats->nr_unordered_events);
 }
 volatile int session_done;
-static int __perf_session__process_pipe_events(struct perf_session *session,
+static int __perf_session__process_pipe_events(struct perf_session *session)
-                                               struct perf_tool *tool)
 {
+        struct ordered_events *oe = &session->ordered_events;
+        struct perf_tool *tool = oe->tool;
        int fd = perf_data_file__fd(session->file);
        union perf_event *event;
        uint32_t size, cur_size = 0;
@@ -1187,7 +1229,7 @@ more:
                }
        }
-        if ((skip = perf_session__process_event(session, event, tool, head)) < 0) {
+        if ((skip = perf_session__process_event(session, event, head)) < 0) {
                pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
                       head, event->header.size, event->header.type);
                err = -EINVAL;
@@ -1203,10 +1245,10 @@ more:
                goto more;
 done:
        /* do the final flush for ordered samples */
-        err = ordered_events__flush(session, tool, OE_FLUSH__FINAL);
+        err = ordered_events__flush(oe, OE_FLUSH__FINAL);
 out_err:
        free(buf);
-        perf_session__warn_about_errors(session, tool);
+        perf_tool__warn_about_errors(tool, &session->evlist->stats);
        ordered_events__free(&session->ordered_events);
        return err;
 }
@@ -1253,8 +1295,10 @@ fetch_mmaped_event(struct perf_session *session,
 static int __perf_session__process_events(struct perf_session *session,
                                          u64 data_offset, u64 data_size,
-                                          u64 file_size, struct perf_tool *tool)
+                                          u64 file_size)
 {
+        struct ordered_events *oe = &session->ordered_events;
+        struct perf_tool *tool = oe->tool;
        int fd = perf_data_file__fd(session->file);
        u64 head, page_offset, file_offset, file_pos, size;
        int err, mmap_prot, mmap_flags, map_idx = 0;
@@ -1323,8 +1367,7 @@ more:
        size = event->header.size;
        if (size < sizeof(struct perf_event_header) ||
-            (skip = perf_session__process_event(session, event, tool, file_pos))
+            (skip = perf_session__process_event(session, event, file_pos)) < 0) {
-                                                                        < 0) {
                pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
                       file_offset + head, event->header.size,
                       event->header.type);
@@ -1348,17 +1391,16 @@ more:
 out:
        /* do the final flush for ordered samples */
-        err = ordered_events__flush(session, tool, OE_FLUSH__FINAL);
+        err = ordered_events__flush(oe, OE_FLUSH__FINAL);
 out_err:
        ui_progress__finish();
-        perf_session__warn_about_errors(session, tool);
+        perf_tool__warn_about_errors(tool, &session->evlist->stats);
        ordered_events__free(&session->ordered_events);
        session->one_mmap = false;
        return err;
 }
-int perf_session__process_events(struct perf_session *session,
+int perf_session__process_events(struct perf_session *session)
-                                 struct perf_tool *tool)
 {
        u64 size = perf_data_file__size(session->file);
        int err;
@@ -1369,10 +1411,9 @@ int perf_session__process_events(struct perf_session *session,
        if (!perf_data_file__is_pipe(session->file))
                err = __perf_session__process_events(session,
                                                     session->header.data_offset,
-                                                     session->header.data_size,
+                                                     session->header.data_size, size);
-                                                     size, tool);
        else
-                err = __perf_session__process_pipe_events(session, tool);
+                err = __perf_session__process_pipe_events(session);
        return err;
 }
@@ -1436,7 +1477,7 @@ size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
 {
        size_t ret = fprintf(fp, "Aggregated stats:\n");
-        ret += events_stats__fprintf(&session->stats, fp);
+        ret += events_stats__fprintf(&session->evlist->stats, fp);
        return ret;
 }
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 6d663dc76404..1310998f8318 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -20,7 +20,6 @@ struct perf_session {
        struct machines         machines;
        struct perf_evlist      *evlist;
        struct trace_event      tevent;
-        struct events_stats     stats;
        bool                    repipe;
        bool                    one_mmap;
        void                    *one_mmap_addr;
@@ -49,20 +48,13 @@ int perf_session__peek_event(struct perf_session *session, off_t file_offset,
                             union perf_event **event_ptr,
                             struct perf_sample *sample);
-int perf_session__process_events(struct perf_session *session,
+int perf_session__process_events(struct perf_session *session);
-                                 struct perf_tool *tool);
-int perf_session_queue_event(struct perf_session *s, union perf_event *event,
+int perf_session__queue_event(struct perf_session *s, union perf_event *event,
-                             struct perf_tool *tool, struct perf_sample *sample,
+                              struct perf_sample *sample, u64 file_offset);
-                             u64 file_offset);
 void perf_tool__fill_defaults(struct perf_tool *tool);
-int perf_session__deliver_event(struct perf_session *session,
-                                union perf_event *event,
-                                struct perf_sample *sample,
-                                struct perf_tool *tool, u64 file_offset);
 int perf_session__resolve_callchain(struct perf_session *session,
                                    struct perf_evsel *evsel,
                                    struct thread *thread,
@@ -126,8 +118,7 @@ extern volatile int session_done;
 int perf_session__deliver_synth_event(struct perf_session *session,
                                      union perf_event *event,
-                                      struct perf_sample *sample,
+                                      struct perf_sample *sample);
-                                      struct perf_tool *tool);
 int perf_event__process_id_index(struct perf_tool *tool,
                                 union perf_event *event,
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index d0aee4b9dfd4..1833103768cb 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -25,7 +25,7 @@ cflags += ['-fno-strict-aliasing', '-Wno-write-strings', '-Wno-unused-parameter'
 build_lib = getenv('PYTHON_EXTBUILD_LIB')
 build_tmp = getenv('PYTHON_EXTBUILD_TMP')
 libtraceevent = getenv('LIBTRACEEVENT')
-libapikfs = getenv('LIBAPIKFS')
+libapikfs = getenv('LIBAPI')
 ext_sources = [f.strip() for f in file('util/python-ext-sources')
                                if len(f.strip()) > 0 and f[0] != '#']
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 7a39c1ed8d37..4593f36ecc4c 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1463,6 +1463,15 @@ int sort_dimension__add(const char *tok)
                        sort__has_parent = 1;
                } else if (sd->entry == &sort_sym) {
                        sort__has_sym = 1;
+                        /*
+                         * perf diff displays the performance difference amongst
+                         * two or more perf.data files. Those files could come
+                         * from different binaries. So we should not compare
+                         * their ips, but the name of symbol.
+                         */
+                        if (sort__mode == SORT_MODE__DIFF)
+                                sd->entry->se_collapse = sort__sym_sort;
                } else if (sd->entry == &sort_dso) {
                        sort__has_dso = 1;
                }
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index c03e4ff8beff..846036a921dc 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -44,6 +44,7 @@ extern struct sort_entry sort_dso_to;
 extern struct sort_entry sort_sym_from;
 extern struct sort_entry sort_sym_to;
 extern enum sort_type sort__first_dimension;
+extern const char default_mem_sort_order[];
 struct he_stat {
        u64                     period;
@@ -102,7 +103,6 @@ struct hist_entry {
        bool                    init_have_children;
        char                    level;
-        bool                    used;
        u8                      filtered;
        char                    *srcline;
        struct symbol           *parent;
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 33b7a2aef713..476268c99431 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -74,6 +74,10 @@ static inline uint8_t elf_sym__type(const GElf_Sym *sym)
        return GELF_ST_TYPE(sym->st_info);
 }
+#ifndef STT_GNU_IFUNC
+#define STT_GNU_IFUNC 10
+#endif
 static inline int elf_sym__is_function(const GElf_Sym *sym)
 {
        return (elf_sym__type(sym) == STT_FUNC ||
@@ -575,32 +579,37 @@ static int dso__swap_init(struct dso *dso, unsigned char eidata)
 static int decompress_kmodule(struct dso *dso, const char *name,
                              enum dso_binary_type type)
 {
-        int fd;
+        int fd = -1;
-        const char *ext = strrchr(name, '.');
        char tmpbuf[] = "/tmp/perf-kmod-XXXXXX";
+        struct kmod_path m;
        if (type != DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP &&
            type != DSO_BINARY_TYPE__GUEST_KMODULE_COMP &&
            type != DSO_BINARY_TYPE__BUILD_ID_CACHE)
                return -1;
-        if (!ext || !is_supported_compression(ext + 1)) {
+        if (type == DSO_BINARY_TYPE__BUILD_ID_CACHE)
-                ext = strrchr(dso->name, '.');
+                name = dso->long_name;
-                if (!ext || !is_supported_compression(ext + 1))
-                        return -1;
-        }
-        fd = mkstemp(tmpbuf);
+        if (kmod_path__parse_ext(&m, name) || !m.comp)
-        if (fd < 0)
                return -1;
-        if (!decompress_to_file(ext + 1, name, fd)) {
+        fd = mkstemp(tmpbuf);
+        if (fd < 0) {
+                dso->load_errno = errno;
+                goto out;
+        }
+        if (!decompress_to_file(m.ext, name, fd)) {
+                dso->load_errno = DSO_LOAD_ERRNO__DECOMPRESSION_FAILURE;
                close(fd);
                fd = -1;
        }
        unlink(tmpbuf);
+out:
+        free(m.ext);
        return fd;
 }
@@ -629,37 +638,49 @@ int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
        Elf *elf;
        int fd;
-        if (dso__needs_decompress(dso))
+        if (dso__needs_decompress(dso)) {
                fd = decompress_kmodule(dso, name, type);
-        else
+                if (fd < 0)
+                        return -1;
+        } else {
                fd = open(name, O_RDONLY);
+                if (fd < 0) {
-        if (fd < 0)
+                        dso->load_errno = errno;
-                return -1;
+                        return -1;
+                }
+        }
        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
        if (elf == NULL) {
                pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
+                dso->load_errno = DSO_LOAD_ERRNO__INVALID_ELF;
                goto out_close;
        }
        if (gelf_getehdr(elf, &ehdr) == NULL) {
+                dso->load_errno = DSO_LOAD_ERRNO__INVALID_ELF;
                pr_debug("%s: cannot get elf header.\n", __func__);
                goto out_elf_end;
        }
-        if (dso__swap_init(dso, ehdr.e_ident[EI_DATA]))
+        if (dso__swap_init(dso, ehdr.e_ident[EI_DATA])) {
+                dso->load_errno = DSO_LOAD_ERRNO__INTERNAL_ERROR;
                goto out_elf_end;
+        }
        /* Always reject images with a mismatched build-id: */
        if (dso->has_build_id) {
                u8 build_id[BUILD_ID_SIZE];
-                if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
+                if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0) {
+                        dso->load_errno = DSO_LOAD_ERRNO__CANNOT_READ_BUILDID;
                        goto out_elf_end;
+                }
-                if (!dso__build_id_equal(dso, build_id))
+                if (!dso__build_id_equal(dso, build_id)) {
+                        dso->load_errno = DSO_LOAD_ERRNO__MISMATCHING_BUILDID;
                        goto out_elf_end;
+                }
        }
        ss->is_64_bit = (gelf_getclass(elf) == ELFCLASS64);
@@ -695,8 +716,10 @@ int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
        }
        ss->name   = strdup(name);
-        if (!ss->name)
+        if (!ss->name) {
+                dso->load_errno = errno;
                goto out_elf_end;
+        }
        ss->elf    = elf;
        ss->fd     = fd;
@@ -864,10 +887,9 @@ int dso__load_sym(struct dso *dso, struct map *map,
                /* Reject ARM ELF "mapping symbols": these aren't unique and
                 * don't identify functions, so will confuse the profile
                 * output: */
-                if (ehdr.e_machine == EM_ARM) {
+                if (ehdr.e_machine == EM_ARM || ehdr.e_machine == EM_AARCH64) {
-                        if (!strcmp(elf_name, "$a") ||
+                        if (elf_name[0] == '$' && strchr("adtx", elf_name[1])
-                            !strcmp(elf_name, "$d") ||
+                            && (elf_name[2] == '\0' || elf_name[2] == '.'))
-                            !strcmp(elf_name, "$t"))
                                continue;
                }
@@ -1045,7 +1067,8 @@ new_symbol:
         * For misannotated, zeroed, ASM function sizes.
         */
        if (nr > 0) {
-                symbols__fixup_duplicate(&dso->symbols[map->type]);
+                if (!symbol_conf.allow_aliases)
+                        symbols__fixup_duplicate(&dso->symbols[map->type]);
                symbols__fixup_end(&dso->symbols[map->type]);
                if (kmap) {
                        /*
diff --git a/tools/perf/util/symbol-minimal.c b/tools/perf/util/symbol-minimal.c
index d7efb03b3f9a..fd8477cacf88 100644
--- a/tools/perf/util/symbol-minimal.c
+++ b/tools/perf/util/symbol-minimal.c
@@ -246,13 +246,12 @@ out:
        return ret;
 }
-int symsrc__init(struct symsrc *ss, struct dso *dso __maybe_unused,
+int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
-                 const char *name,
                 enum dso_binary_type type)
 {
        int fd = open(name, O_RDONLY);
        if (fd < 0)
-                return -1;
+                goto out_errno;
        ss->name = strdup(name);
        if (!ss->name)
@@ -264,6 +263,8 @@ int symsrc__init(struct symsrc *ss, struct dso *dso __maybe_unused,
        return 0;
 out_close:
        close(fd);
+out_errno:
+        dso->load_errno = errno;
        return -1;
 }
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index a69066865a55..fddeb9073039 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -15,6 +15,7 @@
 #include "machine.h"
 #include "symbol.h"
 #include "strlist.h"
+#include "intlist.h"
 #include "header.h"
 #include <elf.h>
@@ -1859,6 +1860,20 @@ int setup_list(struct strlist **list, const char *list_str,
        return 0;
 }
+int setup_intlist(struct intlist **list, const char *list_str,
+                  const char *list_name)
+{
+        if (list_str == NULL)
+                return 0;
+        *list = intlist__new(list_str);
+        if (!*list) {
+                pr_err("problems parsing %s list\n", list_name);
+                return -1;
+        }
+        return 0;
+}
 static bool symbol__read_kptr_restrict(void)
 {
        bool value = false;
@@ -1909,9 +1924,17 @@ int symbol__init(struct perf_session_env *env)
                       symbol_conf.comm_list_str, "comm") < 0)
                goto out_free_dso_list;
+        if (setup_intlist(&symbol_conf.pid_list,
+                       symbol_conf.pid_list_str, "pid") < 0)
+                goto out_free_comm_list;
+        if (setup_intlist(&symbol_conf.tid_list,
+                       symbol_conf.tid_list_str, "tid") < 0)
+                goto out_free_pid_list;
        if (setup_list(&symbol_conf.sym_list,
                       symbol_conf.sym_list_str, "symbol") < 0)
-                goto out_free_comm_list;
+                goto out_free_tid_list;
        /*
         * A path to symbols of "/" is identical to ""
@@ -1930,6 +1953,10 @@ int symbol__init(struct perf_session_env *env)
        symbol_conf.initialized = true;
        return 0;
+out_free_tid_list:
+        intlist__delete(symbol_conf.tid_list);
+out_free_pid_list:
+        intlist__delete(symbol_conf.pid_list);
 out_free_comm_list:
        strlist__delete(symbol_conf.comm_list);
 out_free_dso_list:
@@ -1944,6 +1971,8 @@ void symbol__exit(void)
        strlist__delete(symbol_conf.sym_list);
        strlist__delete(symbol_conf.dso_list);
        strlist__delete(symbol_conf.comm_list);
+        intlist__delete(symbol_conf.tid_list);
+        intlist__delete(symbol_conf.pid_list);
        vmlinux_path__exit();
        symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
        symbol_conf.initialized = false;
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 1650dcb3a67b..09561500164a 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -78,6 +78,7 @@ static inline size_t symbol__size(const struct symbol *sym)
 }
 struct strlist;
+struct intlist;
 struct symbol_conf {
        unsigned short  priv_size;
@@ -87,6 +88,7 @@ struct symbol_conf {
                        ignore_vmlinux_buildid,
                        show_kernel_path,
                        use_modules,
+                        allow_aliases,
                        sort_by_name,
                        show_nr_samples,
                        show_total_period,
@@ -114,6 +116,8 @@ struct symbol_conf {
        const char      *guestmount;
        const char      *dso_list_str,
                        *comm_list_str,
+                        *pid_list_str,
+                        *tid_list_str,
                        *sym_list_str,
                        *col_width_list_str;
       struct strlist   *dso_list,
@@ -123,6 +127,8 @@ struct symbol_conf {
                        *dso_to_list,
                        *sym_from_list,
                        *sym_to_list;
+        struct intlist  *pid_list,
+                        *tid_list;
        const char      *symfs;
 };
@@ -294,5 +300,7 @@ int compare_proc_modules(const char *from, const char *to);
 int setup_list(struct strlist **list, const char *list_str,
               const char *list_name);
+int setup_intlist(struct intlist **list, const char *list_str,
+                  const char *list_name);
 #endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/target.c b/tools/perf/util/target.c
index e74c5963dc7a..a53603b27e52 100644
--- a/tools/perf/util/target.c
+++ b/tools/perf/util/target.c
@@ -123,11 +123,8 @@ int target__strerror(struct target *target, int errnum,
        if (errnum >= 0) {
                const char *err = strerror_r(errnum, buf, buflen);
-                if (err != buf) {
+                if (err != buf)
-                        size_t len = strlen(err);
+                        scnprintf(buf, buflen, "%s", err);
-                        memcpy(buf, err, min(buflen - 1, len));
-                        *(buf + min(buflen - 1, len)) = '\0';
-                }
                return 0;
        }
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 9ebc8b1f9be5..1c8fbc9588c5 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -82,6 +82,20 @@ void thread__delete(struct thread *thread)
        free(thread);
 }
+struct thread *thread__get(struct thread *thread)
+{
+        ++thread->refcnt;
+        return thread;
+}
+void thread__put(struct thread *thread)
+{
+        if (thread && --thread->refcnt == 0) {
+                list_del_init(&thread->node);
+                thread__delete(thread);
+        }
+}
 struct comm *thread__comm(const struct thread *thread)
 {
        if (list_empty(&thread->comm_list))
@@ -192,7 +206,6 @@ int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp)
                err = thread__set_comm(thread, comm, timestamp);
                if (err)
                        return err;
-                thread->comm_set = true;
        }
        thread->ppid = parent->tid;
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 160fd066a7d1..9b8a54dc34a8 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -7,6 +7,7 @@
 #include <sys/types.h>
 #include "symbol.h"
 #include <strlist.h>
+#include <intlist.h>
 struct thread_stack;
@@ -20,6 +21,7 @@ struct thread {
        pid_t                   tid;
        pid_t                   ppid;
        int                     cpu;
+        int                     refcnt;
        char                    shortname[3];
        bool                    comm_set;
        bool                    dead; /* if set thread has exited */
@@ -37,6 +39,18 @@ struct comm;
 struct thread *thread__new(pid_t pid, pid_t tid);
 int thread__init_map_groups(struct thread *thread, struct machine *machine);
 void thread__delete(struct thread *thread);
+struct thread *thread__get(struct thread *thread);
+void thread__put(struct thread *thread);
+static inline void __thread__zput(struct thread **thread)
+{
+        thread__put(*thread);
+        *thread = NULL;
+}
+#define thread__zput(thread) __thread__zput(&thread)
 static inline void thread__exited(struct thread *thread)
 {
        thread->dead = true;
@@ -87,6 +101,16 @@ static inline bool thread__is_filtered(struct thread *thread)
                return true;
        }
+        if (symbol_conf.pid_list &&
+            !intlist__has_entry(symbol_conf.pid_list, thread->pid_)) {
+                return true;
+        }
+        if (symbol_conf.tid_list &&
+            !intlist__has_entry(symbol_conf.tid_list, thread->tid)) {
+                return true;
+        }
        return false;
 }
diff --git a/tools/perf/util/tool.h b/tools/perf/util/tool.h
index bb2708bbfaca..51d9e56c0f84 100644
--- a/tools/perf/util/tool.h
+++ b/tools/perf/util/tool.h
@@ -10,6 +10,7 @@ struct perf_evsel;
 struct perf_sample;
 struct perf_tool;
 struct machine;
+struct ordered_events;
 typedef int (*event_sample)(struct perf_tool *tool, union perf_event *event,
                            struct perf_sample *sample,
@@ -25,6 +26,9 @@ typedef int (*event_attr_op)(struct perf_tool *tool,
 typedef int (*event_op2)(struct perf_tool *tool, union perf_event *event,
                         struct perf_session *session);
+typedef int (*event_oe)(struct perf_tool *tool, union perf_event *event,
+                        struct ordered_events *oe);
 struct perf_tool {
        event_sample    sample,
                        read;
@@ -38,8 +42,8 @@ struct perf_tool {
                        unthrottle;
        event_attr_op   attr;
        event_op2       tracing_data;
-        event_op2       finished_round,
+        event_oe        finished_round;
-                        build_id,
+        event_op2       build_id,
                        id_index;
        bool            ordered_events;
        bool            ordering_requires_timestamps;
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index c36636fd825b..25d6c737be3e 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -112,8 +112,8 @@ unsigned long long read_size(struct event_format *event, void *ptr, int size)
        return pevent_read_number(event->pevent, ptr, size);
 }
-void event_format__print(struct event_format *event,
+void event_format__fprintf(struct event_format *event,
-                         int cpu, void *data, int size)
+                           int cpu, void *data, int size, FILE *fp)
 {
        struct pevent_record record;
        struct trace_seq s;
@@ -125,10 +125,16 @@ void event_format__print(struct event_format *event,
        trace_seq_init(&s);
        pevent_event_info(&s, event, &record);
-        trace_seq_do_printf(&s);
+        trace_seq_do_fprintf(&s, fp);
        trace_seq_destroy(&s);
 }
+void event_format__print(struct event_format *event,
+                         int cpu, void *data, int size)
+{
+        return event_format__fprintf(event, cpu, data, size, stdout);
+}
 void parse_proc_kallsyms(struct pevent *pevent,
                         char *file, unsigned int size __maybe_unused)
 {
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 52aaa19e1eb1..356629a30ca9 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -23,6 +23,9 @@ trace_event__tp_format(const char *sys, const char *name);
 int bigendian(void);
+void event_format__fprintf(struct event_format *event,
+                           int cpu, void *data, int size, FILE *fp);
 void event_format__print(struct event_format *event,
                         int cpu, void *data, int size);
diff --git a/tools/perf/util/unwind-libunwind.c b/tools/perf/util/unwind-libunwind.c
index e3c40a520a25..7b09a443a280 100644
--- a/tools/perf/util/unwind-libunwind.c
+++ b/tools/perf/util/unwind-libunwind.c
@@ -266,7 +266,7 @@ static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine,
                                     u64 *fde_count)
 {
        int ret = -EINVAL, fd;
-        u64 offset = dso->data.frame_offset;
+        u64 offset = dso->data.eh_frame_hdr_offset;
        if (offset == 0) {
                fd = dso__data_fd(dso, machine);
@@ -275,7 +275,7 @@ static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine,
                /* Check the .eh_frame section for unwinding info */
                offset = elf_section_offset(fd, ".eh_frame_hdr");
-                dso->data.frame_offset = offset;
+                dso->data.eh_frame_hdr_offset = offset;
        }
        if (offset)
@@ -291,7 +291,7 @@ static int read_unwind_spec_debug_frame(struct dso *dso,
                                        struct machine *machine, u64 *offset)
 {
        int fd;
-        u64 ofs = dso->data.frame_offset;
+        u64 ofs = dso->data.debug_frame_offset;
        if (ofs == 0) {
                fd = dso__data_fd(dso, machine);
@@ -300,7 +300,7 @@ static int read_unwind_spec_debug_frame(struct dso *dso,
                /* Check the .debug_frame section for unwinding info */
                ofs = elf_section_offset(fd, ".debug_frame");
-                dso->data.frame_offset = ofs;
+                dso->data.debug_frame_offset = ofs;
        }
        *offset = ofs;
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index b86744f29eef..4ee6d0d4c993 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -269,6 +269,13 @@ void dump_stack(void)
 void dump_stack(void) {}
 #endif
+void sighandler_dump_stack(int sig)
+{
+        psignal(sig, "perf");
+        dump_stack();
+        exit(sig);
+}
 void get_term_dimensions(struct winsize *ws)
 {
        char *s = getenv("LINES");
@@ -303,13 +310,26 @@ void set_term_quiet_input(struct termios *old)
        tcsetattr(0, TCSANOW, &tc);
 }
-static void set_tracing_events_path(const char *mountpoint)
+static void set_tracing_events_path(const char *tracing, const char *mountpoint)
 {
-        snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s",
+        snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s%s",
-                 mountpoint, "tracing/events");
+                 mountpoint, tracing, "events");
 }
-const char *perf_debugfs_mount(const char *mountpoint)
+static const char *__perf_tracefs_mount(const char *mountpoint)
+{
+        const char *mnt;
+        mnt = tracefs_mount(mountpoint);
+        if (!mnt)
+                return NULL;
+        set_tracing_events_path("", mnt);
+        return mnt;
+}
+static const char *__perf_debugfs_mount(const char *mountpoint)
 {
        const char *mnt;
@@ -317,7 +337,20 @@ const char *perf_debugfs_mount(const char *mountpoint)
        if (!mnt)
                return NULL;
-        set_tracing_events_path(mnt);
+        set_tracing_events_path("tracing/", mnt);
+        return mnt;
+}
+const char *perf_debugfs_mount(const char *mountpoint)
+{
+        const char *mnt;
+        mnt = __perf_tracefs_mount(mountpoint);
+        if (mnt)
+                return mnt;
+        mnt = __perf_debugfs_mount(mountpoint);
        return mnt;
 }
@@ -325,12 +358,19 @@ const char *perf_debugfs_mount(const char *mountpoint)
 void perf_debugfs_set_path(const char *mntpt)
 {
        snprintf(debugfs_mountpoint, strlen(debugfs_mountpoint), "%s", mntpt);
-        set_tracing_events_path(mntpt);
+        set_tracing_events_path("tracing/", mntpt);
+}
+static const char *find_tracefs(void)
+{
+        const char *path = __perf_tracefs_mount(NULL);
+        return path;
 }
 static const char *find_debugfs(void)
 {
-        const char *path = perf_debugfs_mount(NULL);
+        const char *path = __perf_debugfs_mount(NULL);
        if (!path)
                fprintf(stderr, "Your kernel does not support the debugfs filesystem");
@@ -344,6 +384,7 @@ static const char *find_debugfs(void)
 */
 const char *find_tracing_dir(void)
 {
+        const char *tracing_dir = "";
        static char *tracing;
        static int tracing_found;
        const char *debugfs;
@@ -351,11 +392,15 @@ const char *find_tracing_dir(void)
        if (tracing_found)
                return tracing;
-        debugfs = find_debugfs();
+        debugfs = find_tracefs();
-        if (!debugfs)
+        if (!debugfs) {
-                return NULL;
+                tracing_dir = "/tracing";
+                debugfs = find_debugfs();
+                if (!debugfs)
+                        return NULL;
+        }
-        if (asprintf(&tracing, "%s/tracing", debugfs) < 0)
+        if (asprintf(&tracing, "%s%s", debugfs, tracing_dir) < 0)
                return NULL;
        tracing_found = 1;
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 027a5153495c..1ff23e04ad27 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -75,6 +75,7 @@
 #include <linux/types.h>
 #include <sys/ttydefaults.h>
 #include <api/fs/debugfs.h>
+#include <api/fs/tracefs.h>
 #include <termios.h>
 #include <linux/bitops.h>
 #include <termios.h>
@@ -276,6 +277,7 @@ char *ltrim(char *s);
 char *rtrim(char *s);
 void dump_stack(void);
+void sighandler_dump_stack(int sig);
 extern unsigned int page_size;
 extern int cacheline_size;
@@ -327,4 +329,8 @@ bool find_process(const char *name);
 int gzip_decompress_to_file(const char *input, int output_fd);
 #endif
+#ifdef HAVE_LZMA_SUPPORT
+int lzma_decompress_to_file(const char *input, int output_fd);
+#endif
 #endif /* GIT_COMPAT_UTIL_H */
author	Ingo Molnar <mingo@kernel.org>	2015-03-27 05:10:47 -0400
committer	Ingo Molnar <mingo@kernel.org>	2015-03-27 05:10:47 -0400
commit	b381e63b48a0b6befc7b4e55408c39012a0dcf8c (patch)
tree	92e70447e1b0cf721ef40515db6b97cb881c5066 /tools
parent	4e6d7c2aa95158315902647963b359b32da5c295 (diff)
parent	ccd41c86ad4d464d0ed4e48d80759ff85c2115b0 (diff)