106 files changed, 2731 insertions, 813 deletions

diff --git a/tools/perf/Documentation/intel-pt.txt b/tools/perf/Documentation/intel-pt.txt
index b0b3007d3c9c..4b6cdbf8f935 100644
--- a/tools/perf/Documentation/intel-pt.txt
+++ b/tools/perf/Documentation/intel-pt.txt
@@ -108,6 +108,9 @@ approach is available to export the data to a postgresql database.  Refer to
 script export-to-postgresql.py for more details, and to script
 call-graph-from-postgresql.py for an example of using the database.
 
+There is also script intel-pt-events.py which provides an example of how to
+unpack the raw data for power events and PTWRITE.
+
 As mentioned above, it is easy to capture too much data.  One way to limit the
 data captured is to use 'snapshot' mode which is explained further below.
 Refer to 'new snapshot option' and 'Intel PT modes of operation' further below.
@@ -364,6 +367,42 @@ cyc_thresh	Specifies how frequently CYC packets are produced - see cyc
 
                 CYC packets are not requested by default.
 
+pt              Specifies pass-through which enables the 'branch' config term.
+
+                The default config selects 'pt' if it is available, so a user will
+                never need to specify this term.
+
+branch          Enable branch tracing.  Branch tracing is enabled by default so to
+                disable branch tracing use 'branch=0'.
+
+                The default config selects 'branch' if it is available.
+
+ptw             Enable PTWRITE packets which are produced when a ptwrite instruction
+                is executed.
+
+                Support for this feature is indicated by:
+
+                        /sys/bus/event_source/devices/intel_pt/caps/ptwrite
+
+                which contains "1" if the feature is supported and
+                "0" otherwise.
+
+fup_on_ptw      Enable a FUP packet to follow the PTWRITE packet.  The FUP packet
+                provides the address of the ptwrite instruction.  In the absence of
+                fup_on_ptw, the decoder will use the address of the previous branch
+                if branch tracing is enabled, otherwise the address will be zero.
+                Note that fup_on_ptw will work even when branch tracing is disabled.
+
+pwr_evt         Enable power events.  The power events provide information about
+                changes to the CPU C-state.
+
+                Support for this feature is indicated by:
+
+                        /sys/bus/event_source/devices/intel_pt/caps/power_event_trace
+
+                which contains "1" if the feature is supported and
+                "0" otherwise.
+
 
 new snapshot option
 -------------------
@@ -674,13 +713,15 @@ Having no option is the same as
 
 which, in turn, is the same as
 
-        --itrace=ibxe
+        --itrace=ibxwpe
 
 The letters are:
 
         i       synthesize "instructions" events
         b       synthesize "branches" events
         x       synthesize "transactions" events
+        w       synthesize "ptwrite" events
+        p       synthesize "power" events
         c       synthesize branches events (calls only)
         r       synthesize branches events (returns only)
         e       synthesize tracing error events
@@ -699,7 +740,40 @@ and "r" can be combined to get calls and returns.
 'flags' field can be used in perf script to determine whether the event is a
 tranasaction start, commit or abort.
 
-Error events are new.  They show where the decoder lost the trace.  Error events
+Note that "instructions", "branches" and "transactions" events depend on code
+flow packets which can be disabled by using the config term "branch=0".  Refer
+to the config terms section above.
+
+"ptwrite" events record the payload of the ptwrite instruction and whether
+"fup_on_ptw" was used.  "ptwrite" events depend on PTWRITE packets which are
+recorded only if the "ptw" config term was used.  Refer to the config terms
+section above.  perf script "synth" field displays "ptwrite" information like
+this: "ip: 0 payload: 0x123456789abcdef0"  where "ip" is 1 if "fup_on_ptw" was
+used.
+
+"Power" events correspond to power event packets and CBR (core-to-bus ratio)
+packets.  While CBR packets are always recorded when tracing is enabled, power
+event packets are recorded only if the "pwr_evt" config term was used.  Refer to
+the config terms section above.  The power events record information about
+C-state changes, whereas CBR is indicative of CPU frequency.  perf script
+"event,synth" fields display information like this:
+        cbr:  cbr: 22 freq: 2189 MHz (200%)
+        mwait:  hints: 0x60 extensions: 0x1
+        pwre:  hw: 0 cstate: 2 sub-cstate: 0
+        exstop:  ip: 1
+        pwrx:  deepest cstate: 2 last cstate: 2 wake reason: 0x4
+Where:
+        "cbr" includes the frequency and the percentage of maximum non-turbo
+        "mwait" shows mwait hints and extensions
+        "pwre" shows C-state transitions (to a C-state deeper than C0) and
+        whether initiated by hardware
+        "exstop" indicates execution stopped and whether the IP was recorded
+        exactly,
+        "pwrx" indicates return to C0
+For more details refer to the Intel 64 and IA-32 Architectures Software
+Developer Manuals.
+
+Error events show where the decoder lost the trace.  Error events
 are quite important.  Users must know if what they are seeing is a complete
 picture or not.
 
diff --git a/tools/perf/Documentation/itrace.txt b/tools/perf/Documentation/itrace.txt
index e2a4c5e0dbe5..a3abe04c779d 100644
--- a/tools/perf/Documentation/itrace.txt
+++ b/tools/perf/Documentation/itrace.txt
@@ -3,13 +3,15 @@
                 c       synthesize branches events (calls only)
                 r       synthesize branches events (returns only)
                 x       synthesize transactions events
+                w       synthesize ptwrite events
+                p       synthesize power events
                 e       synthesize error events
                 d       create a debug log
                 g       synthesize a call chain (use with i or x)
                 l       synthesize last branch entries (use with i or x)
                 s       skip initial number of events
 
-        The default is all events i.e. the same as --itrace=ibxe
+        The default is all events i.e. the same as --itrace=ibxwpe
 
         In addition, the period (default 100000) for instructions events
         can be specified in units of:
@@ -26,8 +28,8 @@
         Also the number of last branch entries (default 64, max. 1024) for
         instructions or transactions events can be specified.
 
-        It is also possible to skip events generated (instructions, branches, transactions)
-        at the beginning. This is useful to ignore initialization code.
+        It is also possible to skip events generated (instructions, branches, transactions,
+        ptwrite, power) at the beginning. This is useful to ignore initialization code.
 
         --itrace=i0nss1000000
 
diff --git a/tools/perf/Documentation/perf-ftrace.txt b/tools/perf/Documentation/perf-ftrace.txt
index 6e6a8b22c859..721a447f046e 100644
--- a/tools/perf/Documentation/perf-ftrace.txt
+++ b/tools/perf/Documentation/perf-ftrace.txt
@@ -48,6 +48,39 @@ OPTIONS
         Ranges of CPUs are specified with -: 0-2.
         Default is to trace on all online CPUs.
 
+-T::
+--trace-funcs=::
+        Only trace functions given by the argument.  Multiple functions
+        can be given by using this option more than once.  The function
+        argument also can be a glob pattern.  It will be passed to
+        'set_ftrace_filter' in tracefs.
+
+-N::
+--notrace-funcs=::
+        Do not trace functions given by the argument.  Like -T option,
+        this can be used more than once to specify multiple functions
+        (or glob patterns).  It will be passed to 'set_ftrace_notrace'
+        in tracefs.
+
+-G::
+--graph-funcs=::
+        Set graph filter on the given function (or a glob pattern).
+        This is useful for the function_graph tracer only and enables
+        tracing for functions executed from the given function.
+        This can be used more than once to specify multiple functions.
+        It will be passed to 'set_graph_function' in tracefs.
+
+-g::
+--nograph-funcs=::
+        Set graph notrace filter on the given function (or a glob pattern).
+        Like -G option, this is useful for the function_graph tracer only
+        and disables tracing for function executed from the given function.
+        This can be used more than once to specify multiple functions.
+        It will be passed to 'set_graph_notrace' in tracefs.
+
+-D::
+--graph-depth=::
+        Set max depth for function graph tracer to follow
 
 SEE ALSO
 --------
diff --git a/tools/perf/Documentation/perf-probe.txt b/tools/perf/Documentation/perf-probe.txt
index e6c9902c6d82..165c2b1d4317 100644
--- a/tools/perf/Documentation/perf-probe.txt
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -240,9 +240,13 @@ Add a probe on schedule() function 12th line with recording cpu local variable:
  or
  ./perf probe --add='schedule:12 cpu'
 
- this will add one or more probes which has the name start with "schedule".
+Add one or more probes which has the name start with "schedule".
 
- Add probes on lines in schedule() function which calls update_rq_clock().
+ ./perf probe schedule*
+ or
+ ./perf probe --add='schedule*'
+
+Add probes on lines in schedule() function which calls update_rq_clock().
 
  ./perf probe 'schedule;update_rq_clock*'
  or
diff --git a/tools/perf/Documentation/perf-script-perl.txt b/tools/perf/Documentation/perf-script-perl.txt
index dfbb506d2c34..142606c0ec9c 100644
--- a/tools/perf/Documentation/perf-script-perl.txt
+++ b/tools/perf/Documentation/perf-script-perl.txt
@@ -39,7 +39,7 @@ EVENT HANDLERS
 When perf script is invoked using a trace script, a user-defined
 'handler function' is called for each event in the trace.  If there's
 no handler function defined for a given event type, the event is
-ignored (or passed to a 'trace_handled' function, see below) and the
+ignored (or passed to a 'trace_unhandled' function, see below) and the
 next event is processed.
 
 Most of the event's field values are passed as arguments to the
diff --git a/tools/perf/Documentation/perf-script-python.txt b/tools/perf/Documentation/perf-script-python.txt
index 54acba221558..51ec2d20068a 100644
--- a/tools/perf/Documentation/perf-script-python.txt
+++ b/tools/perf/Documentation/perf-script-python.txt
@@ -149,10 +149,8 @@ def raw_syscalls__sys_enter(event_name, context, common_cpu,
                 print "id=%d, args=%s\n" % \
                 (id, args),
 
-def trace_unhandled(event_name, context, common_cpu, common_secs, common_nsecs,
-                common_pid, common_comm):
-                print_header(event_name, common_cpu, common_secs, common_nsecs,
-                common_pid, common_comm)
+def trace_unhandled(event_name, context, event_fields_dict):
+                print ' '.join(['%s=%s'%(k,str(v))for k,v in sorted(event_fields_dict.items())])
 
 def print_header(event_name, cpu, secs, nsecs, pid, comm):
         print "%-20s %5u %05u.%09u %8u %-20s " % \
@@ -321,7 +319,7 @@ So those are the essential steps in writing and running a script.  The
 process can be generalized to any tracepoint or set of tracepoints
 you're interested in - basically find the tracepoint(s) you're
 interested in by looking at the list of available events shown by
-'perf list' and/or look in /sys/kernel/debug/tracing events for
+'perf list' and/or look in /sys/kernel/debug/tracing/events/ for
 detailed event and field info, record the corresponding trace data
 using 'perf record', passing it the list of interesting events,
 generate a skeleton script using 'perf script -g python' and modify the
@@ -334,7 +332,7 @@ right place, you can have your script listed alongside the other
 scripts listed by the 'perf script -l' command e.g.:
 
 ----
-root@tropicana:~# perf script -l
+# perf script -l
 List of available trace scripts:
   wakeup-latency                       system-wide min/max/avg wakeup latency
   rw-by-file <comm>                    r/w activity for a program, by file
@@ -383,8 +381,6 @@ source tree:
 
 ----
 # ls -al kernel-source/tools/perf/scripts/python
-
-root@tropicana:/home/trz/src/tip# ls -al tools/perf/scripts/python
 total 32
 drwxr-xr-x 4 trz trz 4096 2010-01-26 22:30 .
 drwxr-xr-x 4 trz trz 4096 2010-01-26 22:29 ..
@@ -399,7 +395,7 @@ otherwise your script won't show up at run-time), 'perf script -l'
 should show a new entry for your script:
 
 ----
-root@tropicana:~# perf script -l
+# perf script -l
 List of available trace scripts:
   wakeup-latency                       system-wide min/max/avg wakeup latency
   rw-by-file <comm>                    r/w activity for a program, by file
@@ -437,7 +433,7 @@ EVENT HANDLERS
 When perf script is invoked using a trace script, a user-defined
 'handler function' is called for each event in the trace.  If there's
 no handler function defined for a given event type, the event is
-ignored (or passed to a 'trace_handled' function, see below) and the
+ignored (or passed to a 'trace_unhandled' function, see below) and the
 next event is processed.
 
 Most of the event's field values are passed as arguments to the
@@ -532,7 +528,7 @@ can implement a set of optional functions:
 gives scripts a chance to do setup tasks:
 
 ----
-def trace_begin:
+def trace_begin():
     pass
 ----
 
@@ -541,7 +537,7 @@ def trace_begin:
  as display results:
 
 ----
-def trace_end:
+def trace_end():
     pass
 ----
 
@@ -550,8 +546,7 @@ def trace_end:
  of common arguments are passed into it:
 
 ----
-def trace_unhandled(event_name, context, common_cpu, common_secs,
-        common_nsecs, common_pid, common_comm):
+def trace_unhandled(event_name, context, event_fields_dict):
     pass
 ----
 
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index cb0eda3925e6..5ee8796be96e 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -116,8 +116,9 @@ OPTIONS
 --fields::
         Comma separated list of fields to print. Options are:
         comm, tid, pid, time, cpu, event, trace, ip, sym, dso, addr, symoff,
-        srcline, period, iregs, brstack, brstacksym, flags, bpf-output, brstackinsn,
-        callindent, insn, insnlen. Field list can be prepended with the type, trace, sw or hw,
+        srcline, period, iregs, brstack, brstacksym, flags, bpf-output, brstackinsn, brstackoff,
+        callindent, insn, insnlen, synth.
+        Field list can be prepended with the type, trace, sw or hw,
         to indicate to which event type the field list applies.
         e.g., -F sw:comm,tid,time,ip,sym  and -F trace:time,cpu,trace
 
@@ -130,6 +131,14 @@ OPTIONS
         i.e., the specified fields apply to all event types if the type string
         is not given.
 
+        In addition to overriding fields, it is also possible to add or remove
+        fields from the defaults. For example
+
+                -F -cpu,+insn
+
+        removes the cpu field and adds the insn field. Adding/removing fields
+        cannot be mixed with normal overriding.
+
         The arguments are processed in the order received. A later usage can
         reset a prior request. e.g.:
 
@@ -185,6 +194,9 @@ OPTIONS
         instruction bytes and the instruction length of the current
         instruction.
 
+        The synth field is used by synthesized events which may be created when
+        Instruction Trace decoding.
+
         Finally, a user may not set fields to none for all event types.
         i.e., -F "" is not allowed.
 
@@ -203,6 +215,8 @@ OPTIONS
         is printed. This is the full execution path leading to the sample. This is only supported when the
         sample was recorded with perf record -b or -j any.
 
+        The brstackoff field will print an offset into a specific dso/binary.
+
 -k::
 --vmlinux=<file>::
         vmlinux pathname
@@ -311,6 +325,10 @@ include::itrace.txt[]
         Set the maximum number of program blocks to print with brstackasm for
         each sample.
 
+--inline::
+        If a callgraph address belongs to an inlined function, the inline stack
+        will be printed. Each entry has function name and file/line.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script-perl[1],
diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
index bd0e4417f2be..698076313606 100644
--- a/tools/perf/Documentation/perf-stat.txt
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -239,6 +239,20 @@ taskset.
 --no-merge::
 Do not merge results from same PMUs.
 
+--smi-cost::
+Measure SMI cost if msr/aperf/ and msr/smi/ events are supported.
+
+During the measurement, the /sys/device/cpu/freeze_on_smi will be set to
+freeze core counters on SMI.
+The aperf counter will not be effected by the setting.
+The cost of SMI can be measured by (aperf - unhalted core cycles).
+
+In practice, the percentages of SMI cycles is very useful for performance
+oriented analysis. --metric_only will be applied by default.
+The output is SMI cycles%, equals to (aperf - unhalted core cycles) / aperf
+
+Users who wants to get the actual value can apply --no-metric-only.
+
 EXAMPLES
 --------
 
diff --git a/tools/perf/Makefile.config b/tools/perf/Makefile.config
index 8354d04b392f..bdf0e87f9b29 100644
--- a/tools/perf/Makefile.config
+++ b/tools/perf/Makefile.config
@@ -19,18 +19,18 @@ CFLAGS := $(EXTRA_CFLAGS) $(EXTRA_WARNINGS)
 
 include $(srctree)/tools/scripts/Makefile.arch
 
-$(call detected_var,ARCH)
+$(call detected_var,SRCARCH)
 
 NO_PERF_REGS := 1
 
 # Additional ARCH settings for ppc
-ifeq ($(ARCH),powerpc)
+ifeq ($(SRCARCH),powerpc)
   NO_PERF_REGS := 0
   LIBUNWIND_LIBS := -lunwind -lunwind-ppc64
 endif
 
 # Additional ARCH settings for x86
-ifeq ($(ARCH),x86)
+ifeq ($(SRCARCH),x86)
   $(call detected,CONFIG_X86)
   ifeq (${IS_64_BIT}, 1)
     CFLAGS += -DHAVE_ARCH_X86_64_SUPPORT -DHAVE_SYSCALL_TABLE -I$(OUTPUT)arch/x86/include/generated
@@ -43,12 +43,12 @@ ifeq ($(ARCH),x86)
   NO_PERF_REGS := 0
 endif
 
-ifeq ($(ARCH),arm)
+ifeq ($(SRCARCH),arm)
   NO_PERF_REGS := 0
   LIBUNWIND_LIBS = -lunwind -lunwind-arm
 endif
 
-ifeq ($(ARCH),arm64)
+ifeq ($(SRCARCH),arm64)
   NO_PERF_REGS := 0
   LIBUNWIND_LIBS = -lunwind -lunwind-aarch64
 endif
@@ -61,7 +61,7 @@ endif
 # Disable it on all other architectures in case libdw unwind
 # support is detected in system. Add supported architectures
 # to the check.
-ifneq ($(ARCH),$(filter $(ARCH),x86 arm))
+ifneq ($(SRCARCH),$(filter $(SRCARCH),x86 arm powerpc))
   NO_LIBDW_DWARF_UNWIND := 1
 endif
 
@@ -115,9 +115,9 @@ endif
 FEATURE_CHECK_CFLAGS-libbabeltrace := $(LIBBABELTRACE_CFLAGS)
 FEATURE_CHECK_LDFLAGS-libbabeltrace := $(LIBBABELTRACE_LDFLAGS) -lbabeltrace-ctf
 
-FEATURE_CHECK_CFLAGS-bpf = -I. -I$(srctree)/tools/include -I$(srctree)/tools/arch/$(ARCH)/include/uapi -I$(srctree)/tools/include/uapi
+FEATURE_CHECK_CFLAGS-bpf = -I. -I$(srctree)/tools/include -I$(srctree)/tools/arch/$(SRCARCH)/include/uapi -I$(srctree)/tools/include/uapi
 # include ARCH specific config
--include $(src-perf)/arch/$(ARCH)/Makefile
+-include $(src-perf)/arch/$(SRCARCH)/Makefile
 
 ifdef PERF_HAVE_ARCH_REGS_QUERY_REGISTER_OFFSET
   CFLAGS += -DHAVE_ARCH_REGS_QUERY_REGISTER_OFFSET
@@ -228,12 +228,12 @@ ifeq ($(DEBUG),0)
 endif
 
 INC_FLAGS += -I$(src-perf)/util/include
-INC_FLAGS += -I$(src-perf)/arch/$(ARCH)/include
+INC_FLAGS += -I$(src-perf)/arch/$(SRCARCH)/include
 INC_FLAGS += -I$(srctree)/tools/include/uapi
 INC_FLAGS += -I$(srctree)/tools/include/
-INC_FLAGS += -I$(srctree)/tools/arch/$(ARCH)/include/uapi
-INC_FLAGS += -I$(srctree)/tools/arch/$(ARCH)/include/
-INC_FLAGS += -I$(srctree)/tools/arch/$(ARCH)/
+INC_FLAGS += -I$(srctree)/tools/arch/$(SRCARCH)/include/uapi
+INC_FLAGS += -I$(srctree)/tools/arch/$(SRCARCH)/include/
+INC_FLAGS += -I$(srctree)/tools/arch/$(SRCARCH)/
 
 # $(obj-perf)      for generated common-cmds.h
 # $(obj-perf)/util for generated bison/flex headers
@@ -355,7 +355,7 @@ ifndef NO_LIBELF
 
   ifndef NO_DWARF
     ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)
-      msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);
+      msg := $(warning DWARF register mappings have not been defined for architecture $(SRCARCH), DWARF support disabled);
       NO_DWARF := 1
     else
       CFLAGS += -DHAVE_DWARF_SUPPORT $(LIBDW_CFLAGS)
@@ -380,7 +380,7 @@ ifndef NO_LIBELF
         CFLAGS += -DHAVE_BPF_PROLOGUE
         $(call detected,CONFIG_BPF_PROLOGUE)
       else
-        msg := $(warning BPF prologue is not supported by architecture $(ARCH), missing regs_query_register_offset());
+        msg := $(warning BPF prologue is not supported by architecture $(SRCARCH), missing regs_query_register_offset());
       endif
     else
       msg := $(warning DWARF support is off, BPF prologue is disabled);
@@ -406,7 +406,7 @@ ifdef PERF_HAVE_JITDUMP
   endif
 endif
 
-ifeq ($(ARCH),powerpc)
+ifeq ($(SRCARCH),powerpc)
   ifndef NO_DWARF
     CFLAGS += -DHAVE_SKIP_CALLCHAIN_IDX
   endif
@@ -487,7 +487,7 @@ else
 endif
 
 ifndef NO_LOCAL_LIBUNWIND
-  ifeq ($(ARCH),$(filter $(ARCH),arm arm64))
+  ifeq ($(SRCARCH),$(filter $(SRCARCH),arm arm64))
     $(call feature_check,libunwind-debug-frame)
     ifneq ($(feature-libunwind-debug-frame), 1)
       msg := $(warning No debug_frame support found in libunwind);
@@ -740,7 +740,7 @@ ifeq (${IS_64_BIT}, 1)
       NO_PERF_READ_VDSO32 := 1
     endif
   endif
-  ifneq ($(ARCH), x86)
+  ifneq ($(SRCARCH), x86)
     NO_PERF_READ_VDSOX32 := 1
   endif
   ifndef NO_PERF_READ_VDSOX32
@@ -769,7 +769,7 @@ ifdef LIBBABELTRACE
 endif
 
 ifndef NO_AUXTRACE
-  ifeq ($(ARCH),x86)
+  ifeq ($(SRCARCH),x86)
     ifeq ($(feature-get_cpuid), 0)
       msg := $(warning Your gcc lacks the __get_cpuid() builtin, disables support for auxtrace/Intel PT, please install a newer gcc);
       NO_AUXTRACE := 1
@@ -872,7 +872,7 @@ sysconfdir = $(prefix)/etc
 ETC_PERFCONFIG = etc/perfconfig
 endif
 ifndef lib
-ifeq ($(ARCH)$(IS_64_BIT), x861)
+ifeq ($(SRCARCH)$(IS_64_BIT), x861)
 lib = lib64
 else
 lib = lib
diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf
index 79fe31f20a17..5008f51a08a2 100644
--- a/tools/perf/Makefile.perf
+++ b/tools/perf/Makefile.perf
@@ -226,7 +226,7 @@ endif
 
 ifeq ($(config),0)
 include $(srctree)/tools/scripts/Makefile.arch
--include arch/$(ARCH)/Makefile
+-include arch/$(SRCARCH)/Makefile
 endif
 
 # The FEATURE_DUMP_EXPORT holds location of the actual
diff --git a/tools/perf/arch/Build b/tools/perf/arch/Build
index 109eb75cf7de..d9b6af837c7d 100644
--- a/tools/perf/arch/Build
+++ b/tools/perf/arch/Build
@@ -1,2 +1,2 @@
 libperf-y += common.o
-libperf-y += $(ARCH)/
+libperf-y += $(SRCARCH)/
diff --git a/tools/perf/arch/arm/util/cs-etm.c b/tools/perf/arch/arm/util/cs-etm.c
index 29361d9b635a..7ce3d1a25133 100644
--- a/tools/perf/arch/arm/util/cs-etm.c
+++ b/tools/perf/arch/arm/util/cs-etm.c
@@ -17,6 +17,7 @@
 
 #include <api/fs/fs.h>
 #include <linux/bitops.h>
+#include <linux/compiler.h>
 #include <linux/coresight-pmu.h>
 #include <linux/kernel.h>
 #include <linux/log2.h>
@@ -202,19 +203,18 @@ static int cs_etm_recording_options(struct auxtrace_record *itr,
                 pr_debug2("%s snapshot size: %zu\n", CORESIGHT_ETM_PMU_NAME,
                           opts->auxtrace_snapshot_size);
 
-        if (cs_etm_evsel) {
-                /*
-                 * To obtain the auxtrace buffer file descriptor, the auxtrace
-                 * event must come first.
-                 */
-                perf_evlist__to_front(evlist, cs_etm_evsel);
-                /*
-                 * In the case of per-cpu mmaps, we need the CPU on the
-                 * AUX event.
-                 */
-                if (!cpu_map__empty(cpus))
-                        perf_evsel__set_sample_bit(cs_etm_evsel, CPU);
-        }
+        /*
+         * To obtain the auxtrace buffer file descriptor, the auxtrace
+         * event must come first.
+         */
+        perf_evlist__to_front(evlist, cs_etm_evsel);
+
+        /*
+         * In the case of per-cpu mmaps, we need the CPU on the
+         * AUX event.
+         */
+        if (!cpu_map__empty(cpus))
+                perf_evsel__set_sample_bit(cs_etm_evsel, CPU);
 
         /* Add dummy event to keep tracking */
         if (opts->full_auxtrace) {
@@ -583,8 +583,7 @@ static FILE *cs_device__open_file(const char *name)
 
 }
 
-static __attribute__((format(printf, 2, 3)))
-int cs_device__print_file(const char *name, const char *fmt, ...)
+static int __printf(2, 3) cs_device__print_file(const char *name, const char *fmt, ...)
 {
         va_list args;
         FILE *file;
diff --git a/tools/perf/arch/common.c b/tools/perf/arch/common.c
index 837067f48a4c..6b40e9f01740 100644
--- a/tools/perf/arch/common.c
+++ b/tools/perf/arch/common.c
@@ -26,6 +26,7 @@ const char *const arm64_triplets[] = {
 
 const char *const powerpc_triplets[] = {
         "powerpc-unknown-linux-gnu-",
+        "powerpc-linux-gnu-",
         "powerpc64-unknown-linux-gnu-",
         "powerpc64-linux-gnu-",
         "powerpc64le-linux-gnu-",
diff --git a/tools/perf/arch/powerpc/util/Build b/tools/perf/arch/powerpc/util/Build
index 90ad64b231cd..2e6595310420 100644
--- a/tools/perf/arch/powerpc/util/Build
+++ b/tools/perf/arch/powerpc/util/Build
@@ -5,4 +5,6 @@ libperf-y += perf_regs.o
 
 libperf-$(CONFIG_DWARF) += dwarf-regs.o
 libperf-$(CONFIG_DWARF) += skip-callchain-idx.o
+
 libperf-$(CONFIG_LIBUNWIND) += unwind-libunwind.o
+libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
diff --git a/tools/perf/arch/powerpc/util/unwind-libdw.c b/tools/perf/arch/powerpc/util/unwind-libdw.c
new file mode 100644
index 000000000000..3a24b3c43273
--- /dev/null
+++ b/tools/perf/arch/powerpc/util/unwind-libdw.c
@@ -0,0 +1,73 @@
+#include <elfutils/libdwfl.h>
+#include "../../util/unwind-libdw.h"
+#include "../../util/perf_regs.h"
+#include "../../util/event.h"
+
+/* See backends/ppc_initreg.c and backends/ppc_regs.c in elfutils.  */
+static const int special_regs[3][2] = {
+        { 65, PERF_REG_POWERPC_LINK },
+        { 101, PERF_REG_POWERPC_XER },
+        { 109, PERF_REG_POWERPC_CTR },
+};
+
+bool libdw__arch_set_initial_registers(Dwfl_Thread *thread, void *arg)
+{
+        struct unwind_info *ui = arg;
+        struct regs_dump *user_regs = &ui->sample->user_regs;
+        Dwarf_Word dwarf_regs[32], dwarf_nip;
+        size_t i;
+
+#define REG(r) ({                                               \
+        Dwarf_Word val = 0;                                     \
+        perf_reg_value(&val, user_regs, PERF_REG_POWERPC_##r);  \
+        val;                                                    \
+})
+
+        dwarf_regs[0]  = REG(R0);
+        dwarf_regs[1]  = REG(R1);
+        dwarf_regs[2]  = REG(R2);
+        dwarf_regs[3]  = REG(R3);
+        dwarf_regs[4]  = REG(R4);
+        dwarf_regs[5]  = REG(R5);
+        dwarf_regs[6]  = REG(R6);
+        dwarf_regs[7]  = REG(R7);
+        dwarf_regs[8]  = REG(R8);
+        dwarf_regs[9]  = REG(R9);
+        dwarf_regs[10] = REG(R10);
+        dwarf_regs[11] = REG(R11);
+        dwarf_regs[12] = REG(R12);
+        dwarf_regs[13] = REG(R13);
+        dwarf_regs[14] = REG(R14);
+        dwarf_regs[15] = REG(R15);
+        dwarf_regs[16] = REG(R16);
+        dwarf_regs[17] = REG(R17);
+        dwarf_regs[18] = REG(R18);
+        dwarf_regs[19] = REG(R19);
+        dwarf_regs[20] = REG(R20);
+        dwarf_regs[21] = REG(R21);
+        dwarf_regs[22] = REG(R22);
+        dwarf_regs[23] = REG(R23);
+        dwarf_regs[24] = REG(R24);
+        dwarf_regs[25] = REG(R25);
+        dwarf_regs[26] = REG(R26);
+        dwarf_regs[27] = REG(R27);
+        dwarf_regs[28] = REG(R28);
+        dwarf_regs[29] = REG(R29);
+        dwarf_regs[30] = REG(R30);
+        dwarf_regs[31] = REG(R31);
+        if (!dwfl_thread_state_registers(thread, 0, 32, dwarf_regs))
+                return false;
+
+        dwarf_nip = REG(NIP);
+        dwfl_thread_state_register_pc(thread, dwarf_nip);
+        for (i = 0; i < ARRAY_SIZE(special_regs); i++) {
+                Dwarf_Word val = 0;
+                perf_reg_value(&val, user_regs, special_regs[i][1]);
+                if (!dwfl_thread_state_registers(thread,
+                                                 special_regs[i][0], 1,
+                                                 &val))
+                        return false;
+        }
+
+        return true;
+}
diff --git a/tools/perf/arch/x86/tests/insn-x86-dat-32.c b/tools/perf/arch/x86/tests/insn-x86-dat-32.c
index 0f196eec9f48..3cbf6fad169f 100644
--- a/tools/perf/arch/x86/tests/insn-x86-dat-32.c
+++ b/tools/perf/arch/x86/tests/insn-x86-dat-32.c
@@ -1664,3 +1664,15 @@
 "0f c7 1d 78 56 34 12 \txrstors 0x12345678",},
 {{0x0f, 0xc7, 0x9c, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
 "0f c7 9c c8 78 56 34 12 \txrstors 0x12345678(%eax,%ecx,8)",},
+{{0xf3, 0x0f, 0xae, 0x20, }, 4, 0, "", "",
+"f3 0f ae 20          \tptwritel (%eax)",},
+{{0xf3, 0x0f, 0xae, 0x25, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"f3 0f ae 25 78 56 34 12 \tptwritel 0x12345678",},
+{{0xf3, 0x0f, 0xae, 0xa4, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 9, 0, "", "",
+"f3 0f ae a4 c8 78 56 34 12 \tptwritel 0x12345678(%eax,%ecx,8)",},
+{{0xf3, 0x0f, 0xae, 0x20, }, 4, 0, "", "",
+"f3 0f ae 20          \tptwritel (%eax)",},
+{{0xf3, 0x0f, 0xae, 0x25, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"f3 0f ae 25 78 56 34 12 \tptwritel 0x12345678",},
+{{0xf3, 0x0f, 0xae, 0xa4, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 9, 0, "", "",
+"f3 0f ae a4 c8 78 56 34 12 \tptwritel 0x12345678(%eax,%ecx,8)",},
diff --git a/tools/perf/arch/x86/tests/insn-x86-dat-64.c b/tools/perf/arch/x86/tests/insn-x86-dat-64.c
index af25bc8240d0..aa512fa944dd 100644
--- a/tools/perf/arch/x86/tests/insn-x86-dat-64.c
+++ b/tools/perf/arch/x86/tests/insn-x86-dat-64.c
@@ -1696,3 +1696,33 @@
 "0f c7 9c c8 78 56 34 12 \txrstors 0x12345678(%rax,%rcx,8)",},
 {{0x41, 0x0f, 0xc7, 0x9c, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 9, 0, "", "",
 "41 0f c7 9c c8 78 56 34 12 \txrstors 0x12345678(%r8,%rcx,8)",},
+{{0xf3, 0x0f, 0xae, 0x20, }, 4, 0, "", "",
+"f3 0f ae 20          \tptwritel (%rax)",},
+{{0xf3, 0x41, 0x0f, 0xae, 0x20, }, 5, 0, "", "",
+"f3 41 0f ae 20       \tptwritel (%r8)",},
+{{0xf3, 0x0f, 0xae, 0x24, 0x25, 0x78, 0x56, 0x34, 0x12, }, 9, 0, "", "",
+"f3 0f ae 24 25 78 56 34 12 \tptwritel 0x12345678",},
+{{0xf3, 0x0f, 0xae, 0xa4, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 9, 0, "", "",
+"f3 0f ae a4 c8 78 56 34 12 \tptwritel 0x12345678(%rax,%rcx,8)",},
+{{0xf3, 0x41, 0x0f, 0xae, 0xa4, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 10, 0, "", "",
+"f3 41 0f ae a4 c8 78 56 34 12 \tptwritel 0x12345678(%r8,%rcx,8)",},
+{{0xf3, 0x0f, 0xae, 0x20, }, 4, 0, "", "",
+"f3 0f ae 20          \tptwritel (%rax)",},
+{{0xf3, 0x41, 0x0f, 0xae, 0x20, }, 5, 0, "", "",
+"f3 41 0f ae 20       \tptwritel (%r8)",},
+{{0xf3, 0x0f, 0xae, 0x24, 0x25, 0x78, 0x56, 0x34, 0x12, }, 9, 0, "", "",
+"f3 0f ae 24 25 78 56 34 12 \tptwritel 0x12345678",},
+{{0xf3, 0x0f, 0xae, 0xa4, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 9, 0, "", "",
+"f3 0f ae a4 c8 78 56 34 12 \tptwritel 0x12345678(%rax,%rcx,8)",},
+{{0xf3, 0x41, 0x0f, 0xae, 0xa4, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 10, 0, "", "",
+"f3 41 0f ae a4 c8 78 56 34 12 \tptwritel 0x12345678(%r8,%rcx,8)",},
+{{0xf3, 0x48, 0x0f, 0xae, 0x20, }, 5, 0, "", "",
+"f3 48 0f ae 20       \tptwriteq (%rax)",},
+{{0xf3, 0x49, 0x0f, 0xae, 0x20, }, 5, 0, "", "",
+"f3 49 0f ae 20       \tptwriteq (%r8)",},
+{{0xf3, 0x48, 0x0f, 0xae, 0x24, 0x25, 0x78, 0x56, 0x34, 0x12, }, 10, 0, "", "",
+"f3 48 0f ae 24 25 78 56 34 12 \tptwriteq 0x12345678",},
+{{0xf3, 0x48, 0x0f, 0xae, 0xa4, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 10, 0, "", "",
+"f3 48 0f ae a4 c8 78 56 34 12 \tptwriteq 0x12345678(%rax,%rcx,8)",},
+{{0xf3, 0x49, 0x0f, 0xae, 0xa4, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 10, 0, "", "",
+"f3 49 0f ae a4 c8 78 56 34 12 \tptwriteq 0x12345678(%r8,%rcx,8)",},
diff --git a/tools/perf/arch/x86/tests/insn-x86-dat-src.c b/tools/perf/arch/x86/tests/insn-x86-dat-src.c
index 979487dae8d4..6cdb65d25b79 100644
--- a/tools/perf/arch/x86/tests/insn-x86-dat-src.c
+++ b/tools/perf/arch/x86/tests/insn-x86-dat-src.c
@@ -1343,6 +1343,26 @@ int main(void)
         asm volatile("xrstors 0x12345678(%rax,%rcx,8)");
         asm volatile("xrstors 0x12345678(%r8,%rcx,8)");
 
+        /* ptwrite */
+
+        asm volatile("ptwrite (%rax)");
+        asm volatile("ptwrite (%r8)");
+        asm volatile("ptwrite (0x12345678)");
+        asm volatile("ptwrite 0x12345678(%rax,%rcx,8)");
+        asm volatile("ptwrite 0x12345678(%r8,%rcx,8)");
+
+        asm volatile("ptwritel (%rax)");
+        asm volatile("ptwritel (%r8)");
+        asm volatile("ptwritel (0x12345678)");
+        asm volatile("ptwritel 0x12345678(%rax,%rcx,8)");
+        asm volatile("ptwritel 0x12345678(%r8,%rcx,8)");
+
+        asm volatile("ptwriteq (%rax)");
+        asm volatile("ptwriteq (%r8)");
+        asm volatile("ptwriteq (0x12345678)");
+        asm volatile("ptwriteq 0x12345678(%rax,%rcx,8)");
+        asm volatile("ptwriteq 0x12345678(%r8,%rcx,8)");
+
 #else  /* #ifdef __x86_64__ */
 
         /* bound r32, mem (same op code as EVEX prefix) */
@@ -2653,6 +2673,16 @@ int main(void)
         asm volatile("xrstors (0x12345678)");
         asm volatile("xrstors 0x12345678(%eax,%ecx,8)");
 
+        /* ptwrite */
+
+        asm volatile("ptwrite (%eax)");
+        asm volatile("ptwrite (0x12345678)");
+        asm volatile("ptwrite 0x12345678(%eax,%ecx,8)");
+
+        asm volatile("ptwritel (%eax)");
+        asm volatile("ptwritel (0x12345678)");
+        asm volatile("ptwritel 0x12345678(%eax,%ecx,8)");
+
 #endif /* #ifndef __x86_64__ */
 
         /* Following line is a marker for the awk script - do not change */
diff --git a/tools/perf/arch/x86/util/intel-bts.c b/tools/perf/arch/x86/util/intel-bts.c
index af2bce7a2cd6..781df40b2966 100644
--- a/tools/perf/arch/x86/util/intel-bts.c
+++ b/tools/perf/arch/x86/util/intel-bts.c
@@ -35,10 +35,6 @@
 #define KiB_MASK(x) (KiB(x) - 1)
 #define MiB_MASK(x) (MiB(x) - 1)
 
-#define INTEL_BTS_DFLT_SAMPLE_SIZE      KiB(4)
-
-#define INTEL_BTS_MAX_SAMPLE_SIZE       KiB(60)
-
 struct intel_bts_snapshot_ref {
         void    *ref_buf;
         size_t  ref_offset;
diff --git a/tools/perf/arch/x86/util/intel-pt.c b/tools/perf/arch/x86/util/intel-pt.c
index f630de0206a1..9535be57033f 100644
--- a/tools/perf/arch/x86/util/intel-pt.c
+++ b/tools/perf/arch/x86/util/intel-pt.c
@@ -40,10 +40,6 @@
 #define KiB_MASK(x) (KiB(x) - 1)
 #define MiB_MASK(x) (MiB(x) - 1)
 
-#define INTEL_PT_DEFAULT_SAMPLE_SIZE    KiB(4)
-
-#define INTEL_PT_MAX_SAMPLE_SIZE        KiB(60)
-
 #define INTEL_PT_PSB_PERIOD_NEAR        256
 
 struct intel_pt_snapshot_ref {
@@ -196,6 +192,7 @@ static u64 intel_pt_default_config(struct perf_pmu *intel_pt_pmu)
         int psb_cyc, psb_periods, psb_period;
         int pos = 0;
         u64 config;
+        char c;
 
         pos += scnprintf(buf + pos, sizeof(buf) - pos, "tsc");
 
@@ -229,6 +226,10 @@ static u64 intel_pt_default_config(struct perf_pmu *intel_pt_pmu)
                 }
         }
 
+        if (perf_pmu__scan_file(intel_pt_pmu, "format/pt", "%c", &c) == 1 &&
+            perf_pmu__scan_file(intel_pt_pmu, "format/branch", "%c", &c) == 1)
+                pos += scnprintf(buf + pos, sizeof(buf) - pos, ",pt,branch");
+
         pr_debug2("%s default config: %s\n", intel_pt_pmu->name, buf);
 
         intel_pt_parse_terms(&intel_pt_pmu->format, buf, &config);
diff --git a/tools/perf/bench/numa.c b/tools/perf/bench/numa.c
index 27de0c8c5c19..469d65b21122 100644
--- a/tools/perf/bench/numa.c
+++ b/tools/perf/bench/numa.c
@@ -700,7 +700,7 @@ static inline uint32_t lfsr_32(uint32_t lfsr)
  * kernel (KSM, zero page, etc.) cannot optimize away RAM
  * accesses:
  */
-static inline u64 access_data(u64 *data __attribute__((unused)), u64 val)
+static inline u64 access_data(u64 *data, u64 val)
 {
         if (g->p.data_reads)
                 val += *data;
diff --git a/tools/perf/builtin-c2c.c b/tools/perf/builtin-c2c.c
index 620a467ee304..475999e48f66 100644
--- a/tools/perf/builtin-c2c.c
+++ b/tools/perf/builtin-c2c.c
@@ -1725,10 +1725,10 @@ static int c2c_hists__init_sort(struct perf_hpp_list *hpp_list, char *name)
                                 tok; tok = strtok_r(NULL, ", ", &tmp)) {        \
                         ret = _fn(hpp_list, tok);                               \
                         if (ret == -EINVAL) {                                   \
-                                error("Invalid --fields key: `%s'", tok);       \
+                                pr_err("Invalid --fields key: `%s'", tok);      \
                                 break;                                          \
                         } else if (ret == -ESRCH) {                             \
-                                error("Unknown --fields key: `%s'", tok);       \
+                                pr_err("Unknown --fields key: `%s'", tok);      \
                                 break;                                          \
                         }                                                       \
                 }                                                               \
diff --git a/tools/perf/builtin-config.c b/tools/perf/builtin-config.c
index 80668fa7556e..ece45582a48d 100644
--- a/tools/perf/builtin-config.c
+++ b/tools/perf/builtin-config.c
@@ -156,7 +156,7 @@ static int parse_config_arg(char *arg, char **var, char **value)
 
 int cmd_config(int argc, const char **argv)
 {
-        int i, ret = 0;
+        int i, ret = -1;
         struct perf_config_set *set;
         char *user_config = mkpath("%s/.perfconfig", getenv("HOME"));
         const char *config_filename;
@@ -186,10 +186,8 @@ int cmd_config(int argc, const char **argv)
          * because of reinitializing with options config file location.
          */
         set = perf_config_set__new();
-        if (!set) {
-                ret = -1;
+        if (!set)
                 goto out_err;
-        }
 
         switch (actions) {
         case ACTION_LIST:
@@ -197,41 +195,54 @@ int cmd_config(int argc, const char **argv)
                         pr_err("Error: takes no arguments\n");
                         parse_options_usage(config_usage, config_options, "l", 1);
                 } else {
-                        ret = show_config(set);
-                        if (ret < 0)
+                        if (show_config(set) < 0) {
                                 pr_err("Nothing configured, "
                                        "please check your %s \n", config_filename);
+                                goto out_err;
+                        }
                 }
                 break;
         default:
-                if (argc) {
-                        for (i = 0; argv[i]; i++) {
-                                char *var, *value;
-                                char *arg = strdup(argv[i]);
-
-                                if (!arg) {
-                                        pr_err("%s: strdup failed\n", __func__);
-                                        ret = -1;
-                                        break;
-                                }
+                if (!argc) {
+                        usage_with_options(config_usage, config_options);
+                        break;
+                }
 
-                                if (parse_config_arg(arg, &var, &value) < 0) {
-                                        free(arg);
-                                        ret = -1;
-                                        break;
-                                }
+                for (i = 0; argv[i]; i++) {
+                        char *var, *value;
+                        char *arg = strdup(argv[i]);
+
+                        if (!arg) {
+                                pr_err("%s: strdup failed\n", __func__);
+                                goto out_err;
+                        }
 
-                                if (value == NULL)
-                                        ret = show_spec_config(set, var);
-                                else
-                                        ret = set_config(set, config_filename, var, value);
+                        if (parse_config_arg(arg, &var, &value) < 0) {
                                 free(arg);
+                                goto out_err;
                         }
-                } else
-                        usage_with_options(config_usage, config_options);
+
+                        if (value == NULL) {
+                                if (show_spec_config(set, var) < 0) {
+                                        pr_err("%s is not configured: %s\n",
+                                               var, config_filename);
+                                        free(arg);
+                                        goto out_err;
+                                }
+                        } else {
+                                if (set_config(set, config_filename, var, value) < 0) {
+                                        pr_err("Failed to set '%s=%s' on %s\n",
+                                               var, value, config_filename);
+                                        free(arg);
+                                        goto out_err;
+                                }
+                        }
+                        free(arg);
+                }
         }
 
-        perf_config_set__delete(set);
+        ret = 0;
 out_err:
+        perf_config_set__delete(set);
         return ret;
 }
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index eec5df80f5a3..0cd4cf6a344b 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -1302,7 +1302,10 @@ static int diff__config(const char *var, const char *value,
                         void *cb __maybe_unused)
 {
         if (!strcmp(var, "diff.order")) {
-                sort_compute = perf_config_int(var, value);
+                int ret;
+                if (perf_config_int(&ret, var, value) < 0)
+                        return -1;
+                sort_compute = ret;
                 return 0;
         }
         if (!strcmp(var, "diff.compute")) {
diff --git a/tools/perf/builtin-ftrace.c b/tools/perf/builtin-ftrace.c
index 9e0b35cd0eea..dd26c62c9893 100644
--- a/tools/perf/builtin-ftrace.c
+++ b/tools/perf/builtin-ftrace.c
@@ -28,9 +28,19 @@
 #define DEFAULT_TRACER  "function_graph"
 
 struct perf_ftrace {
-        struct perf_evlist *evlist;
-        struct target target;
-        const char *tracer;
+        struct perf_evlist      *evlist;
+        struct target           target;
+        const char              *tracer;
+        struct list_head        filters;
+        struct list_head        notrace;
+        struct list_head        graph_funcs;
+        struct list_head        nograph_funcs;
+        int                     graph_depth;
+};
+
+struct filter_entry {
+        struct list_head        list;
+        char                    name[];
 };
 
 static bool done;
@@ -61,6 +71,7 @@ static int __write_tracing_file(const char *name, const char *val, bool append)
         int fd, ret = -1;
         ssize_t size = strlen(val);
         int flags = O_WRONLY;
+        char errbuf[512];
 
         file = get_tracing_file(name);
         if (!file) {
@@ -75,14 +86,16 @@ static int __write_tracing_file(const char *name, const char *val, bool append)
 
         fd = open(file, flags);
         if (fd < 0) {
-                pr_debug("cannot open tracing file: %s\n", name);
+                pr_debug("cannot open tracing file: %s: %s\n",
+                         name, str_error_r(errno, errbuf, sizeof(errbuf)));
                 goto out;
         }
 
         if (write(fd, val, size) == size)
                 ret = 0;
         else
-                pr_debug("write '%s' to tracing/%s failed\n", val, name);
+                pr_debug("write '%s' to tracing/%s failed: %s\n",
+                         val, name, str_error_r(errno, errbuf, sizeof(errbuf)));
 
         close(fd);
 out:
@@ -101,6 +114,7 @@ static int append_tracing_file(const char *name, const char *val)
 }
 
 static int reset_tracing_cpu(void);
+static void reset_tracing_filters(void);
 
 static int reset_tracing_files(struct perf_ftrace *ftrace __maybe_unused)
 {
@@ -116,6 +130,10 @@ static int reset_tracing_files(struct perf_ftrace *ftrace __maybe_unused)
         if (reset_tracing_cpu() < 0)
                 return -1;
 
+        if (write_tracing_file("max_graph_depth", "0") < 0)
+                return -1;
+
+        reset_tracing_filters();
         return 0;
 }
 
@@ -181,6 +199,68 @@ static int reset_tracing_cpu(void)
         return ret;
 }
 
+static int __set_tracing_filter(const char *filter_file, struct list_head *funcs)
+{
+        struct filter_entry *pos;
+
+        list_for_each_entry(pos, funcs, list) {
+                if (append_tracing_file(filter_file, pos->name) < 0)
+                        return -1;
+        }
+
+        return 0;
+}
+
+static int set_tracing_filters(struct perf_ftrace *ftrace)
+{
+        int ret;
+
+        ret = __set_tracing_filter("set_ftrace_filter", &ftrace->filters);
+        if (ret < 0)
+                return ret;
+
+        ret = __set_tracing_filter("set_ftrace_notrace", &ftrace->notrace);
+        if (ret < 0)
+                return ret;
+
+        ret = __set_tracing_filter("set_graph_function", &ftrace->graph_funcs);
+        if (ret < 0)
+                return ret;
+
+        /* old kernels do not have this filter */
+        __set_tracing_filter("set_graph_notrace", &ftrace->nograph_funcs);
+
+        return ret;
+}
+
+static void reset_tracing_filters(void)
+{
+        write_tracing_file("set_ftrace_filter", " ");
+        write_tracing_file("set_ftrace_notrace", " ");
+        write_tracing_file("set_graph_function", " ");
+        write_tracing_file("set_graph_notrace", " ");
+}
+
+static int set_tracing_depth(struct perf_ftrace *ftrace)
+{
+        char buf[16];
+
+        if (ftrace->graph_depth == 0)
+                return 0;
+
+        if (ftrace->graph_depth < 0) {
+                pr_err("invalid graph depth: %d\n", ftrace->graph_depth);
+                return -1;
+        }
+
+        snprintf(buf, sizeof(buf), "%d", ftrace->graph_depth);
+
+        if (write_tracing_file("max_graph_depth", buf) < 0)
+                return -1;
+
+        return 0;
+}
+
 static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
 {
         char *trace_file;
@@ -223,11 +303,23 @@ static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
                 goto out_reset;
         }
 
+        if (set_tracing_filters(ftrace) < 0) {
+                pr_err("failed to set tracing filters\n");
+                goto out_reset;
+        }
+
+        if (set_tracing_depth(ftrace) < 0) {
+                pr_err("failed to set graph depth\n");
+                goto out_reset;
+        }
+
         if (write_tracing_file("current_tracer", ftrace->tracer) < 0) {
                 pr_err("failed to set current_tracer to %s\n", ftrace->tracer);
                 goto out_reset;
         }
 
+        setup_pager();
+
         trace_file = get_tracing_file("trace_pipe");
         if (!trace_file) {
                 pr_err("failed to open trace_pipe\n");
@@ -251,8 +343,6 @@ static int __cmd_ftrace(struct perf_ftrace *ftrace, int argc, const char **argv)
                 goto out_close_fd;
         }
 
-        setup_pager();
-
         perf_evlist__start_workload(ftrace->evlist);
 
         while (!done) {
@@ -307,6 +397,32 @@ static int perf_ftrace_config(const char *var, const char *value, void *cb)
         return -1;
 }
 
+static int parse_filter_func(const struct option *opt, const char *str,
+                             int unset __maybe_unused)
+{
+        struct list_head *head = opt->value;
+        struct filter_entry *entry;
+
+        entry = malloc(sizeof(*entry) + strlen(str) + 1);
+        if (entry == NULL)
+                return -ENOMEM;
+
+        strcpy(entry->name, str);
+        list_add_tail(&entry->list, head);
+
+        return 0;
+}
+
+static void delete_filter_func(struct list_head *head)
+{
+        struct filter_entry *pos, *tmp;
+
+        list_for_each_entry_safe(pos, tmp, head, list) {
+                list_del(&pos->list);
+                free(pos);
+        }
+}
+
 int cmd_ftrace(int argc, const char **argv)
 {
         int ret;
@@ -330,9 +446,24 @@ int cmd_ftrace(int argc, const char **argv)
                     "system-wide collection from all CPUs"),
         OPT_STRING('C', "cpu", &ftrace.target.cpu_list, "cpu",
                     "list of cpus to monitor"),
+        OPT_CALLBACK('T', "trace-funcs", &ftrace.filters, "func",
+                     "trace given functions only", parse_filter_func),
+        OPT_CALLBACK('N', "notrace-funcs", &ftrace.notrace, "func",
+                     "do not trace given functions", parse_filter_func),
+        OPT_CALLBACK('G', "graph-funcs", &ftrace.graph_funcs, "func",
+                     "Set graph filter on given functions", parse_filter_func),
+        OPT_CALLBACK('g', "nograph-funcs", &ftrace.nograph_funcs, "func",
+                     "Set nograph filter on given functions", parse_filter_func),
+        OPT_INTEGER('D', "graph-depth", &ftrace.graph_depth,
+                    "Max depth for function graph tracer"),
         OPT_END()
         };
 
+        INIT_LIST_HEAD(&ftrace.filters);
+        INIT_LIST_HEAD(&ftrace.notrace);
+        INIT_LIST_HEAD(&ftrace.graph_funcs);
+        INIT_LIST_HEAD(&ftrace.nograph_funcs);
+
         ret = perf_config(perf_ftrace_config, &ftrace);
         if (ret < 0)
                 return -1;
@@ -348,12 +479,14 @@ int cmd_ftrace(int argc, const char **argv)
 
                 target__strerror(&ftrace.target, ret, errbuf, 512);
                 pr_err("%s\n", errbuf);
-                return -EINVAL;
+                goto out_delete_filters;
         }
 
         ftrace.evlist = perf_evlist__new();
-        if (ftrace.evlist == NULL)
-                return -ENOMEM;
+        if (ftrace.evlist == NULL) {
+                ret = -ENOMEM;
+                goto out_delete_filters;
+        }
 
         ret = perf_evlist__create_maps(ftrace.evlist, &ftrace.target);
         if (ret < 0)
@@ -364,5 +497,11 @@ int cmd_ftrace(int argc, const char **argv)
 out_delete_evlist:
         perf_evlist__delete(ftrace.evlist);
 
+out_delete_filters:
+        delete_filter_func(&ftrace.filters);
+        delete_filter_func(&ftrace.notrace);
+        delete_filter_func(&ftrace.graph_funcs);
+        delete_filter_func(&ftrace.nograph_funcs);
+
         return ret;
 }
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index 492f8e14ab09..530a7f2fa0f3 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -108,10 +108,14 @@ out:
         return ret;
 }
 
-static void exec_woman_emacs(const char *path, const char *page)
+static void exec_failed(const char *cmd)
 {
         char sbuf[STRERR_BUFSIZE];
+        pr_warning("failed to exec '%s': %s", cmd, str_error_r(errno, sbuf, sizeof(sbuf)));
+}
 
+static void exec_woman_emacs(const char *path, const char *page)
+{
         if (!check_emacsclient_version()) {
                 /* This works only with emacsclient version >= 22. */
                 char *man_page;
@@ -122,8 +126,7 @@ static void exec_woman_emacs(const char *path, const char *page)
                         execlp(path, "emacsclient", "-e", man_page, NULL);
                         free(man_page);
                 }
-                warning("failed to exec '%s': %s", path,
-                        str_error_r(errno, sbuf, sizeof(sbuf)));
+                exec_failed(path);
         }
 }
 
@@ -134,7 +137,6 @@ static void exec_man_konqueror(const char *path, const char *page)
         if (display && *display) {
                 char *man_page;
                 const char *filename = "kfmclient";
-                char sbuf[STRERR_BUFSIZE];
 
                 /* It's simpler to launch konqueror using kfmclient. */
                 if (path) {
@@ -155,33 +157,27 @@ static void exec_man_konqueror(const char *path, const char *page)
                         execlp(path, filename, "newTab", man_page, NULL);
                         free(man_page);
                 }
-                warning("failed to exec '%s': %s", path,
-                        str_error_r(errno, sbuf, sizeof(sbuf)));
+                exec_failed(path);
         }
 }
 
 static void exec_man_man(const char *path, const char *page)
 {
-        char sbuf[STRERR_BUFSIZE];
-
         if (!path)
                 path = "man";
         execlp(path, "man", page, NULL);
-        warning("failed to exec '%s': %s", path,
-                str_error_r(errno, sbuf, sizeof(sbuf)));
+        exec_failed(path);
 }
 
 static void exec_man_cmd(const char *cmd, const char *page)
 {
-        char sbuf[STRERR_BUFSIZE];
         char *shell_cmd;
 
         if (asprintf(&shell_cmd, "%s %s", cmd, page) > 0) {
                 execl("/bin/sh", "sh", "-c", shell_cmd, NULL);
                 free(shell_cmd);
         }
-        warning("failed to exec '%s': %s", cmd,
-                str_error_r(errno, sbuf, sizeof(sbuf)));
+        exec_failed(cmd);
 }
 
 static void add_man_viewer(const char *name)
@@ -214,6 +210,12 @@ static void do_add_man_viewer_info(const char *name,
         man_viewer_info_list = new;
 }
 
+static void unsupported_man_viewer(const char *name, const char *var)
+{
+        pr_warning("'%s': path for unsupported man viewer.\n"
+                   "Please consider using 'man.<tool>.%s' instead.", name, var);
+}
+
 static int add_man_viewer_path(const char *name,
                                size_t len,
                                const char *value)
@@ -221,9 +223,7 @@ static int add_man_viewer_path(const char *name,
         if (supported_man_viewer(name, len))
                 do_add_man_viewer_info(name, len, value);
         else
-                warning("'%s': path for unsupported man viewer.\n"
-                        "Please consider using 'man.<tool>.cmd' instead.",
-                        name);
+                unsupported_man_viewer(name, "cmd");
 
         return 0;
 }
@@ -233,9 +233,7 @@ static int add_man_viewer_cmd(const char *name,
                               const char *value)
 {
         if (supported_man_viewer(name, len))
-                warning("'%s': cmd for supported man viewer.\n"
-                        "Please consider using 'man.<tool>.path' instead.",
-                        name);
+                unsupported_man_viewer(name, "path");
         else
                 do_add_man_viewer_info(name, len, value);
 
@@ -247,8 +245,10 @@ static int add_man_viewer_info(const char *var, const char *value)
         const char *name = var + 4;
         const char *subkey = strrchr(name, '.');
 
-        if (!subkey)
-                return error("Config with no key for man viewer: %s", name);
+        if (!subkey) {
+                pr_err("Config with no key for man viewer: %s", name);
+                return -1;
+        }
 
         if (!strcmp(subkey, ".path")) {
                 if (!value)
@@ -261,7 +261,7 @@ static int add_man_viewer_info(const char *var, const char *value)
                 return add_man_viewer_cmd(name, subkey - name, value);
         }
 
-        warning("'%s': unsupported man viewer sub key.", subkey);
+        pr_warning("'%s': unsupported man viewer sub key.", subkey);
         return 0;
 }
 
@@ -332,7 +332,7 @@ static void setup_man_path(void)
                 setenv("MANPATH", new_path, 1);
                 free(new_path);
         } else {
-                error("Unable to setup man path");
+                pr_err("Unable to setup man path");
         }
 }
 
@@ -349,7 +349,7 @@ static void exec_viewer(const char *name, const char *page)
         else if (info)
                 exec_man_cmd(info, page);
         else
-                warning("'%s': unknown man viewer.", name);
+                pr_warning("'%s': unknown man viewer.", name);
 }
 
 static int show_man_page(const char *perf_cmd)
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index 9409c9464667..0a8a1c45af87 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -1715,7 +1715,7 @@ static int setup_slab_sorting(struct list_head *sort_list, const char *arg)
                 if (!tok)
                         break;
                 if (slab_sort_dimension__add(tok, sort_list) < 0) {
-                        error("Unknown slab --sort key: '%s'", tok);
+                        pr_err("Unknown slab --sort key: '%s'", tok);
                         free(str);
                         return -1;
                 }
@@ -1741,7 +1741,7 @@ static int setup_page_sorting(struct list_head *sort_list, const char *arg)
                 if (!tok)
                         break;
                 if (page_sort_dimension__add(tok, sort_list) < 0) {
-                        error("Unknown page --sort key: '%s'", tok);
+                        pr_err("Unknown page --sort key: '%s'", tok);
                         free(str);
                         return -1;
                 }
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index ee7d0a82ccd0..17a14bcce34a 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -453,7 +453,7 @@ try_again:
         }
 
         if (perf_evlist__apply_filters(evlist, &pos)) {
-                error("failed to set filter \"%s\" on event %s with %d (%s)\n",
+                pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n",
                         pos->filter, perf_evsel__name(pos), errno,
                         str_error_r(errno, msg, sizeof(msg)));
                 rc = -1;
@@ -461,7 +461,7 @@ try_again:
         }
 
         if (perf_evlist__apply_drv_configs(evlist, &pos, &err_term)) {
-                error("failed to set config \"%s\" on event %s with %d (%s)\n",
+                pr_err("failed to set config \"%s\" on event %s with %d (%s)\n",
                       err_term->val.drv_cfg, perf_evsel__name(pos), errno,
                       str_error_r(errno, msg, sizeof(msg)));
                 rc = -1;
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 22478ff2b706..79a33eb1a10d 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -94,10 +94,9 @@ static int report__config(const char *var, const char *value, void *cb)
                 symbol_conf.cumulate_callchain = perf_config_bool(var, value);
                 return 0;
         }
-        if (!strcmp(var, "report.queue-size")) {
-                rep->queue_size = perf_config_u64(var, value);
-                return 0;
-        }
+        if (!strcmp(var, "report.queue-size"))
+                return perf_config_u64(&rep->queue_size, var, value);
+
         if (!strcmp(var, "report.sort_order")) {
                 default_sort_order = strdup(value);
                 return 0;
@@ -558,6 +557,7 @@ static int __cmd_report(struct report *rep)
                         ui__error("failed to set cpu bitmap\n");
                         return ret;
                 }
+                session->itrace_synth_opts->cpu_bitmap = rep->cpu_bitmap;
         }
 
         if (rep->show_threads) {
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index 39996c53995a..322b4def8411 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -2066,7 +2066,7 @@ static void save_task_callchain(struct perf_sched *sched,
         if (thread__resolve_callchain(thread, cursor, evsel, sample,
                                       NULL, NULL, sched->max_stack + 2) != 0) {
                 if (verbose > 0)
-                        error("Failed to resolve callchain. Skipping\n");
+                        pr_err("Failed to resolve callchain. Skipping\n");
 
                 return;
         }
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index d05aec491cff..83cdc0a61fd6 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -85,6 +85,8 @@ enum perf_output_field {
         PERF_OUTPUT_INSN            = 1U << 21,
         PERF_OUTPUT_INSNLEN         = 1U << 22,
         PERF_OUTPUT_BRSTACKINSN     = 1U << 23,
+        PERF_OUTPUT_BRSTACKOFF      = 1U << 24,
+        PERF_OUTPUT_SYNTH           = 1U << 25,
 };
 
 struct output_option {
@@ -115,6 +117,13 @@ struct output_option {
         {.str = "insn", .field = PERF_OUTPUT_INSN},
         {.str = "insnlen", .field = PERF_OUTPUT_INSNLEN},
         {.str = "brstackinsn", .field = PERF_OUTPUT_BRSTACKINSN},
+        {.str = "brstackoff", .field = PERF_OUTPUT_BRSTACKOFF},
+        {.str = "synth", .field = PERF_OUTPUT_SYNTH},
+};
+
+enum {
+        OUTPUT_TYPE_SYNTH = PERF_TYPE_MAX,
+        OUTPUT_TYPE_MAX
 };
 
 /* default set to maintain compatibility with current format */
@@ -124,7 +133,7 @@ static struct {
         unsigned int print_ip_opts;
         u64 fields;
         u64 invalid_fields;
-} output[PERF_TYPE_MAX] = {
+} output[OUTPUT_TYPE_MAX] = {
 
         [PERF_TYPE_HARDWARE] = {
                 .user_set = false,
@@ -182,12 +191,44 @@ static struct {
 
                 .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
         },
+
+        [OUTPUT_TYPE_SYNTH] = {
+                .user_set = false,
+
+                .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
+                              PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
+                              PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
+                              PERF_OUTPUT_SYM | PERF_OUTPUT_DSO |
+                              PERF_OUTPUT_SYNTH,
+
+                .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
+        },
 };
 
+static inline int output_type(unsigned int type)
+{
+        switch (type) {
+        case PERF_TYPE_SYNTH:
+                return OUTPUT_TYPE_SYNTH;
+        default:
+                return type;
+        }
+}
+
+static inline unsigned int attr_type(unsigned int type)
+{
+        switch (type) {
+        case OUTPUT_TYPE_SYNTH:
+                return PERF_TYPE_SYNTH;
+        default:
+                return type;
+        }
+}
+
 static bool output_set_by_user(void)
 {
         int j;
-        for (j = 0; j < PERF_TYPE_MAX; ++j) {
+        for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
                 if (output[j].user_set)
                         return true;
         }
@@ -208,7 +249,7 @@ static const char *output_field2str(enum perf_output_field field)
         return str;
 }
 
-#define PRINT_FIELD(x)  (output[attr->type].fields & PERF_OUTPUT_##x)
+#define PRINT_FIELD(x)  (output[output_type(attr->type)].fields & PERF_OUTPUT_##x)
 
 static int perf_evsel__do_check_stype(struct perf_evsel *evsel,
                                       u64 sample_type, const char *sample_msg,
@@ -216,7 +257,7 @@ static int perf_evsel__do_check_stype(struct perf_evsel *evsel,
                                       bool allow_user_set)
 {
         struct perf_event_attr *attr = &evsel->attr;
-        int type = attr->type;
+        int type = output_type(attr->type);
         const char *evname;
 
         if (attr->sample_type & sample_type)
@@ -298,10 +339,10 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                        "selected.\n");
                 return -EINVAL;
         }
-        if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
-                pr_err("Display of DSO requested but neither sample IP nor "
-                           "sample address\nis selected. Hence, no addresses to convert "
-                       "to DSO.\n");
+        if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR) &&
+            !PRINT_FIELD(BRSTACK) && !PRINT_FIELD(BRSTACKSYM) && !PRINT_FIELD(BRSTACKOFF)) {
+                pr_err("Display of DSO requested but no address to convert.  Select\n"
+                       "sample IP, sample address, brstack, brstacksym, or brstackoff.\n");
                 return -EINVAL;
         }
         if (PRINT_FIELD(SRCLINE) && !PRINT_FIELD(IP)) {
@@ -346,7 +387,7 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
 
 static void set_print_ip_opts(struct perf_event_attr *attr)
 {
-        unsigned int type = attr->type;
+        unsigned int type = output_type(attr->type);
 
         output[type].print_ip_opts = 0;
         if (PRINT_FIELD(IP))
@@ -374,16 +415,17 @@ static int perf_session__check_output_opt(struct perf_session *session)
         unsigned int j;
         struct perf_evsel *evsel;
 
-        for (j = 0; j < PERF_TYPE_MAX; ++j) {
-                evsel = perf_session__find_first_evtype(session, j);
+        for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
+                evsel = perf_session__find_first_evtype(session, attr_type(j));
 
                 /*
                  * even if fields is set to 0 (ie., show nothing) event must
                  * exist if user explicitly includes it on the command line
                  */
-                if (!evsel && output[j].user_set && !output[j].wildcard_set) {
+                if (!evsel && output[j].user_set && !output[j].wildcard_set &&
+                    j != OUTPUT_TYPE_SYNTH) {
                         pr_err("%s events do not exist. "
-                               "Remove corresponding -f option to proceed.\n",
+                               "Remove corresponding -F option to proceed.\n",
                                event_type(j));
                         return -1;
                 }
@@ -514,18 +556,43 @@ mispred_str(struct branch_entry *br)
         return br->flags.predicted ? 'P' : 'M';
 }
 
-static void print_sample_brstack(struct perf_sample *sample)
+static void print_sample_brstack(struct perf_sample *sample,
+                                 struct thread *thread,
+                                 struct perf_event_attr *attr)
 {
         struct branch_stack *br = sample->branch_stack;
-        u64 i;
+        struct addr_location alf, alt;
+        u64 i, from, to;
 
         if (!(br && br->nr))
                 return;
 
         for (i = 0; i < br->nr; i++) {
-                printf(" 0x%"PRIx64"/0x%"PRIx64"/%c/%c/%c/%d ",
-                        br->entries[i].from,
-                        br->entries[i].to,
+                from = br->entries[i].from;
+                to   = br->entries[i].to;
+
+                if (PRINT_FIELD(DSO)) {
+                        memset(&alf, 0, sizeof(alf));
+                        memset(&alt, 0, sizeof(alt));
+                        thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, from, &alf);
+                        thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, to, &alt);
+                }
+
+                printf("0x%"PRIx64, from);
+                if (PRINT_FIELD(DSO)) {
+                        printf("(");
+                        map__fprintf_dsoname(alf.map, stdout);
+                        printf(")");
+                }
+
+                printf("/0x%"PRIx64, to);
+                if (PRINT_FIELD(DSO)) {
+                        printf("(");
+                        map__fprintf_dsoname(alt.map, stdout);
+                        printf(")");
+                }
+
+                printf("/%c/%c/%c/%d ",
                         mispred_str( br->entries + i),
                         br->entries[i].flags.in_tx? 'X' : '-',
                         br->entries[i].flags.abort? 'A' : '-',
@@ -534,7 +601,8 @@ static void print_sample_brstack(struct perf_sample *sample)
 }
 
 static void print_sample_brstacksym(struct perf_sample *sample,
-                                    struct thread *thread)
+                                    struct thread *thread,
+                                    struct perf_event_attr *attr)
 {
         struct branch_stack *br = sample->branch_stack;
         struct addr_location alf, alt;
@@ -559,8 +627,18 @@ static void print_sample_brstacksym(struct perf_sample *sample,
                         alt.sym = map__find_symbol(alt.map, alt.addr);
 
                 symbol__fprintf_symname_offs(alf.sym, &alf, stdout);
+                if (PRINT_FIELD(DSO)) {
+                        printf("(");
+                        map__fprintf_dsoname(alf.map, stdout);
+                        printf(")");
+                }
                 putchar('/');
                 symbol__fprintf_symname_offs(alt.sym, &alt, stdout);
+                if (PRINT_FIELD(DSO)) {
+                        printf("(");
+                        map__fprintf_dsoname(alt.map, stdout);
+                        printf(")");
+                }
                 printf("/%c/%c/%c/%d ",
                         mispred_str( br->entries + i),
                         br->entries[i].flags.in_tx? 'X' : '-',
@@ -569,6 +647,51 @@ static void print_sample_brstacksym(struct perf_sample *sample,
         }
 }
 
+static void print_sample_brstackoff(struct perf_sample *sample,
+                                    struct thread *thread,
+                                    struct perf_event_attr *attr)
+{
+        struct branch_stack *br = sample->branch_stack;
+        struct addr_location alf, alt;
+        u64 i, from, to;
+
+        if (!(br && br->nr))
+                return;
+
+        for (i = 0; i < br->nr; i++) {
+
+                memset(&alf, 0, sizeof(alf));
+                memset(&alt, 0, sizeof(alt));
+                from = br->entries[i].from;
+                to   = br->entries[i].to;
+
+                thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, from, &alf);
+                if (alf.map && !alf.map->dso->adjust_symbols)
+                        from = map__map_ip(alf.map, from);
+
+                thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, to, &alt);
+                if (alt.map && !alt.map->dso->adjust_symbols)
+                        to = map__map_ip(alt.map, to);
+
+                printf("0x%"PRIx64, from);
+                if (PRINT_FIELD(DSO)) {
+                        printf("(");
+                        map__fprintf_dsoname(alf.map, stdout);
+                        printf(")");
+                }
+                printf("/0x%"PRIx64, to);
+                if (PRINT_FIELD(DSO)) {
+                        printf("(");
+                        map__fprintf_dsoname(alt.map, stdout);
+                        printf(")");
+                }
+                printf("/%c/%c/%c/%d ",
+                        mispred_str(br->entries + i),
+                        br->entries[i].flags.in_tx ? 'X' : '-',
+                        br->entries[i].flags.abort ? 'A' : '-',
+                        br->entries[i].flags.cycles);
+        }
+}
 #define MAXBB 16384UL
 
 static int grab_bb(u8 *buffer, u64 start, u64 end,
@@ -906,6 +1029,7 @@ static void print_sample_bts(struct perf_sample *sample,
                              struct machine *machine)
 {
         struct perf_event_attr *attr = &evsel->attr;
+        unsigned int type = output_type(attr->type);
         bool print_srcline_last = false;
 
         if (PRINT_FIELD(CALLINDENT))
@@ -913,7 +1037,7 @@ static void print_sample_bts(struct perf_sample *sample,
 
         /* print branch_from information */
         if (PRINT_FIELD(IP)) {
-                unsigned int print_opts = output[attr->type].print_ip_opts;
+                unsigned int print_opts = output[type].print_ip_opts;
                 struct callchain_cursor *cursor = NULL;
 
                 if (symbol_conf.use_callchain && sample->callchain &&
@@ -936,7 +1060,7 @@ static void print_sample_bts(struct perf_sample *sample,
         /* print branch_to information */
         if (PRINT_FIELD(ADDR) ||
             ((evsel->attr.sample_type & PERF_SAMPLE_ADDR) &&
-             !output[attr->type].user_set)) {
+             !output[type].user_set)) {
                 printf(" => ");
                 print_sample_addr(sample, thread, attr);
         }
@@ -1079,6 +1203,127 @@ static void print_sample_bpf_output(struct perf_sample *sample)
                        (char *)(sample->raw_data));
 }
 
+static void print_sample_spacing(int len, int spacing)
+{
+        if (len > 0 && len < spacing)
+                printf("%*s", spacing - len, "");
+}
+
+static void print_sample_pt_spacing(int len)
+{
+        print_sample_spacing(len, 34);
+}
+
+static void print_sample_synth_ptwrite(struct perf_sample *sample)
+{
+        struct perf_synth_intel_ptwrite *data = perf_sample__synth_ptr(sample);
+        int len;
+
+        if (perf_sample__bad_synth_size(sample, *data))
+                return;
+
+        len = printf(" IP: %u payload: %#" PRIx64 " ",
+                     data->ip, le64_to_cpu(data->payload));
+        print_sample_pt_spacing(len);
+}
+
+static void print_sample_synth_mwait(struct perf_sample *sample)
+{
+        struct perf_synth_intel_mwait *data = perf_sample__synth_ptr(sample);
+        int len;
+
+        if (perf_sample__bad_synth_size(sample, *data))
+                return;
+
+        len = printf(" hints: %#x extensions: %#x ",
+                     data->hints, data->extensions);
+        print_sample_pt_spacing(len);
+}
+
+static void print_sample_synth_pwre(struct perf_sample *sample)
+{
+        struct perf_synth_intel_pwre *data = perf_sample__synth_ptr(sample);
+        int len;
+
+        if (perf_sample__bad_synth_size(sample, *data))
+                return;
+
+        len = printf(" hw: %u cstate: %u sub-cstate: %u ",
+                     data->hw, data->cstate, data->subcstate);
+        print_sample_pt_spacing(len);
+}
+
+static void print_sample_synth_exstop(struct perf_sample *sample)
+{
+        struct perf_synth_intel_exstop *data = perf_sample__synth_ptr(sample);
+        int len;
+
+        if (perf_sample__bad_synth_size(sample, *data))
+                return;
+
+        len = printf(" IP: %u ", data->ip);
+        print_sample_pt_spacing(len);
+}
+
+static void print_sample_synth_pwrx(struct perf_sample *sample)
+{
+        struct perf_synth_intel_pwrx *data = perf_sample__synth_ptr(sample);
+        int len;
+
+        if (perf_sample__bad_synth_size(sample, *data))
+                return;
+
+        len = printf(" deepest cstate: %u last cstate: %u wake reason: %#x ",
+                     data->deepest_cstate, data->last_cstate,
+                     data->wake_reason);
+        print_sample_pt_spacing(len);
+}
+
+static void print_sample_synth_cbr(struct perf_sample *sample)
+{
+        struct perf_synth_intel_cbr *data = perf_sample__synth_ptr(sample);
+        unsigned int percent, freq;
+        int len;
+
+        if (perf_sample__bad_synth_size(sample, *data))
+                return;
+
+        freq = (le32_to_cpu(data->freq) + 500) / 1000;
+        len = printf(" cbr: %2u freq: %4u MHz ", data->cbr, freq);
+        if (data->max_nonturbo) {
+                percent = (5 + (1000 * data->cbr) / data->max_nonturbo) / 10;
+                len += printf("(%3u%%) ", percent);
+        }
+        print_sample_pt_spacing(len);
+}
+
+static void print_sample_synth(struct perf_sample *sample,
+                               struct perf_evsel *evsel)
+{
+        switch (evsel->attr.config) {
+        case PERF_SYNTH_INTEL_PTWRITE:
+                print_sample_synth_ptwrite(sample);
+                break;
+        case PERF_SYNTH_INTEL_MWAIT:
+                print_sample_synth_mwait(sample);
+                break;
+        case PERF_SYNTH_INTEL_PWRE:
+                print_sample_synth_pwre(sample);
+                break;
+        case PERF_SYNTH_INTEL_EXSTOP:
+                print_sample_synth_exstop(sample);
+                break;
+        case PERF_SYNTH_INTEL_PWRX:
+                print_sample_synth_pwrx(sample);
+                break;
+        case PERF_SYNTH_INTEL_CBR:
+                print_sample_synth_cbr(sample);
+                break;
+        default:
+                break;
+        }
+}
+
 struct perf_script {
         struct perf_tool        tool;
         struct perf_session     *session;
@@ -1132,8 +1377,9 @@ static void process_event(struct perf_script *script,
 {
         struct thread *thread = al->thread;
         struct perf_event_attr *attr = &evsel->attr;
+        unsigned int type = output_type(attr->type);
 
-        if (output[attr->type].fields == 0)
+        if (output[type].fields == 0)
                 return;
 
         print_sample_start(sample, thread, evsel);
@@ -1162,6 +1408,10 @@ static void process_event(struct perf_script *script,
         if (PRINT_FIELD(TRACE))
                 event_format__print(evsel->tp_format, sample->cpu,
                                     sample->raw_data, sample->raw_size);
+
+        if (attr->type == PERF_TYPE_SYNTH && PRINT_FIELD(SYNTH))
+                print_sample_synth(sample, evsel);
+
         if (PRINT_FIELD(ADDR))
                 print_sample_addr(sample, thread, attr);
 
@@ -1180,16 +1430,18 @@ static void process_event(struct perf_script *script,
                         cursor = &callchain_cursor;
 
                 putchar(cursor ? '\n' : ' ');
-                sample__fprintf_sym(sample, al, 0, output[attr->type].print_ip_opts, cursor, stdout);
+                sample__fprintf_sym(sample, al, 0, output[type].print_ip_opts, cursor, stdout);
         }
 
         if (PRINT_FIELD(IREGS))
                 print_sample_iregs(sample, attr);
 
         if (PRINT_FIELD(BRSTACK))
-                print_sample_brstack(sample);
+                print_sample_brstack(sample, thread, attr);
         else if (PRINT_FIELD(BRSTACKSYM))
-                print_sample_brstacksym(sample, thread);
+                print_sample_brstacksym(sample, thread, attr);
+        else if (PRINT_FIELD(BRSTACKOFF))
+                print_sample_brstackoff(sample, thread, attr);
 
         if (perf_evsel__is_bpf_output(evsel) && PRINT_FIELD(BPF_OUTPUT))
                 print_sample_bpf_output(sample);
@@ -1325,7 +1577,8 @@ static int process_attr(struct perf_tool *tool, union perf_event *event,
         evlist = *pevlist;
         evsel = perf_evlist__last(*pevlist);
 
-        if (evsel->attr.type >= PERF_TYPE_MAX)
+        if (evsel->attr.type >= PERF_TYPE_MAX &&
+            evsel->attr.type != PERF_TYPE_SYNTH)
                 return 0;
 
         evlist__for_each_entry(evlist, pos) {
@@ -1727,6 +1980,7 @@ static int parse_output_fields(const struct option *opt __maybe_unused,
         int rc = 0;
         char *str = strdup(arg);
         int type = -1;
+        enum { DEFAULT, SET, ADD, REMOVE } change = DEFAULT;
 
         if (!str)
                 return -ENOMEM;
@@ -1749,6 +2003,8 @@ static int parse_output_fields(const struct option *opt __maybe_unused,
                         type = PERF_TYPE_RAW;
                 else if (!strcmp(str, "break"))
                         type = PERF_TYPE_BREAKPOINT;
+                else if (!strcmp(str, "synth"))
+                        type = OUTPUT_TYPE_SYNTH;
                 else {
                         fprintf(stderr, "Invalid event type in field string.\n");
                         rc = -EINVAL;
@@ -1772,23 +2028,44 @@ static int parse_output_fields(const struct option *opt __maybe_unused,
                         goto out;
                 }
 
+                /* Don't override defaults for +- */
+                if (strchr(str, '+') || strchr(str, '-'))
+                        goto parse;
+
                 if (output_set_by_user())
                         pr_warning("Overriding previous field request for all events.\n");
 
-                for (j = 0; j < PERF_TYPE_MAX; ++j) {
+                for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
                         output[j].fields = 0;
                         output[j].user_set = true;
                         output[j].wildcard_set = true;
                 }
         }
 
+parse:
         for (tok = strtok_r(tok, ",", &strtok_saveptr); tok; tok = strtok_r(NULL, ",", &strtok_saveptr)) {
+                if (*tok == '+') {
+                        if (change == SET)
+                                goto out_badmix;
+                        change = ADD;
+                        tok++;
+                } else if (*tok == '-') {
+                        if (change == SET)
+                                goto out_badmix;
+                        change = REMOVE;
+                        tok++;
+                } else {
+                        if (change != SET && change != DEFAULT)
+                                goto out_badmix;
+                        change = SET;
+                }
+
                 for (i = 0; i < imax; ++i) {
                         if (strcmp(tok, all_output_options[i].str) == 0)
                                 break;
                 }
                 if (i == imax && strcmp(tok, "flags") == 0) {
-                        print_flags = true;
+                        print_flags = change == REMOVE ? false : true;
                         continue;
                 }
                 if (i == imax) {
@@ -1801,12 +2078,16 @@ static int parse_output_fields(const struct option *opt __maybe_unused,
                         /* add user option to all events types for
                          * which it is valid
                          */
-                        for (j = 0; j < PERF_TYPE_MAX; ++j) {
+                        for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
                                 if (output[j].invalid_fields & all_output_options[i].field) {
                                         pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
                                                    all_output_options[i].str, event_type(j));
-                                } else
-                                        output[j].fields |= all_output_options[i].field;
+                                } else {
+                                        if (change == REMOVE)
+                                                output[j].fields &= ~all_output_options[i].field;
+                                        else
+                                                output[j].fields |= all_output_options[i].field;
+                                }
                         }
                 } else {
                         if (output[type].invalid_fields & all_output_options[i].field) {
@@ -1826,7 +2107,11 @@ static int parse_output_fields(const struct option *opt __maybe_unused,
                                  "Events will not be displayed.\n", event_type(type));
                 }
         }
+        goto out;
 
+out_badmix:
+        fprintf(stderr, "Cannot mix +-field with overridden fields\n");
+        rc = -EINVAL;
 out:
         free(str);
         return rc;
@@ -2444,10 +2729,11 @@ int cmd_script(int argc, const char **argv)
                      symbol__config_symfs),
         OPT_CALLBACK('F', "fields", NULL, "str",
                      "comma separated output fields prepend with 'type:'. "
-                     "Valid types: hw,sw,trace,raw. "
+                     "+field to add and -field to remove."
+                     "Valid types: hw,sw,trace,raw,synth. "
                      "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
                      "addr,symoff,period,iregs,brstack,brstacksym,flags,"
-                     "bpf-output,callindent,insn,insnlen,brstackinsn",
+                     "bpf-output,callindent,insn,insnlen,brstackinsn,synth",
                      parse_output_fields),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
                     "system-wide collection from all CPUs"),
@@ -2494,6 +2780,8 @@ int cmd_script(int argc, const char **argv)
                         "Enable kernel symbol demangling"),
         OPT_STRING(0, "time", &script.time_str, "str",
                    "Time span of interest (start,stop)"),
+        OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
+                    "Show inline function"),
         OPT_END()
         };
         const char * const script_subcommands[] = { "record", "report", NULL };
@@ -2704,6 +2992,7 @@ int cmd_script(int argc, const char **argv)
                 err = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
                 if (err < 0)
                         goto out_delete;
+                itrace_synth_opts.cpu_bitmap = cpu_bitmap;
         }
 
         if (!no_callchain)
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index a935b5023732..48ac53b199fc 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -86,6 +86,7 @@
 #define DEFAULT_SEPARATOR       " "
 #define CNTR_NOT_SUPPORTED      "<not supported>"
 #define CNTR_NOT_COUNTED        "<not counted>"
+#define FREEZE_ON_SMI_PATH      "devices/cpu/freeze_on_smi"
 
 static void print_counters(struct timespec *ts, int argc, const char **argv);
 
@@ -122,6 +123,14 @@ static const char * topdown_attrs[] = {
         NULL,
 };
 
+static const char *smi_cost_attrs = {
+        "{"
+        "msr/aperf/,"
+        "msr/smi/,"
+        "cycles"
+        "}"
+};
+
 static struct perf_evlist       *evsel_list;
 
 static struct target target = {
@@ -137,6 +146,8 @@ static bool			null_run			=  false;
 static int                      detailed_run                    =  0;
 static bool                     transaction_run;
 static bool                     topdown_run                     = false;
+static bool                     smi_cost                        = false;
+static bool                     smi_reset                       = false;
 static bool                     big_num                         =  true;
 static int                      big_num_opt                     =  -1;
 static const char               *csv_sep                        = NULL;
@@ -625,14 +636,14 @@ try_again:
         }
 
         if (perf_evlist__apply_filters(evsel_list, &counter)) {
-                error("failed to set filter \"%s\" on event %s with %d (%s)\n",
+                pr_err("failed to set filter \"%s\" on event %s with %d (%s)\n",
                         counter->filter, perf_evsel__name(counter), errno,
                         str_error_r(errno, msg, sizeof(msg)));
                 return -1;
         }
 
         if (perf_evlist__apply_drv_configs(evsel_list, &counter, &err_term)) {
-                error("failed to set config \"%s\" on event %s with %d (%s)\n",
+                pr_err("failed to set config \"%s\" on event %s with %d (%s)\n",
                       err_term->val.drv_cfg, perf_evsel__name(counter), errno,
                       str_error_r(errno, msg, sizeof(msg)));
                 return -1;
@@ -1578,6 +1589,7 @@ static void print_header(int argc, const char **argv)
 static void print_footer(void)
 {
         FILE *output = stat_config.output;
+        int n;
 
         if (!null_run)
                 fprintf(output, "\n");
@@ -1590,7 +1602,9 @@ static void print_footer(void)
         }
         fprintf(output, "\n\n");
 
-        if (print_free_counters_hint)
+        if (print_free_counters_hint &&
+            sysctl__read_int("kernel/nmi_watchdog", &n) >= 0 &&
+            n > 0)
                 fprintf(output,
 "Some events weren't counted. Try disabling the NMI watchdog:\n"
 "       echo 0 > /proc/sys/kernel/nmi_watchdog\n"
@@ -1779,6 +1793,8 @@ static const struct option stat_options[] = {
                         "Only print computed metrics. No raw values", enable_metric_only),
         OPT_BOOLEAN(0, "topdown", &topdown_run,
                         "measure topdown level 1 statistics"),
+        OPT_BOOLEAN(0, "smi-cost", &smi_cost,
+                        "measure SMI cost"),
         OPT_END()
 };
 
@@ -2157,6 +2173,39 @@ static int add_default_attributes(void)
                 return 0;
         }
 
+        if (smi_cost) {
+                int smi;
+
+                if (sysfs__read_int(FREEZE_ON_SMI_PATH, &smi) < 0) {
+                        fprintf(stderr, "freeze_on_smi is not supported.\n");
+                        return -1;
+                }
+
+                if (!smi) {
+                        if (sysfs__write_int(FREEZE_ON_SMI_PATH, 1) < 0) {
+                                fprintf(stderr, "Failed to set freeze_on_smi.\n");
+                                return -1;
+                        }
+                        smi_reset = true;
+                }
+
+                if (pmu_have_event("msr", "aperf") &&
+                    pmu_have_event("msr", "smi")) {
+                        if (!force_metric_only)
+                                metric_only = true;
+                        err = parse_events(evsel_list, smi_cost_attrs, NULL);
+                } else {
+                        fprintf(stderr, "To measure SMI cost, it needs "
+                                "msr/aperf/, msr/smi/ and cpu/cycles/ support\n");
+                        return -1;
+                }
+                if (err) {
+                        fprintf(stderr, "Cannot set up SMI cost events\n");
+                        return -1;
+                }
+                return 0;
+        }
+
         if (topdown_run) {
                 char *str = NULL;
                 bool warn = false;
@@ -2739,6 +2788,9 @@ int cmd_stat(int argc, const char **argv)
         perf_stat__exit_aggr_mode();
         perf_evlist__free_stats(evsel_list);
 out:
+        if (smi_cost && smi_reset)
+                sysfs__write_int(FREEZE_ON_SMI_PATH, 0);
+
         perf_evlist__delete(evsel_list);
         return status;
 }
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 10b6362ca0bf..6052376634c0 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -134,7 +134,7 @@ static int perf_top__parse_source(struct perf_top *top, struct hist_entry *he)
                 return err;
         }
 
-        err = symbol__disassemble(sym, map, NULL, 0);
+        err = symbol__disassemble(sym, map, NULL, 0, NULL);
         if (err == 0) {
 out_assign:
                 top->sym_filter_entry = he;
@@ -958,7 +958,7 @@ static int __cmd_top(struct perf_top *top)
 
         ret = perf_evlist__apply_drv_configs(evlist, &pos, &err_term);
         if (ret) {
-                error("failed to set config \"%s\" on event %s with %d (%s)\n",
+                pr_err("failed to set config \"%s\" on event %s with %d (%s)\n",
                         err_term->val.drv_cfg, perf_evsel__name(pos), errno,
                         str_error_r(errno, msg, sizeof(msg)));
                 goto out_delete;
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index d014350adc52..4b2a5d298197 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -681,6 +681,10 @@ static struct syscall_fmt {
         { .name     = "mlockall",   .errmsg = true,
           .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
         { .name     = "mmap",       .hexret = true,
+/* The standard mmap maps to old_mmap on s390x */
+#if defined(__s390x__)
+        .alias = "old_mmap",
+#endif
           .arg_scnprintf = { [0] = SCA_HEX,       /* addr */
                              [2] = SCA_MMAP_PROT, /* prot */
                              [3] = SCA_MMAP_FLAGS, /* flags */ }, },
diff --git a/tools/perf/jvmti/jvmti_agent.c b/tools/perf/jvmti/jvmti_agent.c
index e9651a9d670e..cf36de7ea255 100644
--- a/tools/perf/jvmti/jvmti_agent.c
+++ b/tools/perf/jvmti/jvmti_agent.c
@@ -304,7 +304,7 @@ jvmti_close(void *agent)
         FILE *fp = agent;
 
         if (!fp) {
-                warnx("jvmti: incalid fd in close_agent");
+                warnx("jvmti: invalid fd in close_agent");
                 return -1;
         }
 
diff --git a/tools/perf/jvmti/jvmti_agent.h b/tools/perf/jvmti/jvmti_agent.h
index bedf5d0ba9ff..c53a41f48b63 100644
--- a/tools/perf/jvmti/jvmti_agent.h
+++ b/tools/perf/jvmti/jvmti_agent.h
@@ -5,8 +5,6 @@
 #include <stdint.h>
 #include <jvmti.h>
 
-#define __unused __attribute__((unused))
-
 #if defined(__cplusplus)
 extern "C" {
 #endif
diff --git a/tools/perf/jvmti/libjvmti.c b/tools/perf/jvmti/libjvmti.c
index 5612641c69b4..6d710904c837 100644
--- a/tools/perf/jvmti/libjvmti.c
+++ b/tools/perf/jvmti/libjvmti.c
@@ -1,3 +1,4 @@
+#include <linux/compiler.h>
 #include <sys/types.h>
 #include <stdio.h>
 #include <string.h>
@@ -238,7 +239,7 @@ code_generated_cb(jvmtiEnv *jvmti,
 }
 
 JNIEXPORT jint JNICALL
-Agent_OnLoad(JavaVM *jvm, char *options, void *reserved __unused)
+Agent_OnLoad(JavaVM *jvm, char *options, void *reserved __maybe_unused)
 {
         jvmtiEventCallbacks cb;
         jvmtiCapabilities caps1;
@@ -313,7 +314,7 @@ Agent_OnLoad(JavaVM *jvm, char *options, void *reserved __unused)
 }
 
 JNIEXPORT void JNICALL
-Agent_OnUnload(JavaVM *jvm __unused)
+Agent_OnUnload(JavaVM *jvm __maybe_unused)
 {
         int ret;
 
diff --git a/tools/perf/pmu-events/Build b/tools/perf/pmu-events/Build
index 9213a1273697..999a4e878162 100644
--- a/tools/perf/pmu-events/Build
+++ b/tools/perf/pmu-events/Build
@@ -2,7 +2,7 @@ hostprogs := jevents
 
 jevents-y       += json.o jsmn.o jevents.o
 pmu-events-y    += pmu-events.o
-JDIR            =  pmu-events/arch/$(ARCH)
+JDIR            =  pmu-events/arch/$(SRCARCH)
 JSON            =  $(shell [ -d $(JDIR) ] &&                            \
                         find $(JDIR) -name '*.json' -o -name 'mapfile.csv')
 #
@@ -10,4 +10,4 @@ JSON		=  $(shell [ -d $(JDIR) ] &&				\
 # directory and create tables in pmu-events.c.
 #
 $(OUTPUT)pmu-events/pmu-events.c: $(JSON) $(JEVENTS)
-        $(Q)$(call echo-cmd,gen)$(JEVENTS) $(ARCH) pmu-events/arch $(OUTPUT)pmu-events/pmu-events.c $(V)
+        $(Q)$(call echo-cmd,gen)$(JEVENTS) $(SRCARCH) pmu-events/arch $(OUTPUT)pmu-events/pmu-events.c $(V)
diff --git a/tools/perf/pmu-events/jevents.c b/tools/perf/pmu-events/jevents.c
index baa073f38334..bd0aabb2bd0f 100644
--- a/tools/perf/pmu-events/jevents.c
+++ b/tools/perf/pmu-events/jevents.c
@@ -48,10 +48,6 @@
 #include "json.h"
 #include "jevents.h"
 
-#ifndef __maybe_unused
-#define __maybe_unused                  __attribute__((unused))
-#endif
-
 int verbose;
 char *prog;
 
diff --git a/tools/perf/scripts/python/bin/intel-pt-events-record b/tools/perf/scripts/python/bin/intel-pt-events-record
new file mode 100644
index 000000000000..10fe2b6977d4
--- /dev/null
+++ b/tools/perf/scripts/python/bin/intel-pt-events-record
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+#
+# print Intel PT Power Events and PTWRITE. The intel_pt PMU event needs
+# to be specified with appropriate config terms.
+#
+if ! echo "$@" | grep -q intel_pt ; then
+        echo "Options must include the Intel PT event e.g. -e intel_pt/pwr_evt,ptw/"
+        echo "and for power events it probably needs to be system wide i.e. -a option"
+        echo "For example: -a -e intel_pt/pwr_evt,branch=0/ sleep 1"
+        exit 1
+fi
+perf record $@
diff --git a/tools/perf/scripts/python/bin/intel-pt-events-report b/tools/perf/scripts/python/bin/intel-pt-events-report
new file mode 100644
index 000000000000..9a9c92fcd026
--- /dev/null
+++ b/tools/perf/scripts/python/bin/intel-pt-events-report
@@ -0,0 +1,3 @@
+#!/bin/bash
+# description: print Intel PT Power Events and PTWRITE
+perf script $@ -s "$PERF_EXEC_PATH"/scripts/python/intel-pt-events.py
\ No newline at end of file
diff --git a/tools/perf/scripts/python/intel-pt-events.py b/tools/perf/scripts/python/intel-pt-events.py
new file mode 100644
index 000000000000..b19172d673af
--- /dev/null
+++ b/tools/perf/scripts/python/intel-pt-events.py
@@ -0,0 +1,128 @@
+# intel-pt-events.py: Print Intel PT Power Events and PTWRITE
+# Copyright (c) 2017, Intel Corporation.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms and conditions of the GNU General Public License,
+# version 2, as published by the Free Software Foundation.
+#
+# This program is distributed in the hope it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+import os
+import sys
+import struct
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+# These perf imports are not used at present
+#from perf_trace_context import *
+#from Core import *
+
+def trace_begin():
+        print "Intel PT Power Events and PTWRITE"
+
+def trace_end():
+        print "End"
+
+def trace_unhandled(event_name, context, event_fields_dict):
+                print ' '.join(['%s=%s'%(k,str(v))for k,v in sorted(event_fields_dict.items())])
+
+def print_ptwrite(raw_buf):
+        data = struct.unpack_from("<IQ", raw_buf)
+        flags = data[0]
+        payload = data[1]
+        exact_ip = flags & 1
+        print "IP: %u payload: %#x" % (exact_ip, payload),
+
+def print_cbr(raw_buf):
+        data = struct.unpack_from("<BBBBII", raw_buf)
+        cbr = data[0]
+        f = (data[4] + 500) / 1000
+        p = ((cbr * 1000 / data[2]) + 5) / 10
+        print "%3u  freq: %4u MHz  (%3u%%)" % (cbr, f, p),
+
+def print_mwait(raw_buf):
+        data = struct.unpack_from("<IQ", raw_buf)
+        payload = data[1]
+        hints = payload & 0xff
+        extensions = (payload >> 32) & 0x3
+        print "hints: %#x extensions: %#x" % (hints, extensions),
+
+def print_pwre(raw_buf):
+        data = struct.unpack_from("<IQ", raw_buf)
+        payload = data[1]
+        hw = (payload >> 7) & 1
+        cstate = (payload >> 12) & 0xf
+        subcstate = (payload >> 8) & 0xf
+        print "hw: %u cstate: %u sub-cstate: %u" % (hw, cstate, subcstate),
+
+def print_exstop(raw_buf):
+        data = struct.unpack_from("<I", raw_buf)
+        flags = data[0]
+        exact_ip = flags & 1
+        print "IP: %u" % (exact_ip),
+
+def print_pwrx(raw_buf):
+        data = struct.unpack_from("<IQ", raw_buf)
+        payload = data[1]
+        deepest_cstate = payload & 0xf
+        last_cstate = (payload >> 4) & 0xf
+        wake_reason = (payload >> 8) & 0xf
+        print "deepest cstate: %u last cstate: %u wake reason: %#x" % (deepest_cstate, last_cstate, wake_reason),
+
+def print_common_start(comm, sample, name):
+        ts = sample["time"]
+        cpu = sample["cpu"]
+        pid = sample["pid"]
+        tid = sample["tid"]
+        print "%16s %5u/%-5u [%03u] %9u.%09u %7s:" % (comm, pid, tid, cpu, ts / 1000000000, ts %1000000000, name),
+
+def print_common_ip(sample, symbol, dso):
+        ip = sample["ip"]
+        print "%16x %s (%s)" % (ip, symbol, dso)
+
+def process_event(param_dict):
+        event_attr = param_dict["attr"]
+        sample     = param_dict["sample"]
+        raw_buf    = param_dict["raw_buf"]
+        comm       = param_dict["comm"]
+        name       = param_dict["ev_name"]
+
+        # Symbol and dso info are not always resolved
+        if (param_dict.has_key("dso")):
+                dso = param_dict["dso"]
+        else:
+                dso = "[unknown]"
+
+        if (param_dict.has_key("symbol")):
+                symbol = param_dict["symbol"]
+        else:
+                symbol = "[unknown]"
+
+        if name == "ptwrite":
+                print_common_start(comm, sample, name)
+                print_ptwrite(raw_buf)
+                print_common_ip(sample, symbol, dso)
+        elif name == "cbr":
+                print_common_start(comm, sample, name)
+                print_cbr(raw_buf)
+                print_common_ip(sample, symbol, dso)
+        elif name == "mwait":
+                print_common_start(comm, sample, name)
+                print_mwait(raw_buf)
+                print_common_ip(sample, symbol, dso)
+        elif name == "pwre":
+                print_common_start(comm, sample, name)
+                print_pwre(raw_buf)
+                print_common_ip(sample, symbol, dso)
+        elif name == "exstop":
+                print_common_start(comm, sample, name)
+                print_exstop(raw_buf)
+                print_common_ip(sample, symbol, dso)
+        elif name == "pwrx":
+                print_common_start(comm, sample, name)
+                print_pwrx(raw_buf)
+                print_common_ip(sample, symbol, dso)
diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
index af58ebc243ef..84222bdb8689 100644
--- a/tools/perf/tests/Build
+++ b/tools/perf/tests/Build
@@ -75,7 +75,7 @@ $(OUTPUT)tests/llvm-src-relocation.c: tests/bpf-script-test-relocation.c tests/B
         $(Q)sed -e 's/"/\\"/g' -e 's/\(.*\)/"\1\\n"/g' $< >> $@
         $(Q)echo ';' >> $@
 
-ifeq ($(ARCH),$(filter $(ARCH),x86 arm arm64 powerpc))
+ifeq ($(SRCARCH),$(filter $(SRCARCH),x86 arm arm64 powerpc))
 perf-$(CONFIG_DWARF_UNWIND) += dwarf-unwind.o
 endif
 
diff --git a/tools/perf/tests/attr.c b/tools/perf/tests/attr.c
index 0dd77494bb58..0e77b2cf61ec 100644
--- a/tools/perf/tests/attr.c
+++ b/tools/perf/tests/attr.c
@@ -18,6 +18,7 @@
  * permissions. All the event text files are stored there.
  */
 
+#include <debug.h>
 #include <errno.h>
 #include <inttypes.h>
 #include <stdlib.h>
@@ -29,14 +30,11 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #include "../perf.h"
-#include "util.h"
 #include <subcmd/exec-cmd.h>
 #include "tests.h"
 
 #define ENV "PERF_TEST_ATTR"
 
-extern int verbose;
-
 static char *dir;
 
 void test_attr__init(void)
@@ -138,8 +136,10 @@ void test_attr__open(struct perf_event_attr *attr, pid_t pid, int cpu,
 {
         int errno_saved = errno;
 
-        if (store_event(attr, pid, cpu, fd, group_fd, flags))
-                die("test attr FAILED");
+        if (store_event(attr, pid, cpu, fd, group_fd, flags)) {
+                pr_err("test attr FAILED");
+                exit(128);
+        }
 
         errno = errno_saved;
 }
diff --git a/tools/perf/tests/attr.py b/tools/perf/tests/attr.py
index 1091bd47adfd..cdf21a9d0c35 100644
--- a/tools/perf/tests/attr.py
+++ b/tools/perf/tests/attr.py
@@ -16,6 +16,13 @@ class Fail(Exception):
     def getMsg(self):
         return '\'%s\' - %s' % (self.test.path, self.msg)
 
+class Notest(Exception):
+    def __init__(self, test, arch):
+        self.arch = arch
+        self.test = test
+    def getMsg(self):
+        return '[%s] \'%s\'' % (self.arch, self.test.path)
+
 class Unsup(Exception):
     def __init__(self, test):
         self.test = test
@@ -112,6 +119,9 @@ class Event(dict):
 #     'command' - perf command name
 #     'args'    - special command arguments
 #     'ret'     - expected command return value (0 by default)
+#     'arch'    - architecture specific test (optional)
+#                 comma separated list, ! at the beginning
+#                 negates it.
 #
 # [eventX:base]
 #   - one or multiple instances in file
@@ -134,6 +144,12 @@ class Test(object):
         except:
             self.ret  = 0
 
+        try:
+            self.arch  = parser.get('config', 'arch')
+            log.warning("test limitation '%s'" % self.arch)
+        except:
+            self.arch  = ''
+
         self.expect   = {}
         self.result   = {}
         log.debug("  loading expected events");
@@ -145,6 +161,31 @@ class Test(object):
         else:
             return True
 
+    def skip_test(self, myarch):
+        # If architecture not set always run test
+        if self.arch == '':
+            # log.warning("test for arch %s is ok" % myarch)
+            return False
+
+        # Allow multiple values in assignment separated by ','
+        arch_list = self.arch.split(',')
+
+        # Handle negated list such as !s390x,ppc
+        if arch_list[0][0] == '!':
+            arch_list[0] = arch_list[0][1:]
+            log.warning("excluded architecture list %s" % arch_list)
+            for arch_item in arch_list:
+                # log.warning("test for %s arch is %s" % (arch_item, myarch))
+                if arch_item == myarch:
+                    return True
+            return False
+
+        for arch_item in arch_list:
+            # log.warning("test for architecture '%s' current '%s'" % (arch_item, myarch))
+            if arch_item == myarch:
+                return False
+        return True
+
     def load_events(self, path, events):
         parser_event = ConfigParser.SafeConfigParser()
         parser_event.read(path)
@@ -168,6 +209,11 @@ class Test(object):
             events[section] = e
 
     def run_cmd(self, tempdir):
+        junk1, junk2, junk3, junk4, myarch = (os.uname())
+
+        if self.skip_test(myarch):
+            raise Notest(self, myarch)
+
         cmd = "PERF_TEST_ATTR=%s %s %s -o %s/perf.data %s" % (tempdir,
               self.perf, self.command, tempdir, self.args)
         ret = os.WEXITSTATUS(os.system(cmd))
@@ -265,6 +311,8 @@ def run_tests(options):
             Test(f, options).run()
         except Unsup, obj:
             log.warning("unsupp  %s" % obj.getMsg())
+        except Notest, obj:
+            log.warning("skipped %s" % obj.getMsg())
 
 def setup_log(verbose):
     global log
diff --git a/tools/perf/tests/bp_signal.c b/tools/perf/tests/bp_signal.c
index e7664fe3bd33..39bbb97cd30a 100644
--- a/tools/perf/tests/bp_signal.c
+++ b/tools/perf/tests/bp_signal.c
@@ -62,8 +62,7 @@ static void __test_function(volatile long *ptr)
 }
 #endif
 
-__attribute__ ((noinline))
-static int test_function(void)
+static noinline int test_function(void)
 {
         __test_function(&the_var);
         the_var++;
@@ -288,3 +287,17 @@ int test__bp_signal(int subtest __maybe_unused)
         return count1 == 1 && overflows == 3 && count2 == 3 && overflows_2 == 3 && count3 == 2 ?
                 TEST_OK : TEST_FAIL;
 }
+
+bool test__bp_signal_is_supported(void)
+{
+/*
+ * The powerpc so far does not have support to even create
+ * instruction breakpoint using the perf event interface.
+ * Once it's there we can release this.
+ */
+#ifdef __powerpc__
+        return false;
+#else
+        return true;
+#endif
+}
diff --git a/tools/perf/tests/bp_signal_overflow.c b/tools/perf/tests/bp_signal_overflow.c
index 89f92fa67cc4..3b1ac6f31b15 100644
--- a/tools/perf/tests/bp_signal_overflow.c
+++ b/tools/perf/tests/bp_signal_overflow.c
@@ -28,8 +28,7 @@
 
 static int overflows;
 
-__attribute__ ((noinline))
-static int test_function(void)
+static noinline int test_function(void)
 {
         return time(NULL);
 }
diff --git a/tools/perf/tests/bpf-script-test-prologue.c b/tools/perf/tests/bpf-script-test-prologue.c
index 7230e62c70fc..b4ebc75e25ae 100644
--- a/tools/perf/tests/bpf-script-test-prologue.c
+++ b/tools/perf/tests/bpf-script-test-prologue.c
@@ -10,6 +10,15 @@
 
 #include <uapi/linux/fs.h>
 
+/*
+ * If CONFIG_PROFILE_ALL_BRANCHES is selected,
+ * 'if' is redefined after include kernel header.
+ * Recover 'if' for BPF object code.
+ */
+#ifdef if
+# undef if
+#endif
+
 #define FMODE_READ              0x1
 #define FMODE_WRITE             0x2
 
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 9e08d297f1a9..3ccfd58a8c3c 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -97,10 +97,12 @@ static struct test generic_tests[] = {
         {
                 .desc = "Breakpoint overflow signal handler",
                 .func = test__bp_signal,
+                .is_supported = test__bp_signal_is_supported,
         },
         {
                 .desc = "Breakpoint overflow sampling",
                 .func = test__bp_signal_overflow,
+                .is_supported = test__bp_signal_is_supported,
         },
         {
                 .desc = "Number of exit events of a simple workload",
@@ -401,6 +403,11 @@ static int __cmd_test(int argc, const char *argv[], struct intlist *skiplist)
                 if (!perf_test__matches(t, curr, argc, argv))
                         continue;
 
+                if (t->is_supported && !t->is_supported()) {
+                        pr_debug("%2d: %-*s: Disabled\n", i, width, t->desc);
+                        continue;
+                }
+
                 pr_info("%2d: %-*s:", i, width, t->desc);
 
                 if (intlist__find(skiplist, i)) {
diff --git a/tools/perf/tests/code-reading.c b/tools/perf/tests/code-reading.c
index 1f14e7612cbb..94b7c7b02bde 100644
--- a/tools/perf/tests/code-reading.c
+++ b/tools/perf/tests/code-reading.c
@@ -229,6 +229,8 @@ static int read_object_code(u64 addr, size_t len, u8 cpumode,
         unsigned char buf2[BUFSZ];
         size_t ret_len;
         u64 objdump_addr;
+        const char *objdump_name;
+        char decomp_name[KMOD_DECOMP_LEN];
         int ret;
 
         pr_debug("Reading object code for memory address: %#"PRIx64"\n", addr);
@@ -289,9 +291,25 @@ static int read_object_code(u64 addr, size_t len, u8 cpumode,
                 state->done[state->done_cnt++] = al.map->start;
         }
 
+        objdump_name = al.map->dso->long_name;
+        if (dso__needs_decompress(al.map->dso)) {
+                if (dso__decompress_kmodule_path(al.map->dso, objdump_name,
+                                                 decomp_name,
+                                                 sizeof(decomp_name)) < 0) {
+                        pr_debug("decompression failed\n");
+                        return -1;
+                }
+
+                objdump_name = decomp_name;
+        }
+
         /* Read the object code using objdump */
         objdump_addr = map__rip_2objdump(al.map, al.addr);
-        ret = read_via_objdump(al.map->dso->long_name, objdump_addr, buf2, len);
+        ret = read_via_objdump(objdump_name, objdump_addr, buf2, len);
+
+        if (dso__needs_decompress(al.map->dso))
+                unlink(objdump_name);
+
         if (ret > 0) {
                 /*
                  * The kernel maps are inaccurate - assume objdump is right in
diff --git a/tools/perf/tests/dwarf-unwind.c b/tools/perf/tests/dwarf-unwind.c
index dfe5c89e2049..3e56d08f7995 100644
--- a/tools/perf/tests/dwarf-unwind.c
+++ b/tools/perf/tests/dwarf-unwind.c
@@ -76,8 +76,7 @@ static int unwind_entry(struct unwind_entry *entry, void *arg)
         return strcmp((const char *) symbol, funcs[idx]);
 }
 
-__attribute__ ((noinline))
-static int unwind_thread(struct thread *thread)
+static noinline int unwind_thread(struct thread *thread)
 {
         struct perf_sample sample;
         unsigned long cnt = 0;
@@ -108,8 +107,7 @@ static int unwind_thread(struct thread *thread)
 
 static int global_unwind_retval = -INT_MAX;
 
-__attribute__ ((noinline))
-static int compare(void *p1, void *p2)
+static noinline int compare(void *p1, void *p2)
 {
         /* Any possible value should be 'thread' */
         struct thread *thread = *(struct thread **)p1;
@@ -128,8 +126,7 @@ static int compare(void *p1, void *p2)
         return p1 - p2;
 }
 
-__attribute__ ((noinline))
-static int krava_3(struct thread *thread)
+static noinline int krava_3(struct thread *thread)
 {
         struct thread *array[2] = {thread, thread};
         void *fp = &bsearch;
@@ -147,14 +144,12 @@ static int krava_3(struct thread *thread)
         return global_unwind_retval;
 }
 
-__attribute__ ((noinline))
-static int krava_2(struct thread *thread)
+static noinline int krava_2(struct thread *thread)
 {
         return krava_3(thread);
 }
 
-__attribute__ ((noinline))
-static int krava_1(struct thread *thread)
+static noinline int krava_1(struct thread *thread)
 {
         return krava_2(thread);
 }
diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index 7fad885491c5..812a053d1941 100644
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -1810,17 +1810,6 @@ static int test_pmu_events(void)
         return ret;
 }
 
-static void debug_warn(const char *warn, va_list params)
-{
-        char msg[1024];
-
-        if (verbose <= 0)
-                return;
-
-        vsnprintf(msg, sizeof(msg), warn, params);
-        fprintf(stderr, " Warning: %s\n", msg);
-}
-
 int test__parse_events(int subtest __maybe_unused)
 {
         int ret1, ret2 = 0;
@@ -1832,8 +1821,6 @@ do {							\
                 ret2 = ret1;                            \
 } while (0)
 
-        set_warning_routine(debug_warn);
-
         TEST_EVENTS(test__events);
 
         if (test_pmu())
diff --git a/tools/perf/tests/task-exit.c b/tools/perf/tests/task-exit.c
index 32873ec91a4e..cf00ebad2ef5 100644
--- a/tools/perf/tests/task-exit.c
+++ b/tools/perf/tests/task-exit.c
@@ -83,7 +83,7 @@ int test__task_exit(int subtest __maybe_unused)
 
         evsel = perf_evlist__first(evlist);
         evsel->attr.task = 1;
-        evsel->attr.sample_freq = 0;
+        evsel->attr.sample_freq = 1;
         evsel->attr.inherit = 0;
         evsel->attr.watermark = 0;
         evsel->attr.wakeup_events = 1;
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index 631859629403..577363809c9b 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -34,6 +34,7 @@ struct test {
                 int (*get_nr)(void);
                 const char *(*get_desc)(int subtest);
         } subtest;
+        bool (*is_supported)(void);
 };
 
 /* Tests */
@@ -99,6 +100,8 @@ const char *test__clang_subtest_get_desc(int subtest);
 int test__clang_subtest_get_nr(void);
 int test__unit_number__scnprint(int subtest);
 
+bool test__bp_signal_is_supported(void);
+
 #if defined(__arm__) || defined(__aarch64__)
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
 struct thread;
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
index d990ad08a3c6..27f41f28dcb4 100644
--- a/tools/perf/ui/browsers/annotate.c
+++ b/tools/perf/ui/browsers/annotate.c
@@ -46,12 +46,15 @@ static struct annotate_browser_opt {
         .jump_arrows    = true,
 };
 
+struct arch;
+
 struct annotate_browser {
         struct ui_browser b;
         struct rb_root    entries;
         struct rb_node    *curr_hot;
         struct disasm_line  *selection;
         struct disasm_line  **offsets;
+        struct arch         *arch;
         int                 nr_events;
         u64                 start;
         int                 nr_asm_entries;
@@ -125,43 +128,57 @@ static void annotate_browser__write(struct ui_browser *browser, void *entry, int
         int i, pcnt_width = annotate_browser__pcnt_width(ab);
         double percent_max = 0.0;
         char bf[256];
+        bool show_title = false;
 
         for (i = 0; i < ab->nr_events; i++) {
                 if (bdl->samples[i].percent > percent_max)
                         percent_max = bdl->samples[i].percent;
         }
 
+        if ((row == 0) && (dl->offset == -1 || percent_max == 0.0)) {
+                if (ab->have_cycles) {
+                        if (dl->ipc == 0.0 && dl->cycles == 0)
+                                show_title = true;
+                } else
+                        show_title = true;
+        }
+
         if (dl->offset != -1 && percent_max != 0.0) {
-                if (percent_max != 0.0) {
-                        for (i = 0; i < ab->nr_events; i++) {
-                                ui_browser__set_percent_color(browser,
-                                                        bdl->samples[i].percent,
-                                                        current_entry);
-                                if (annotate_browser__opts.show_total_period) {
-                                        ui_browser__printf(browser, "%6" PRIu64 " ",
-                                                           bdl->samples[i].nr);
-                                } else {
-                                        ui_browser__printf(browser, "%6.2f ",
-                                                           bdl->samples[i].percent);
-                                }
+                for (i = 0; i < ab->nr_events; i++) {
+                        ui_browser__set_percent_color(browser,
+                                                bdl->samples[i].percent,
+                                                current_entry);
+                        if (annotate_browser__opts.show_total_period) {
+                                ui_browser__printf(browser, "%6" PRIu64 " ",
+                                                   bdl->samples[i].nr);
+                        } else {
+                                ui_browser__printf(browser, "%6.2f ",
+                                                   bdl->samples[i].percent);
                         }
-                } else {
-                        ui_browser__write_nstring(browser, " ", 7 * ab->nr_events);
                 }
         } else {
                 ui_browser__set_percent_color(browser, 0, current_entry);
-                ui_browser__write_nstring(browser, " ", 7 * ab->nr_events);
+
+                if (!show_title)
+                        ui_browser__write_nstring(browser, " ", 7 * ab->nr_events);
+                else
+                        ui_browser__printf(browser, "%*s", 7, "Percent");
         }
         if (ab->have_cycles) {
                 if (dl->ipc)
                         ui_browser__printf(browser, "%*.2f ", IPC_WIDTH - 1, dl->ipc);
-                else
+                else if (!show_title)
                         ui_browser__write_nstring(browser, " ", IPC_WIDTH);
+                else
+                        ui_browser__printf(browser, "%*s ", IPC_WIDTH - 1, "IPC");
+
                 if (dl->cycles)
                         ui_browser__printf(browser, "%*" PRIu64 " ",
                                            CYCLES_WIDTH - 1, dl->cycles);
-                else
+                else if (!show_title)
                         ui_browser__write_nstring(browser, " ", CYCLES_WIDTH);
+                else
+                        ui_browser__printf(browser, "%*s ", CYCLES_WIDTH - 1, "Cycle");
         }
 
         SLsmg_write_char(' ');
@@ -1056,7 +1073,8 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map,
                   (nr_pcnt - 1);
         }
 
-        err = symbol__disassemble(sym, map, perf_evsel__env_arch(evsel), sizeof_bdl);
+        err = symbol__disassemble(sym, map, perf_evsel__env_arch(evsel),
+                                  sizeof_bdl, &browser.arch);
         if (err) {
                 char msg[BUFSIZ];
                 symbol__strerror_disassemble(sym, map, err, msg, sizeof(msg));
diff --git a/tools/perf/ui/gtk/annotate.c b/tools/perf/ui/gtk/annotate.c
index e99ba86158d2..d903fd493416 100644
--- a/tools/perf/ui/gtk/annotate.c
+++ b/tools/perf/ui/gtk/annotate.c
@@ -168,7 +168,8 @@ static int symbol__gtk_annotate(struct symbol *sym, struct map *map,
         if (map->dso->annotate_warned)
                 return -1;
 
-        err = symbol__disassemble(sym, map, perf_evsel__env_arch(evsel), 0);
+        err = symbol__disassemble(sym, map, perf_evsel__env_arch(evsel),
+                                  0, NULL);
         if (err) {
                 char msg[BUFSIZ];
                 symbol__strerror_disassemble(sym, map, err, msg, sizeof(msg));
diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c
index 59addd52d9cd..ddb2c6fbdf91 100644
--- a/tools/perf/ui/hist.c
+++ b/tools/perf/ui/hist.c
@@ -210,6 +210,8 @@ static int __hpp__sort_acc(struct hist_entry *a, struct hist_entry *b,
                         return 0;
 
                 ret = b->callchain->max_depth - a->callchain->max_depth;
+                if (callchain_param.order == ORDER_CALLER)
+                        ret = -ret;
         }
         return ret;
 }
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 683f8340460c..be1caabb9290 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -239,10 +239,20 @@ static int jump__parse(struct arch *arch __maybe_unused, struct ins_operands *op
         const char *s = strchr(ops->raw, '+');
         const char *c = strchr(ops->raw, ',');
 
-        if (c++ != NULL)
+        /*
+         * skip over possible up to 2 operands to get to address, e.g.:
+         * tbnz  w0, #26, ffff0000083cd190 <security_file_permission+0xd0>
+         */
+        if (c++ != NULL) {
                 ops->target.addr = strtoull(c, NULL, 16);
-        else
+                if (!ops->target.addr) {
+                        c = strchr(c, ',');
+                        if (c++ != NULL)
+                                ops->target.addr = strtoull(c, NULL, 16);
+                }
+        } else {
                 ops->target.addr = strtoull(ops->raw, NULL, 16);
+        }
 
         if (s++ != NULL) {
                 ops->target.offset = strtoull(s, NULL, 16);
@@ -257,10 +267,27 @@ static int jump__parse(struct arch *arch __maybe_unused, struct ins_operands *op
 static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
                            struct ins_operands *ops)
 {
+        const char *c = strchr(ops->raw, ',');
+
         if (!ops->target.addr || ops->target.offset < 0)
                 return ins__raw_scnprintf(ins, bf, size, ops);
 
-        return scnprintf(bf, size, "%-6.6s %" PRIx64, ins->name, ops->target.offset);
+        if (c != NULL) {
+                const char *c2 = strchr(c + 1, ',');
+
+                /* check for 3-op insn */
+                if (c2 != NULL)
+                        c = c2;
+                c++;
+
+                /* mirror arch objdump's space-after-comma style */
+                if (*c == ' ')
+                        c++;
+        }
+
+        return scnprintf(bf, size, "%-6.6s %.*s%" PRIx64,
+                         ins->name, c ? c - ops->raw : 0, ops->raw,
+                         ops->target.offset);
 }
 
 static struct ins_ops jump_ops = {
@@ -1294,6 +1321,7 @@ static int dso__disassemble_filename(struct dso *dso, char *filename, size_t fil
         char linkname[PATH_MAX];
         char *build_id_filename;
         char *build_id_path = NULL;
+        char *pos;
 
         if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
             !dso__is_kcore(dso))
@@ -1313,7 +1341,14 @@ static int dso__disassemble_filename(struct dso *dso, char *filename, size_t fil
         if (!build_id_path)
                 return -1;
 
-        dirname(build_id_path);
+        /*
+         * old style build-id cache has name of XX/XXXXXXX.. while
+         * new style has XX/XXXXXXX../{elf,kallsyms,vdso}.
+         * extract the build-id part of dirname in the new style only.
+         */
+        pos = strrchr(build_id_path, '/');
+        if (pos && strlen(pos) < SBUILD_ID_SIZE - 2)
+                dirname(build_id_path);
 
         if (dso__is_kcore(dso) ||
             readlink(build_id_path, linkname, sizeof(linkname)) < 0 ||
@@ -1344,7 +1379,9 @@ static const char *annotate__norm_arch(const char *arch_name)
         return normalize_arch((char *)arch_name);
 }
 
-int symbol__disassemble(struct symbol *sym, struct map *map, const char *arch_name, size_t privsize)
+int symbol__disassemble(struct symbol *sym, struct map *map,
+                        const char *arch_name, size_t privsize,
+                        struct arch **parch)
 {
         struct dso *dso = map->dso;
         char command[PATH_MAX * 2];
@@ -1370,6 +1407,9 @@ int symbol__disassemble(struct symbol *sym, struct map *map, const char *arch_na
         if (arch == NULL)
                 return -ENOTSUP;
 
+        if (parch)
+                *parch = arch;
+
         if (arch->init) {
                 err = arch->init(arch);
                 if (err) {
@@ -1396,31 +1436,10 @@ int symbol__disassemble(struct symbol *sym, struct map *map, const char *arch_na
                                 sizeof(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;
-
-                snprintf(tmp, PATH_MAX, "/tmp/perf-kmod-XXXXXX");
-
-                fd = mkstemp(tmp);
-                if (fd < 0) {
-                        free(m.ext);
-                        goto out;
-                }
-
-                ret = decompress_to_file(m.ext, symfs_filename, fd);
-
-                if (ret)
-                        pr_err("Cannot decompress %s %s\n", m.ext, symfs_filename);
-
-                free(m.ext);
-                close(fd);
+                char tmp[KMOD_DECOMP_LEN];
 
-                if (!ret)
+                if (dso__decompress_kmodule_path(dso, symfs_filename,
+                                                 tmp, sizeof(tmp)) < 0)
                         goto out;
 
                 strcpy(symfs_filename, tmp);
@@ -1429,7 +1448,7 @@ int symbol__disassemble(struct symbol *sym, struct map *map, const char *arch_na
         snprintf(command, sizeof(command),
                  "%s %s%s --start-address=0x%016" PRIx64
                  " --stop-address=0x%016" PRIx64
-                 " -l -d %s %s -C %s 2>/dev/null|grep -v %s:|expand",
+                 " -l -d %s %s -C \"%s\" 2>/dev/null|grep -v \"%s:\"|expand",
                  objdump_path ? objdump_path : "objdump",
                  disassembler_style ? "-M " : "",
                  disassembler_style ? disassembler_style : "",
@@ -1887,7 +1906,8 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map,
         struct rb_root source_line = RB_ROOT;
         u64 len;
 
-        if (symbol__disassemble(sym, map, perf_evsel__env_arch(evsel), 0) < 0)
+        if (symbol__disassemble(sym, map, perf_evsel__env_arch(evsel),
+                                0, NULL) < 0)
                 return -1;
 
         len = symbol__size(sym);
diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
index 948aa8e6fd39..21055034aedd 100644
--- a/tools/perf/util/annotate.h
+++ b/tools/perf/util/annotate.h
@@ -158,7 +158,9 @@ int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 addr);
 int symbol__alloc_hist(struct symbol *sym);
 void symbol__annotate_zero_histograms(struct symbol *sym);
 
-int symbol__disassemble(struct symbol *sym, struct map *map, const char *arch_name, size_t privsize);
+int symbol__disassemble(struct symbol *sym, struct map *map,
+                        const char *arch_name, size_t privsize,
+                        struct arch **parch);
 
 enum symbol_disassemble_errno {
         SYMBOL_ANNOTATE_ERRNO__SUCCESS          = 0,
diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c
index 0daf63b9ee3e..5547457566a7 100644
--- a/tools/perf/util/auxtrace.c
+++ b/tools/perf/util/auxtrace.c
@@ -322,6 +322,13 @@ static int auxtrace_queues__add_event_buffer(struct auxtrace_queues *queues,
         return auxtrace_queues__add_buffer(queues, idx, buffer);
 }
 
+static bool filter_cpu(struct perf_session *session, int cpu)
+{
+        unsigned long *cpu_bitmap = session->itrace_synth_opts->cpu_bitmap;
+
+        return cpu_bitmap && cpu != -1 && !test_bit(cpu, cpu_bitmap);
+}
+
 int auxtrace_queues__add_event(struct auxtrace_queues *queues,
                                struct perf_session *session,
                                union perf_event *event, off_t data_offset,
@@ -331,6 +338,9 @@ int auxtrace_queues__add_event(struct auxtrace_queues *queues,
         unsigned int idx;
         int err;
 
+        if (filter_cpu(session, event->auxtrace.cpu))
+                return 0;
+
         buffer = zalloc(sizeof(struct auxtrace_buffer));
         if (!buffer)
                 return -ENOMEM;
@@ -947,6 +957,8 @@ void itrace_synth_opts__set_default(struct itrace_synth_opts *synth_opts)
         synth_opts->instructions = true;
         synth_opts->branches = true;
         synth_opts->transactions = true;
+        synth_opts->ptwrites = true;
+        synth_opts->pwr_events = true;
         synth_opts->errors = true;
         synth_opts->period_type = PERF_ITRACE_DEFAULT_PERIOD_TYPE;
         synth_opts->period = PERF_ITRACE_DEFAULT_PERIOD;
@@ -1030,6 +1042,12 @@ int itrace_parse_synth_opts(const struct option *opt, const char *str,
                 case 'x':
                         synth_opts->transactions = true;
                         break;
+                case 'w':
+                        synth_opts->ptwrites = true;
+                        break;
+                case 'p':
+                        synth_opts->pwr_events = true;
+                        break;
                 case 'e':
                         synth_opts->errors = true;
                         break;
diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h
index 9f0de72d58e2..33b5e6cdf38c 100644
--- a/tools/perf/util/auxtrace.h
+++ b/tools/perf/util/auxtrace.h
@@ -59,6 +59,8 @@ enum itrace_period_type {
  * @instructions: whether to synthesize 'instructions' events
  * @branches: whether to synthesize 'branches' events
  * @transactions: whether to synthesize events for transactions
+ * @ptwrites: whether to synthesize events for ptwrites
+ * @pwr_events: whether to synthesize power events
  * @errors: whether to synthesize decoder error events
  * @dont_decode: whether to skip decoding entirely
  * @log: write a decoding log
@@ -72,6 +74,7 @@ enum itrace_period_type {
  * @period: 'instructions' events period
  * @period_type: 'instructions' events period type
  * @initial_skip: skip N events at the beginning.
+ * @cpu_bitmap: CPUs for which to synthesize events, or NULL for all
  */
 struct itrace_synth_opts {
         bool                    set;
@@ -79,6 +82,8 @@ struct itrace_synth_opts {
         bool                    instructions;
         bool                    branches;
         bool                    transactions;
+        bool                    ptwrites;
+        bool                    pwr_events;
         bool                    errors;
         bool                    dont_decode;
         bool                    log;
@@ -92,6 +97,7 @@ struct itrace_synth_opts {
         unsigned long long      period;
         enum itrace_period_type period_type;
         unsigned long           initial_skip;
+        unsigned long           *cpu_bitmap;
 };
 
 /**
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 168cc49654e7..e0148b081bdf 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -278,51 +278,6 @@ char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size)
         return bf;
 }
 
-bool dso__build_id_is_kmod(const struct dso *dso, char *bf, size_t size)
-{
-        char *id_name = NULL, *ch;
-        struct stat sb;
-        char sbuild_id[SBUILD_ID_SIZE];
-
-        if (!dso->has_build_id)
-                goto err;
-
-        build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
-        id_name = build_id_cache__linkname(sbuild_id, NULL, 0);
-        if (!id_name)
-                goto err;
-        if (access(id_name, F_OK))
-                goto err;
-        if (lstat(id_name, &sb) == -1)
-                goto err;
-        if ((size_t)sb.st_size > size - 1)
-                goto err;
-        if (readlink(id_name, bf, size - 1) < 0)
-                goto err;
-
-        bf[sb.st_size] = '\0';
-
-        /*
-         * link should be:
-         * ../../lib/modules/4.4.0-rc4/kernel/net/ipv4/netfilter/nf_nat_ipv4.ko/a09fe3eb3147dafa4e3b31dbd6257e4d696bdc92
-         */
-        ch = strrchr(bf, '/');
-        if (!ch)
-                goto err;
-        if (ch - 3 < bf)
-                goto err;
-
-        free(id_name);
-        return strncmp(".ko", ch - 3, 3) == 0;
-err:
-        pr_err("Invalid build id: %s\n", id_name ? :
-                                         dso->long_name ? :
-                                         dso->short_name ? :
-                                         "[unknown]");
-        free(id_name);
-        return false;
-}
-
 #define dsos__for_each_with_build_id(pos, head) \
         list_for_each_entry(pos, head, node)    \
                 if (!pos->has_build_id)         \
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
index 8a89b195c1fc..96690a55c62c 100644
--- a/tools/perf/util/build-id.h
+++ b/tools/perf/util/build-id.h
@@ -17,7 +17,6 @@ char *build_id_cache__kallsyms_path(const char *sbuild_id, char *bf,
                                     size_t size);
 
 char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size);
-bool dso__build_id_is_kmod(const struct dso *dso, char *bf, size_t size);
 
 int build_id__mark_dso_hit(struct perf_tool *tool, union perf_event *event,
                            struct perf_sample *sample, struct perf_evsel *evsel,
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 0328f297a748..0175765c05b9 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -5,6 +5,7 @@
 #include <subcmd/pager.h>
 #include "../ui/ui.h"
 
+#include <linux/compiler.h>
 #include <linux/string.h>
 
 #define CMD_EXEC_PATH "--exec-path"
@@ -24,6 +25,6 @@ static inline int is_absolute_path(const char *path)
         return path[0] == '/';
 }
 
-char *mkpath(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
+char *mkpath(const char *fmt, ...) __printf(1, 2);
 
 #endif /* __PERF_CACHE_H */
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 81fc29ac798f..b4204b43ed58 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -621,14 +621,19 @@ enum match_result {
 static enum match_result match_chain_srcline(struct callchain_cursor_node *node,
                                              struct callchain_list *cnode)
 {
-        char *left = get_srcline(cnode->ms.map->dso,
+        char *left = NULL;
+        char *right = NULL;
+        enum match_result ret = MATCH_EQ;
+        int cmp;
+
+        if (cnode->ms.map)
+                left = get_srcline(cnode->ms.map->dso,
                                  map__rip_2objdump(cnode->ms.map, cnode->ip),
                                  cnode->ms.sym, true, false);
-        char *right = get_srcline(node->map->dso,
+        if (node->map)
+                right = get_srcline(node->map->dso,
                                   map__rip_2objdump(node->map, node->ip),
                                   node->sym, true, false);
-        enum match_result ret = MATCH_EQ;
-        int cmp;
 
         if (left && right)
                 cmp = strcmp(left, right);
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index 8d724f0fa5a8..31a7dea248d0 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -335,32 +335,42 @@ static int perf_parse_long(const char *value, long *ret)
         return 0;
 }
 
-static void die_bad_config(const char *name)
+static void bad_config(const char *name)
 {
         if (config_file_name)
-                die("bad config value for '%s' in %s", name, config_file_name);
-        die("bad config value for '%s'", name);
+                pr_warning("bad config value for '%s' in %s, ignoring...\n", name, config_file_name);
+        else
+                pr_warning("bad config value for '%s', ignoring...\n", name);
 }
 
-u64 perf_config_u64(const char *name, const char *value)
+int perf_config_u64(u64 *dest, const char *name, const char *value)
 {
         long long ret = 0;
 
-        if (!perf_parse_llong(value, &ret))
-                die_bad_config(name);
-        return (u64) ret;
+        if (!perf_parse_llong(value, &ret)) {
+                bad_config(name);
+                return -1;
+        }
+
+        *dest = ret;
+        return 0;
 }
 
-int perf_config_int(const char *name, const char *value)
+int perf_config_int(int *dest, const char *name, const char *value)
 {
         long ret = 0;
-        if (!perf_parse_long(value, &ret))
-                die_bad_config(name);
-        return ret;
+        if (!perf_parse_long(value, &ret)) {
+                bad_config(name);
+                return -1;
+        }
+        *dest = ret;
+        return 0;
 }
 
 static int perf_config_bool_or_int(const char *name, const char *value, int *is_bool)
 {
+        int ret;
+
         *is_bool = 1;
         if (!value)
                 return 1;
@@ -371,7 +381,7 @@ static int perf_config_bool_or_int(const char *name, const char *value, int *is_
         if (!strcasecmp(value, "false") || !strcasecmp(value, "no") || !strcasecmp(value, "off"))
                 return 0;
         *is_bool = 0;
-        return perf_config_int(name, value);
+        return perf_config_int(&ret, name, value) < 0 ? -1 : ret;
 }
 
 int perf_config_bool(const char *name, const char *value)
@@ -657,8 +667,7 @@ static int perf_config_set__init(struct perf_config_set *set)
 
         user_config = strdup(mkpath("%s/.perfconfig", home));
         if (user_config == NULL) {
-                warning("Not enough memory to process %s/.perfconfig, "
-                        "ignoring it.", home);
+                pr_warning("Not enough memory to process %s/.perfconfig, ignoring it.", home);
                 goto out;
         }
 
@@ -671,8 +680,7 @@ static int perf_config_set__init(struct perf_config_set *set)
         ret = 0;
 
         if (st.st_uid && (st.st_uid != geteuid())) {
-                warning("File %s not owned by current user or root, "
-                        "ignoring it.", user_config);
+                pr_warning("File %s not owned by current user or root, ignoring it.", user_config);
                 goto out_free;
         }
 
@@ -795,7 +803,8 @@ void perf_config_set__delete(struct perf_config_set *set)
  */
 int config_error_nonbool(const char *var)
 {
-        return error("Missing value for '%s'", var);
+        pr_err("Missing value for '%s'", var);
+        return -1;
 }
 
 void set_buildid_dir(const char *dir)
diff --git a/tools/perf/util/config.h b/tools/perf/util/config.h
index 1a59a6b43f8b..b6bb11f3f165 100644
--- a/tools/perf/util/config.h
+++ b/tools/perf/util/config.h
@@ -27,8 +27,8 @@ extern const char *config_exclusive_filename;
 typedef int (*config_fn_t)(const char *, const char *, void *);
 int perf_default_config(const char *, const char *, void *);
 int perf_config(config_fn_t fn, void *);
-int perf_config_int(const char *, const char *);
-u64 perf_config_u64(const char *, const char *);
+int perf_config_int(int *dest, const char *, const char *);
+int perf_config_u64(u64 *dest, const char *, const char *);
 int perf_config_bool(const char *, const char *);
 int config_error_nonbool(const char *);
 const char *perf_etc_perfconfig(void);
diff --git a/tools/perf/util/data-convert-bt.c b/tools/perf/util/data-convert-bt.c
index 89d50318833d..3149b70799fd 100644
--- a/tools/perf/util/data-convert-bt.c
+++ b/tools/perf/util/data-convert-bt.c
@@ -1444,10 +1444,8 @@ static int convert__config(const char *var, const char *value, void *cb)
 {
         struct convert *c = cb;
 
-        if (!strcmp(var, "convert.queue-size")) {
-                c->queue_size = perf_config_u64(var, value);
-                return 0;
-        }
+        if (!strcmp(var, "convert.queue-size"))
+                return perf_config_u64(&c->queue_size, var, value);
 
         return 0;
 }
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 8a23ea1a71c7..c818bdb1c1ab 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -4,6 +4,7 @@
 
 #include <stdbool.h>
 #include <string.h>
+#include <linux/compiler.h>
 #include "event.h"
 #include "../ui/helpline.h"
 #include "../ui/progress.h"
@@ -40,16 +41,16 @@ extern int debug_data_convert;
 
 #define STRERR_BUFSIZE  128     /* For the buffer size of str_error_r */
 
-int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
+int dump_printf(const char *fmt, ...) __printf(1, 2);
 void trace_event(union perf_event *event);
 
-int ui__error(const char *format, ...) __attribute__((format(printf, 1, 2)));
-int ui__warning(const char *format, ...) __attribute__((format(printf, 1, 2)));
+int ui__error(const char *format, ...) __printf(1, 2);
+int ui__warning(const char *format, ...) __printf(1, 2);
 
 void pr_stat(const char *fmt, ...);
 
-int eprintf(int level, int var, const char *fmt, ...) __attribute__((format(printf, 3, 4)));
-int eprintf_time(int level, int var, u64 t, const char *fmt, ...) __attribute__((format(printf, 4, 5)));
+int eprintf(int level, int var, const char *fmt, ...) __printf(3, 4);
+int eprintf_time(int level, int var, u64 t, const char *fmt, ...) __printf(4, 5);
 int veprintf(int level, int var, const char *fmt, va_list args);
 
 int perf_debug_option(const char *str);
diff --git a/tools/perf/util/dso.c b/tools/perf/util/dso.c
index a96a99d2369f..4e7ab611377a 100644
--- a/tools/perf/util/dso.c
+++ b/tools/perf/util/dso.c
@@ -248,6 +248,64 @@ bool dso__needs_decompress(struct dso *dso)
                 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
 }
 
+static int decompress_kmodule(struct dso *dso, const char *name, char *tmpbuf)
+{
+        int fd = -1;
+        struct kmod_path m;
+
+        if (!dso__needs_decompress(dso))
+                return -1;
+
+        if (kmod_path__parse_ext(&m, dso->long_name))
+                return -1;
+
+        if (!m.comp)
+                goto out;
+
+        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;
+        }
+
+out:
+        free(m.ext);
+        return fd;
+}
+
+int dso__decompress_kmodule_fd(struct dso *dso, const char *name)
+{
+        char tmpbuf[] = KMOD_DECOMP_NAME;
+        int fd;
+
+        fd = decompress_kmodule(dso, name, tmpbuf);
+        unlink(tmpbuf);
+        return fd;
+}
+
+int dso__decompress_kmodule_path(struct dso *dso, const char *name,
+                                 char *pathname, size_t len)
+{
+        char tmpbuf[] = KMOD_DECOMP_NAME;
+        int fd;
+
+        fd = decompress_kmodule(dso, name, tmpbuf);
+        if (fd < 0) {
+                unlink(tmpbuf);
+                return -1;
+        }
+
+        strncpy(pathname, tmpbuf, len);
+        close(fd);
+        return 0;
+}
+
 /*
  * Parses kernel module specified in @path and updates
  * @m argument like:
@@ -335,6 +393,21 @@ int __kmod_path__parse(struct kmod_path *m, const char *path,
         return 0;
 }
 
+void dso__set_module_info(struct dso *dso, struct kmod_path *m,
+                          struct machine *machine)
+{
+        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);
+}
+
 /*
  * Global list of open DSOs and the counter.
  */
@@ -381,7 +454,7 @@ static int do_open(char *name)
 
 static int __open_dso(struct dso *dso, struct machine *machine)
 {
-        int fd;
+        int fd = -EINVAL;
         char *root_dir = (char *)"";
         char *name = malloc(PATH_MAX);
 
@@ -392,15 +465,30 @@ static int __open_dso(struct dso *dso, struct machine *machine)
                 root_dir = machine->root_dir;
 
         if (dso__read_binary_type_filename(dso, dso->binary_type,
-                                            root_dir, name, PATH_MAX)) {
-                free(name);
-                return -EINVAL;
-        }
+                                            root_dir, name, PATH_MAX))
+                goto out;
 
         if (!is_regular_file(name))
-                return -EINVAL;
+                goto out;
+
+        if (dso__needs_decompress(dso)) {
+                char newpath[KMOD_DECOMP_LEN];
+                size_t len = sizeof(newpath);
+
+                if (dso__decompress_kmodule_path(dso, name, newpath, len) < 0) {
+                        fd = -dso->load_errno;
+                        goto out;
+                }
+
+                strcpy(name, newpath);
+        }
 
         fd = do_open(name);
+
+        if (dso__needs_decompress(dso))
+                unlink(name);
+
+out:
         free(name);
         return fd;
 }
diff --git a/tools/perf/util/dso.h b/tools/perf/util/dso.h
index 12350b171727..bd061ba7b47c 100644
--- a/tools/perf/util/dso.h
+++ b/tools/perf/util/dso.h
@@ -244,6 +244,12 @@ bool is_supported_compression(const char *ext);
 bool is_kernel_module(const char *pathname, int cpumode);
 bool decompress_to_file(const char *ext, const char *filename, int output_fd);
 bool dso__needs_decompress(struct dso *dso);
+int dso__decompress_kmodule_fd(struct dso *dso, const char *name);
+int dso__decompress_kmodule_path(struct dso *dso, const char *name,
+                                 char *pathname, size_t len);
+
+#define KMOD_DECOMP_NAME  "/tmp/perf-kmod-XXXXXX"
+#define KMOD_DECOMP_LEN   sizeof(KMOD_DECOMP_NAME)
 
 struct kmod_path {
         char *name;
@@ -259,6 +265,9 @@ int __kmod_path__parse(struct kmod_path *m, const char *path,
 #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)
 
+void dso__set_module_info(struct dso *dso, struct kmod_path *m,
+                          struct machine *machine);
+
 /*
  * The dso__data_* external interface provides following functions:
  *   dso__data_get_fd
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 7c3fa1c8cbcd..9967c87af7a6 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -252,6 +252,127 @@ enum auxtrace_error_type {
         PERF_AUXTRACE_ERROR_MAX
 };
 
+/* Attribute type for custom synthesized events */
+#define PERF_TYPE_SYNTH         (INT_MAX + 1U)
+
+/* Attribute config for custom synthesized events */
+enum perf_synth_id {
+        PERF_SYNTH_INTEL_PTWRITE,
+        PERF_SYNTH_INTEL_MWAIT,
+        PERF_SYNTH_INTEL_PWRE,
+        PERF_SYNTH_INTEL_EXSTOP,
+        PERF_SYNTH_INTEL_PWRX,
+        PERF_SYNTH_INTEL_CBR,
+};
+
+/*
+ * Raw data formats for synthesized events. Note that 4 bytes of padding are
+ * present to match the 'size' member of PERF_SAMPLE_RAW data which is always
+ * 8-byte aligned. That means we must dereference raw_data with an offset of 4.
+ * Refer perf_sample__synth_ptr() and perf_synth__raw_data().  It also means the
+ * structure sizes are 4 bytes bigger than the raw_size, refer
+ * perf_synth__raw_size().
+ */
+
+struct perf_synth_intel_ptwrite {
+        u32 padding;
+        union {
+                struct {
+                        u32     ip              :  1,
+                                reserved        : 31;
+                };
+                u32     flags;
+        };
+        u64     payload;
+};
+
+struct perf_synth_intel_mwait {
+        u32 padding;
+        u32 reserved;
+        union {
+                struct {
+                        u64     hints           :  8,
+                                reserved1       : 24,
+                                extensions      :  2,
+                                reserved2       : 30;
+                };
+                u64     payload;
+        };
+};
+
+struct perf_synth_intel_pwre {
+        u32 padding;
+        u32 reserved;
+        union {
+                struct {
+                        u64     reserved1       :  7,
+                                hw              :  1,
+                                subcstate       :  4,
+                                cstate          :  4,
+                                reserved2       : 48;
+                };
+                u64     payload;
+        };
+};
+
+struct perf_synth_intel_exstop {
+        u32 padding;
+        union {
+                struct {
+                        u32     ip              :  1,
+                                reserved        : 31;
+                };
+                u32     flags;
+        };
+};
+
+struct perf_synth_intel_pwrx {
+        u32 padding;
+        u32 reserved;
+        union {
+                struct {
+                        u64     deepest_cstate  :  4,
+                                last_cstate     :  4,
+                                wake_reason     :  4,
+                                reserved1       : 52;
+                };
+                u64     payload;
+        };
+};
+
+struct perf_synth_intel_cbr {
+        u32 padding;
+        union {
+                struct {
+                        u32     cbr             :  8,
+                                reserved1       :  8,
+                                max_nonturbo    :  8,
+                                reserved2       :  8;
+                };
+                u32     flags;
+        };
+        u32 freq;
+        u32 reserved3;
+};
+
+/*
+ * raw_data is always 4 bytes from an 8-byte boundary, so subtract 4 to get
+ * 8-byte alignment.
+ */
+static inline void *perf_sample__synth_ptr(struct perf_sample *sample)
+{
+        return sample->raw_data - 4;
+}
+
+static inline void *perf_synth__raw_data(void *p)
+{
+        return p + 4;
+}
+
+#define perf_synth__raw_size(d) (sizeof(d) - 4)
+
+#define perf_sample__bad_synth_size(s, d) ((s)->raw_size < sizeof(d) - 4)
+
 /*
  * The kernel collects the number of events it couldn't send in a stretch and
  * when possible sends this number in a PERF_RECORD_LOST event. The number of
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 94cea4398a13..8d601fbdd8d6 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -1,6 +1,7 @@
 #ifndef __PERF_EVLIST_H
 #define __PERF_EVLIST_H 1
 
+#include <linux/compiler.h>
 #include <linux/kernel.h>
 #include <linux/refcount.h>
 #include <linux/list.h>
@@ -34,7 +35,7 @@ struct perf_mmap {
         refcount_t       refcnt;
         u64              prev;
         struct auxtrace_mmap auxtrace_mmap;
-        char             event_copy[PERF_SAMPLE_MAX_SIZE] __attribute__((aligned(8)));
+        char             event_copy[PERF_SAMPLE_MAX_SIZE] __aligned(8);
 };
 
 static inline size_t
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index e4f7902d5afa..6f4882f8d61f 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -11,13 +11,17 @@
 #include <errno.h>
 #include <inttypes.h>
 #include <linux/bitops.h>
+#include <api/fs/fs.h>
 #include <api/fs/tracing_path.h>
 #include <traceevent/event-parse.h>
 #include <linux/hw_breakpoint.h>
 #include <linux/perf_event.h>
+#include <linux/compiler.h>
 #include <linux/err.h>
 #include <sys/ioctl.h>
 #include <sys/resource.h>
+#include <sys/types.h>
+#include <dirent.h>
 #include "asm/bug.h"
 #include "callchain.h"
 #include "cgroup.h"
@@ -273,8 +277,20 @@ struct perf_evsel *perf_evsel__new_cycles(void)
         struct perf_evsel *evsel;
 
         event_attr_init(&attr);
+        /*
+         * Unnamed union member, not supported as struct member named
+         * initializer in older compilers such as gcc 4.4.7
+         *
+         * Just for probing the precise_ip:
+         */
+        attr.sample_period = 1;
 
         perf_event_attr__set_max_precise_ip(&attr);
+        /*
+         * Now let the usual logic to set up the perf_event_attr defaults
+         * to kick in when we return and before perf_evsel__open() is called.
+         */
+        attr.sample_period = 0;
 
         evsel = perf_evsel__new(&attr);
         if (evsel == NULL)
@@ -1429,7 +1445,7 @@ int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr,
 }
 
 static int __open_attr__fprintf(FILE *fp, const char *name, const char *val,
-                                void *priv __attribute__((unused)))
+                                void *priv __maybe_unused)
 {
         return fprintf(fp, "  %-32s %s\n", name, val);
 }
@@ -2459,6 +2475,42 @@ bool perf_evsel__fallback(struct perf_evsel *evsel, int err,
         return false;
 }
 
+static bool find_process(const char *name)
+{
+        size_t len = strlen(name);
+        DIR *dir;
+        struct dirent *d;
+        int ret = -1;
+
+        dir = opendir(procfs__mountpoint());
+        if (!dir)
+                return false;
+
+        /* Walk through the directory. */
+        while (ret && (d = readdir(dir)) != NULL) {
+                char path[PATH_MAX];
+                char *data;
+                size_t size;
+
+                if ((d->d_type != DT_DIR) ||
+                     !strcmp(".", d->d_name) ||
+                     !strcmp("..", d->d_name))
+                        continue;
+
+                scnprintf(path, sizeof(path), "%s/%s/comm",
+                          procfs__mountpoint(), d->d_name);
+
+                if (filename__read_str(path, &data, &size))
+                        continue;
+
+                ret = strncmp(name, data, len);
+                free(data);
+        }
+
+        closedir(dir);
+        return ret ? false : true;
+}
+
 int perf_evsel__open_strerror(struct perf_evsel *evsel, struct target *target,
                               int err, char *msg, size_t size)
 {
diff --git a/tools/perf/util/evsel_fprintf.c b/tools/perf/util/evsel_fprintf.c
index e415aee6a245..583f3a602506 100644
--- a/tools/perf/util/evsel_fprintf.c
+++ b/tools/perf/util/evsel_fprintf.c
@@ -7,6 +7,7 @@
 #include "map.h"
 #include "strlist.h"
 #include "symbol.h"
+#include "srcline.h"
 
 static int comma_fprintf(FILE *fp, bool *first, const char *fmt, ...)
 {
@@ -168,6 +169,38 @@ int sample__fprintf_callchain(struct perf_sample *sample, int left_alignment,
                         if (!print_oneline)
                                 printed += fprintf(fp, "\n");
 
+                        if (symbol_conf.inline_name && node->map) {
+                                struct inline_node *inode;
+
+                                addr = map__rip_2objdump(node->map, node->ip),
+                                inode = dso__parse_addr_inlines(node->map->dso, addr);
+
+                                if (inode) {
+                                        struct inline_list *ilist;
+
+                                        list_for_each_entry(ilist, &inode->val, list) {
+                                                if (print_arrow)
+                                                        printed += fprintf(fp, " <-");
+
+                                                /* IP is same, just skip it */
+                                                if (print_ip)
+                                                        printed += fprintf(fp, "%c%16s",
+                                                                           s, "");
+                                                if (print_sym)
+                                                        printed += fprintf(fp, " %s",
+                                                                           ilist->funcname);
+                                                if (print_srcline)
+                                                        printed += fprintf(fp, "\n  %s:%d",
+                                                                           ilist->filename,
+                                                                           ilist->line_nr);
+                                                if (!print_oneline)
+                                                        printed += fprintf(fp, "\n");
+                                        }
+
+                                        inline_node__delete(inode);
+                                }
+                        }
+
                         if (symbol_conf.bt_stop_list &&
                             node->sym &&
                             strlist__has_entry(symbol_conf.bt_stop_list,
diff --git a/tools/perf/util/genelf_debug.c b/tools/perf/util/genelf_debug.c
index 5980f7d256b1..40789d8603d0 100644
--- a/tools/perf/util/genelf_debug.c
+++ b/tools/perf/util/genelf_debug.c
@@ -11,6 +11,7 @@
  * @remark Copyright 2007 OProfile authors
  * @author Philippe Elie
  */
+#include <linux/compiler.h>
 #include <sys/types.h>
 #include <stdio.h>
 #include <getopt.h>
@@ -125,7 +126,7 @@ struct debug_line_header {
          * and filesize, last entry is followed by en empty string.
          */
         /* follow the first program statement */
-} __attribute__((packed));
+} __packed;
 
 /* DWARF 2 spec talk only about one possible compilation unit header while
  * binutils can handle two flavours of dwarf 2, 32 and 64 bits, this is not
@@ -138,7 +139,7 @@ struct compilation_unit_header {
         uhalf version;
         uword debug_abbrev_offset;
         ubyte pointer_size;
-} __attribute__((packed));
+} __packed;
 
 #define DW_LNS_num_opcode (DW_LNS_set_isa + 1)
 
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 314a07151fb7..76ed7d03e500 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -8,6 +8,7 @@
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <linux/compiler.h>
 #include <linux/list.h>
 #include <linux/kernel.h>
 #include <linux/bitops.h>
@@ -841,7 +842,7 @@ static int write_group_desc(int fd, struct perf_header *h __maybe_unused,
 
 /*
  * default get_cpuid(): nothing gets recorded
- * actual implementation must be in arch/$(ARCH)/util/header.c
+ * actual implementation must be in arch/$(SRCARCH)/util/header.c
  */
 int __weak get_cpuid(char *buffer __maybe_unused, size_t sz __maybe_unused)
 {
@@ -1274,7 +1275,7 @@ error:
 }
 
 static int __desc_attr__fprintf(FILE *fp, const char *name, const char *val,
-                                void *priv __attribute__((unused)))
+                                void *priv __maybe_unused)
 {
         return fprintf(fp, ", %s = %s", name, val);
 }
@@ -1469,8 +1470,16 @@ static int __event_process_build_id(struct build_id_event *bev,
 
                 dso__set_build_id(dso, &bev->build_id);
 
-                if (!is_kernel_module(filename, cpumode))
-                        dso->kernel = dso_type;
+                if (dso_type != DSO_TYPE_USER) {
+                        struct kmod_path m = { .name = NULL, };
+
+                        if (!kmod_path__parse_name(&m, filename) && m.kmod)
+                                dso__set_module_info(dso, &m, machine);
+                        else
+                                dso->kernel = dso_type;
+
+                        free(m.name);
+                }
 
                 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
                                   sbuild_id);
diff --git a/tools/perf/util/help-unknown-cmd.c b/tools/perf/util/help-unknown-cmd.c
index 1c88ad6425b8..15b95300d7f3 100644
--- a/tools/perf/util/help-unknown-cmd.c
+++ b/tools/perf/util/help-unknown-cmd.c
@@ -12,7 +12,7 @@ static int perf_unknown_cmd_config(const char *var, const char *value,
                                    void *cb __maybe_unused)
 {
         if (!strcmp(var, "help.autocorrect"))
-                autocorrect = perf_config_int(var,value);
+                return perf_config_int(&autocorrect, var,value);
 
         return 0;
 }
diff --git a/tools/perf/util/intel-bts.c b/tools/perf/util/intel-bts.c
index b2834ac7b1f5..218ee2bac9a5 100644
--- a/tools/perf/util/intel-bts.c
+++ b/tools/perf/util/intel-bts.c
@@ -866,8 +866,6 @@ static void intel_bts_print_info(u64 *arr, int start, int finish)
                 fprintf(stdout, intel_bts_info_fmts[i], arr[i]);
 }
 
-u64 intel_bts_auxtrace_info_priv[INTEL_BTS_AUXTRACE_PRIV_SIZE];
-
 int intel_bts_process_auxtrace_info(union perf_event *event,
                                     struct perf_session *session)
 {
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
index 7cf7f7aca4d2..aa1593ce551d 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
@@ -64,6 +64,25 @@ enum intel_pt_pkt_state {
         INTEL_PT_STATE_FUP_NO_TIP,
 };
 
+static inline bool intel_pt_sample_time(enum intel_pt_pkt_state pkt_state)
+{
+        switch (pkt_state) {
+        case INTEL_PT_STATE_NO_PSB:
+        case INTEL_PT_STATE_NO_IP:
+        case INTEL_PT_STATE_ERR_RESYNC:
+        case INTEL_PT_STATE_IN_SYNC:
+        case INTEL_PT_STATE_TNT:
+                return true;
+        case INTEL_PT_STATE_TIP:
+        case INTEL_PT_STATE_TIP_PGD:
+        case INTEL_PT_STATE_FUP:
+        case INTEL_PT_STATE_FUP_NO_TIP:
+                return false;
+        default:
+                return true;
+        };
+}
+
 #ifdef INTEL_PT_STRICT
 #define INTEL_PT_STATE_ERR1     INTEL_PT_STATE_NO_PSB
 #define INTEL_PT_STATE_ERR2     INTEL_PT_STATE_NO_PSB
@@ -87,11 +106,13 @@ struct intel_pt_decoder {
         const unsigned char *buf;
         size_t len;
         bool return_compression;
+        bool branch_enable;
         bool mtc_insn;
         bool pge;
         bool have_tma;
         bool have_cyc;
         bool fixup_last_mtc;
+        bool have_last_ip;
         uint64_t pos;
         uint64_t last_ip;
         uint64_t ip;
@@ -99,6 +120,7 @@ struct intel_pt_decoder {
         uint64_t timestamp;
         uint64_t tsc_timestamp;
         uint64_t ref_timestamp;
+        uint64_t sample_timestamp;
         uint64_t ret_addr;
         uint64_t ctc_timestamp;
         uint64_t ctc_delta;
@@ -119,6 +141,7 @@ struct intel_pt_decoder {
         int pkt_len;
         int last_packet_type;
         unsigned int cbr;
+        unsigned int cbr_seen;
         unsigned int max_non_turbo_ratio;
         double max_non_turbo_ratio_fp;
         double cbr_cyc_to_tsc;
@@ -136,9 +159,18 @@ struct intel_pt_decoder {
         bool continuous_period;
         bool overflow;
         bool set_fup_tx_flags;
+        bool set_fup_ptw;
+        bool set_fup_mwait;
+        bool set_fup_pwre;
+        bool set_fup_exstop;
         unsigned int fup_tx_flags;
         unsigned int tx_flags;
+        uint64_t fup_ptw_payload;
+        uint64_t fup_mwait_payload;
+        uint64_t fup_pwre_payload;
+        uint64_t cbr_payload;
         uint64_t timestamp_insn_cnt;
+        uint64_t sample_insn_cnt;
         uint64_t stuck_ip;
         int no_progress;
         int stuck_ip_prd;
@@ -192,6 +224,7 @@ struct intel_pt_decoder *intel_pt_decoder_new(struct intel_pt_params *params)
         decoder->pgd_ip             = params->pgd_ip;
         decoder->data               = params->data;
         decoder->return_compression = params->return_compression;
+        decoder->branch_enable      = params->branch_enable;
 
         decoder->period             = params->period;
         decoder->period_type        = params->period_type;
@@ -398,6 +431,7 @@ static uint64_t intel_pt_calc_ip(const struct intel_pt_pkt *packet,
 static inline void intel_pt_set_last_ip(struct intel_pt_decoder *decoder)
 {
         decoder->last_ip = intel_pt_calc_ip(&decoder->packet, decoder->last_ip);
+        decoder->have_last_ip = true;
 }
 
 static inline void intel_pt_set_ip(struct intel_pt_decoder *decoder)
@@ -635,6 +669,8 @@ static int intel_pt_calc_cyc_cb(struct intel_pt_pkt_info *pkt_info)
         case INTEL_PT_PAD:
         case INTEL_PT_VMCS:
         case INTEL_PT_MNT:
+        case INTEL_PT_PTWRITE:
+        case INTEL_PT_PTWRITE_IP:
                 return 0;
 
         case INTEL_PT_MTC:
@@ -675,6 +711,12 @@ static int intel_pt_calc_cyc_cb(struct intel_pt_pkt_info *pkt_info)
                 break;
 
         case INTEL_PT_TSC:
+                /*
+                 * For now, do not support using TSC packets - refer
+                 * intel_pt_calc_cyc_to_tsc().
+                 */
+                if (data->from_mtc)
+                        return 1;
                 timestamp = pkt_info->packet.payload |
                             (data->timestamp & (0xffULL << 56));
                 if (data->from_mtc && timestamp < data->timestamp &&
@@ -733,6 +775,11 @@ static int intel_pt_calc_cyc_cb(struct intel_pt_pkt_info *pkt_info)
 
         case INTEL_PT_TIP_PGD:
         case INTEL_PT_TRACESTOP:
+        case INTEL_PT_EXSTOP:
+        case INTEL_PT_EXSTOP_IP:
+        case INTEL_PT_MWAIT:
+        case INTEL_PT_PWRE:
+        case INTEL_PT_PWRX:
         case INTEL_PT_OVF:
         case INTEL_PT_BAD: /* Does not happen */
         default:
@@ -787,6 +834,14 @@ static void intel_pt_calc_cyc_to_tsc(struct intel_pt_decoder *decoder,
                 .cbr_cyc_to_tsc = 0,
         };
 
+        /*
+         * For now, do not support using TSC packets for at least the reasons:
+         * 1) timing might have stopped
+         * 2) TSC packets within PSB+ can slip against CYC packets
+         */
+        if (!from_mtc)
+                return;
+
         intel_pt_pkt_lookahead(decoder, intel_pt_calc_cyc_cb, &data);
 }
 
@@ -898,6 +953,7 @@ static int intel_pt_walk_insn(struct intel_pt_decoder *decoder,
 
         decoder->tot_insn_cnt += insn_cnt;
         decoder->timestamp_insn_cnt += insn_cnt;
+        decoder->sample_insn_cnt += insn_cnt;
         decoder->period_insn_cnt += insn_cnt;
 
         if (err) {
@@ -990,6 +1046,57 @@ out_no_progress:
         return err;
 }
 
+static bool intel_pt_fup_event(struct intel_pt_decoder *decoder)
+{
+        bool ret = false;
+
+        if (decoder->set_fup_tx_flags) {
+                decoder->set_fup_tx_flags = false;
+                decoder->tx_flags = decoder->fup_tx_flags;
+                decoder->state.type = INTEL_PT_TRANSACTION;
+                decoder->state.from_ip = decoder->ip;
+                decoder->state.to_ip = 0;
+                decoder->state.flags = decoder->fup_tx_flags;
+                return true;
+        }
+        if (decoder->set_fup_ptw) {
+                decoder->set_fup_ptw = false;
+                decoder->state.type = INTEL_PT_PTW;
+                decoder->state.flags |= INTEL_PT_FUP_IP;
+                decoder->state.from_ip = decoder->ip;
+                decoder->state.to_ip = 0;
+                decoder->state.ptw_payload = decoder->fup_ptw_payload;
+                return true;
+        }
+        if (decoder->set_fup_mwait) {
+                decoder->set_fup_mwait = false;
+                decoder->state.type = INTEL_PT_MWAIT_OP;
+                decoder->state.from_ip = decoder->ip;
+                decoder->state.to_ip = 0;
+                decoder->state.mwait_payload = decoder->fup_mwait_payload;
+                ret = true;
+        }
+        if (decoder->set_fup_pwre) {
+                decoder->set_fup_pwre = false;
+                decoder->state.type |= INTEL_PT_PWR_ENTRY;
+                decoder->state.type &= ~INTEL_PT_BRANCH;
+                decoder->state.from_ip = decoder->ip;
+                decoder->state.to_ip = 0;
+                decoder->state.pwre_payload = decoder->fup_pwre_payload;
+                ret = true;
+        }
+        if (decoder->set_fup_exstop) {
+                decoder->set_fup_exstop = false;
+                decoder->state.type |= INTEL_PT_EX_STOP;
+                decoder->state.type &= ~INTEL_PT_BRANCH;
+                decoder->state.flags |= INTEL_PT_FUP_IP;
+                decoder->state.from_ip = decoder->ip;
+                decoder->state.to_ip = 0;
+                ret = true;
+        }
+        return ret;
+}
+
 static int intel_pt_walk_fup(struct intel_pt_decoder *decoder)
 {
         struct intel_pt_insn intel_pt_insn;
@@ -1003,15 +1110,8 @@ static int intel_pt_walk_fup(struct intel_pt_decoder *decoder)
                 if (err == INTEL_PT_RETURN)
                         return 0;
                 if (err == -EAGAIN) {
-                        if (decoder->set_fup_tx_flags) {
-                                decoder->set_fup_tx_flags = false;
-                                decoder->tx_flags = decoder->fup_tx_flags;
-                                decoder->state.type = INTEL_PT_TRANSACTION;
-                                decoder->state.from_ip = decoder->ip;
-                                decoder->state.to_ip = 0;
-                                decoder->state.flags = decoder->fup_tx_flags;
+                        if (intel_pt_fup_event(decoder))
                                 return 0;
-                        }
                         return err;
                 }
                 decoder->set_fup_tx_flags = false;
@@ -1360,7 +1460,9 @@ static void intel_pt_calc_mtc_timestamp(struct intel_pt_decoder *decoder)
 
 static void intel_pt_calc_cbr(struct intel_pt_decoder *decoder)
 {
-        unsigned int cbr = decoder->packet.payload;
+        unsigned int cbr = decoder->packet.payload & 0xff;
+
+        decoder->cbr_payload = decoder->packet.payload;
 
         if (decoder->cbr == cbr)
                 return;
@@ -1417,6 +1519,13 @@ static int intel_pt_walk_psbend(struct intel_pt_decoder *decoder)
                 case INTEL_PT_TRACESTOP:
                 case INTEL_PT_BAD:
                 case INTEL_PT_PSB:
+                case INTEL_PT_PTWRITE:
+                case INTEL_PT_PTWRITE_IP:
+                case INTEL_PT_EXSTOP:
+                case INTEL_PT_EXSTOP_IP:
+                case INTEL_PT_MWAIT:
+                case INTEL_PT_PWRE:
+                case INTEL_PT_PWRX:
                         decoder->have_tma = false;
                         intel_pt_log("ERROR: Unexpected packet\n");
                         return -EAGAIN;
@@ -1446,7 +1555,8 @@ static int intel_pt_walk_psbend(struct intel_pt_decoder *decoder)
 
                 case INTEL_PT_FUP:
                         decoder->pge = true;
-                        intel_pt_set_last_ip(decoder);
+                        if (decoder->packet.count)
+                                intel_pt_set_last_ip(decoder);
                         break;
 
                 case INTEL_PT_MODE_TSX:
@@ -1497,6 +1607,13 @@ static int intel_pt_walk_fup_tip(struct intel_pt_decoder *decoder)
                 case INTEL_PT_MODE_TSX:
                 case INTEL_PT_BAD:
                 case INTEL_PT_PSBEND:
+                case INTEL_PT_PTWRITE:
+                case INTEL_PT_PTWRITE_IP:
+                case INTEL_PT_EXSTOP:
+                case INTEL_PT_EXSTOP_IP:
+                case INTEL_PT_MWAIT:
+                case INTEL_PT_PWRE:
+                case INTEL_PT_PWRX:
                         intel_pt_log("ERROR: Missing TIP after FUP\n");
                         decoder->pkt_state = INTEL_PT_STATE_ERR3;
                         return -ENOENT;
@@ -1625,6 +1742,15 @@ next:
                                 break;
                         }
                         intel_pt_set_last_ip(decoder);
+                        if (!decoder->branch_enable) {
+                                decoder->ip = decoder->last_ip;
+                                if (intel_pt_fup_event(decoder))
+                                        return 0;
+                                no_tip = false;
+                                break;
+                        }
+                        if (decoder->set_fup_mwait)
+                                no_tip = true;
                         err = intel_pt_walk_fup(decoder);
                         if (err != -EAGAIN) {
                                 if (err)
@@ -1650,6 +1776,8 @@ next:
                         break;
 
                 case INTEL_PT_PSB:
+                        decoder->last_ip = 0;
+                        decoder->have_last_ip = true;
                         intel_pt_clear_stack(&decoder->stack);
                         err = intel_pt_walk_psbend(decoder);
                         if (err == -EAGAIN)
@@ -1696,6 +1824,16 @@ next:
 
                 case INTEL_PT_CBR:
                         intel_pt_calc_cbr(decoder);
+                        if (!decoder->branch_enable &&
+                            decoder->cbr != decoder->cbr_seen) {
+                                decoder->cbr_seen = decoder->cbr;
+                                decoder->state.type = INTEL_PT_CBR_CHG;
+                                decoder->state.from_ip = decoder->ip;
+                                decoder->state.to_ip = 0;
+                                decoder->state.cbr_payload =
+                                                        decoder->packet.payload;
+                                return 0;
+                        }
                         break;
 
                 case INTEL_PT_MODE_EXEC:
@@ -1722,6 +1860,71 @@ next:
                 case INTEL_PT_PAD:
                         break;
 
+                case INTEL_PT_PTWRITE_IP:
+                        decoder->fup_ptw_payload = decoder->packet.payload;
+                        err = intel_pt_get_next_packet(decoder);
+                        if (err)
+                                return err;
+                        if (decoder->packet.type == INTEL_PT_FUP) {
+                                decoder->set_fup_ptw = true;
+                                no_tip = true;
+                        } else {
+                                intel_pt_log_at("ERROR: Missing FUP after PTWRITE",
+                                                decoder->pos);
+                        }
+                        goto next;
+
+                case INTEL_PT_PTWRITE:
+                        decoder->state.type = INTEL_PT_PTW;
+                        decoder->state.from_ip = decoder->ip;
+                        decoder->state.to_ip = 0;
+                        decoder->state.ptw_payload = decoder->packet.payload;
+                        return 0;
+
+                case INTEL_PT_MWAIT:
+                        decoder->fup_mwait_payload = decoder->packet.payload;
+                        decoder->set_fup_mwait = true;
+                        break;
+
+                case INTEL_PT_PWRE:
+                        if (decoder->set_fup_mwait) {
+                                decoder->fup_pwre_payload =
+                                                        decoder->packet.payload;
+                                decoder->set_fup_pwre = true;
+                                break;
+                        }
+                        decoder->state.type = INTEL_PT_PWR_ENTRY;
+                        decoder->state.from_ip = decoder->ip;
+                        decoder->state.to_ip = 0;
+                        decoder->state.pwrx_payload = decoder->packet.payload;
+                        return 0;
+
+                case INTEL_PT_EXSTOP_IP:
+                        err = intel_pt_get_next_packet(decoder);
+                        if (err)
+                                return err;
+                        if (decoder->packet.type == INTEL_PT_FUP) {
+                                decoder->set_fup_exstop = true;
+                                no_tip = true;
+                        } else {
+                                intel_pt_log_at("ERROR: Missing FUP after EXSTOP",
+                                                decoder->pos);
+                        }
+                        goto next;
+
+                case INTEL_PT_EXSTOP:
+                        decoder->state.type = INTEL_PT_EX_STOP;
+                        decoder->state.from_ip = decoder->ip;
+                        decoder->state.to_ip = 0;
+                        return 0;
+
+                case INTEL_PT_PWRX:
+                        decoder->state.type = INTEL_PT_PWR_EXIT;
+                        decoder->state.from_ip = decoder->ip;
+                        decoder->state.to_ip = 0;
+                        decoder->state.pwrx_payload = decoder->packet.payload;
+                        return 0;
+
                 default:
                         return intel_pt_bug(decoder);
                 }
@@ -1730,8 +1933,9 @@ next:
 
 static inline bool intel_pt_have_ip(struct intel_pt_decoder *decoder)
 {
-        return decoder->last_ip || decoder->packet.count == 0 ||
-               decoder->packet.count == 3 || decoder->packet.count == 6;
+        return decoder->packet.count &&
+               (decoder->have_last_ip || decoder->packet.count == 3 ||
+                decoder->packet.count == 6);
 }
 
 /* Walk PSB+ packets to get in sync. */
@@ -1750,6 +1954,13 @@ static int intel_pt_walk_psb(struct intel_pt_decoder *decoder)
                         __fallthrough;
                 case INTEL_PT_TIP_PGE:
                 case INTEL_PT_TIP:
+                case INTEL_PT_PTWRITE:
+                case INTEL_PT_PTWRITE_IP:
+                case INTEL_PT_EXSTOP:
+                case INTEL_PT_EXSTOP_IP:
+                case INTEL_PT_MWAIT:
+                case INTEL_PT_PWRE:
+                case INTEL_PT_PWRX:
                         intel_pt_log("ERROR: Unexpected packet\n");
                         return -ENOENT;
 
@@ -1854,14 +2065,10 @@ static int intel_pt_walk_to_ip(struct intel_pt_decoder *decoder)
                         break;
 
                 case INTEL_PT_FUP:
-                        if (decoder->overflow) {
-                                if (intel_pt_have_ip(decoder))
-                                        intel_pt_set_ip(decoder);
-                                if (decoder->ip)
-                                        return 0;
-                        }
-                        if (decoder->packet.count)
-                                intel_pt_set_last_ip(decoder);
+                        if (intel_pt_have_ip(decoder))
+                                intel_pt_set_ip(decoder);
+                        if (decoder->ip)
+                                return 0;
                         break;
 
                 case INTEL_PT_MTC:
@@ -1910,6 +2117,9 @@ static int intel_pt_walk_to_ip(struct intel_pt_decoder *decoder)
                         break;
 
                 case INTEL_PT_PSB:
+                        decoder->last_ip = 0;
+                        decoder->have_last_ip = true;
+                        intel_pt_clear_stack(&decoder->stack);
                         err = intel_pt_walk_psb(decoder);
                         if (err)
                                 return err;
@@ -1925,6 +2135,13 @@ static int intel_pt_walk_to_ip(struct intel_pt_decoder *decoder)
                 case INTEL_PT_VMCS:
                 case INTEL_PT_MNT:
                 case INTEL_PT_PAD:
+                case INTEL_PT_PTWRITE:
+                case INTEL_PT_PTWRITE_IP:
+                case INTEL_PT_EXSTOP:
+                case INTEL_PT_EXSTOP_IP:
+                case INTEL_PT_MWAIT:
+                case INTEL_PT_PWRE:
+                case INTEL_PT_PWRX:
                 default:
                         break;
                 }
@@ -1935,6 +2152,19 @@ static int intel_pt_sync_ip(struct intel_pt_decoder *decoder)
 {
         int err;
 
+        decoder->set_fup_tx_flags = false;
+        decoder->set_fup_ptw = false;
+        decoder->set_fup_mwait = false;
+        decoder->set_fup_pwre = false;
+        decoder->set_fup_exstop = false;
+
+        if (!decoder->branch_enable) {
+                decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
+                decoder->overflow = false;
+                decoder->state.type = 0; /* Do not have a sample */
+                return 0;
+        }
+
         intel_pt_log("Scanning for full IP\n");
         err = intel_pt_walk_to_ip(decoder);
         if (err)
@@ -2043,6 +2273,7 @@ static int intel_pt_sync(struct intel_pt_decoder *decoder)
 
         decoder->pge = false;
         decoder->continuous_period = false;
+        decoder->have_last_ip = false;
         decoder->last_ip = 0;
         decoder->ip = 0;
         intel_pt_clear_stack(&decoder->stack);
@@ -2051,6 +2282,7 @@ static int intel_pt_sync(struct intel_pt_decoder *decoder)
         if (err)
                 return err;
 
+        decoder->have_last_ip = true;
         decoder->pkt_state = INTEL_PT_STATE_NO_IP;
 
         err = intel_pt_walk_psb(decoder);
@@ -2069,7 +2301,7 @@ static int intel_pt_sync(struct intel_pt_decoder *decoder)
 
 static uint64_t intel_pt_est_timestamp(struct intel_pt_decoder *decoder)
 {
-        uint64_t est = decoder->timestamp_insn_cnt << 1;
+        uint64_t est = decoder->sample_insn_cnt << 1;
 
         if (!decoder->cbr || !decoder->max_non_turbo_ratio)
                 goto out;
@@ -2077,7 +2309,7 @@ static uint64_t intel_pt_est_timestamp(struct intel_pt_decoder *decoder)
         est *= decoder->max_non_turbo_ratio;
         est /= decoder->cbr;
 out:
-        return decoder->timestamp + est;
+        return decoder->sample_timestamp + est;
 }
 
 const struct intel_pt_state *intel_pt_decode(struct intel_pt_decoder *decoder)
@@ -2093,8 +2325,10 @@ const struct intel_pt_state *intel_pt_decode(struct intel_pt_decoder *decoder)
                         err = intel_pt_sync(decoder);
                         break;
                 case INTEL_PT_STATE_NO_IP:
+                        decoder->have_last_ip = false;
                         decoder->last_ip = 0;
-                        /* Fall through */
+                        decoder->ip = 0;
+                        __fallthrough;
                 case INTEL_PT_STATE_ERR_RESYNC:
                         err = intel_pt_sync_ip(decoder);
                         break;
@@ -2130,15 +2364,29 @@ const struct intel_pt_state *intel_pt_decode(struct intel_pt_decoder *decoder)
                 }
         } while (err == -ENOLINK);
 
-        decoder->state.err = err ? intel_pt_ext_err(err) : 0;
-        decoder->state.timestamp = decoder->timestamp;
+        if (err) {
+                decoder->state.err = intel_pt_ext_err(err);
+                decoder->state.from_ip = decoder->ip;
+                decoder->sample_timestamp = decoder->timestamp;
+                decoder->sample_insn_cnt = decoder->timestamp_insn_cnt;
+        } else {
+                decoder->state.err = 0;
+                if (decoder->cbr != decoder->cbr_seen && decoder->state.type) {
+                        decoder->cbr_seen = decoder->cbr;
+                        decoder->state.type |= INTEL_PT_CBR_CHG;
+                        decoder->state.cbr_payload = decoder->cbr_payload;
+                }
+                if (intel_pt_sample_time(decoder->pkt_state)) {
+                        decoder->sample_timestamp = decoder->timestamp;
+                        decoder->sample_insn_cnt = decoder->timestamp_insn_cnt;
+                }
+        }
+
+        decoder->state.timestamp = decoder->sample_timestamp;
         decoder->state.est_timestamp = intel_pt_est_timestamp(decoder);
         decoder->state.cr3 = decoder->cr3;
         decoder->state.tot_insn_cnt = decoder->tot_insn_cnt;
 
-        if (err)
-                decoder->state.from_ip = decoder->ip;
-
         return &decoder->state;
 }
 
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
index e90619a43c0c..921b22e8ca0e 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
@@ -25,11 +25,18 @@
 #define INTEL_PT_IN_TX          (1 << 0)
 #define INTEL_PT_ABORT_TX       (1 << 1)
 #define INTEL_PT_ASYNC          (1 << 2)
+#define INTEL_PT_FUP_IP         (1 << 3)
 
 enum intel_pt_sample_type {
         INTEL_PT_BRANCH         = 1 << 0,
         INTEL_PT_INSTRUCTION    = 1 << 1,
         INTEL_PT_TRANSACTION    = 1 << 2,
+        INTEL_PT_PTW            = 1 << 3,
+        INTEL_PT_MWAIT_OP       = 1 << 4,
+        INTEL_PT_PWR_ENTRY      = 1 << 5,
+        INTEL_PT_EX_STOP        = 1 << 6,
+        INTEL_PT_PWR_EXIT       = 1 << 7,
+        INTEL_PT_CBR_CHG        = 1 << 8,
 };
 
 enum intel_pt_period_type {
@@ -63,6 +70,11 @@ struct intel_pt_state {
         uint64_t timestamp;
         uint64_t est_timestamp;
         uint64_t trace_nr;
+        uint64_t ptw_payload;
+        uint64_t mwait_payload;
+        uint64_t pwre_payload;
+        uint64_t pwrx_payload;
+        uint64_t cbr_payload;
         uint32_t flags;
         enum intel_pt_insn_op insn_op;
         int insn_len;
@@ -87,6 +99,7 @@ struct intel_pt_params {
         bool (*pgd_ip)(uint64_t ip, void *data);
         void *data;
         bool return_compression;
+        bool branch_enable;
         uint64_t period;
         enum intel_pt_period_type period_type;
         unsigned max_non_turbo_ratio;
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-log.h b/tools/perf/util/intel-pt-decoder/intel-pt-log.h
index debe751dc3d6..45b64f93f358 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-log.h
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-log.h
@@ -16,6 +16,7 @@
 #ifndef INCLUDE__INTEL_PT_LOG_H__
 #define INCLUDE__INTEL_PT_LOG_H__
 
+#include <linux/compiler.h>
 #include <stdint.h>
 #include <inttypes.h>
 
@@ -34,8 +35,7 @@ void __intel_pt_log_insn(struct intel_pt_insn *intel_pt_insn, uint64_t ip);
 void __intel_pt_log_insn_no_data(struct intel_pt_insn *intel_pt_insn,
                                  uint64_t ip);
 
-__attribute__((format(printf, 1, 2)))
-void __intel_pt_log(const char *fmt, ...);
+void __intel_pt_log(const char *fmt, ...) __printf(1, 2);
 
 #define intel_pt_log(fmt, ...) \
         do { \
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
index 7528ae4f7e28..ba4c9dd18643 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
@@ -64,6 +64,13 @@ static const char * const packet_name[] = {
         [INTEL_PT_PIP]          = "PIP",
         [INTEL_PT_OVF]          = "OVF",
         [INTEL_PT_MNT]          = "MNT",
+        [INTEL_PT_PTWRITE]      = "PTWRITE",
+        [INTEL_PT_PTWRITE_IP]   = "PTWRITE",
+        [INTEL_PT_EXSTOP]       = "EXSTOP",
+        [INTEL_PT_EXSTOP_IP]    = "EXSTOP",
+        [INTEL_PT_MWAIT]        = "MWAIT",
+        [INTEL_PT_PWRE]         = "PWRE",
+        [INTEL_PT_PWRX]         = "PWRX",
 };
 
 const char *intel_pt_pkt_name(enum intel_pt_pkt_type type)
@@ -123,7 +130,7 @@ static int intel_pt_get_cbr(const unsigned char *buf, size_t len,
         if (len < 4)
                 return INTEL_PT_NEED_MORE_BYTES;
         packet->type = INTEL_PT_CBR;
-        packet->payload = buf[2];
+        packet->payload = le16_to_cpu(*(uint16_t *)(buf + 2));
         return 4;
 }
 
@@ -217,12 +224,80 @@ static int intel_pt_get_3byte(const unsigned char *buf, size_t len,
         }
 }
 
+static int intel_pt_get_ptwrite(const unsigned char *buf, size_t len,
+                                struct intel_pt_pkt *packet)
+{
+        packet->count = (buf[1] >> 5) & 0x3;
+        packet->type = buf[1] & BIT(7) ? INTEL_PT_PTWRITE_IP :
+                                         INTEL_PT_PTWRITE;
+
+        switch (packet->count) {
+        case 0:
+                if (len < 6)
+                        return INTEL_PT_NEED_MORE_BYTES;
+                packet->payload = le32_to_cpu(*(uint32_t *)(buf + 2));
+                return 6;
+        case 1:
+                if (len < 10)
+                        return INTEL_PT_NEED_MORE_BYTES;
+                packet->payload = le64_to_cpu(*(uint64_t *)(buf + 2));
+                return 10;
+        default:
+                return INTEL_PT_BAD_PACKET;
+        }
+}
+
+static int intel_pt_get_exstop(struct intel_pt_pkt *packet)
+{
+        packet->type = INTEL_PT_EXSTOP;
+        return 2;
+}
+
+static int intel_pt_get_exstop_ip(struct intel_pt_pkt *packet)
+{
+        packet->type = INTEL_PT_EXSTOP_IP;
+        return 2;
+}
+
+static int intel_pt_get_mwait(const unsigned char *buf, size_t len,
+                              struct intel_pt_pkt *packet)
+{
+        if (len < 10)
+                return INTEL_PT_NEED_MORE_BYTES;
+        packet->type = INTEL_PT_MWAIT;
+        packet->payload = le64_to_cpu(*(uint64_t *)(buf + 2));
+        return 10;
+}
+
+static int intel_pt_get_pwre(const unsigned char *buf, size_t len,
+                             struct intel_pt_pkt *packet)
+{
+        if (len < 4)
+                return INTEL_PT_NEED_MORE_BYTES;
+        packet->type = INTEL_PT_PWRE;
+        memcpy_le64(&packet->payload, buf + 2, 2);
+        return 4;
+}
+
+static int intel_pt_get_pwrx(const unsigned char *buf, size_t len,
+                             struct intel_pt_pkt *packet)
+{
+        if (len < 7)
+                return INTEL_PT_NEED_MORE_BYTES;
+        packet->type = INTEL_PT_PWRX;
+        memcpy_le64(&packet->payload, buf + 2, 5);
+        return 7;
+}
+
 static int intel_pt_get_ext(const unsigned char *buf, size_t len,
                             struct intel_pt_pkt *packet)
 {
         if (len < 2)
                 return INTEL_PT_NEED_MORE_BYTES;
 
+        if ((buf[1] & 0x1f) == 0x12)
+                return intel_pt_get_ptwrite(buf, len, packet);
+
         switch (buf[1]) {
         case 0xa3: /* Long TNT */
                 return intel_pt_get_long_tnt(buf, len, packet);
@@ -244,6 +319,16 @@ static int intel_pt_get_ext(const unsigned char *buf, size_t len,
                 return intel_pt_get_tma(buf, len, packet);
         case 0xC3: /* 3-byte header */
                 return intel_pt_get_3byte(buf, len, packet);
+        case 0x62: /* EXSTOP no IP */
+                return intel_pt_get_exstop(packet);
+        case 0xE2: /* EXSTOP with IP */
+                return intel_pt_get_exstop_ip(packet);
+        case 0xC2: /* MWAIT */
+                return intel_pt_get_mwait(buf, len, packet);
+        case 0x22: /* PWRE */
+                return intel_pt_get_pwre(buf, len, packet);
+        case 0xA2: /* PWRX */
+                return intel_pt_get_pwrx(buf, len, packet);
         default:
                 return INTEL_PT_BAD_PACKET;
         }
@@ -522,6 +607,29 @@ int intel_pt_pkt_desc(const struct intel_pt_pkt *packet, char *buf,
                 ret = snprintf(buf, buf_len, "%s 0x%llx (NR=%d)",
                                name, payload, nr);
                 return ret;
+        case INTEL_PT_PTWRITE:
+                return snprintf(buf, buf_len, "%s 0x%llx IP:0", name, payload);
+        case INTEL_PT_PTWRITE_IP:
+                return snprintf(buf, buf_len, "%s 0x%llx IP:1", name, payload);
+        case INTEL_PT_EXSTOP:
+                return snprintf(buf, buf_len, "%s IP:0", name);
+        case INTEL_PT_EXSTOP_IP:
+                return snprintf(buf, buf_len, "%s IP:1", name);
+        case INTEL_PT_MWAIT:
+                return snprintf(buf, buf_len, "%s 0x%llx Hints 0x%x Extensions 0x%x",
+                                name, payload, (unsigned int)(payload & 0xff),
+                                (unsigned int)((payload >> 32) & 0x3));
+        case INTEL_PT_PWRE:
+                return snprintf(buf, buf_len, "%s 0x%llx HW:%u CState:%u Sub-CState:%u",
+                                name, payload, !!(payload & 0x80),
+                                (unsigned int)((payload >> 12) & 0xf),
+                                (unsigned int)((payload >> 8) & 0xf));
+        case INTEL_PT_PWRX:
+                return snprintf(buf, buf_len, "%s 0x%llx Last CState:%u Deepest CState:%u Wake Reason 0x%x",
+                                name, payload,
+                                (unsigned int)((payload >> 4) & 0xf),
+                                (unsigned int)(payload & 0xf),
+                                (unsigned int)((payload >> 8) & 0xf));
         default:
                 break;
         }
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.h b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.h
index 781bb79883bd..73ddc3a88d07 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.h
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.h
@@ -52,6 +52,13 @@ enum intel_pt_pkt_type {
         INTEL_PT_PIP,
         INTEL_PT_OVF,
         INTEL_PT_MNT,
+        INTEL_PT_PTWRITE,
+        INTEL_PT_PTWRITE_IP,
+        INTEL_PT_EXSTOP,
+        INTEL_PT_EXSTOP_IP,
+        INTEL_PT_MWAIT,
+        INTEL_PT_PWRE,
+        INTEL_PT_PWRX,
 };
 
 struct intel_pt_pkt {
diff --git a/tools/perf/util/intel-pt-decoder/x86-opcode-map.txt b/tools/perf/util/intel-pt-decoder/x86-opcode-map.txt
index 767be7c76034..12e377184ee4 100644
--- a/tools/perf/util/intel-pt-decoder/x86-opcode-map.txt
+++ b/tools/perf/util/intel-pt-decoder/x86-opcode-map.txt
@@ -1009,7 +1009,7 @@ GrpTable: Grp15
 1: fxstor | RDGSBASE Ry (F3),(11B)
 2: vldmxcsr Md (v1) | WRFSBASE Ry (F3),(11B)
 3: vstmxcsr Md (v1) | WRGSBASE Ry (F3),(11B)
-4: XSAVE
+4: XSAVE | ptwrite Ey (F3),(11B)
 5: XRSTOR | lfence (11B)
 6: XSAVEOPT | clwb (66) | mfence (11B)
 7: clflush | clflushopt (66) | sfence (11B)
diff --git a/tools/perf/util/intel-pt.c b/tools/perf/util/intel-pt.c
index 4c7718f87a08..b58f9fd1e2ee 100644
--- a/tools/perf/util/intel-pt.c
+++ b/tools/perf/util/intel-pt.c
@@ -81,7 +81,6 @@ struct intel_pt {
 
         bool sample_instructions;
         u64 instructions_sample_type;
-        u64 instructions_sample_period;
         u64 instructions_id;
 
         bool sample_branches;
@@ -93,6 +92,18 @@ struct intel_pt {
         u64 transactions_sample_type;
         u64 transactions_id;
 
+        bool sample_ptwrites;
+        u64 ptwrites_sample_type;
+        u64 ptwrites_id;
+
+        bool sample_pwr_events;
+        u64 pwr_events_sample_type;
+        u64 mwait_id;
+        u64 pwre_id;
+        u64 exstop_id;
+        u64 pwrx_id;
+        u64 cbr_id;
+
         bool synth_needs_swap;
 
         u64 tsc_bit;
@@ -103,6 +114,7 @@ struct intel_pt {
         u64 cyc_bit;
         u64 noretcomp_bit;
         unsigned max_non_turbo_ratio;
+        unsigned cbr2khz;
 
         unsigned long num_events;
 
@@ -668,6 +680,19 @@ static bool intel_pt_return_compression(struct intel_pt *pt)
         return true;
 }
 
+static bool intel_pt_branch_enable(struct intel_pt *pt)
+{
+        struct perf_evsel *evsel;
+        u64 config;
+
+        evlist__for_each_entry(pt->session->evlist, evsel) {
+                if (intel_pt_get_config(pt, &evsel->attr, &config) &&
+                    (config & 1) && !(config & 0x2000))
+                        return false;
+        }
+        return true;
+}
+
 static unsigned int intel_pt_mtc_period(struct intel_pt *pt)
 {
         struct perf_evsel *evsel;
@@ -799,6 +824,7 @@ static struct intel_pt_queue *intel_pt_alloc_queue(struct intel_pt *pt,
         params.walk_insn = intel_pt_walk_next_insn;
         params.data = ptq;
         params.return_compression = intel_pt_return_compression(pt);
+        params.branch_enable = intel_pt_branch_enable(pt);
         params.max_non_turbo_ratio = pt->max_non_turbo_ratio;
         params.mtc_period = intel_pt_mtc_period(pt);
         params.tsc_ctc_ratio_n = pt->tsc_ctc_ratio_n;
@@ -1044,6 +1070,36 @@ static void intel_pt_update_last_branch_rb(struct intel_pt_queue *ptq)
                 bs->nr += 1;
 }
 
+static inline bool intel_pt_skip_event(struct intel_pt *pt)
+{
+        return pt->synth_opts.initial_skip &&
+               pt->num_events++ < pt->synth_opts.initial_skip;
+}
+
+static void intel_pt_prep_b_sample(struct intel_pt *pt,
+                                   struct intel_pt_queue *ptq,
+                                   union perf_event *event,
+                                   struct perf_sample *sample)
+{
+        event->sample.header.type = PERF_RECORD_SAMPLE;
+        event->sample.header.misc = PERF_RECORD_MISC_USER;
+        event->sample.header.size = sizeof(struct perf_event_header);
+
+        if (!pt->timeless_decoding)
+                sample->time = tsc_to_perf_time(ptq->timestamp, &pt->tc);
+
+        sample->cpumode = PERF_RECORD_MISC_USER;
+        sample->ip = ptq->state->from_ip;
+        sample->pid = ptq->pid;
+        sample->tid = ptq->tid;
+        sample->addr = ptq->state->to_ip;
+        sample->period = 1;
+        sample->cpu = ptq->cpu;
+        sample->flags = ptq->flags;
+        sample->insn_len = ptq->insn_len;
+        memcpy(sample->insn, ptq->insn, INTEL_PT_INSN_BUF_SZ);
+}
+
 static int intel_pt_inject_event(union perf_event *event,
                                  struct perf_sample *sample, u64 type,
                                  bool swapped)
@@ -1052,9 +1108,35 @@ static int intel_pt_inject_event(union perf_event *event,
         return perf_event__synthesize_sample(event, type, 0, sample, swapped);
 }
 
-static int intel_pt_synth_branch_sample(struct intel_pt_queue *ptq)
+static inline int intel_pt_opt_inject(struct intel_pt *pt,
+                                      union perf_event *event,
+                                      struct perf_sample *sample, u64 type)
+{
+        if (!pt->synth_opts.inject)
+                return 0;
+
+        return intel_pt_inject_event(event, sample, type, pt->synth_needs_swap);
+}
+
+static int intel_pt_deliver_synth_b_event(struct intel_pt *pt,
+                                          union perf_event *event,
+                                          struct perf_sample *sample, u64 type)
 {
         int ret;
+
+        ret = intel_pt_opt_inject(pt, event, sample, type);
+        if (ret)
+                return ret;
+
+        ret = perf_session__deliver_synth_event(pt->session, event, sample);
+        if (ret)
+                pr_err("Intel PT: failed to deliver event, error %d\n", ret);
+
+        return ret;
+}
+
+static int intel_pt_synth_branch_sample(struct intel_pt_queue *ptq)
+{
         struct intel_pt *pt = ptq->pt;
         union perf_event *event = ptq->event_buf;
         struct perf_sample sample = { .ip = 0, };
@@ -1066,29 +1148,13 @@ static int intel_pt_synth_branch_sample(struct intel_pt_queue *ptq)
         if (pt->branches_filter && !(pt->branches_filter & ptq->flags))
                 return 0;
 
-        if (pt->synth_opts.initial_skip &&
-            pt->num_events++ < pt->synth_opts.initial_skip)
+        if (intel_pt_skip_event(pt))
                 return 0;
 
-        event->sample.header.type = PERF_RECORD_SAMPLE;
-        event->sample.header.misc = PERF_RECORD_MISC_USER;
-        event->sample.header.size = sizeof(struct perf_event_header);
+        intel_pt_prep_b_sample(pt, ptq, event, &sample);
 
-        if (!pt->timeless_decoding)
-                sample.time = tsc_to_perf_time(ptq->timestamp, &pt->tc);
-
-        sample.cpumode = PERF_RECORD_MISC_USER;
-        sample.ip = ptq->state->from_ip;
-        sample.pid = ptq->pid;
-        sample.tid = ptq->tid;
-        sample.addr = ptq->state->to_ip;
         sample.id = ptq->pt->branches_id;
         sample.stream_id = ptq->pt->branches_id;
-        sample.period = 1;
-        sample.cpu = ptq->cpu;
-        sample.flags = ptq->flags;
-        sample.insn_len = ptq->insn_len;
-        memcpy(sample.insn, ptq->insn, INTEL_PT_INSN_BUF_SZ);
 
         /*
          * perf report cannot handle events without a branch stack when using
@@ -1105,144 +1171,251 @@ static int intel_pt_synth_branch_sample(struct intel_pt_queue *ptq)
                 sample.branch_stack = (struct branch_stack *)&dummy_bs;
         }
 
-        if (pt->synth_opts.inject) {
-                ret = intel_pt_inject_event(event, &sample,
-                                            pt->branches_sample_type,
-                                            pt->synth_needs_swap);
-                if (ret)
-                        return ret;
+        return intel_pt_deliver_synth_b_event(pt, event, &sample,
+                                              pt->branches_sample_type);
+}
+
+static void intel_pt_prep_sample(struct intel_pt *pt,
+                                 struct intel_pt_queue *ptq,
+                                 union perf_event *event,
+                                 struct perf_sample *sample)
+{
+        intel_pt_prep_b_sample(pt, ptq, event, sample);
+
+        if (pt->synth_opts.callchain) {
+                thread_stack__sample(ptq->thread, ptq->chain,
+                                     pt->synth_opts.callchain_sz, sample->ip);
+                sample->callchain = ptq->chain;
         }
 
-        ret = perf_session__deliver_synth_event(pt->session, event, &sample);
-        if (ret)
-                pr_err("Intel Processor Trace: failed to deliver branch event, error %d\n",
-                       ret);
+        if (pt->synth_opts.last_branch) {
+                intel_pt_copy_last_branch_rb(ptq);
+                sample->branch_stack = ptq->last_branch;
+        }
+}
+
+static inline int intel_pt_deliver_synth_event(struct intel_pt *pt,
+                                               struct intel_pt_queue *ptq,
+                                               union perf_event *event,
+                                               struct perf_sample *sample,
+                                               u64 type)
+{
+        int ret;
+
+        ret = intel_pt_deliver_synth_b_event(pt, event, sample, type);
+
+        if (pt->synth_opts.last_branch)
+                intel_pt_reset_last_branch_rb(ptq);
 
         return ret;
 }
 
 static int intel_pt_synth_instruction_sample(struct intel_pt_queue *ptq)
 {
-        int ret;
         struct intel_pt *pt = ptq->pt;
         union perf_event *event = ptq->event_buf;
         struct perf_sample sample = { .ip = 0, };
 
-        if (pt->synth_opts.initial_skip &&
-            pt->num_events++ < pt->synth_opts.initial_skip)
+        if (intel_pt_skip_event(pt))
                 return 0;
 
-        event->sample.header.type = PERF_RECORD_SAMPLE;
-        event->sample.header.misc = PERF_RECORD_MISC_USER;
-        event->sample.header.size = sizeof(struct perf_event_header);
-
-        if (!pt->timeless_decoding)
-                sample.time = tsc_to_perf_time(ptq->timestamp, &pt->tc);
+        intel_pt_prep_sample(pt, ptq, event, &sample);
 
-        sample.cpumode = PERF_RECORD_MISC_USER;
-        sample.ip = ptq->state->from_ip;
-        sample.pid = ptq->pid;
-        sample.tid = ptq->tid;
-        sample.addr = ptq->state->to_ip;
         sample.id = ptq->pt->instructions_id;
         sample.stream_id = ptq->pt->instructions_id;
         sample.period = ptq->state->tot_insn_cnt - ptq->last_insn_cnt;
-        sample.cpu = ptq->cpu;
-        sample.flags = ptq->flags;
-        sample.insn_len = ptq->insn_len;
-        memcpy(sample.insn, ptq->insn, INTEL_PT_INSN_BUF_SZ);
 
         ptq->last_insn_cnt = ptq->state->tot_insn_cnt;
 
-        if (pt->synth_opts.callchain) {
-                thread_stack__sample(ptq->thread, ptq->chain,
-                                     pt->synth_opts.callchain_sz, sample.ip);
-                sample.callchain = ptq->chain;
-        }
+        return intel_pt_deliver_synth_event(pt, ptq, event, &sample,
+                                            pt->instructions_sample_type);
+}
 
-        if (pt->synth_opts.last_branch) {
-                intel_pt_copy_last_branch_rb(ptq);
-                sample.branch_stack = ptq->last_branch;
-        }
+static int intel_pt_synth_transaction_sample(struct intel_pt_queue *ptq)
+{
+        struct intel_pt *pt = ptq->pt;
+        union perf_event *event = ptq->event_buf;
+        struct perf_sample sample = { .ip = 0, };
 
-        if (pt->synth_opts.inject) {
-                ret = intel_pt_inject_event(event, &sample,
-                                            pt->instructions_sample_type,
-                                            pt->synth_needs_swap);
-                if (ret)
-                        return ret;
-        }
+        if (intel_pt_skip_event(pt))
+                return 0;
 
-        ret = perf_session__deliver_synth_event(pt->session, event, &sample);
-        if (ret)
-                pr_err("Intel Processor Trace: failed to deliver instruction event, error %d\n",
-                       ret);
+        intel_pt_prep_sample(pt, ptq, event, &sample);
 
-        if (pt->synth_opts.last_branch)
-                intel_pt_reset_last_branch_rb(ptq);
+        sample.id = ptq->pt->transactions_id;
+        sample.stream_id = ptq->pt->transactions_id;
 
-        return ret;
+        return intel_pt_deliver_synth_event(pt, ptq, event, &sample,
+                                            pt->transactions_sample_type);
 }
 
-static int intel_pt_synth_transaction_sample(struct intel_pt_queue *ptq)
+static void intel_pt_prep_p_sample(struct intel_pt *pt,
+                                   struct intel_pt_queue *ptq,
+                                   union perf_event *event,
+                                   struct perf_sample *sample)
+{
+        intel_pt_prep_sample(pt, ptq, event, sample);
+
+        /*
+         * Zero IP is used to mean "trace start" but that is not the case for
+         * power or PTWRITE events with no IP, so clear the flags.
+         */
+        if (!sample->ip)
+                sample->flags = 0;
+}
+
+static int intel_pt_synth_ptwrite_sample(struct intel_pt_queue *ptq)
 {
-        int ret;
         struct intel_pt *pt = ptq->pt;
         union perf_event *event = ptq->event_buf;
         struct perf_sample sample = { .ip = 0, };
+        struct perf_synth_intel_ptwrite raw;
 
-        if (pt->synth_opts.initial_skip &&
-            pt->num_events++ < pt->synth_opts.initial_skip)
+        if (intel_pt_skip_event(pt))
                 return 0;
 
-        event->sample.header.type = PERF_RECORD_SAMPLE;
-        event->sample.header.misc = PERF_RECORD_MISC_USER;
-        event->sample.header.size = sizeof(struct perf_event_header);
+        intel_pt_prep_p_sample(pt, ptq, event, &sample);
 
-        if (!pt->timeless_decoding)
-                sample.time = tsc_to_perf_time(ptq->timestamp, &pt->tc);
+        sample.id = ptq->pt->ptwrites_id;
+        sample.stream_id = ptq->pt->ptwrites_id;
 
-        sample.cpumode = PERF_RECORD_MISC_USER;
-        sample.ip = ptq->state->from_ip;
-        sample.pid = ptq->pid;
-        sample.tid = ptq->tid;
-        sample.addr = ptq->state->to_ip;
-        sample.id = ptq->pt->transactions_id;
-        sample.stream_id = ptq->pt->transactions_id;
-        sample.period = 1;
-        sample.cpu = ptq->cpu;
-        sample.flags = ptq->flags;
-        sample.insn_len = ptq->insn_len;
-        memcpy(sample.insn, ptq->insn, INTEL_PT_INSN_BUF_SZ);
+        raw.flags = 0;
+        raw.ip = !!(ptq->state->flags & INTEL_PT_FUP_IP);
+        raw.payload = cpu_to_le64(ptq->state->ptw_payload);
 
-        if (pt->synth_opts.callchain) {
-                thread_stack__sample(ptq->thread, ptq->chain,
-                                     pt->synth_opts.callchain_sz, sample.ip);
-                sample.callchain = ptq->chain;
-        }
+        sample.raw_size = perf_synth__raw_size(raw);
+        sample.raw_data = perf_synth__raw_data(&raw);
 
-        if (pt->synth_opts.last_branch) {
-                intel_pt_copy_last_branch_rb(ptq);
-                sample.branch_stack = ptq->last_branch;
-        }
+        return intel_pt_deliver_synth_event(pt, ptq, event, &sample,
+                                            pt->ptwrites_sample_type);
+}
 
-        if (pt->synth_opts.inject) {
-                ret = intel_pt_inject_event(event, &sample,
-                                            pt->transactions_sample_type,
-                                            pt->synth_needs_swap);
-                if (ret)
-                        return ret;
-        }
+static int intel_pt_synth_cbr_sample(struct intel_pt_queue *ptq)
+{
+        struct intel_pt *pt = ptq->pt;
+        union perf_event *event = ptq->event_buf;
+        struct perf_sample sample = { .ip = 0, };
+        struct perf_synth_intel_cbr raw;
+        u32 flags;
 
-        ret = perf_session__deliver_synth_event(pt->session, event, &sample);
-        if (ret)
-                pr_err("Intel Processor Trace: failed to deliver transaction event, error %d\n",
-                       ret);
+        if (intel_pt_skip_event(pt))
+                return 0;
 
-        if (pt->synth_opts.last_branch)
-                intel_pt_reset_last_branch_rb(ptq);
+        intel_pt_prep_p_sample(pt, ptq, event, &sample);
 
-        return ret;
+        sample.id = ptq->pt->cbr_id;
+        sample.stream_id = ptq->pt->cbr_id;
+
+        flags = (u16)ptq->state->cbr_payload | (pt->max_non_turbo_ratio << 16);
+        raw.flags = cpu_to_le32(flags);
+        raw.freq = cpu_to_le32(raw.cbr * pt->cbr2khz);
+        raw.reserved3 = 0;
+
+        sample.raw_size = perf_synth__raw_size(raw);
+        sample.raw_data = perf_synth__raw_data(&raw);
+
+        return intel_pt_deliver_synth_event(pt, ptq, event, &sample,
+                                            pt->pwr_events_sample_type);
+}
+
+static int intel_pt_synth_mwait_sample(struct intel_pt_queue *ptq)
+{
+        struct intel_pt *pt = ptq->pt;
+        union perf_event *event = ptq->event_buf;
+        struct perf_sample sample = { .ip = 0, };
+        struct perf_synth_intel_mwait raw;
+
+        if (intel_pt_skip_event(pt))
+                return 0;
+
+        intel_pt_prep_p_sample(pt, ptq, event, &sample);
+
+        sample.id = ptq->pt->mwait_id;
+        sample.stream_id = ptq->pt->mwait_id;
+
+        raw.reserved = 0;
+        raw.payload = cpu_to_le64(ptq->state->mwait_payload);
+
+        sample.raw_size = perf_synth__raw_size(raw);
+        sample.raw_data = perf_synth__raw_data(&raw);
+
+        return intel_pt_deliver_synth_event(pt, ptq, event, &sample,
+                                            pt->pwr_events_sample_type);
+}
+
+static int intel_pt_synth_pwre_sample(struct intel_pt_queue *ptq)
+{
+        struct intel_pt *pt = ptq->pt;
+        union perf_event *event = ptq->event_buf;
+        struct perf_sample sample = { .ip = 0, };
+        struct perf_synth_intel_pwre raw;
+
+        if (intel_pt_skip_event(pt))
+                return 0;
+
+        intel_pt_prep_p_sample(pt, ptq, event, &sample);
+
+        sample.id = ptq->pt->pwre_id;
+        sample.stream_id = ptq->pt->pwre_id;
+
+        raw.reserved = 0;
+        raw.payload = cpu_to_le64(ptq->state->pwre_payload);
+
+        sample.raw_size = perf_synth__raw_size(raw);
+        sample.raw_data = perf_synth__raw_data(&raw);
+
+        return intel_pt_deliver_synth_event(pt, ptq, event, &sample,
+                                            pt->pwr_events_sample_type);
+}
+
+static int intel_pt_synth_exstop_sample(struct intel_pt_queue *ptq)
+{
+        struct intel_pt *pt = ptq->pt;
+        union perf_event *event = ptq->event_buf;
+        struct perf_sample sample = { .ip = 0, };
+        struct perf_synth_intel_exstop raw;
+
+        if (intel_pt_skip_event(pt))
+                return 0;
+
+        intel_pt_prep_p_sample(pt, ptq, event, &sample);
+
+        sample.id = ptq->pt->exstop_id;
+        sample.stream_id = ptq->pt->exstop_id;
+
+        raw.flags = 0;
+        raw.ip = !!(ptq->state->flags & INTEL_PT_FUP_IP);
+
+        sample.raw_size = perf_synth__raw_size(raw);
+        sample.raw_data = perf_synth__raw_data(&raw);
+
+        return intel_pt_deliver_synth_event(pt, ptq, event, &sample,
+                                            pt->pwr_events_sample_type);
+}
+
+static int intel_pt_synth_pwrx_sample(struct intel_pt_queue *ptq)
+{
+        struct intel_pt *pt = ptq->pt;
+        union perf_event *event = ptq->event_buf;
+        struct perf_sample sample = { .ip = 0, };
+        struct perf_synth_intel_pwrx raw;
+
+        if (intel_pt_skip_event(pt))
+                return 0;
+
+        intel_pt_prep_p_sample(pt, ptq, event, &sample);
+
+        sample.id = ptq->pt->pwrx_id;
+        sample.stream_id = ptq->pt->pwrx_id;
+
+        raw.reserved = 0;
+        raw.payload = cpu_to_le64(ptq->state->pwrx_payload);
+
+        sample.raw_size = perf_synth__raw_size(raw);
+        sample.raw_data = perf_synth__raw_data(&raw);
+
+        return intel_pt_deliver_synth_event(pt, ptq, event, &sample,
+                                            pt->pwr_events_sample_type);
 }
 
 static int intel_pt_synth_error(struct intel_pt *pt, int code, int cpu,
@@ -1296,6 +1469,10 @@ static inline bool intel_pt_is_switch_ip(struct intel_pt_queue *ptq, u64 ip)
                                PERF_IP_FLAG_INTERRUPT | PERF_IP_FLAG_TX_ABORT));
 }
 
+#define INTEL_PT_PWR_EVT (INTEL_PT_MWAIT_OP | INTEL_PT_PWR_ENTRY | \
+                          INTEL_PT_EX_STOP | INTEL_PT_PWR_EXIT | \
+                          INTEL_PT_CBR_CHG)
+
 static int intel_pt_sample(struct intel_pt_queue *ptq)
 {
         const struct intel_pt_state *state = ptq->state;
@@ -1307,24 +1484,52 @@ static int intel_pt_sample(struct intel_pt_queue *ptq)
 
         ptq->have_sample = false;
 
-        if (pt->sample_instructions &&
-            (state->type & INTEL_PT_INSTRUCTION) &&
-            (!pt->synth_opts.initial_skip ||
-             pt->num_events++ >= pt->synth_opts.initial_skip)) {
+        if (pt->sample_pwr_events && (state->type & INTEL_PT_PWR_EVT)) {
+                if (state->type & INTEL_PT_CBR_CHG) {
+                        err = intel_pt_synth_cbr_sample(ptq);
+                        if (err)
+                                return err;
+                }
+                if (state->type & INTEL_PT_MWAIT_OP) {
+                        err = intel_pt_synth_mwait_sample(ptq);
+                        if (err)
+                                return err;
+                }
+                if (state->type & INTEL_PT_PWR_ENTRY) {
+                        err = intel_pt_synth_pwre_sample(ptq);
+                        if (err)
+                                return err;
+                }
+                if (state->type & INTEL_PT_EX_STOP) {
+                        err = intel_pt_synth_exstop_sample(ptq);
+                        if (err)
+                                return err;
+                }
+                if (state->type & INTEL_PT_PWR_EXIT) {
+                        err = intel_pt_synth_pwrx_sample(ptq);
+                        if (err)
+                                return err;
+                }
+        }
+
+        if (pt->sample_instructions && (state->type & INTEL_PT_INSTRUCTION)) {
                 err = intel_pt_synth_instruction_sample(ptq);
                 if (err)
                         return err;
         }
 
-        if (pt->sample_transactions &&
-            (state->type & INTEL_PT_TRANSACTION) &&
-            (!pt->synth_opts.initial_skip ||
-             pt->num_events++ >= pt->synth_opts.initial_skip)) {
+        if (pt->sample_transactions && (state->type & INTEL_PT_TRANSACTION)) {
                 err = intel_pt_synth_transaction_sample(ptq);
                 if (err)
                         return err;
         }
 
+        if (pt->sample_ptwrites && (state->type & INTEL_PT_PTW)) {
+                err = intel_pt_synth_ptwrite_sample(ptq);
+                if (err)
+                        return err;
+        }
+
         if (!(state->type & INTEL_PT_BRANCH))
                 return 0;
 
@@ -1925,36 +2130,65 @@ static int intel_pt_event_synth(struct perf_tool *tool,
                                                  NULL);
 }
 
-static int intel_pt_synth_event(struct perf_session *session,
+static int intel_pt_synth_event(struct perf_session *session, const char *name,
                                 struct perf_event_attr *attr, u64 id)
 {
         struct intel_pt_synth intel_pt_synth;
+        int err;
+
+        pr_debug("Synthesizing '%s' event with id %" PRIu64 " sample type %#" PRIx64 "\n",
+                 name, id, (u64)attr->sample_type);
 
         memset(&intel_pt_synth, 0, sizeof(struct intel_pt_synth));
         intel_pt_synth.session = session;
 
-        return perf_event__synthesize_attr(&intel_pt_synth.dummy_tool, attr, 1,
-                                           &id, intel_pt_event_synth);
+        err = perf_event__synthesize_attr(&intel_pt_synth.dummy_tool, attr, 1,
+                                          &id, intel_pt_event_synth);
+        if (err)
+                pr_err("%s: failed to synthesize '%s' event type\n",
+                       __func__, name);
+
+        return err;
 }
 
-static int intel_pt_synth_events(struct intel_pt *pt,
-                                 struct perf_session *session)
+static void intel_pt_set_event_name(struct perf_evlist *evlist, u64 id,
+                                    const char *name)
 {
-        struct perf_evlist *evlist = session->evlist;
         struct perf_evsel *evsel;
-        struct perf_event_attr attr;
-        bool found = false;
-        u64 id;
-        int err;
 
         evlist__for_each_entry(evlist, evsel) {
-                if (evsel->attr.type == pt->pmu_type && evsel->ids) {
-                        found = true;
+                if (evsel->id && evsel->id[0] == id) {
+                        if (evsel->name)
+                                zfree(&evsel->name);
+                        evsel->name = strdup(name);
                         break;
                 }
         }
+}
 
-        if (!found) {
+static struct perf_evsel *intel_pt_evsel(struct intel_pt *pt,
+                                         struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+
+        evlist__for_each_entry(evlist, evsel) {
+                if (evsel->attr.type == pt->pmu_type && evsel->ids)
+                        return evsel;
+        }
+
+        return NULL;
+}
+
+static int intel_pt_synth_events(struct intel_pt *pt,
+                                 struct perf_session *session)
+{
+        struct perf_evlist *evlist = session->evlist;
+        struct perf_evsel *evsel = intel_pt_evsel(pt, evlist);
+        struct perf_event_attr attr;
+        u64 id;
+        int err;
+
+        if (!evsel) {
                 pr_debug("There are no selected events with Intel Processor Trace data\n");
                 return 0;
         }
@@ -1983,6 +2217,25 @@ static int intel_pt_synth_events(struct intel_pt *pt,
         if (!id)
                 id = 1;
 
+        if (pt->synth_opts.branches) {
+                attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
+                attr.sample_period = 1;
+                attr.sample_type |= PERF_SAMPLE_ADDR;
+                err = intel_pt_synth_event(session, "branches", &attr, id);
+                if (err)
+                        return err;
+                pt->sample_branches = true;
+                pt->branches_sample_type = attr.sample_type;
+                pt->branches_id = id;
+                id += 1;
+                attr.sample_type &= ~(u64)PERF_SAMPLE_ADDR;
+        }
+
+        if (pt->synth_opts.callchain)
+                attr.sample_type |= PERF_SAMPLE_CALLCHAIN;
+        if (pt->synth_opts.last_branch)
+                attr.sample_type |= PERF_SAMPLE_BRANCH_STACK;
+
         if (pt->synth_opts.instructions) {
                 attr.config = PERF_COUNT_HW_INSTRUCTIONS;
                 if (pt->synth_opts.period_type == PERF_ITRACE_PERIOD_NANOSECS)
@@ -1990,70 +2243,90 @@ static int intel_pt_synth_events(struct intel_pt *pt,
                                 intel_pt_ns_to_ticks(pt, pt->synth_opts.period);
                 else
                         attr.sample_period = pt->synth_opts.period;
-                pt->instructions_sample_period = attr.sample_period;
-                if (pt->synth_opts.callchain)
-                        attr.sample_type |= PERF_SAMPLE_CALLCHAIN;
-                if (pt->synth_opts.last_branch)
-                        attr.sample_type |= PERF_SAMPLE_BRANCH_STACK;
-                pr_debug("Synthesizing 'instructions' event with id %" PRIu64 " sample type %#" PRIx64 "\n",
-                         id, (u64)attr.sample_type);
-                err = intel_pt_synth_event(session, &attr, id);
-                if (err) {
-                        pr_err("%s: failed to synthesize 'instructions' event type\n",
-                               __func__);
+                err = intel_pt_synth_event(session, "instructions", &attr, id);
+                if (err)
                         return err;
-                }
                 pt->sample_instructions = true;
                 pt->instructions_sample_type = attr.sample_type;
                 pt->instructions_id = id;
                 id += 1;
         }
 
+        attr.sample_type &= ~(u64)PERF_SAMPLE_PERIOD;
+        attr.sample_period = 1;
+
         if (pt->synth_opts.transactions) {
                 attr.config = PERF_COUNT_HW_INSTRUCTIONS;
-                attr.sample_period = 1;
-                if (pt->synth_opts.callchain)
-                        attr.sample_type |= PERF_SAMPLE_CALLCHAIN;
-                if (pt->synth_opts.last_branch)
-                        attr.sample_type |= PERF_SAMPLE_BRANCH_STACK;
-                pr_debug("Synthesizing 'transactions' event with id %" PRIu64 " sample type %#" PRIx64 "\n",
-                         id, (u64)attr.sample_type);
-                err = intel_pt_synth_event(session, &attr, id);
-                if (err) {
-                        pr_err("%s: failed to synthesize 'transactions' event type\n",
-                               __func__);
+                err = intel_pt_synth_event(session, "transactions", &attr, id);
+                if (err)
                         return err;
-                }
                 pt->sample_transactions = true;
+                pt->transactions_sample_type = attr.sample_type;
                 pt->transactions_id = id;
+                intel_pt_set_event_name(evlist, id, "transactions");
                 id += 1;
-                evlist__for_each_entry(evlist, evsel) {
-                        if (evsel->id && evsel->id[0] == pt->transactions_id) {
-                                if (evsel->name)
-                                        zfree(&evsel->name);
-                                evsel->name = strdup("transactions");
-                                break;
-                        }
-                }
         }
 
-        if (pt->synth_opts.branches) {
-                attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
-                attr.sample_period = 1;
-                attr.sample_type |= PERF_SAMPLE_ADDR;
-                attr.sample_type &= ~(u64)PERF_SAMPLE_CALLCHAIN;
-                attr.sample_type &= ~(u64)PERF_SAMPLE_BRANCH_STACK;
-                pr_debug("Synthesizing 'branches' event with id %" PRIu64 " sample type %#" PRIx64 "\n",
-                         id, (u64)attr.sample_type);
-                err = intel_pt_synth_event(session, &attr, id);
-                if (err) {
-                        pr_err("%s: failed to synthesize 'branches' event type\n",
-                               __func__);
+        attr.type = PERF_TYPE_SYNTH;
+        attr.sample_type |= PERF_SAMPLE_RAW;
+
+        if (pt->synth_opts.ptwrites) {
+                attr.config = PERF_SYNTH_INTEL_PTWRITE;
+                err = intel_pt_synth_event(session, "ptwrite", &attr, id);
+                if (err)
                         return err;
-                }
-                pt->sample_branches = true;
-                pt->branches_sample_type = attr.sample_type;
-                pt->branches_id = id;
+                pt->sample_ptwrites = true;
+                pt->ptwrites_sample_type = attr.sample_type;
+                pt->ptwrites_id = id;
+                intel_pt_set_event_name(evlist, id, "ptwrite");
+                id += 1;
+        }
+
+        if (pt->synth_opts.pwr_events) {
+                pt->sample_pwr_events = true;
+                pt->pwr_events_sample_type = attr.sample_type;
+
+                attr.config = PERF_SYNTH_INTEL_CBR;
+                err = intel_pt_synth_event(session, "cbr", &attr, id);
+                if (err)
+                        return err;
+                pt->cbr_id = id;
+                intel_pt_set_event_name(evlist, id, "cbr");
+                id += 1;
+        }
+
+        if (pt->synth_opts.pwr_events && (evsel->attr.config & 0x10)) {
+                attr.config = PERF_SYNTH_INTEL_MWAIT;
+                err = intel_pt_synth_event(session, "mwait", &attr, id);
+                if (err)
+                        return err;
+                pt->mwait_id = id;
+                intel_pt_set_event_name(evlist, id, "mwait");
+                id += 1;
+
+                attr.config = PERF_SYNTH_INTEL_PWRE;
+                err = intel_pt_synth_event(session, "pwre", &attr, id);
+                if (err)
+                        return err;
+                pt->pwre_id = id;
+                intel_pt_set_event_name(evlist, id, "pwre");
+                id += 1;
+
+                attr.config = PERF_SYNTH_INTEL_EXSTOP;
+                err = intel_pt_synth_event(session, "exstop", &attr, id);
+                if (err)
+                        return err;
+                pt->exstop_id = id;
+                intel_pt_set_event_name(evlist, id, "exstop");
+                id += 1;
+
+                attr.config = PERF_SYNTH_INTEL_PWRX;
+                err = intel_pt_synth_event(session, "pwrx", &attr, id);
+                if (err)
+                        return err;
+                pt->pwrx_id = id;
+                intel_pt_set_event_name(evlist, id, "pwrx");
+                id += 1;
         }
 
         pt->synth_needs_swap = evsel->needs_swap;
@@ -2322,6 +2595,7 @@ int intel_pt_process_auxtrace_info(union perf_event *event,
                 intel_pt_log("TSC frequency %"PRIu64"\n", tsc_freq);
                 intel_pt_log("Maximum non-turbo ratio %u\n",
                              pt->max_non_turbo_ratio);
+                pt->cbr2khz = tsc_freq / pt->max_non_turbo_ratio / 1000;
         }
 
         if (pt->synth_opts.calls)
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index d97e014c3df3..5de2b86b9880 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -572,16 +572,7 @@ static struct dso *machine__findnew_module_dso(struct machine *machine,
                 if (dso == NULL)
                         goto out_unlock;
 
-                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_module_info(dso, m, machine);
                 dso__set_long_name(dso, strdup(filename), true);
         }
 
@@ -1218,10 +1209,12 @@ int machine__create_kernel_maps(struct machine *machine)
          */
         map_groups__fixup_end(&machine->kmaps);
 
-        if (machine__get_running_kernel_start(machine, &name, &addr)) {
-        } else if (maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, name, addr)) {
-                machine__destroy_kernel_maps(machine);
-                return -1;
+        if (!machine__get_running_kernel_start(machine, &name, &addr)) {
+                if (name &&
+                    maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, name, addr)) {
+                        machine__destroy_kernel_maps(machine);
+                        return -1;
+                }
         }
 
         return 0;
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index ea7f450dc609..389e9729331f 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -2,6 +2,7 @@
 #define __PMU_H
 
 #include <linux/bitmap.h>
+#include <linux/compiler.h>
 #include <linux/perf_event.h>
 #include <stdbool.h>
 #include "evsel.h"
@@ -83,8 +84,7 @@ void print_pmu_events(const char *event_glob, bool name_only, bool quiet,
                       bool long_desc, bool details_flag);
 bool pmu_have_event(const char *pname, const char *name);
 
-int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
-                        ...) __attribute__((format(scanf, 3, 4)));
+int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt, ...) __scanf(3, 4);
 
 int perf_pmu__test(void);
 
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 84e7e698411e..a2670e9d652d 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -619,7 +619,7 @@ static int post_process_probe_trace_point(struct probe_trace_point *tp,
                                            struct map *map, unsigned long offs)
 {
         struct symbol *sym;
-        u64 addr = tp->address + tp->offset - offs;
+        u64 addr = tp->address - offs;
 
         sym = map__find_symbol(map, addr);
         if (!sym)
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 373842656fb6..5812947418dd 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -1,6 +1,7 @@
 #ifndef _PROBE_EVENT_H
 #define _PROBE_EVENT_H
 
+#include <linux/compiler.h>
 #include <stdbool.h>
 #include "intlist.h"
 
@@ -171,8 +172,7 @@ void arch__fix_tev_from_maps(struct perf_probe_event *pev,
                              struct symbol *sym);
 
 /* If there is no space to write, returns -E2BIG. */
-int e_snprintf(char *str, size_t size, const char *format, ...)
-        __attribute__((format(printf, 3, 4)));
+int e_snprintf(char *str, size_t size, const char *format, ...) __printf(3, 4);
 
 /* Maximum index number of event-name postfix */
 #define MAX_EVENT_INDEX 1024
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 9d92af7d0718..57b7a00e6f16 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -28,6 +28,7 @@
 #include <stdbool.h>
 #include <errno.h>
 #include <linux/bitmap.h>
+#include <linux/compiler.h>
 #include <linux/time64.h>
 
 #include "../../perf.h"
@@ -84,7 +85,7 @@ struct tables {
 
 static struct tables tables_global;
 
-static void handler_call_die(const char *handler_name) NORETURN;
+static void handler_call_die(const char *handler_name) __noreturn;
 static void handler_call_die(const char *handler_name)
 {
         PyErr_Print();
@@ -1219,7 +1220,7 @@ static int python_generate_script(struct pevent *pevent, const char *outfile)
         fprintf(ofp, "# be retrieved using Python functions of the form "
                 "common_*(context).\n");
 
-        fprintf(ofp, "# See the perf-trace-python Documentation for the list "
+        fprintf(ofp, "# See the perf-script-python Documentation for the list "
                 "of available functions.\n\n");
 
         fprintf(ofp, "import os\n");
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 7dc1096264c5..d19c40a81040 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -2035,7 +2035,7 @@ int perf_session__cpu_bitmap(struct perf_session *session,
 
                 if (!(evsel->attr.sample_type & PERF_SAMPLE_CPU)) {
                         pr_err("File does not contain CPU events. "
-                               "Remove -c option to proceed.\n");
+                               "Remove -C option to proceed.\n");
                         return -1;
                 }
         }
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 5762ae4e9e91..8b327c955a4f 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -2532,12 +2532,12 @@ static int setup_sort_list(struct perf_hpp_list *list, char *str,
                         ret = sort_dimension__add(list, tok, evlist, level);
                         if (ret == -EINVAL) {
                                 if (!cacheline_size && !strncasecmp(tok, "dcacheline", strlen(tok)))
-                                        error("The \"dcacheline\" --sort key needs to know the cacheline size and it couldn't be determined on this system");
+                                        pr_err("The \"dcacheline\" --sort key needs to know the cacheline size and it couldn't be determined on this system");
                                 else
-                                        error("Invalid --sort key: `%s'", tok);
+                                        pr_err("Invalid --sort key: `%s'", tok);
                                 break;
                         } else if (ret == -ESRCH) {
-                                error("Unknown --sort key: `%s'", tok);
+                                pr_err("Unknown --sort key: `%s'", tok);
                                 break;
                         }
                 }
@@ -2594,7 +2594,7 @@ static int setup_sort_order(struct perf_evlist *evlist)
                 return 0;
 
         if (sort_order[1] == '\0') {
-                error("Invalid --sort key: `+'");
+                pr_err("Invalid --sort key: `+'");
                 return -EINVAL;
         }
 
@@ -2604,7 +2604,7 @@ static int setup_sort_order(struct perf_evlist *evlist)
          */
         if (asprintf(&new_sort_order, "%s,%s",
                      get_default_sort_order(evlist), sort_order + 1) < 0) {
-                error("Not enough memory to set up --sort");
+                pr_err("Not enough memory to set up --sort");
                 return -ENOMEM;
         }
 
@@ -2668,7 +2668,7 @@ static int __setup_sorting(struct perf_evlist *evlist)
 
         str = strdup(sort_keys);
         if (str == NULL) {
-                error("Not enough memory to setup sort keys");
+                pr_err("Not enough memory to setup sort keys");
                 return -ENOMEM;
         }
 
@@ -2678,7 +2678,7 @@ static int __setup_sorting(struct perf_evlist *evlist)
         if (!is_strict_order(field_order)) {
                 str = setup_overhead(str);
                 if (str == NULL) {
-                        error("Not enough memory to setup overhead keys");
+                        pr_err("Not enough memory to setup overhead keys");
                         return -ENOMEM;
                 }
         }
@@ -2834,10 +2834,10 @@ static int setup_output_list(struct perf_hpp_list *list, char *str)
                         tok; tok = strtok_r(NULL, ", ", &tmp)) {
                 ret = output_field_add(list, tok);
                 if (ret == -EINVAL) {
-                        error("Invalid --fields key: `%s'", tok);
+                        pr_err("Invalid --fields key: `%s'", tok);
                         break;
                 } else if (ret == -ESRCH) {
-                        error("Unknown --fields key: `%s'", tok);
+                        pr_err("Unknown --fields key: `%s'", tok);
                         break;
                 }
         }
@@ -2877,7 +2877,7 @@ static int __setup_output_field(void)
 
         strp = str = strdup(field_order);
         if (str == NULL) {
-                error("Not enough memory to setup output fields");
+                pr_err("Not enough memory to setup output fields");
                 return -ENOMEM;
         }
 
@@ -2885,7 +2885,7 @@ static int __setup_output_field(void)
                 strp++;
 
         if (!strlen(strp)) {
-                error("Invalid --fields key: `+'");
+                pr_err("Invalid --fields key: `+'");
                 goto out;
         }
 
diff --git a/tools/perf/util/srcline.c b/tools/perf/util/srcline.c
index df051a52393c..ebc88a74e67b 100644
--- a/tools/perf/util/srcline.c
+++ b/tools/perf/util/srcline.c
@@ -56,7 +56,10 @@ static int inline_list__append(char *filename, char *funcname, int line_nr,
                 }
         }
 
-        list_add_tail(&ilist->list, &node->val);
+        if (callchain_param.order == ORDER_CALLEE)
+                list_add_tail(&ilist->list, &node->val);
+        else
+                list_add(&ilist->list, &node->val);
 
         return 0;
 }
@@ -200,12 +203,14 @@ static void addr2line_cleanup(struct a2l_data *a2l)
 
 #define MAX_INLINE_NEST 1024
 
-static void inline_list__reverse(struct inline_node *node)
+static int inline_list__append_dso_a2l(struct dso *dso,
+                                       struct inline_node *node)
 {
-        struct inline_list *ilist, *n;
+        struct a2l_data *a2l = dso->a2l;
+        char *funcname = a2l->funcname ? strdup(a2l->funcname) : NULL;
+        char *filename = a2l->filename ? strdup(a2l->filename) : NULL;
 
-        list_for_each_entry_safe_reverse(ilist, n, &node->val, list)
-                list_move_tail(&ilist->list, &node->val);
+        return inline_list__append(filename, funcname, a2l->line, node, dso);
 }
 
 static int addr2line(const char *dso_name, u64 addr,
@@ -230,36 +235,36 @@ static int addr2line(const char *dso_name, u64 addr,
 
         bfd_map_over_sections(a2l->abfd, find_address_in_section, a2l);
 
-        if (a2l->found && unwind_inlines) {
+        if (!a2l->found)
+                return 0;
+
+        if (unwind_inlines) {
                 int cnt = 0;
 
+                if (node && inline_list__append_dso_a2l(dso, node))
+                        return 0;
+
                 while (bfd_find_inliner_info(a2l->abfd, &a2l->filename,
                                              &a2l->funcname, &a2l->line) &&
                        cnt++ < MAX_INLINE_NEST) {
 
                         if (node != NULL) {
-                                if (inline_list__append(strdup(a2l->filename),
-                                                        strdup(a2l->funcname),
-                                                        a2l->line, node,
-                                                        dso) != 0)
+                                if (inline_list__append_dso_a2l(dso, node))
                                         return 0;
+                                // found at least one inline frame
+                                ret = 1;
                         }
                 }
+        }
 
-                if ((node != NULL) &&
-                    (callchain_param.order != ORDER_CALLEE)) {
-                        inline_list__reverse(node);
-                }
+        if (file) {
+                *file = a2l->filename ? strdup(a2l->filename) : NULL;
+                ret = *file ? 1 : 0;
         }
 
-        if (a2l->found && a2l->filename) {
-                *file = strdup(a2l->filename);
+        if (line)
                 *line = a2l->line;
 
-                if (*file)
-                        ret = 1;
-        }
-
         return ret;
 }
 
@@ -278,8 +283,6 @@ void dso__free_a2l(struct dso *dso)
 static struct inline_node *addr2inlines(const char *dso_name, u64 addr,
         struct dso *dso)
 {
-        char *file = NULL;
-        unsigned int line = 0;
         struct inline_node *node;
 
         node = zalloc(sizeof(*node));
@@ -291,7 +294,7 @@ static struct inline_node *addr2inlines(const char *dso_name, u64 addr,
         INIT_LIST_HEAD(&node->val);
         node->addr = addr;
 
-        if (!addr2line(dso_name, addr, &file, &line, dso, TRUE, node))
+        if (!addr2line(dso_name, addr, NULL, NULL, dso, TRUE, node))
                 goto out_free_inline_node;
 
         if (list_empty(&node->val))
diff --git a/tools/perf/util/stat-shadow.c b/tools/perf/util/stat-shadow.c
index ac10cc675d39..719d6cb86952 100644
--- a/tools/perf/util/stat-shadow.c
+++ b/tools/perf/util/stat-shadow.c
@@ -44,6 +44,8 @@ static struct stats runtime_topdown_slots_issued[NUM_CTX][MAX_NR_CPUS];
 static struct stats runtime_topdown_slots_retired[NUM_CTX][MAX_NR_CPUS];
 static struct stats runtime_topdown_fetch_bubbles[NUM_CTX][MAX_NR_CPUS];
 static struct stats runtime_topdown_recovery_bubbles[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_smi_num_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_aperf_stats[NUM_CTX][MAX_NR_CPUS];
 static struct rblist runtime_saved_values;
 static bool have_frontend_stalled;
 
@@ -157,6 +159,8 @@ void perf_stat__reset_shadow_stats(void)
         memset(runtime_topdown_slots_issued, 0, sizeof(runtime_topdown_slots_issued));
         memset(runtime_topdown_fetch_bubbles, 0, sizeof(runtime_topdown_fetch_bubbles));
         memset(runtime_topdown_recovery_bubbles, 0, sizeof(runtime_topdown_recovery_bubbles));
+        memset(runtime_smi_num_stats, 0, sizeof(runtime_smi_num_stats));
+        memset(runtime_aperf_stats, 0, sizeof(runtime_aperf_stats));
 
         next = rb_first(&runtime_saved_values.entries);
         while (next) {
@@ -217,6 +221,10 @@ void perf_stat__update_shadow_stats(struct perf_evsel *counter, u64 *count,
                 update_stats(&runtime_dtlb_cache_stats[ctx][cpu], count[0]);
         else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB))
                 update_stats(&runtime_itlb_cache_stats[ctx][cpu], count[0]);
+        else if (perf_stat_evsel__is(counter, SMI_NUM))
+                update_stats(&runtime_smi_num_stats[ctx][cpu], count[0]);
+        else if (perf_stat_evsel__is(counter, APERF))
+                update_stats(&runtime_aperf_stats[ctx][cpu], count[0]);
 
         if (counter->collect_stat) {
                 struct saved_value *v = saved_value_lookup(counter, cpu, ctx,
@@ -592,6 +600,29 @@ static double td_be_bound(int ctx, int cpu)
         return sanitize_val(1.0 - sum);
 }
 
+static void print_smi_cost(int cpu, struct perf_evsel *evsel,
+                           struct perf_stat_output_ctx *out)
+{
+        double smi_num, aperf, cycles, cost = 0.0;
+        int ctx = evsel_context(evsel);
+        const char *color = NULL;
+
+        smi_num = avg_stats(&runtime_smi_num_stats[ctx][cpu]);
+        aperf = avg_stats(&runtime_aperf_stats[ctx][cpu]);
+        cycles = avg_stats(&runtime_cycles_stats[ctx][cpu]);
+
+        if ((cycles == 0) || (aperf == 0))
+                return;
+
+        if (smi_num)
+                cost = (aperf - cycles) / aperf * 100.00;
+
+        if (cost > 10)
+                color = PERF_COLOR_RED;
+        out->print_metric(out->ctx, color, "%8.1f%%", "SMI cycles%", cost);
+        out->print_metric(out->ctx, NULL, "%4.0f", "SMI#", smi_num);
+}
+
 void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                    double avg, int cpu,
                                    struct perf_stat_output_ctx *out)
@@ -825,6 +856,8 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                 }
                 snprintf(unit_buf, sizeof(unit_buf), "%c/sec", unit);
                 print_metric(ctxp, NULL, "%8.3f", unit_buf, ratio);
+        } else if (perf_stat_evsel__is(evsel, SMI_NUM)) {
+                print_smi_cost(cpu, evsel, out);
         } else {
                 print_metric(ctxp, NULL, NULL, NULL, 0);
         }
diff --git a/tools/perf/util/stat.c b/tools/perf/util/stat.c
index c58174443dc1..53b9a994a3dc 100644
--- a/tools/perf/util/stat.c
+++ b/tools/perf/util/stat.c
@@ -86,6 +86,8 @@ static const char *id_str[PERF_STAT_EVSEL_ID__MAX] = {
         ID(TOPDOWN_SLOTS_RETIRED, topdown-slots-retired),
         ID(TOPDOWN_FETCH_BUBBLES, topdown-fetch-bubbles),
         ID(TOPDOWN_RECOVERY_BUBBLES, topdown-recovery-bubbles),
+        ID(SMI_NUM, msr/smi/),
+        ID(APERF, msr/aperf/),
 };
 #undef ID
 
diff --git a/tools/perf/util/stat.h b/tools/perf/util/stat.h
index 0a65ae23f495..7522bf10b03e 100644
--- a/tools/perf/util/stat.h
+++ b/tools/perf/util/stat.h
@@ -22,6 +22,8 @@ enum perf_stat_evsel_id {
         PERF_STAT_EVSEL_ID__TOPDOWN_SLOTS_RETIRED,
         PERF_STAT_EVSEL_ID__TOPDOWN_FETCH_BUBBLES,
         PERF_STAT_EVSEL_ID__TOPDOWN_RECOVERY_BUBBLES,
+        PERF_STAT_EVSEL_ID__SMI_NUM,
+        PERF_STAT_EVSEL_ID__APERF,
         PERF_STAT_EVSEL_ID__MAX,
 };
 
diff --git a/tools/perf/util/strbuf.h b/tools/perf/util/strbuf.h
index 318424ea561d..802d743378af 100644
--- a/tools/perf/util/strbuf.h
+++ b/tools/perf/util/strbuf.h
@@ -42,6 +42,7 @@
 #include <stdarg.h>
 #include <stddef.h>
 #include <string.h>
+#include <linux/compiler.h>
 #include <sys/types.h>
 
 extern char strbuf_slopbuf[];
@@ -85,8 +86,7 @@ static inline int strbuf_addstr(struct strbuf *sb, const char *s) {
         return strbuf_add(sb, s, strlen(s));
 }
 
-__attribute__((format(printf,2,3)))
-int strbuf_addf(struct strbuf *sb, const char *fmt, ...);
+int strbuf_addf(struct strbuf *sb, const char *fmt, ...) __printf(2, 3);
 
 /* XXX: if read fails, any partial read is undone */
 ssize_t strbuf_read(struct strbuf *, int fd, ssize_t hint);
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index e7ee47f7377a..502505cf236a 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -637,43 +637,6 @@ static int dso__swap_init(struct dso *dso, unsigned char eidata)
         return 0;
 }
 
-static int decompress_kmodule(struct dso *dso, const char *name,
-                              enum dso_binary_type type)
-{
-        int fd = -1;
-        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 (type == DSO_BINARY_TYPE__BUILD_ID_CACHE)
-                name = dso->long_name;
-
-        if (kmod_path__parse_ext(&m, name) || !m.comp)
-                return -1;
-
-        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;
-}
-
 bool symsrc__possibly_runtime(struct symsrc *ss)
 {
         return ss->dynsym || ss->opdsec;
@@ -705,9 +668,11 @@ int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
         int fd;
 
         if (dso__needs_decompress(dso)) {
-                fd = decompress_kmodule(dso, name, type);
+                fd = dso__decompress_kmodule_fd(dso, name);
                 if (fd < 0)
                         return -1;
+
+                type = dso->symtab_type;
         } else {
                 fd = open(name, O_RDONLY);
                 if (fd < 0) {
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 8f2b068ff756..e7a98dbd2aed 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1562,10 +1562,6 @@ int dso__load(struct dso *dso, struct map *map)
         if (!runtime_ss && syms_ss)
                 runtime_ss = syms_ss;
 
-        if (syms_ss && syms_ss->type == DSO_BINARY_TYPE__BUILD_ID_CACHE)
-                if (dso__build_id_is_kmod(dso, name, PATH_MAX))
-                        kmod = true;
-
         if (syms_ss)
                 ret = dso__load_sym(dso, map, syms_ss, runtime_ss, kmod);
         else
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 746bbee645d9..e0a6e9a6a053 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -24,7 +24,7 @@
 #include <errno.h>
 
 #include "../perf.h"
-#include "util.h"
+#include "debug.h"
 #include "trace-event.h"
 
 #include "sane_ctype.h"
@@ -150,7 +150,7 @@ void parse_ftrace_printk(struct pevent *pevent,
         while (line) {
                 addr_str = strtok_r(line, ":", &fmt);
                 if (!addr_str) {
-                        warning("printk format with empty entry");
+                        pr_warning("printk format with empty entry");
                         break;
                 }
                 addr = strtoull(addr_str, NULL, 16);
diff --git a/tools/perf/util/unwind-libdw.c b/tools/perf/util/unwind-libdw.c
index f90e11a555b2..7755a5e0fe5e 100644
--- a/tools/perf/util/unwind-libdw.c
+++ b/tools/perf/util/unwind-libdw.c
@@ -39,6 +39,14 @@ static int __report_module(struct addr_location *al, u64 ip,
                 return 0;
 
         mod = dwfl_addrmodule(ui->dwfl, ip);
+        if (mod) {
+                Dwarf_Addr s;
+
+                dwfl_module_info(mod, NULL, &s, NULL, NULL, NULL, NULL, NULL);
+                if (s != al->map->start)
+                        mod = 0;
+        }
+
         if (!mod)
                 mod = dwfl_report_elf(ui->dwfl, dso->short_name,
                                       dso->long_name, -1, al->map->start,
@@ -168,12 +176,24 @@ frame_callback(Dwfl_Frame *state, void *arg)
 {
         struct unwind_info *ui = arg;
         Dwarf_Addr pc;
+        bool isactivation;
 
         if (!dwfl_frame_pc(state, &pc, NULL)) {
                 pr_err("%s", dwfl_errmsg(-1));
                 return DWARF_CB_ABORT;
         }
 
+        // report the module before we query for isactivation
+        report_module(pc, ui);
+
+        if (!dwfl_frame_pc(state, &pc, &isactivation)) {
+                pr_err("%s", dwfl_errmsg(-1));
+                return DWARF_CB_ABORT;
+        }
+
+        if (!isactivation)
+                --pc;
+
         return entry(pc, ui) || !(--ui->max_stack) ?
                DWARF_CB_ABORT : DWARF_CB_OK;
 }
@@ -220,7 +240,7 @@ int unwind__get_entries(unwind_entry_cb_t cb, void *arg,
 
         err = dwfl_getthread_frames(ui->dwfl, thread->tid, frame_callback, ui);
 
-        if (err && !ui->max_stack)
+        if (err && ui->max_stack != max_stack)
                 err = 0;
 
         /*
diff --git a/tools/perf/util/unwind-libunwind-local.c b/tools/perf/util/unwind-libunwind-local.c
index f8455bed6e65..672c2ada9357 100644
--- a/tools/perf/util/unwind-libunwind-local.c
+++ b/tools/perf/util/unwind-libunwind-local.c
@@ -692,6 +692,17 @@ static int get_entries(struct unwind_info *ui, unwind_entry_cb_t cb,
 
                 while (!ret && (unw_step(&c) > 0) && i < max_stack) {
                         unw_get_reg(&c, UNW_REG_IP, &ips[i]);
+
+                        /*
+                         * Decrement the IP for any non-activation frames.
+                         * this is required to properly find the srcline
+                         * for caller frames.
+                         * See also the documentation for dwfl_frame_pc(),
+                         * which this code tries to replicate.
+                         */
+                        if (unw_is_signal_frame(&c) <= 0)
+                                --ips[i];
+
                         ++i;
                 }
 
diff --git a/tools/perf/util/usage.c b/tools/perf/util/usage.c
index 996046a66fe5..6cc9d9888ce0 100644
--- a/tools/perf/util/usage.c
+++ b/tools/perf/util/usage.c
@@ -9,75 +9,17 @@
 #include "util.h"
 #include "debug.h"
 
-static void report(const char *prefix, const char *err, va_list params)
-{
-        char msg[1024];
-        vsnprintf(msg, sizeof(msg), err, params);
-        fprintf(stderr, " %s%s\n", prefix, msg);
-}
-
-static NORETURN void usage_builtin(const char *err)
+static __noreturn void usage_builtin(const char *err)
 {
         fprintf(stderr, "\n Usage: %s\n", err);
         exit(129);
 }
 
-static NORETURN void die_builtin(const char *err, va_list params)
-{
-        report(" Fatal: ", err, params);
-        exit(128);
-}
-
-static void error_builtin(const char *err, va_list params)
-{
-        report(" Error: ", err, params);
-}
-
-static void warn_builtin(const char *warn, va_list params)
-{
-        report(" Warning: ", warn, params);
-}
-
 /* If we are in a dlopen()ed .so write to a global variable would segfault
  * (ugh), so keep things static. */
-static void (*usage_routine)(const char *err) NORETURN = usage_builtin;
-static void (*error_routine)(const char *err, va_list params) = error_builtin;
-static void (*warn_routine)(const char *err, va_list params) = warn_builtin;
-
-void set_warning_routine(void (*routine)(const char *err, va_list params))
-{
-        warn_routine = routine;
-}
+static void (*usage_routine)(const char *err) __noreturn = usage_builtin;
 
 void usage(const char *err)
 {
         usage_routine(err);
 }
-
-void die(const char *err, ...)
-{
-        va_list params;
-
-        va_start(params, err);
-        die_builtin(err, params);
-        va_end(params);
-}
-
-int error(const char *err, ...)
-{
-        va_list params;
-
-        va_start(params, err);
-        error_routine(err, params);
-        va_end(params);
-        return -1;
-}
-
-void warning(const char *warn, ...)
-{
-        va_list params;
-
-        va_start(params, warn);
-        warn_routine(warn, params);
-        va_end(params);
-}
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 28c9f335006c..988111e0bab5 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -343,43 +343,6 @@ int perf_event_paranoid(void)
 
         return value;
 }
-
-bool find_process(const char *name)
-{
-        size_t len = strlen(name);
-        DIR *dir;
-        struct dirent *d;
-        int ret = -1;
-
-        dir = opendir(procfs__mountpoint());
-        if (!dir)
-                return false;
-
-        /* Walk through the directory. */
-        while (ret && (d = readdir(dir)) != NULL) {
-                char path[PATH_MAX];
-                char *data;
-                size_t size;
-
-                if ((d->d_type != DT_DIR) ||
-                     !strcmp(".", d->d_name) ||
-                     !strcmp("..", d->d_name))
-                        continue;
-
-                scnprintf(path, sizeof(path), "%s/%s/comm",
-                          procfs__mountpoint(), d->d_name);
-
-                if (filename__read_str(path, &data, &size))
-                        continue;
-
-                ret = strncmp(name, data, len);
-                free(data);
-        }
-
-        closedir(dir);
-        return ret ? false : true;
-}
-
 static int
 fetch_ubuntu_kernel_version(unsigned int *puint)
 {
@@ -387,8 +350,12 @@ fetch_ubuntu_kernel_version(unsigned int *puint)
         size_t line_len = 0;
         char *ptr, *line = NULL;
         int version, patchlevel, sublevel, err;
-        FILE *vsig = fopen("/proc/version_signature", "r");
+        FILE *vsig;
+
+        if (!puint)
+                return 0;
 
+        vsig = fopen("/proc/version_signature", "r");
         if (!vsig) {
                 pr_debug("Open /proc/version_signature failed: %s\n",
                          strerror(errno));
@@ -418,8 +385,7 @@ fetch_ubuntu_kernel_version(unsigned int *puint)
                 goto errout;
         }
 
-        if (puint)
-                *puint = (version << 16) + (patchlevel << 8) + sublevel;
+        *puint = (version << 16) + (patchlevel << 8) + sublevel;
         err = 0;
 errout:
         free(line);
@@ -446,6 +412,9 @@ fetch_kernel_version(unsigned int *puint, char *str,
                 str[str_size - 1] = '\0';
         }
 
+        if (!puint || int_ver_ready)
+                return 0;
+
         err = sscanf(utsname.release, "%d.%d.%d",
                      &version, &patchlevel, &sublevel);
 
@@ -455,8 +424,7 @@ fetch_kernel_version(unsigned int *puint, char *str,
                 return -1;
         }
 
-        if (puint && !int_ver_ready)
-                *puint = (version << 16) + (patchlevel << 8) + sublevel;
+        *puint = (version << 16) + (patchlevel << 8) + sublevel;
         return 0;
 }
 
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 5dfb9bb6482d..2c9e58a45310 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -1,7 +1,6 @@
 #ifndef GIT_COMPAT_UTIL_H
 #define GIT_COMPAT_UTIL_H
 
-#define _ALL_SOURCE 1
 #define _BSD_SOURCE 1
 /* glibc 2.20 deprecates _BSD_SOURCE in favour of _DEFAULT_SOURCE */
 #define _DEFAULT_SOURCE 1
@@ -11,24 +10,12 @@
 #include <stddef.h>
 #include <stdlib.h>
 #include <stdarg.h>
+#include <linux/compiler.h>
 #include <linux/types.h>
 
-#ifdef __GNUC__
-#define NORETURN __attribute__((__noreturn__))
-#else
-#define NORETURN
-#ifndef __attribute__
-#define __attribute__(x)
-#endif
-#endif
-
 /* General helper functions */
-void usage(const char *err) NORETURN;
-void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
-int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
-void warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
-
-void set_warning_routine(void (*routine)(const char *err, va_list params));
+void usage(const char *err) __noreturn;
+void die(const char *err, ...) __noreturn __printf(1, 2);
 
 static inline void *zalloc(size_t size)
 {
@@ -57,8 +44,6 @@ int hex2u64(const char *ptr, u64 *val);
 extern unsigned int page_size;
 extern int cacheline_size;
 
-bool find_process(const char *name);
-
 int fetch_kernel_version(unsigned int *puint,
                          char *str, size_t str_sz);
 #define KVER_VERSION(x)         (((x) >> 16) & 0xff)