106 files changed, 2521 insertions, 868 deletions

diff --git a/tools/hv/Makefile b/tools/hv/Makefile
index bd22f786a60c..99ffe61051a7 100644
--- a/tools/hv/Makefile
+++ b/tools/hv/Makefile
@@ -5,9 +5,9 @@ PTHREAD_LIBS = -lpthread
 WARNINGS = -Wall -Wextra
 CFLAGS = $(WARNINGS) -g $(PTHREAD_LIBS)
 
-all: hv_kvp_daemon hv_vss_daemon
+all: hv_kvp_daemon hv_vss_daemon hv_fcopy_daemon
 %: %.c
         $(CC) $(CFLAGS) -o $@ $^
 
 clean:
-        $(RM) hv_kvp_daemon hv_vss_daemon
+        $(RM) hv_kvp_daemon hv_vss_daemon hv_fcopy_daemon
diff --git a/tools/hv/hv_fcopy_daemon.c b/tools/hv/hv_fcopy_daemon.c
index f437d739f37d..9445d8f264a4 100644
--- a/tools/hv/hv_fcopy_daemon.c
+++ b/tools/hv/hv_fcopy_daemon.c
@@ -43,15 +43,9 @@ static int hv_start_fcopy(struct hv_start_fcopy *smsg)
         int error = HV_E_FAIL;
         char *q, *p;
 
-        /*
-         * If possile append a path seperator to the path.
-         */
-        if (strlen((char *)smsg->path_name) < (W_MAX_PATH - 2))
-                strcat((char *)smsg->path_name, "/");
-
         p = (char *)smsg->path_name;
         snprintf(target_fname, sizeof(target_fname), "%s/%s",
-                (char *)smsg->path_name, smsg->file_name);
+                 (char *)smsg->path_name, (char *)smsg->file_name);
 
         syslog(LOG_INFO, "Target file name: %s", target_fname);
         /*
@@ -137,7 +131,7 @@ void print_usage(char *argv[])
 
 int main(int argc, char *argv[])
 {
-        int fd, fcopy_fd, len;
+        int fcopy_fd, len;
         int error;
         int daemonize = 1, long_index = 0, opt;
         int version = FCOPY_CURRENT_VERSION;
diff --git a/tools/hv/hv_kvp_daemon.c b/tools/hv/hv_kvp_daemon.c
index 6a6432a20a1d..408bb076a234 100644
--- a/tools/hv/hv_kvp_daemon.c
+++ b/tools/hv/hv_kvp_daemon.c
@@ -147,7 +147,6 @@ static void kvp_release_lock(int pool)
 static void kvp_update_file(int pool)
 {
         FILE *filep;
-        size_t bytes_written;
 
         /*
          * We are going to write our in-memory registry out to
@@ -163,8 +162,7 @@ static void kvp_update_file(int pool)
                 exit(EXIT_FAILURE);
         }
 
-        bytes_written = fwrite(kvp_file_info[pool].records,
-                                sizeof(struct kvp_record),
+        fwrite(kvp_file_info[pool].records, sizeof(struct kvp_record),
                                 kvp_file_info[pool].num_records, filep);
 
         if (ferror(filep) || fclose(filep)) {
@@ -310,7 +308,7 @@ static int kvp_file_init(void)
         return 0;
 }
 
-static int kvp_key_delete(int pool, const char *key, int key_size)
+static int kvp_key_delete(int pool, const __u8 *key, int key_size)
 {
         int i;
         int j, k;
@@ -353,8 +351,8 @@ static int kvp_key_delete(int pool, const char *key, int key_size)
         return 1;
 }
 
-static int kvp_key_add_or_modify(int pool, const char *key, int key_size, const char *value,
-                        int value_size)
+static int kvp_key_add_or_modify(int pool, const __u8 *key, int key_size,
+                                 const __u8 *value, int value_size)
 {
         int i;
         int num_records;
@@ -407,7 +405,7 @@ static int kvp_key_add_or_modify(int pool, const char *key, int key_size, const
         return 0;
 }
 
-static int kvp_get_value(int pool, const char *key, int key_size, char *value,
+static int kvp_get_value(int pool, const __u8 *key, int key_size, __u8 *value,
                         int value_size)
 {
         int i;
@@ -439,8 +437,8 @@ static int kvp_get_value(int pool, const char *key, int key_size, char *value,
         return 1;
 }
 
-static int kvp_pool_enumerate(int pool, int index, char *key, int key_size,
-                                char *value, int value_size)
+static int kvp_pool_enumerate(int pool, int index, __u8 *key, int key_size,
+                                __u8 *value, int value_size)
 {
         struct kvp_record *record;
 
@@ -661,7 +659,7 @@ static char *kvp_if_name_to_mac(char *if_name)
         char    *p, *x;
         char    buf[256];
         char addr_file[256];
-        int i;
+        unsigned int i;
         char *mac_addr = NULL;
 
         snprintf(addr_file, sizeof(addr_file), "%s%s%s", "/sys/class/net/",
@@ -700,7 +698,7 @@ static char *kvp_mac_to_if_name(char *mac)
         char    buf[256];
         char *kvp_net_dir = "/sys/class/net/";
         char dev_id[256];
-        int i;
+        unsigned int i;
 
         dir = opendir(kvp_net_dir);
         if (dir == NULL)
@@ -750,7 +748,7 @@ static char *kvp_mac_to_if_name(char *mac)
 
 
 static void kvp_process_ipconfig_file(char *cmd,
-                                        char *config_buf, int len,
+                                        char *config_buf, unsigned int len,
                                         int element_size, int offset)
 {
         char buf[256];
@@ -768,7 +766,7 @@ static void kvp_process_ipconfig_file(char *cmd,
         if (offset == 0)
                 memset(config_buf, 0, len);
         while ((p = fgets(buf, sizeof(buf), file)) != NULL) {
-                if ((len - strlen(config_buf)) < (element_size + 1))
+                if (len < strlen(config_buf) + element_size + 1)
                         break;
 
                 x = strchr(p, '\n');
@@ -916,7 +914,7 @@ static int kvp_process_ip_address(void *addrp,
 
 static int
 kvp_get_ip_info(int family, char *if_name, int op,
-                 void  *out_buffer, int length)
+                 void  *out_buffer, unsigned int length)
 {
         struct ifaddrs *ifap;
         struct ifaddrs *curp;
@@ -1019,8 +1017,7 @@ kvp_get_ip_info(int family, char *if_name, int op,
                                         weight += hweight32(&w[i]);
 
                                 sprintf(cidr_mask, "/%d", weight);
-                                if ((length - sn_offset) <
-                                        (strlen(cidr_mask) + 1))
+                                if (length < sn_offset + strlen(cidr_mask) + 1)
                                         goto gather_ipaddr;
 
                                 if (sn_offset == 0)
@@ -1308,16 +1305,17 @@ static int kvp_set_ip_info(char *if_name, struct hv_kvp_ipaddr_value *new_val)
         if (error)
                 goto setval_error;
 
+        /*
+         * The dhcp_enabled flag is only for IPv4. In the case the host only
+         * injects an IPv6 address, the flag is true, but we still need to
+         * proceed to parse and pass the IPv6 information to the
+         * disto-specific script hv_set_ifconfig.
+         */
         if (new_val->dhcp_enabled) {
                 error = kvp_write_file(file, "BOOTPROTO", "", "dhcp");
                 if (error)
                         goto setval_error;
 
-                /*
-                 * We are done!.
-                 */
-                goto setval_done;
-
         } else {
                 error = kvp_write_file(file, "BOOTPROTO", "", "none");
                 if (error)
@@ -1345,7 +1343,6 @@ static int kvp_set_ip_info(char *if_name, struct hv_kvp_ipaddr_value *new_val)
         if (error)
                 goto setval_error;
 
-setval_done:
         fclose(file);
 
         /*
diff --git a/tools/lib/api/fs/debugfs.c b/tools/lib/api/fs/debugfs.c
index 86ea2d7b8845..d2b18e887071 100644
--- a/tools/lib/api/fs/debugfs.c
+++ b/tools/lib/api/fs/debugfs.c
@@ -1,3 +1,4 @@
+#define _GNU_SOURCE
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -98,3 +99,45 @@ char *debugfs_mount(const char *mountpoint)
 out:
         return debugfs_mountpoint;
 }
+
+int debugfs__strerror_open(int err, char *buf, size_t size, const char *filename)
+{
+        char sbuf[128];
+
+        switch (err) {
+        case ENOENT:
+                if (debugfs_found) {
+                        snprintf(buf, size,
+                                 "Error:\tFile %s/%s not found.\n"
+                                 "Hint:\tPerhaps this kernel misses some CONFIG_ setting to enable this feature?.\n",
+                                 debugfs_mountpoint, filename);
+                        break;
+                }
+                snprintf(buf, size, "%s",
+                         "Error:\tUnable to find debugfs\n"
+                         "Hint:\tWas your kernel compiled with debugfs support?\n"
+                         "Hint:\tIs the debugfs filesystem mounted?\n"
+                         "Hint:\tTry 'sudo mount -t debugfs nodev /sys/kernel/debug'");
+                break;
+        case EACCES:
+                snprintf(buf, size,
+                         "Error:\tNo permissions to read %s/%s\n"
+                         "Hint:\tTry 'sudo mount -o remount,mode=755 %s'\n",
+                         debugfs_mountpoint, filename, debugfs_mountpoint);
+                break;
+        default:
+                snprintf(buf, size, "%s", strerror_r(err, sbuf, sizeof(sbuf)));
+                break;
+        }
+
+        return 0;
+}
+
+int debugfs__strerror_open_tp(int err, char *buf, size_t size, const char *sys, const char *name)
+{
+        char path[PATH_MAX];
+
+        snprintf(path, PATH_MAX, "tracing/events/%s/%s", sys, name ?: "*");
+
+        return debugfs__strerror_open(err, buf, size, path);
+}
diff --git a/tools/lib/api/fs/debugfs.h b/tools/lib/api/fs/debugfs.h
index f19d3df9609d..0739881a9897 100644
--- a/tools/lib/api/fs/debugfs.h
+++ b/tools/lib/api/fs/debugfs.h
@@ -26,4 +26,7 @@ char *debugfs_mount(const char *mountpoint);
 
 extern char debugfs_mountpoint[];
 
+int debugfs__strerror_open(int err, char *buf, size_t size, const char *filename);
+int debugfs__strerror_open_tp(int err, char *buf, size_t size, const char *sys, const char *name);
+
 #endif /* __API_DEBUGFS_H__ */
diff --git a/tools/lib/lockdep/.gitignore b/tools/lib/lockdep/.gitignore
new file mode 100644
index 000000000000..cc0e7a9f99e3
--- /dev/null
+++ b/tools/lib/lockdep/.gitignore
@@ -0,0 +1 @@
+liblockdep.so.*
diff --git a/tools/lib/lockdep/Makefile b/tools/lib/lockdep/Makefile
index 52f9279c6c13..4b866c54f624 100644
--- a/tools/lib/lockdep/Makefile
+++ b/tools/lib/lockdep/Makefile
@@ -104,7 +104,7 @@ N		=
 
 export Q VERBOSE
 
-INCLUDES = -I. -I/usr/local/include -I./uinclude -I./include -I../../include $(CONFIG_INCLUDES)
+INCLUDES = -I. -I./uinclude -I./include -I../../include $(CONFIG_INCLUDES)
 
 # Set compile option CFLAGS if not set elsewhere
 CFLAGS ?= -g -DCONFIG_LOCKDEP -DCONFIG_STACKTRACE -DCONFIG_PROVE_LOCKING -DBITS_PER_LONG=__WORDSIZE -DLIBLOCKDEP_VERSION='"$(LIBLOCKDEP_VERSION)"' -rdynamic -O0 -g
diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index cf3a44bf1ec3..afe20ed9fac8 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <limits.h>
 
+#include <netinet/ip6.h>
 #include "event-parse.h"
 #include "event-utils.h"
 
@@ -4149,6 +4150,324 @@ static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
         trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
 }
 
+static void print_ip4_addr(struct trace_seq *s, char i, unsigned char *buf)
+{
+        const char *fmt;
+
+        if (i == 'i')
+                fmt = "%03d.%03d.%03d.%03d";
+        else
+                fmt = "%d.%d.%d.%d";
+
+        trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3]);
+}
+
+static inline bool ipv6_addr_v4mapped(const struct in6_addr *a)
+{
+        return ((unsigned long)(a->s6_addr32[0] | a->s6_addr32[1]) |
+                (unsigned long)(a->s6_addr32[2] ^ htonl(0x0000ffff))) == 0UL;
+}
+
+static inline bool ipv6_addr_is_isatap(const struct in6_addr *addr)
+{
+        return (addr->s6_addr32[2] | htonl(0x02000000)) == htonl(0x02005EFE);
+}
+
+static void print_ip6c_addr(struct trace_seq *s, unsigned char *addr)
+{
+        int i, j, range;
+        unsigned char zerolength[8];
+        int longest = 1;
+        int colonpos = -1;
+        uint16_t word;
+        uint8_t hi, lo;
+        bool needcolon = false;
+        bool useIPv4;
+        struct in6_addr in6;
+
+        memcpy(&in6, addr, sizeof(struct in6_addr));
+
+        useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
+
+        memset(zerolength, 0, sizeof(zerolength));
+
+        if (useIPv4)
+                range = 6;
+        else
+                range = 8;
+
+        /* find position of longest 0 run */
+        for (i = 0; i < range; i++) {
+                for (j = i; j < range; j++) {
+                        if (in6.s6_addr16[j] != 0)
+                                break;
+                        zerolength[i]++;
+                }
+        }
+        for (i = 0; i < range; i++) {
+                if (zerolength[i] > longest) {
+                        longest = zerolength[i];
+                        colonpos = i;
+                }
+        }
+        if (longest == 1)               /* don't compress a single 0 */
+                colonpos = -1;
+
+        /* emit address */
+        for (i = 0; i < range; i++) {
+                if (i == colonpos) {
+                        if (needcolon || i == 0)
+                                trace_seq_printf(s, ":");
+                        trace_seq_printf(s, ":");
+                        needcolon = false;
+                        i += longest - 1;
+                        continue;
+                }
+                if (needcolon) {
+                        trace_seq_printf(s, ":");
+                        needcolon = false;
+                }
+                /* hex u16 without leading 0s */
+                word = ntohs(in6.s6_addr16[i]);
+                hi = word >> 8;
+                lo = word & 0xff;
+                if (hi)
+                        trace_seq_printf(s, "%x%02x", hi, lo);
+                else
+                        trace_seq_printf(s, "%x", lo);
+
+                needcolon = true;
+        }
+
+        if (useIPv4) {
+                if (needcolon)
+                        trace_seq_printf(s, ":");
+                print_ip4_addr(s, 'I', &in6.s6_addr[12]);
+        }
+
+        return;
+}
+
+static void print_ip6_addr(struct trace_seq *s, char i, unsigned char *buf)
+{
+        int j;
+
+        for (j = 0; j < 16; j += 2) {
+                trace_seq_printf(s, "%02x%02x", buf[j], buf[j+1]);
+                if (i == 'I' && j < 14)
+                        trace_seq_printf(s, ":");
+        }
+}
+
+/*
+ * %pi4   print an IPv4 address with leading zeros
+ * %pI4   print an IPv4 address without leading zeros
+ * %pi6   print an IPv6 address without colons
+ * %pI6   print an IPv6 address with colons
+ * %pI6c  print an IPv6 address in compressed form with colons
+ * %pISpc print an IP address based on sockaddr; p adds port.
+ */
+static int print_ipv4_arg(struct trace_seq *s, const char *ptr, char i,
+                          void *data, int size, struct event_format *event,
+                          struct print_arg *arg)
+{
+        unsigned char *buf;
+
+        if (arg->type == PRINT_FUNC) {
+                process_defined_func(s, data, size, event, arg);
+                return 0;
+        }
+
+        if (arg->type != PRINT_FIELD) {
+                trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
+                return 0;
+        }
+
+        if (!arg->field.field) {
+                arg->field.field =
+                        pevent_find_any_field(event, arg->field.name);
+                if (!arg->field.field) {
+                        do_warning("%s: field %s not found",
+                                   __func__, arg->field.name);
+                        return 0;
+                }
+        }
+
+        buf = data + arg->field.field->offset;
+
+        if (arg->field.field->size != 4) {
+                trace_seq_printf(s, "INVALIDIPv4");
+                return 0;
+        }
+        print_ip4_addr(s, i, buf);
+
+        return 0;
+}
+
+static int print_ipv6_arg(struct trace_seq *s, const char *ptr, char i,
+                          void *data, int size, struct event_format *event,
+                          struct print_arg *arg)
+{
+        char have_c = 0;
+        unsigned char *buf;
+        int rc = 0;
+
+        /* pI6c */
+        if (i == 'I' && *ptr == 'c') {
+                have_c = 1;
+                ptr++;
+                rc++;
+        }
+
+        if (arg->type == PRINT_FUNC) {
+                process_defined_func(s, data, size, event, arg);
+                return rc;
+        }
+
+        if (arg->type != PRINT_FIELD) {
+                trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
+                return rc;
+        }
+
+        if (!arg->field.field) {
+                arg->field.field =
+                        pevent_find_any_field(event, arg->field.name);
+                if (!arg->field.field) {
+                        do_warning("%s: field %s not found",
+                                   __func__, arg->field.name);
+                        return rc;
+                }
+        }
+
+        buf = data + arg->field.field->offset;
+
+        if (arg->field.field->size != 16) {
+                trace_seq_printf(s, "INVALIDIPv6");
+                return rc;
+        }
+
+        if (have_c)
+                print_ip6c_addr(s, buf);
+        else
+                print_ip6_addr(s, i, buf);
+
+        return rc;
+}
+
+static int print_ipsa_arg(struct trace_seq *s, const char *ptr, char i,
+                          void *data, int size, struct event_format *event,
+                          struct print_arg *arg)
+{
+        char have_c = 0, have_p = 0;
+        unsigned char *buf;
+        struct sockaddr_storage *sa;
+        int rc = 0;
+
+        /* pISpc */
+        if (i == 'I') {
+                if (*ptr == 'p') {
+                        have_p = 1;
+                        ptr++;
+                        rc++;
+                }
+                if (*ptr == 'c') {
+                        have_c = 1;
+                        ptr++;
+                        rc++;
+                }
+        }
+
+        if (arg->type == PRINT_FUNC) {
+                process_defined_func(s, data, size, event, arg);
+                return rc;
+        }
+
+        if (arg->type != PRINT_FIELD) {
+                trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
+                return rc;
+        }
+
+        if (!arg->field.field) {
+                arg->field.field =
+                        pevent_find_any_field(event, arg->field.name);
+                if (!arg->field.field) {
+                        do_warning("%s: field %s not found",
+                                   __func__, arg->field.name);
+                        return rc;
+                }
+        }
+
+        sa = (struct sockaddr_storage *) (data + arg->field.field->offset);
+
+        if (sa->ss_family == AF_INET) {
+                struct sockaddr_in *sa4 = (struct sockaddr_in *) sa;
+
+                if (arg->field.field->size < sizeof(struct sockaddr_in)) {
+                        trace_seq_printf(s, "INVALIDIPv4");
+                        return rc;
+                }
+
+                print_ip4_addr(s, i, (unsigned char *) &sa4->sin_addr);
+                if (have_p)
+                        trace_seq_printf(s, ":%d", ntohs(sa4->sin_port));
+
+
+        } else if (sa->ss_family == AF_INET6) {
+                struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) sa;
+
+                if (arg->field.field->size < sizeof(struct sockaddr_in6)) {
+                        trace_seq_printf(s, "INVALIDIPv6");
+                        return rc;
+                }
+
+                if (have_p)
+                        trace_seq_printf(s, "[");
+
+                buf = (unsigned char *) &sa6->sin6_addr;
+                if (have_c)
+                        print_ip6c_addr(s, buf);
+                else
+                        print_ip6_addr(s, i, buf);
+
+                if (have_p)
+                        trace_seq_printf(s, "]:%d", ntohs(sa6->sin6_port));
+        }
+
+        return rc;
+}
+
+static int print_ip_arg(struct trace_seq *s, const char *ptr,
+                        void *data, int size, struct event_format *event,
+                        struct print_arg *arg)
+{
+        char i = *ptr;  /* 'i' or 'I' */
+        char ver;
+        int rc = 0;
+
+        ptr++;
+        rc++;
+
+        ver = *ptr;
+        ptr++;
+        rc++;
+
+        switch (ver) {
+        case '4':
+                rc += print_ipv4_arg(s, ptr, i, data, size, event, arg);
+                break;
+        case '6':
+                rc += print_ipv6_arg(s, ptr, i, data, size, event, arg);
+                break;
+        case 'S':
+                rc += print_ipsa_arg(s, ptr, i, data, size, event, arg);
+                break;
+        default:
+                return 0;
+        }
+
+        return rc;
+}
+
 static int is_printable_array(char *p, unsigned int len)
 {
         unsigned int i;
@@ -4337,6 +4656,15 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                                         ptr++;
                                         arg = arg->next;
                                         break;
+                                } else if (*(ptr+1) == 'I' || *(ptr+1) == 'i') {
+                                        int n;
+
+                                        n = print_ip_arg(s, ptr+1, data, size, event, arg);
+                                        if (n > 0) {
+                                                ptr += n;
+                                                arg = arg->next;
+                                                break;
+                                        }
                                 }
 
                                 /* fall through */
diff --git a/tools/perf/Documentation/perf-buildid-cache.txt b/tools/perf/Documentation/perf-buildid-cache.txt
index fd77d81ea748..0294c57b1f5e 100644
--- a/tools/perf/Documentation/perf-buildid-cache.txt
+++ b/tools/perf/Documentation/perf-buildid-cache.txt
@@ -38,7 +38,7 @@ OPTIONS
 --remove=::
         Remove specified file from the cache.
 -M::
---missing=:: 
+--missing=::
         List missing build ids in the cache for the specified file.
 -u::
 --update::
diff --git a/tools/perf/Documentation/perf-list.txt b/tools/perf/Documentation/perf-list.txt
index cbb4f743d921..3e2aec94f806 100644
--- a/tools/perf/Documentation/perf-list.txt
+++ b/tools/perf/Documentation/perf-list.txt
@@ -89,6 +89,19 @@ raw encoding of 0x1A8 can be used:
 You should refer to the processor specific documentation for getting these
 details. Some of them are referenced in the SEE ALSO section below.
 
+PARAMETERIZED EVENTS
+--------------------
+
+Some pmu events listed by 'perf-list' will be displayed with '?' in them. For
+example:
+
+  hv_gpci/dtbp_ptitc,phys_processor_idx=?/
+
+This means that when provided as an event, a value for '?' must
+also be supplied. For example:
+
+  perf stat -C 0 -e 'hv_gpci/dtbp_ptitc,phys_processor_idx=0x2/' ...
+
 OPTIONS
 -------
 
diff --git a/tools/perf/Documentation/perf-mem.txt b/tools/perf/Documentation/perf-mem.txt
index 1d78a4064da4..43310d8661fe 100644
--- a/tools/perf/Documentation/perf-mem.txt
+++ b/tools/perf/Documentation/perf-mem.txt
@@ -12,11 +12,12 @@ SYNOPSIS
 
 DESCRIPTION
 -----------
-"perf mem -t <TYPE> record" runs a command and gathers memory operation data
+"perf mem record" runs a command and gathers memory operation data
 from it, into perf.data. Perf record options are accepted and are passed through.
 
-"perf mem -t <TYPE> report" displays the result. It invokes perf report with the
-right set of options to display a memory access profile.
+"perf mem report" displays the result. It invokes perf report with the
+right set of options to display a memory access profile. By default, loads
+and stores are sampled. Use the -t option to limit to loads or stores.
 
 Note that on Intel systems the memory latency reported is the use-latency,
 not the pure load (or store latency). Use latency includes any pipeline
@@ -29,7 +30,7 @@ OPTIONS
 
 -t::
 --type=::
-        Select the memory operation type: load or store (default: load)
+        Select the memory operation type: load or store (default: load,store)
 
 -D::
 --dump-raw-samples=::
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index af9a54ece024..31e977459c51 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -33,12 +33,27 @@ OPTIONS
         - a raw PMU event (eventsel+umask) in the form of rNNN where NNN is a
           hexadecimal event descriptor.
 
-        - a hardware breakpoint event in the form of '\mem:addr[:access]'
+        - a symbolically formed PMU event like 'pmu/param1=0x3,param2/' where
+          'param1', 'param2', etc are defined as formats for the PMU in
+          /sys/bus/event_sources/devices/<pmu>/format/*.
+
+        - a symbolically formed event like 'pmu/config=M,config1=N,config3=K/'
+
+          where M, N, K are numbers (in decimal, hex, octal format). Acceptable
+          values for each of 'config', 'config1' and 'config2' are defined by
+          corresponding entries in /sys/bus/event_sources/devices/<pmu>/format/*
+          param1 and param2 are defined as formats for the PMU in:
+          /sys/bus/event_sources/devices/<pmu>/format/*
+
+        - a hardware breakpoint event in the form of '\mem:addr[/len][:access]'
           where addr is the address in memory you want to break in.
           Access is the memory access type (read, write, execute) it can
-          be passed as follows: '\mem:addr[:[r][w][x]]'.
+          be passed as follows: '\mem:addr[:[r][w][x]]'. len is the range,
+          number of bytes from specified addr, which the breakpoint will cover.
           If you want to profile read-write accesses in 0x1000, just set
           'mem:0x1000:rw'.
+          If you want to profile write accesses in [0x1000~1008), just set
+          'mem:0x1000/8:w'.
 
 --filter=<filter>::
         Event filter.
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index 21494806c0ab..a21eec05bc42 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -125,46 +125,46 @@ OPTIONS
         is equivalent to:
 
                 perf script -f trace:<fields> -f sw:<fields> -f hw:<fields>
-    
+
         i.e., the specified fields apply to all event types if the type string
         is not given.
-    
+
         The arguments are processed in the order received. A later usage can
         reset a prior request. e.g.:
-    
+
                 -f trace: -f comm,tid,time,ip,sym
-    
+
         The first -f suppresses trace events (field list is ""), but then the
         second invocation sets the fields to comm,tid,time,ip,sym. In this case a
         warning is given to the user:
-    
+
                 "Overriding previous field request for all events."
-    
+
         Alternatively, consider the order:
-    
+
                 -f comm,tid,time,ip,sym -f trace:
-    
+
         The first -f sets the fields for all events and the second -f
         suppresses trace events. The user is given a warning message about
         the override, and the result of the above is that only S/W and H/W
         events are displayed with the given fields.
-    
+
         For the 'wildcard' option if a user selected field is invalid for an
         event type, a message is displayed to the user that the option is
         ignored for that type. For example:
-    
+
                 $ perf script -f comm,tid,trace
                 'trace' not valid for hardware events. Ignoring.
                 'trace' not valid for software events. Ignoring.
-    
+
         Alternatively, if the type is given an invalid field is specified it
         is an error. For example:
-    
+
         perf script -v -f sw:comm,tid,trace
         'trace' not valid for software events.
-    
+
         At this point usage is displayed, and perf-script exits.
-    
+
         Finally, a user may not set fields to none for all event types.
         i.e., -f "" is not allowed.
 
diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
index 29ee857c09c6..04e150d83e7d 100644
--- a/tools/perf/Documentation/perf-stat.txt
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -25,10 +25,22 @@ OPTIONS
 
 -e::
 --event=::
-        Select the PMU event. Selection can be a symbolic event name
-        (use 'perf list' to list all events) or a raw PMU
-        event (eventsel+umask) in the form of rNNN where NNN is a
-         hexadecimal event descriptor.
+        Select the PMU event. Selection can be:
+
+        - a symbolic event name (use 'perf list' to list all events)
+
+        - a raw PMU event (eventsel+umask) in the form of rNNN where NNN is a
+          hexadecimal event descriptor.
+
+        - a symbolically formed event like 'pmu/param1=0x3,param2/' where
+          param1 and param2 are defined as formats for the PMU in
+          /sys/bus/event_sources/devices/<pmu>/format/*
+
+        - a symbolically formed event like 'pmu/config=M,config1=N,config2=K/'
+          where M, N, K are numbers (in decimal, hex, octal format).
+          Acceptable values for each of 'config', 'config1' and 'config2'
+          parameters are defined by corresponding entries in
+          /sys/bus/event_sources/devices/<pmu>/format/*
 
 -i::
 --no-inherit::
diff --git a/tools/perf/bench/futex.h b/tools/perf/bench/futex.h
index 71f2844cf97f..7ed22ff1e1ac 100644
--- a/tools/perf/bench/futex.h
+++ b/tools/perf/bench/futex.h
@@ -68,4 +68,17 @@ futex_cmp_requeue(u_int32_t *uaddr, u_int32_t val, u_int32_t *uaddr2, int nr_wak
                  val, opflags);
 }
 
+#ifndef HAVE_PTHREAD_ATTR_SETAFFINITY_NP
+#include <pthread.h>
+static inline int pthread_attr_setaffinity_np(pthread_attr_t *attr,
+                                              size_t cpusetsize,
+                                              cpu_set_t *cpuset)
+{
+        attr = attr;
+        cpusetsize = cpusetsize;
+        cpuset = cpuset;
+        return 0;
+}
+#endif
+
 #endif /* _FUTEX_H */
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
index 77d5cae54c6a..50e6b66aea1f 100644
--- a/tools/perf/builtin-buildid-cache.c
+++ b/tools/perf/builtin-buildid-cache.c
@@ -236,10 +236,10 @@ static bool dso__missing_buildid_cache(struct dso *dso, int parm __maybe_unused)
                 if (errno == ENOENT)
                         return false;
 
-                pr_warning("Problems with %s file, consider removing it from the cache\n", 
+                pr_warning("Problems with %s file, consider removing it from the cache\n",
                            filename);
         } else if (memcmp(dso->build_id, build_id, sizeof(dso->build_id))) {
-                pr_warning("Problems with %s file, consider removing it from the cache\n", 
+                pr_warning("Problems with %s file, consider removing it from the cache\n",
                            filename);
         }
 
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index 1fd96c13f199..74aada554b12 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -390,6 +390,15 @@ static void perf_evlist__collapse_resort(struct perf_evlist *evlist)
         }
 }
 
+static struct data__file *fmt_to_data_file(struct perf_hpp_fmt *fmt)
+{
+        struct diff_hpp_fmt *dfmt = container_of(fmt, struct diff_hpp_fmt, fmt);
+        void *ptr = dfmt - dfmt->idx;
+        struct data__file *d = container_of(ptr, struct data__file, fmt);
+
+        return d;
+}
+
 static struct hist_entry*
 get_pair_data(struct hist_entry *he, struct data__file *d)
 {
@@ -407,8 +416,7 @@ get_pair_data(struct hist_entry *he, struct data__file *d)
 static struct hist_entry*
 get_pair_fmt(struct hist_entry *he, struct diff_hpp_fmt *dfmt)
 {
-        void *ptr = dfmt - dfmt->idx;
-        struct data__file *d = container_of(ptr, struct data__file, fmt);
+        struct data__file *d = fmt_to_data_file(&dfmt->fmt);
 
         return get_pair_data(he, d);
 }
@@ -430,7 +438,7 @@ static void hists__baseline_only(struct hists *hists)
                 next = rb_next(&he->rb_node_in);
                 if (!hist_entry__next_pair(he)) {
                         rb_erase(&he->rb_node_in, root);
-                        hist_entry__free(he);
+                        hist_entry__delete(he);
                 }
         }
 }
@@ -448,26 +456,30 @@ static void hists__precompute(struct hists *hists)
         next = rb_first(root);
         while (next != NULL) {
                 struct hist_entry *he, *pair;
+                struct data__file *d;
+                int i;
 
                 he   = rb_entry(next, struct hist_entry, rb_node_in);
                 next = rb_next(&he->rb_node_in);
 
-                pair = get_pair_data(he, &data__files[sort_compute]);
-                if (!pair)
-                        continue;
+                data__for_each_file_new(i, d) {
+                        pair = get_pair_data(he, d);
+                        if (!pair)
+                                continue;
 
-                switch (compute) {
-                case COMPUTE_DELTA:
-                        compute_delta(he, pair);
-                        break;
-                case COMPUTE_RATIO:
-                        compute_ratio(he, pair);
-                        break;
-                case COMPUTE_WEIGHTED_DIFF:
-                        compute_wdiff(he, pair);
-                        break;
-                default:
-                        BUG_ON(1);
+                        switch (compute) {
+                        case COMPUTE_DELTA:
+                                compute_delta(he, pair);
+                                break;
+                        case COMPUTE_RATIO:
+                                compute_ratio(he, pair);
+                                break;
+                        case COMPUTE_WEIGHTED_DIFF:
+                                compute_wdiff(he, pair);
+                                break;
+                        default:
+                                BUG_ON(1);
+                        }
                 }
         }
 }
@@ -517,7 +529,7 @@ __hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
 
 static int64_t
 hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
-                        int c)
+                        int c, int sort_idx)
 {
         bool pairs_left  = hist_entry__has_pairs(left);
         bool pairs_right = hist_entry__has_pairs(right);
@@ -529,8 +541,8 @@ hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
         if (!pairs_left || !pairs_right)
                 return pairs_left ? -1 : 1;
 
-        p_left  = get_pair_data(left,  &data__files[sort_compute]);
-        p_right = get_pair_data(right, &data__files[sort_compute]);
+        p_left  = get_pair_data(left,  &data__files[sort_idx]);
+        p_right = get_pair_data(right, &data__files[sort_idx]);
 
         if (!p_left && !p_right)
                 return 0;
@@ -546,90 +558,102 @@ hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
 }
 
 static int64_t
-hist_entry__cmp_nop(struct hist_entry *left __maybe_unused,
+hist_entry__cmp_compute_idx(struct hist_entry *left, struct hist_entry *right,
+                            int c, int sort_idx)
+{
+        struct hist_entry *p_right, *p_left;
+
+        p_left  = get_pair_data(left,  &data__files[sort_idx]);
+        p_right = get_pair_data(right, &data__files[sort_idx]);
+
+        if (!p_left && !p_right)
+                return 0;
+
+        if (!p_left || !p_right)
+                return p_left ? -1 : 1;
+
+        if (c != COMPUTE_DELTA) {
+                /*
+                 * The delta can be computed without the baseline, but
+                 * others are not.  Put those entries which have no
+                 * values below.
+                 */
+                if (left->dummy && right->dummy)
+                        return 0;
+
+                if (left->dummy || right->dummy)
+                        return left->dummy ? 1 : -1;
+        }
+
+        return __hist_entry__cmp_compute(p_left, p_right, c);
+}
+
+static int64_t
+hist_entry__cmp_nop(struct perf_hpp_fmt *fmt __maybe_unused,
+                    struct hist_entry *left __maybe_unused,
                     struct hist_entry *right __maybe_unused)
 {
         return 0;
 }
 
 static int64_t
-hist_entry__cmp_baseline(struct hist_entry *left, struct hist_entry *right)
+hist_entry__cmp_baseline(struct perf_hpp_fmt *fmt __maybe_unused,
+                         struct hist_entry *left, struct hist_entry *right)
 {
-        if (sort_compute)
-                return 0;
-
         if (left->stat.period == right->stat.period)
                 return 0;
         return left->stat.period > right->stat.period ? 1 : -1;
 }
 
 static int64_t
-hist_entry__cmp_delta(struct hist_entry *left, struct hist_entry *right)
+hist_entry__cmp_delta(struct perf_hpp_fmt *fmt,
+                      struct hist_entry *left, struct hist_entry *right)
 {
-        return hist_entry__cmp_compute(right, left, COMPUTE_DELTA);
+        struct data__file *d = fmt_to_data_file(fmt);
+
+        return hist_entry__cmp_compute(right, left, COMPUTE_DELTA, d->idx);
 }
 
 static int64_t
-hist_entry__cmp_ratio(struct hist_entry *left, struct hist_entry *right)
+hist_entry__cmp_ratio(struct perf_hpp_fmt *fmt,
+                      struct hist_entry *left, struct hist_entry *right)
 {
-        return hist_entry__cmp_compute(right, left, COMPUTE_RATIO);
+        struct data__file *d = fmt_to_data_file(fmt);
+
+        return hist_entry__cmp_compute(right, left, COMPUTE_RATIO, d->idx);
 }
 
 static int64_t
-hist_entry__cmp_wdiff(struct hist_entry *left, struct hist_entry *right)
+hist_entry__cmp_wdiff(struct perf_hpp_fmt *fmt,
+                      struct hist_entry *left, struct hist_entry *right)
 {
-        return hist_entry__cmp_compute(right, left, COMPUTE_WEIGHTED_DIFF);
+        struct data__file *d = fmt_to_data_file(fmt);
+
+        return hist_entry__cmp_compute(right, left, COMPUTE_WEIGHTED_DIFF, d->idx);
 }
 
-static void insert_hist_entry_by_compute(struct rb_root *root,
-                                         struct hist_entry *he,
-                                         int c)
+static int64_t
+hist_entry__cmp_delta_idx(struct perf_hpp_fmt *fmt __maybe_unused,
+                          struct hist_entry *left, struct hist_entry *right)
 {
-        struct rb_node **p = &root->rb_node;
-        struct rb_node *parent = NULL;
-        struct hist_entry *iter;
-
-        while (*p != NULL) {
-                parent = *p;
-                iter = rb_entry(parent, struct hist_entry, rb_node);
-                if (hist_entry__cmp_compute(he, iter, c) < 0)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-
-        rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, root);
+        return hist_entry__cmp_compute_idx(right, left, COMPUTE_DELTA,
+                                           sort_compute);
 }
 
-static void hists__compute_resort(struct hists *hists)
+static int64_t
+hist_entry__cmp_ratio_idx(struct perf_hpp_fmt *fmt __maybe_unused,
+                          struct hist_entry *left, struct hist_entry *right)
 {
-        struct rb_root *root;
-        struct rb_node *next;
-
-        if (sort__need_collapse)
-                root = &hists->entries_collapsed;
-        else
-                root = hists->entries_in;
-
-        hists->entries = RB_ROOT;
-        next = rb_first(root);
-
-        hists__reset_stats(hists);
-        hists__reset_col_len(hists);
-
-        while (next != NULL) {
-                struct hist_entry *he;
-
-                he = rb_entry(next, struct hist_entry, rb_node_in);
-                next = rb_next(&he->rb_node_in);
-
-                insert_hist_entry_by_compute(&hists->entries, he, compute);
-                hists__inc_stats(hists, he);
+        return hist_entry__cmp_compute_idx(right, left, COMPUTE_RATIO,
+                                           sort_compute);
+}
 
-                if (!he->filtered)
-                        hists__calc_col_len(hists, he);
-        }
+static int64_t
+hist_entry__cmp_wdiff_idx(struct perf_hpp_fmt *fmt __maybe_unused,
+                          struct hist_entry *left, struct hist_entry *right)
+{
+        return hist_entry__cmp_compute_idx(right, left, COMPUTE_WEIGHTED_DIFF,
+                                           sort_compute);
 }
 
 static void hists__process(struct hists *hists)
@@ -637,12 +661,8 @@ static void hists__process(struct hists *hists)
         if (show_baseline_only)
                 hists__baseline_only(hists);
 
-        if (sort_compute) {
-                hists__precompute(hists);
-                hists__compute_resort(hists);
-        } else {
-                hists__output_resort(hists, NULL);
-        }
+        hists__precompute(hists);
+        hists__output_resort(hists, NULL);
 
         hists__fprintf(hists, true, 0, 0, 0, stdout);
 }
@@ -841,7 +861,7 @@ static int __hpp__color_compare(struct perf_hpp_fmt *fmt,
         char pfmt[20] = " ";
 
         if (!pair)
-                goto dummy_print;
+                goto no_print;
 
         switch (comparison_method) {
         case COMPUTE_DELTA:
@@ -850,8 +870,6 @@ static int __hpp__color_compare(struct perf_hpp_fmt *fmt,
                 else
                         diff = compute_delta(he, pair);
 
-                if (fabs(diff) < 0.01)
-                        goto dummy_print;
                 scnprintf(pfmt, 20, "%%%+d.2f%%%%", dfmt->header_width - 1);
                 return percent_color_snprintf(hpp->buf, hpp->size,
                                         pfmt, diff);
@@ -883,6 +901,9 @@ static int __hpp__color_compare(struct perf_hpp_fmt *fmt,
         }
 dummy_print:
         return scnprintf(hpp->buf, hpp->size, "%*s",
+                        dfmt->header_width, "N/A");
+no_print:
+        return scnprintf(hpp->buf, hpp->size, "%*s",
                         dfmt->header_width, pfmt);
 }
 
@@ -932,14 +953,15 @@ hpp__entry_pair(struct hist_entry *he, struct hist_entry *pair,
                 else
                         diff = compute_delta(he, pair);
 
-                if (fabs(diff) >= 0.01)
-                        scnprintf(buf, size, "%+4.2F%%", diff);
+                scnprintf(buf, size, "%+4.2F%%", diff);
                 break;
 
         case PERF_HPP_DIFF__RATIO:
                 /* No point for ratio number if we are dummy.. */
-                if (he->dummy)
+                if (he->dummy) {
+                        scnprintf(buf, size, "N/A");
                         break;
+                }
 
                 if (pair->diff.computed)
                         ratio = pair->diff.period_ratio;
@@ -952,8 +974,10 @@ hpp__entry_pair(struct hist_entry *he, struct hist_entry *pair,
 
         case PERF_HPP_DIFF__WEIGHTED_DIFF:
                 /* No point for wdiff number if we are dummy.. */
-                if (he->dummy)
+                if (he->dummy) {
+                        scnprintf(buf, size, "N/A");
                         break;
+                }
 
                 if (pair->diff.computed)
                         wdiff = pair->diff.wdiff;
@@ -1105,9 +1129,10 @@ static void data__hpp_register(struct data__file *d, int idx)
         perf_hpp__register_sort_field(fmt);
 }
 
-static void ui_init(void)
+static int ui_init(void)
 {
         struct data__file *d;
+        struct perf_hpp_fmt *fmt;
         int i;
 
         data__for_each_file(i, d) {
@@ -1137,6 +1162,46 @@ static void ui_init(void)
                         data__hpp_register(d, i ? PERF_HPP_DIFF__PERIOD :
                                                   PERF_HPP_DIFF__PERIOD_BASELINE);
         }
+
+        if (!sort_compute)
+                return 0;
+
+        /*
+         * Prepend an fmt to sort on columns at 'sort_compute' first.
+         * This fmt is added only to the sort list but not to the
+         * output fields list.
+         *
+         * Note that this column (data) can be compared twice - one
+         * for this 'sort_compute' fmt and another for the normal
+         * diff_hpp_fmt.  But it shouldn't a problem as most entries
+         * will be sorted out by first try or baseline and comparing
+         * is not a costly operation.
+         */
+        fmt = zalloc(sizeof(*fmt));
+        if (fmt == NULL) {
+                pr_err("Memory allocation failed\n");
+                return -1;
+        }
+
+        fmt->cmp      = hist_entry__cmp_nop;
+        fmt->collapse = hist_entry__cmp_nop;
+
+        switch (compute) {
+        case COMPUTE_DELTA:
+                fmt->sort = hist_entry__cmp_delta_idx;
+                break;
+        case COMPUTE_RATIO:
+                fmt->sort = hist_entry__cmp_ratio_idx;
+                break;
+        case COMPUTE_WEIGHTED_DIFF:
+                fmt->sort = hist_entry__cmp_wdiff_idx;
+                break;
+        default:
+                BUG_ON(1);
+        }
+
+        list_add(&fmt->sort_list, &perf_hpp__sort_list);
+        return 0;
 }
 
 static int data_init(int argc, const char **argv)
@@ -1202,7 +1267,8 @@ int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused)
         if (data_init(argc, argv) < 0)
                 return -1;
 
-        ui_init();
+        if (ui_init() < 0)
+                return -1;
 
         sort__mode = SORT_MODE__DIFF;
 
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index 84df2deed988..a13641e066f5 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -343,6 +343,7 @@ static int __cmd_inject(struct perf_inject *inject)
         int ret = -EINVAL;
         struct perf_session *session = inject->session;
         struct perf_data_file *file_out = &inject->output;
+        int fd = perf_data_file__fd(file_out);
 
         signal(SIGINT, sig_handler);
 
@@ -376,7 +377,7 @@ static int __cmd_inject(struct perf_inject *inject)
         }
 
         if (!file_out->is_pipe)
-                lseek(file_out->fd, session->header.data_offset, SEEK_SET);
+                lseek(fd, session->header.data_offset, SEEK_SET);
 
         ret = perf_session__process_events(session, &inject->tool);
 
@@ -385,7 +386,7 @@ static int __cmd_inject(struct perf_inject *inject)
                         perf_header__set_feat(&session->header,
                                               HEADER_BUILD_ID);
                 session->header.data_size = inject->bytes_written;
-                perf_session__write_header(session, session->evlist, file_out->fd, true);
+                perf_session__write_header(session, session->evlist, fd, true);
         }
 
         return ret;
diff --git a/tools/perf/builtin-mem.c b/tools/perf/builtin-mem.c
index 24db6ffe2957..9b5663950a4d 100644
--- a/tools/perf/builtin-mem.c
+++ b/tools/perf/builtin-mem.c
@@ -7,44 +7,47 @@
 #include "util/session.h"
 #include "util/data.h"
 
-#define MEM_OPERATION_LOAD      "load"
-#define MEM_OPERATION_STORE     "store"
-
-static const char       *mem_operation          = MEM_OPERATION_LOAD;
+#define MEM_OPERATION_LOAD      0x1
+#define MEM_OPERATION_STORE     0x2
 
 struct perf_mem {
         struct perf_tool        tool;
         char const              *input_name;
         bool                    hide_unresolved;
         bool                    dump_raw;
+        int                     operation;
         const char              *cpu_list;
         DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 };
 
-static int __cmd_record(int argc, const char **argv)
+static int __cmd_record(int argc, const char **argv, struct perf_mem *mem)
 {
         int rec_argc, i = 0, j;
         const char **rec_argv;
-        char event[64];
         int ret;
 
-        rec_argc = argc + 4;
+        rec_argc = argc + 7; /* max number of arguments */
         rec_argv = calloc(rec_argc + 1, sizeof(char *));
         if (!rec_argv)
                 return -1;
 
-        rec_argv[i++] = strdup("record");
-        if (!strcmp(mem_operation, MEM_OPERATION_LOAD))
-                rec_argv[i++] = strdup("-W");
-        rec_argv[i++] = strdup("-d");
-        rec_argv[i++] = strdup("-e");
+        rec_argv[i++] = "record";
 
-        if (strcmp(mem_operation, MEM_OPERATION_LOAD))
-                sprintf(event, "cpu/mem-stores/pp");
-        else
-                sprintf(event, "cpu/mem-loads/pp");
+        if (mem->operation & MEM_OPERATION_LOAD)
+                rec_argv[i++] = "-W";
+
+        rec_argv[i++] = "-d";
+
+        if (mem->operation & MEM_OPERATION_LOAD) {
+                rec_argv[i++] = "-e";
+                rec_argv[i++] = "cpu/mem-loads/pp";
+        }
+
+        if (mem->operation & MEM_OPERATION_STORE) {
+                rec_argv[i++] = "-e";
+                rec_argv[i++] = "cpu/mem-stores/pp";
+        }
 
-        rec_argv[i++] = strdup(event);
         for (j = 1; j < argc; j++, i++)
                 rec_argv[i] = argv[j];
 
@@ -162,17 +165,17 @@ static int report_events(int argc, const char **argv, struct perf_mem *mem)
         if (!rep_argv)
                 return -1;
 
-        rep_argv[i++] = strdup("report");
-        rep_argv[i++] = strdup("--mem-mode");
-        rep_argv[i++] = strdup("-n"); /* display number of samples */
+        rep_argv[i++] = "report";
+        rep_argv[i++] = "--mem-mode";
+        rep_argv[i++] = "-n"; /* display number of samples */
 
         /*
          * there is no weight (cost) associated with stores, so don't print
          * the column
          */
-        if (strcmp(mem_operation, MEM_OPERATION_LOAD))
-                rep_argv[i++] = strdup("--sort=mem,sym,dso,symbol_daddr,"
-                                       "dso_daddr,tlb,locked");
+        if (!(mem->operation & MEM_OPERATION_LOAD))
+                rep_argv[i++] = "--sort=mem,sym,dso,symbol_daddr,"
+                                "dso_daddr,tlb,locked";
 
         for (j = 1; j < argc; j++, i++)
                 rep_argv[i] = argv[j];
@@ -182,6 +185,75 @@ static int report_events(int argc, const char **argv, struct perf_mem *mem)
         return ret;
 }
 
+struct mem_mode {
+        const char *name;
+        int mode;
+};
+
+#define MEM_OPT(n, m) \
+        { .name = n, .mode = (m) }
+
+#define MEM_END { .name = NULL }
+
+static const struct mem_mode mem_modes[]={
+        MEM_OPT("load", MEM_OPERATION_LOAD),
+        MEM_OPT("store", MEM_OPERATION_STORE),
+        MEM_END
+};
+
+static int
+parse_mem_ops(const struct option *opt, const char *str, int unset)
+{
+        int *mode = (int *)opt->value;
+        const struct mem_mode *m;
+        char *s, *os = NULL, *p;
+        int ret = -1;
+
+        if (unset)
+                return 0;
+
+        /* str may be NULL in case no arg is passed to -t */
+        if (str) {
+                /* because str is read-only */
+                s = os = strdup(str);
+                if (!s)
+                        return -1;
+
+                /* reset mode */
+                *mode = 0;
+
+                for (;;) {
+                        p = strchr(s, ',');
+                        if (p)
+                                *p = '\0';
+
+                        for (m = mem_modes; m->name; m++) {
+                                if (!strcasecmp(s, m->name))
+                                        break;
+                        }
+                        if (!m->name) {
+                                fprintf(stderr, "unknown sampling op %s,"
+                                            " check man page\n", s);
+                                goto error;
+                        }
+
+                        *mode |= m->mode;
+
+                        if (!p)
+                                break;
+
+                        s = p + 1;
+                }
+        }
+        ret = 0;
+
+        if (*mode == 0)
+                *mode = MEM_OPERATION_LOAD;
+error:
+        free(os);
+        return ret;
+}
+
 int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
 {
         struct stat st;
@@ -197,10 +269,15 @@ int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
                         .ordered_events = true,
                 },
                 .input_name              = "perf.data",
+                /*
+                 * default to both load an store sampling
+                 */
+                .operation               = MEM_OPERATION_LOAD | MEM_OPERATION_STORE,
         };
         const struct option mem_options[] = {
-        OPT_STRING('t', "type", &mem_operation,
-                   "type", "memory operations(load/store)"),
+        OPT_CALLBACK('t', "type", &mem.operation,
+                   "type", "memory operations(load,store) Default load,store",
+                    parse_mem_ops),
         OPT_BOOLEAN('D', "dump-raw-samples", &mem.dump_raw,
                     "dump raw samples in ASCII"),
         OPT_BOOLEAN('U', "hide-unresolved", &mem.hide_unresolved,
@@ -225,7 +302,7 @@ int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
         argc = parse_options_subcommand(argc, argv, mem_options, mem_subcommands,
                                         mem_usage, PARSE_OPT_STOP_AT_NON_OPTION);
 
-        if (!argc || !(strncmp(argv[0], "rec", 3) || mem_operation))
+        if (!argc || !(strncmp(argv[0], "rec", 3) || mem.operation))
                 usage_with_options(mem_usage, mem_options);
 
         if (!mem.input_name || !strlen(mem.input_name)) {
@@ -236,7 +313,7 @@ int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
         }
 
         if (!strncmp(argv[0], "rec", 3))
-                return __cmd_record(argc, argv);
+                return __cmd_record(argc, argv, &mem);
         else if (!strncmp(argv[0], "rep", 3))
                 return report_events(argc, argv, &mem);
         else
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 8648c6d3003d..404ab3434052 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -190,16 +190,30 @@ out:
         return rc;
 }
 
+static int process_sample_event(struct perf_tool *tool,
+                                union perf_event *event,
+                                struct perf_sample *sample,
+                                struct perf_evsel *evsel,
+                                struct machine *machine)
+{
+        struct record *rec = container_of(tool, struct record, tool);
+
+        rec->samples++;
+
+        return build_id__mark_dso_hit(tool, event, sample, evsel, machine);
+}
+
 static int process_buildids(struct record *rec)
 {
         struct perf_data_file *file  = &rec->file;
         struct perf_session *session = rec->session;
-        u64 start = session->header.data_offset;
 
-        u64 size = lseek(file->fd, 0, SEEK_CUR);
+        u64 size = lseek(perf_data_file__fd(file), 0, SEEK_CUR);
         if (size == 0)
                 return 0;
 
+        file->size = size;
+
         /*
          * During this process, it'll load kernel map and replace the
          * dso->long_name to a real pathname it found.  In this case
@@ -211,9 +225,7 @@ static int process_buildids(struct record *rec)
          */
         symbol_conf.ignore_vmlinux_buildid = true;
 
-        return __perf_session__process_events(session, start,
-                                              size - start,
-                                              size, &build_id__mark_dso_hit_ops);
+        return perf_session__process_events(session, &rec->tool);
 }
 
 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
@@ -322,6 +334,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
         struct perf_data_file *file = &rec->file;
         struct perf_session *session;
         bool disabled = false, draining = false;
+        int fd;
 
         rec->progname = argv[0];
 
@@ -336,6 +349,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
                 return -1;
         }
 
+        fd = perf_data_file__fd(file);
         rec->session = session;
 
         record__init_features(rec);
@@ -360,12 +374,11 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
                 perf_header__clear_feat(&session->header, HEADER_GROUP_DESC);
 
         if (file->is_pipe) {
-                err = perf_header__write_pipe(file->fd);
+                err = perf_header__write_pipe(fd);
                 if (err < 0)
                         goto out_child;
         } else {
-                err = perf_session__write_header(session, rec->evlist,
-                                                 file->fd, false);
+                err = perf_session__write_header(session, rec->evlist, fd, false);
                 if (err < 0)
                         goto out_child;
         }
@@ -397,7 +410,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
                          * return this more properly and also
                          * propagate errors that now are calling die()
                          */
-                        err = perf_event__synthesize_tracing_data(tool, file->fd, rec->evlist,
+                        err = perf_event__synthesize_tracing_data(tool, fd, rec->evlist,
                                                                   process_synthesized_event);
                         if (err <= 0) {
                                 pr_err("Couldn't record tracing data.\n");
@@ -504,19 +517,9 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
                 goto out_child;
         }
 
-        if (!quiet) {
+        if (!quiet)
                 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
 
-                /*
-                 * Approximate RIP event size: 24 bytes.
-                 */
-                fprintf(stderr,
-                        "[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
-                        (double)rec->bytes_written / 1024.0 / 1024.0,
-                        file->path,
-                        rec->bytes_written / 24);
-        }
-
 out_child:
         if (forks) {
                 int exit_status;
@@ -535,13 +538,29 @@ out_child:
         } else
                 status = err;
 
+        /* this will be recalculated during process_buildids() */
+        rec->samples = 0;
+
         if (!err && !file->is_pipe) {
                 rec->session->header.data_size += rec->bytes_written;
 
                 if (!rec->no_buildid)
                         process_buildids(rec);
-                perf_session__write_header(rec->session, rec->evlist,
-                                           file->fd, true);
+                perf_session__write_header(rec->session, rec->evlist, fd, true);
+        }
+
+        if (!err && !quiet) {
+                char samples[128];
+
+                if (rec->samples)
+                        scnprintf(samples, sizeof(samples),
+                                  " (%" PRIu64 " samples)", rec->samples);
+                else
+                        samples[0] = '\0';
+
+                fprintf(stderr, "[ perf record: Captured and wrote %.3f MB %s%s ]\n",
+                        perf_data_file__size(file) / 1024.0 / 1024.0,
+                        file->path, samples);
         }
 
 out_delete_session:
@@ -720,6 +739,13 @@ static struct record record = {
                         .default_per_cpu = true,
                 },
         },
+        .tool = {
+                .sample         = process_sample_event,
+                .fork           = perf_event__process_fork,
+                .comm           = perf_event__process_comm,
+                .mmap           = perf_event__process_mmap,
+                .mmap2          = perf_event__process_mmap2,
+        },
 };
 
 #define CALLCHAIN_HELP "setup and enables call-graph (stack chain/backtrace) recording: "
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 072ae8ad67fc..2f91094e228b 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -86,17 +86,6 @@ static int report__config(const char *var, const char *value, void *cb)
         return perf_default_config(var, value, cb);
 }
 
-static void report__inc_stats(struct report *rep, struct hist_entry *he)
-{
-        /*
-         * The @he is either of a newly created one or an existing one
-         * merging current sample.  We only want to count a new one so
-         * checking ->nr_events being 1.
-         */
-        if (he->stat.nr_events == 1)
-                rep->nr_entries++;
-}
-
 static int hist_iter__report_callback(struct hist_entry_iter *iter,
                                       struct addr_location *al, bool single,
                                       void *arg)
@@ -108,8 +97,6 @@ static int hist_iter__report_callback(struct hist_entry_iter *iter,
         struct mem_info *mi;
         struct branch_info *bi;
 
-        report__inc_stats(rep, he);
-
         if (!ui__has_annotation())
                 return 0;
 
@@ -499,6 +486,9 @@ static int __cmd_report(struct report *rep)
 
         report__warn_kptr_restrict(rep);
 
+        evlist__for_each(session->evlist, pos)
+                rep->nr_entries += evsel__hists(pos)->nr_entries;
+
         if (use_browser == 0) {
                 if (verbose > 3)
                         perf_session__fprintf(session, stdout);
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 891086376381..e598e4e98170 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -1730,7 +1730,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
                     "detailed run - start a lot of events"),
         OPT_BOOLEAN('S', "sync", &sync_run,
                     "call sync() before starting a run"),
-        OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL, 
+        OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL,
                            "print large numbers with thousands\' separators",
                            stat__set_big_num),
         OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 616f0fcb4701..c4c7eac69de4 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -165,7 +165,7 @@ static void ui__warn_map_erange(struct map *map, struct symbol *sym, u64 ip)
                     err ? "[unknown]" : uts.release, perf_version_string);
         if (use_browser <= 0)
                 sleep(5);
-        
+
         map->erange_warned = true;
 }
 
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index badfabc6a01f..7e935f1083ec 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -929,66 +929,66 @@ static struct syscall_fmt {
           .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
         { .name     = "clock_gettime",  .errmsg = true, STRARRAY(0, clk_id, clockid), },
         { .name     = "close",      .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
         { .name     = "connect",    .errmsg = true, },
         { .name     = "dup",        .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "dup2",       .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "dup3",       .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "epoll_ctl",  .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
         { .name     = "eventfd2",   .errmsg = true,
           .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
         { .name     = "faccessat",  .errmsg = true,
           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
         { .name     = "fadvise64",  .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "fallocate",  .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "fchdir",     .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "fchmod",     .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "fchmodat",   .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
         { .name     = "fchown",     .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "fchownat",   .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
         { .name     = "fcntl",      .errmsg = true,
           .arg_scnprintf = { [0] = SCA_FD, /* fd */
                              [1] = SCA_STRARRAY, /* cmd */ },
           .arg_parm      = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
         { .name     = "fdatasync",  .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "flock",      .errmsg = true,
           .arg_scnprintf = { [0] = SCA_FD, /* fd */
                              [1] = SCA_FLOCK, /* cmd */ }, },
         { .name     = "fsetxattr",  .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "fstat",      .errmsg = true, .alias = "newfstat",
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "fstatat",    .errmsg = true, .alias = "newfstatat",
-          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
         { .name     = "fstatfs",    .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "fsync",    .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "ftruncate", .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "futex",      .errmsg = true,
           .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
         { .name     = "futimesat", .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
         { .name     = "getdents",   .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "getdents64", .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "getitimer",  .errmsg = true, STRARRAY(0, which, itimers), },
         { .name     = "getrlimit",  .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
         { .name     = "ioctl",      .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */
 #if defined(__i386__) || defined(__x86_64__)
 /*
  * FIXME: Make this available to all arches.
@@ -1002,7 +1002,7 @@ static struct syscall_fmt {
         { .name     = "kill",       .errmsg = true,
           .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
         { .name     = "linkat",     .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
         { .name     = "lseek",      .errmsg = true,
           .arg_scnprintf = { [0] = SCA_FD, /* fd */
                              [2] = SCA_STRARRAY, /* whence */ },
@@ -1012,9 +1012,9 @@ static struct syscall_fmt {
           .arg_scnprintf = { [0] = SCA_HEX,      /* start */
                              [2] = SCA_MADV_BHV, /* behavior */ }, },
         { .name     = "mkdirat",    .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
         { .name     = "mknodat",    .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
         { .name     = "mlock",      .errmsg = true,
           .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
         { .name     = "mlockall",   .errmsg = true,
@@ -1036,9 +1036,9 @@ static struct syscall_fmt {
         { .name     = "munmap",     .errmsg = true,
           .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
         { .name     = "name_to_handle_at", .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
         { .name     = "newfstatat", .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
         { .name     = "open",       .errmsg = true,
           .arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
         { .name     = "open_by_handle_at", .errmsg = true,
@@ -1052,20 +1052,20 @@ static struct syscall_fmt {
         { .name     = "poll",       .errmsg = true, .timeout = true, },
         { .name     = "ppoll",      .errmsg = true, .timeout = true, },
         { .name     = "pread",      .errmsg = true, .alias = "pread64",
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "preadv",     .errmsg = true, .alias = "pread",
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "prlimit64",  .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
         { .name     = "pwrite",     .errmsg = true, .alias = "pwrite64",
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "pwritev",    .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "read",       .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "readlinkat", .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
         { .name     = "readv",      .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "recvfrom",   .errmsg = true,
           .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
         { .name     = "recvmmsg",   .errmsg = true,
@@ -1073,7 +1073,7 @@ static struct syscall_fmt {
         { .name     = "recvmsg",    .errmsg = true,
           .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
         { .name     = "renameat",   .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
         { .name     = "rt_sigaction", .errmsg = true,
           .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
         { .name     = "rt_sigprocmask",  .errmsg = true, STRARRAY(0, how, sighow), },
@@ -1091,7 +1091,7 @@ static struct syscall_fmt {
         { .name     = "setitimer",  .errmsg = true, STRARRAY(0, which, itimers), },
         { .name     = "setrlimit",  .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
         { .name     = "shutdown",   .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "socket",     .errmsg = true,
           .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
                              [1] = SCA_SK_TYPE, /* type */ },
@@ -1102,7 +1102,7 @@ static struct syscall_fmt {
           .arg_parm      = { [0] = &strarray__socket_families, /* family */ }, },
         { .name     = "stat",       .errmsg = true, .alias = "newstat", },
         { .name     = "symlinkat",  .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
         { .name     = "tgkill",     .errmsg = true,
           .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
         { .name     = "tkill",      .errmsg = true,
@@ -1113,9 +1113,9 @@ static struct syscall_fmt {
         { .name     = "utimensat",  .errmsg = true,
           .arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */ }, },
         { .name     = "write",      .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
         { .name     = "writev",     .errmsg = true,
-          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, }, 
+          .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
 };
 
 static int syscall_fmt__cmp(const void *name, const void *fmtp)
@@ -1191,7 +1191,7 @@ static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
 
         if (thread__priv(thread) == NULL)
                 thread__set_priv(thread, thread_trace__new());
-                
+
         if (thread__priv(thread) == NULL)
                 goto fail;
 
@@ -2056,23 +2056,24 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
         if (trace->trace_syscalls &&
             perf_evlist__add_syscall_newtp(evlist, trace__sys_enter,
                                            trace__sys_exit))
-                goto out_error_tp;
+                goto out_error_raw_syscalls;
 
         if (trace->trace_syscalls)
                 perf_evlist__add_vfs_getname(evlist);
 
         if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
-            perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ))
-                goto out_error_tp;
+            perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ)) {
+                goto out_error_mem;
+        }
 
         if ((trace->trace_pgfaults & TRACE_PFMIN) &&
             perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
-                goto out_error_tp;
+                goto out_error_mem;
 
         if (trace->sched &&
-                perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
-                                trace__sched_stat_runtime))
-                goto out_error_tp;
+            perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
+                                   trace__sched_stat_runtime))
+                goto out_error_sched_stat_runtime;
 
         err = perf_evlist__create_maps(evlist, &trace->opts.target);
         if (err < 0) {
@@ -2202,8 +2203,12 @@ out:
 {
         char errbuf[BUFSIZ];
 
-out_error_tp:
-        perf_evlist__strerror_tp(evlist, errno, errbuf, sizeof(errbuf));
+out_error_sched_stat_runtime:
+        debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
+        goto out_error;
+
+out_error_raw_syscalls:
+        debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
         goto out_error;
 
 out_error_mmap:
@@ -2217,6 +2222,9 @@ out_error:
         fprintf(trace->output, "%s\n", errbuf);
         goto out_delete_evlist;
 }
+out_error_mem:
+        fprintf(trace->output, "Not enough memory to run!\n");
+        goto out_delete_evlist;
 }
 
 static int trace__replay(struct trace *trace)
diff --git a/tools/perf/config/Makefile b/tools/perf/config/Makefile
index 648e31ff4021..cc224080b525 100644
--- a/tools/perf/config/Makefile
+++ b/tools/perf/config/Makefile
@@ -198,6 +198,7 @@ CORE_FEATURE_TESTS =			\
         libpython-version               \
         libslang                        \
         libunwind                       \
+        pthread-attr-setaffinity-np     \
         stackprotector-all              \
         timerfd                         \
         libdw-dwarf-unwind              \
@@ -226,6 +227,7 @@ VF_FEATURE_TESTS =			\
         libelf-getphdrnum               \
         libelf-mmap                     \
         libpython-version               \
+        pthread-attr-setaffinity-np     \
         stackprotector-all              \
         timerfd                         \
         libunwind-debug-frame           \
@@ -301,6 +303,10 @@ ifeq ($(feature-sync-compare-and-swap), 1)
   CFLAGS += -DHAVE_SYNC_COMPARE_AND_SWAP_SUPPORT
 endif
 
+ifeq ($(feature-pthread-attr-setaffinity-np), 1)
+  CFLAGS += -DHAVE_PTHREAD_ATTR_SETAFFINITY_NP
+endif
+
 ifndef NO_BIONIC
   $(call feature_check,bionic)
   ifeq ($(feature-bionic), 1)
diff --git a/tools/perf/config/feature-checks/Makefile b/tools/perf/config/feature-checks/Makefile
index 53f19b5dbc37..42ac05aaf8ac 100644
--- a/tools/perf/config/feature-checks/Makefile
+++ b/tools/perf/config/feature-checks/Makefile
@@ -25,6 +25,7 @@ FILES=					\
         test-libslang.bin               \
         test-libunwind.bin              \
         test-libunwind-debug-frame.bin  \
+        test-pthread-attr-setaffinity-np.bin    \
         test-stackprotector-all.bin     \
         test-timerfd.bin                \
         test-libdw-dwarf-unwind.bin     \
@@ -47,6 +48,9 @@ test-all.bin:
 test-hello.bin:
         $(BUILD)
 
+test-pthread-attr-setaffinity-np.bin:
+        $(BUILD) -Werror -lpthread
+
 test-stackprotector-all.bin:
         $(BUILD) -Werror -fstack-protector-all
 
diff --git a/tools/perf/config/feature-checks/test-all.c b/tools/perf/config/feature-checks/test-all.c
index 652e0098eba6..6d4d09323922 100644
--- a/tools/perf/config/feature-checks/test-all.c
+++ b/tools/perf/config/feature-checks/test-all.c
@@ -97,6 +97,10 @@
 # include "test-zlib.c"
 #undef main
 
+#define main main_test_pthread_attr_setaffinity_np
+# include "test-pthread_attr_setaffinity_np.c"
+#undef main
+
 int main(int argc, char *argv[])
 {
         main_test_libpython();
@@ -121,6 +125,7 @@ int main(int argc, char *argv[])
         main_test_libdw_dwarf_unwind();
         main_test_sync_compare_and_swap(argc, argv);
         main_test_zlib();
+        main_test_pthread_attr_setaffinity_np();
 
         return 0;
 }
diff --git a/tools/perf/config/feature-checks/test-pthread-attr-setaffinity-np.c b/tools/perf/config/feature-checks/test-pthread-attr-setaffinity-np.c
new file mode 100644
index 000000000000..0a0d3ecb4e8a
--- /dev/null
+++ b/tools/perf/config/feature-checks/test-pthread-attr-setaffinity-np.c
@@ -0,0 +1,14 @@
+#include <stdint.h>
+#include <pthread.h>
+
+int main(void)
+{
+        int ret = 0;
+        pthread_attr_t thread_attr;
+
+        pthread_attr_init(&thread_attr);
+        /* don't care abt exact args, just the API itself in libpthread */
+        ret = pthread_attr_setaffinity_np(&thread_attr, 0, NULL);
+
+        return ret;
+}
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Context.c b/tools/perf/scripts/perl/Perf-Trace-Util/Context.c
index 790ceba6ad3f..28431d1bbcf5 100644
--- a/tools/perf/scripts/perl/Perf-Trace-Util/Context.c
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Context.c
@@ -5,7 +5,10 @@
  *      ANY CHANGES MADE HERE WILL BE LOST! 
  *
  */
-
+#include <stdbool.h>
+#ifndef HAS_BOOL
+# define HAS_BOOL 1
+#endif
 #line 1 "Context.xs"
 /*
  * Context.xs.  XS interfaces for perf script.
diff --git a/tools/perf/tests/attr.py b/tools/perf/tests/attr.py
index c9b4b6269b51..1091bd47adfd 100644
--- a/tools/perf/tests/attr.py
+++ b/tools/perf/tests/attr.py
@@ -104,7 +104,6 @@ class Event(dict):
                 continue
             if not self.compare_data(self[t], other[t]):
                 log.warning("expected %s=%s, got %s" % (t, self[t], other[t]))
-                
 
 # Test file description needs to have following sections:
 # [config]
diff --git a/tools/perf/tests/hists_cumulate.c b/tools/perf/tests/hists_cumulate.c
index 8d110dec393e..18619966454c 100644
--- a/tools/perf/tests/hists_cumulate.c
+++ b/tools/perf/tests/hists_cumulate.c
@@ -140,7 +140,7 @@ static void del_hist_entries(struct hists *hists)
                 he = rb_entry(node, struct hist_entry, rb_node);
                 rb_erase(node, root_out);
                 rb_erase(&he->rb_node_in, root_in);
-                hist_entry__free(he);
+                hist_entry__delete(he);
         }
 }
 
diff --git a/tools/perf/tests/hists_output.c b/tools/perf/tests/hists_output.c
index f5547610da02..b52c9faea224 100644
--- a/tools/perf/tests/hists_output.c
+++ b/tools/perf/tests/hists_output.c
@@ -106,7 +106,7 @@ static void del_hist_entries(struct hists *hists)
                 he = rb_entry(node, struct hist_entry, rb_node);
                 rb_erase(node, root_out);
                 rb_erase(&he->rb_node_in, root_in);
-                hist_entry__free(he);
+                hist_entry__delete(he);
         }
 }
 
diff --git a/tools/perf/tests/make b/tools/perf/tests/make
index 69a71ff84e01..75709d2b17b4 100644
--- a/tools/perf/tests/make
+++ b/tools/perf/tests/make
@@ -222,7 +222,6 @@ tarpkg:
         @cmd="$(PERF)/tests/perf-targz-src-pkg $(PERF)"; \
         echo "- $@: $$cmd" && echo $$cmd > $@ && \
         ( eval $$cmd ) >> $@ 2>&1
-        
 
 all: $(run) $(run_O) tarpkg
         @echo OK
diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index 7f2f51f93619..1cdab0ce00e2 100644
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -1145,6 +1145,49 @@ static int test__pinned_group(struct perf_evlist *evlist)
         return 0;
 }
 
+static int test__checkevent_breakpoint_len(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
+
+        TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config", 0 == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong bp_type", (HW_BREAKPOINT_R | HW_BREAKPOINT_W) ==
+                                         evsel->attr.bp_type);
+        TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_1 ==
+                                        evsel->attr.bp_len);
+
+        return 0;
+}
+
+static int test__checkevent_breakpoint_len_w(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
+
+        TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config", 0 == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong bp_type", HW_BREAKPOINT_W ==
+                                         evsel->attr.bp_type);
+        TEST_ASSERT_VAL("wrong bp_len", HW_BREAKPOINT_LEN_2 ==
+                                        evsel->attr.bp_len);
+
+        return 0;
+}
+
+static int
+test__checkevent_breakpoint_len_rw_modifier(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
+
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+
+        return test__checkevent_breakpoint_rw(evlist);
+}
+
 static int count_tracepoints(void)
 {
         char events_path[PATH_MAX];
@@ -1420,6 +1463,21 @@ static struct evlist_test test__events[] = {
                 .check = test__pinned_group,
                 .id    = 41,
         },
+        {
+                .name  = "mem:0/1",
+                .check = test__checkevent_breakpoint_len,
+                .id    = 42,
+        },
+        {
+                .name  = "mem:0/2:w",
+                .check = test__checkevent_breakpoint_len_w,
+                .id    = 43,
+        },
+        {
+                .name  = "mem:0/4:rw:u",
+                .check = test__checkevent_breakpoint_len_rw_modifier,
+                .id    = 44
+        },
 #if defined(__s390x__)
         {
                 .name  = "kvm-s390:kvm_s390_create_vm",
@@ -1471,7 +1529,7 @@ static int test_event(struct evlist_test *e)
         } else {
                 ret = e->check(evlist);
         }
-        
+
         perf_evlist__delete(evlist);
 
         return ret;
diff --git a/tools/perf/tests/sample-parsing.c b/tools/perf/tests/sample-parsing.c
index 4908c648a597..30c02181e78b 100644
--- a/tools/perf/tests/sample-parsing.c
+++ b/tools/perf/tests/sample-parsing.c
@@ -110,7 +110,7 @@ static bool samples_same(const struct perf_sample *s1,
 
         if (type & PERF_SAMPLE_STACK_USER) {
                 COMP(user_stack.size);
-                if (memcmp(s1->user_stack.data, s1->user_stack.data,
+                if (memcmp(s1->user_stack.data, s2->user_stack.data,
                            s1->user_stack.size)) {
                         pr_debug("Samples differ at 'user_stack'\n");
                         return false;
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
index 1e0a2fd80115..9d32e3c0cfee 100644
--- a/tools/perf/ui/browsers/annotate.c
+++ b/tools/perf/ui/browsers/annotate.c
@@ -517,7 +517,7 @@ static bool annotate_browser__jump(struct annotate_browser *browser)
         }
 
         annotate_browser__set_top(browser, dl, idx);
-        
+
         return true;
 }
 
@@ -867,7 +867,6 @@ static void annotate_browser__mark_jump_targets(struct annotate_browser *browser
 
                 ++browser->nr_jumps;
         }
-                
 }
 
 static inline int width_jumps(int n)
diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c
index 482adae3cc44..25d608394d74 100644
--- a/tools/perf/ui/hist.c
+++ b/tools/perf/ui/hist.c
@@ -285,7 +285,8 @@ static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,				\
 }
 
 #define __HPP_SORT_FN(_type, _field)                                            \
-static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b)    \
+static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused,       \
+                                 struct hist_entry *a, struct hist_entry *b)    \
 {                                                                               \
         return __hpp__sort(a, b, he_get_##_field);                              \
 }
@@ -312,7 +313,8 @@ static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,				\
 }
 
 #define __HPP_SORT_ACC_FN(_type, _field)                                        \
-static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b)    \
+static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused,       \
+                                 struct hist_entry *a, struct hist_entry *b)    \
 {                                                                               \
         return __hpp__sort_acc(a, b, he_get_acc_##_field);                      \
 }
@@ -331,7 +333,8 @@ static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,				\
 }
 
 #define __HPP_SORT_RAW_FN(_type, _field)                                        \
-static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b)    \
+static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused,       \
+                                 struct hist_entry *a, struct hist_entry *b)    \
 {                                                                               \
         return __hpp__sort(a, b, he_get_raw_##_field);                          \
 }
@@ -361,7 +364,8 @@ HPP_PERCENT_ACC_FNS(overhead_acc, period)
 HPP_RAW_FNS(samples, nr_events)
 HPP_RAW_FNS(period, period)
 
-static int64_t hpp__nop_cmp(struct hist_entry *a __maybe_unused,
+static int64_t hpp__nop_cmp(struct perf_hpp_fmt *fmt __maybe_unused,
+                            struct hist_entry *a __maybe_unused,
                             struct hist_entry *b __maybe_unused)
 {
         return 0;
diff --git a/tools/perf/ui/progress.h b/tools/perf/ui/progress.h
index f34f89eb607c..717d39d3052b 100644
--- a/tools/perf/ui/progress.h
+++ b/tools/perf/ui/progress.h
@@ -4,12 +4,12 @@
 #include <linux/types.h>
 
 void ui_progress__finish(void);
- 
+
 struct ui_progress {
         const char *title;
         u64 curr, next, step, total;
 };
- 
+
 void ui_progress__init(struct ui_progress *p, u64 total, const char *title);
 void ui_progress__update(struct ui_progress *p, u64 adv);
 
diff --git a/tools/perf/ui/tui/helpline.c b/tools/perf/ui/tui/helpline.c
index 1c8b9afd5d6e..88f5143a5981 100644
--- a/tools/perf/ui/tui/helpline.c
+++ b/tools/perf/ui/tui/helpline.c
@@ -9,6 +9,7 @@
 #include "../libslang.h"
 
 char ui_helpline__last_msg[1024];
+bool tui_helpline__set;
 
 static void tui_helpline__pop(void)
 {
@@ -35,6 +36,8 @@ static int tui_helpline__show(const char *format, va_list ap)
                         sizeof(ui_helpline__last_msg) - backlog, format, ap);
         backlog += ret;
 
+        tui_helpline__set = true;
+
         if (ui_helpline__last_msg[backlog - 1] == '\n') {
                 ui_helpline__puts(ui_helpline__last_msg);
                 SLsmg_refresh();
diff --git a/tools/perf/ui/tui/setup.c b/tools/perf/ui/tui/setup.c
index 3c38f25b1695..b77e1d771363 100644
--- a/tools/perf/ui/tui/setup.c
+++ b/tools/perf/ui/tui/setup.c
@@ -17,6 +17,7 @@
 static volatile int ui__need_resize;
 
 extern struct perf_error_ops perf_tui_eops;
+extern bool tui_helpline__set;
 
 extern void hist_browser__init_hpp(void);
 
@@ -159,7 +160,7 @@ out:
 
 void ui__exit(bool wait_for_ok)
 {
-        if (wait_for_ok)
+        if (wait_for_ok && tui_helpline__set)
                 ui__question_window("Fatal Error",
                                     ui_helpline__last_msg,
                                     "Press any key...", 0);
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 79999ceaf2be..61bf9128e1f2 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -177,14 +177,17 @@ static int lock__parse(struct ins_operands *ops)
                 goto out_free_ops;
 
         ops->locked.ins = ins__find(name);
+        free(name);
+
         if (ops->locked.ins == NULL)
                 goto out_free_ops;
 
         if (!ops->locked.ins->ops)
                 return 0;
 
-        if (ops->locked.ins->ops->parse)
-                ops->locked.ins->ops->parse(ops->locked.ops);
+        if (ops->locked.ins->ops->parse &&
+            ops->locked.ins->ops->parse(ops->locked.ops) < 0)
+                goto out_free_ops;
 
         return 0;
 
@@ -208,6 +211,13 @@ static int lock__scnprintf(struct ins *ins, char *bf, size_t size,
 
 static void lock__delete(struct ins_operands *ops)
 {
+        struct ins *ins = ops->locked.ins;
+
+        if (ins && ins->ops->free)
+                ins->ops->free(ops->locked.ops);
+        else
+                ins__delete(ops->locked.ops);
+
         zfree(&ops->locked.ops);
         zfree(&ops->target.raw);
         zfree(&ops->target.name);
@@ -229,7 +239,7 @@ static int mov__parse(struct ins_operands *ops)
         *s = '\0';
         ops->source.raw = strdup(ops->raw);
         *s = ',';
-        
+
         if (ops->source.raw == NULL)
                 return -1;
 
@@ -531,8 +541,8 @@ static void disasm_line__init_ins(struct disasm_line *dl)
         if (!dl->ins->ops)
                 return;
 
-        if (dl->ins->ops->parse)
-                dl->ins->ops->parse(&dl->ops);
+        if (dl->ins->ops->parse && dl->ins->ops->parse(&dl->ops) < 0)
+                dl->ins = NULL;
 }
 
 static int disasm_line__parse(char *line, char **namep, char **rawp)
diff --git a/tools/perf/util/color.c b/tools/perf/util/color.c
index f4654183d391..55355b3d4f85 100644
--- a/tools/perf/util/color.c
+++ b/tools/perf/util/color.c
@@ -5,132 +5,6 @@
 
 int perf_use_color_default = -1;
 
-static int parse_color(const char *name, int len)
-{
-        static const char * const color_names[] = {
-                "normal", "black", "red", "green", "yellow",
-                "blue", "magenta", "cyan", "white"
-        };
-        char *end;
-        int i;
-
-        for (i = 0; i < (int)ARRAY_SIZE(color_names); i++) {
-                const char *str = color_names[i];
-                if (!strncasecmp(name, str, len) && !str[len])
-                        return i - 1;
-        }
-        i = strtol(name, &end, 10);
-        if (end - name == len && i >= -1 && i <= 255)
-                return i;
-        return -2;
-}
-
-static int parse_attr(const char *name, int len)
-{
-        static const int attr_values[] = { 1, 2, 4, 5, 7 };
-        static const char * const attr_names[] = {
-                "bold", "dim", "ul", "blink", "reverse"
-        };
-        unsigned int i;
-
-        for (i = 0; i < ARRAY_SIZE(attr_names); i++) {
-                const char *str = attr_names[i];
-                if (!strncasecmp(name, str, len) && !str[len])
-                        return attr_values[i];
-        }
-        return -1;
-}
-
-void color_parse(const char *value, const char *var, char *dst)
-{
-        color_parse_mem(value, strlen(value), var, dst);
-}
-
-void color_parse_mem(const char *value, int value_len, const char *var,
-                char *dst)
-{
-        const char *ptr = value;
-        int len = value_len;
-        int attr = -1;
-        int fg = -2;
-        int bg = -2;
-
-        if (!strncasecmp(value, "reset", len)) {
-                strcpy(dst, PERF_COLOR_RESET);
-                return;
-        }
-
-        /* [fg [bg]] [attr] */
-        while (len > 0) {
-                const char *word = ptr;
-                int val, wordlen = 0;
-
-                while (len > 0 && !isspace(word[wordlen])) {
-                        wordlen++;
-                        len--;
-                }
-
-                ptr = word + wordlen;
-                while (len > 0 && isspace(*ptr)) {
-                        ptr++;
-                        len--;
-                }
-
-                val = parse_color(word, wordlen);
-                if (val >= -1) {
-                        if (fg == -2) {
-                                fg = val;
-                                continue;
-                        }
-                        if (bg == -2) {
-                                bg = val;
-                                continue;
-                        }
-                        goto bad;
-                }
-                val = parse_attr(word, wordlen);
-                if (val < 0 || attr != -1)
-                        goto bad;
-                attr = val;
-        }
-
-        if (attr >= 0 || fg >= 0 || bg >= 0) {
-                int sep = 0;
-
-                *dst++ = '\033';
-                *dst++ = '[';
-                if (attr >= 0) {
-                        *dst++ = '0' + attr;
-                        sep++;
-                }
-                if (fg >= 0) {
-                        if (sep++)
-                                *dst++ = ';';
-                        if (fg < 8) {
-                                *dst++ = '3';
-                                *dst++ = '0' + fg;
-                        } else {
-                                dst += sprintf(dst, "38;5;%d", fg);
-                        }
-                }
-                if (bg >= 0) {
-                        if (sep++)
-                                *dst++ = ';';
-                        if (bg < 8) {
-                                *dst++ = '4';
-                                *dst++ = '0' + bg;
-                        } else {
-                                dst += sprintf(dst, "48;5;%d", bg);
-                        }
-                }
-                *dst++ = 'm';
-        }
-        *dst = 0;
-        return;
-bad:
-        die("bad color value '%.*s' for variable '%s'", value_len, value, var);
-}
-
 int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty)
 {
         if (value) {
diff --git a/tools/perf/util/color.h b/tools/perf/util/color.h
index 0a594b8a0c26..38146f922c54 100644
--- a/tools/perf/util/color.h
+++ b/tools/perf/util/color.h
@@ -30,8 +30,6 @@ extern int perf_use_color_default;
 int perf_color_default_config(const char *var, const char *value, void *cb);
 
 int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty);
-void color_parse(const char *value, const char *var, char *dst);
-void color_parse_mem(const char *value, int len, const char *var, char *dst);
 int color_vsnprintf(char *bf, size_t size, const char *color,
                     const char *fmt, va_list args);
 int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args);
diff --git a/tools/perf/util/dso.c b/tools/perf/util/dso.c
index 45be944d450a..c2f7d3b90966 100644
--- a/tools/perf/util/dso.c
+++ b/tools/perf/util/dso.c
@@ -532,12 +532,8 @@ dso_cache__read(struct dso *dso, u64 offset, u8 *data, ssize_t size)
                         break;
 
                 cache_offset = offset & DSO__DATA_CACHE_MASK;
-                ret = -EINVAL;
 
-                if (-1 == lseek(dso->data.fd, cache_offset, SEEK_SET))
-                        break;
-
-                ret = read(dso->data.fd, cache->data, DSO__DATA_CACHE_SIZE);
+                ret = pread(dso->data.fd, cache->data, DSO__DATA_CACHE_SIZE, cache_offset);
                 if (ret <= 0)
                         break;
 
diff --git a/tools/perf/util/dso.h b/tools/perf/util/dso.h
index 3782c82c6e44..ced92841ff97 100644
--- a/tools/perf/util/dso.h
+++ b/tools/perf/util/dso.h
@@ -139,6 +139,7 @@ struct dso {
                 u32              status_seen;
                 size_t           file_size;
                 struct list_head open_entry;
+                u64              frame_offset;
         } data;
 
         union { /* Tool specific area */
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index cbab1fb77b1d..28b8ce86bf12 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -1436,33 +1436,6 @@ size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp)
         return printed + fprintf(fp, "\n");
 }
 
-int perf_evlist__strerror_tp(struct perf_evlist *evlist __maybe_unused,
-                             int err, char *buf, size_t size)
-{
-        char sbuf[128];
-
-        switch (err) {
-        case ENOENT:
-                scnprintf(buf, size, "%s",
-                          "Error:\tUnable to find debugfs\n"
-                          "Hint:\tWas your kernel was compiled with debugfs support?\n"
-                          "Hint:\tIs the debugfs filesystem mounted?\n"
-                          "Hint:\tTry 'sudo mount -t debugfs nodev /sys/kernel/debug'");
-                break;
-        case EACCES:
-                scnprintf(buf, size,
-                          "Error:\tNo permissions to read %s/tracing/events/raw_syscalls\n"
-                          "Hint:\tTry 'sudo mount -o remount,mode=755 %s'\n",
-                          debugfs_mountpoint, debugfs_mountpoint);
-                break;
-        default:
-                scnprintf(buf, size, "%s", strerror_r(err, sbuf, sizeof(sbuf)));
-                break;
-        }
-
-        return 0;
-}
-
 int perf_evlist__strerror_open(struct perf_evlist *evlist __maybe_unused,
                                int err, char *buf, size_t size)
 {
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 0ba93f67ab94..c94a9e03ecf1 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -183,7 +183,6 @@ static inline struct perf_evsel *perf_evlist__last(struct perf_evlist *evlist)
 
 size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp);
 
-int perf_evlist__strerror_tp(struct perf_evlist *evlist, int err, char *buf, size_t size);
 int perf_evlist__strerror_open(struct perf_evlist *evlist, int err, char *buf, size_t size);
 int perf_evlist__strerror_mmap(struct perf_evlist *evlist, int err, char *buf, size_t size);
 
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 1e90c8557ede..ea51a90e20a0 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -709,6 +709,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts)
         if (opts->sample_weight)
                 perf_evsel__set_sample_bit(evsel, WEIGHT);
 
+        attr->task  = track;
         attr->mmap  = track;
         attr->mmap2 = track && !perf_missing_features.mmap2;
         attr->comm  = track;
@@ -797,6 +798,9 @@ int perf_evsel__enable(struct perf_evsel *evsel, int ncpus, int nthreads)
 
 int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
 {
+        if (ncpus == 0 || nthreads == 0)
+                return 0;
+
         if (evsel->system_wide)
                 nthreads = 1;
 
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index b20e40c74468..1f407f7352a7 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -2237,6 +2237,7 @@ static int check_magic_endian(u64 magic, uint64_t hdr_sz,
          * - unique number to identify actual perf.data files
          * - encode endianness of file
          */
+        ph->version = PERF_HEADER_VERSION_2;
 
         /* check magic number with one endianness */
         if (magic == __perf_magic2)
@@ -2247,7 +2248,6 @@ static int check_magic_endian(u64 magic, uint64_t hdr_sz,
                 return -1;
 
         ph->needs_swap = true;
-        ph->version = PERF_HEADER_VERSION_2;
 
         return 0;
 }
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 182395546ddc..70b48a65064c 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -241,6 +241,20 @@ static bool hists__decay_entry(struct hists *hists, struct hist_entry *he)
         return he->stat.period == 0;
 }
 
+static void hists__delete_entry(struct hists *hists, struct hist_entry *he)
+{
+        rb_erase(&he->rb_node, &hists->entries);
+
+        if (sort__need_collapse)
+                rb_erase(&he->rb_node_in, &hists->entries_collapsed);
+
+        --hists->nr_entries;
+        if (!he->filtered)
+                --hists->nr_non_filtered_entries;
+
+        hist_entry__delete(he);
+}
+
 void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
 {
         struct rb_node *next = rb_first(&hists->entries);
@@ -258,16 +272,7 @@ void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
                      (zap_kernel && n->level != '.') ||
                      hists__decay_entry(hists, n)) &&
                     !n->used) {
-                        rb_erase(&n->rb_node, &hists->entries);
-
-                        if (sort__need_collapse)
-                                rb_erase(&n->rb_node_in, &hists->entries_collapsed);
-
-                        --hists->nr_entries;
-                        if (!n->filtered)
-                                --hists->nr_non_filtered_entries;
-
-                        hist_entry__free(n);
+                        hists__delete_entry(hists, n);
                 }
         }
 }
@@ -281,16 +286,7 @@ void hists__delete_entries(struct hists *hists)
                 n = rb_entry(next, struct hist_entry, rb_node);
                 next = rb_next(&n->rb_node);
 
-                rb_erase(&n->rb_node, &hists->entries);
-
-                if (sort__need_collapse)
-                        rb_erase(&n->rb_node_in, &hists->entries_collapsed);
-
-                --hists->nr_entries;
-                if (!n->filtered)
-                        --hists->nr_non_filtered_entries;
-
-                hist_entry__free(n);
+                hists__delete_entry(hists, n);
         }
 }
 
@@ -433,6 +429,8 @@ static struct hist_entry *add_hist_entry(struct hists *hists,
         if (!he)
                 return NULL;
 
+        hists->nr_entries++;
+
         rb_link_node(&he->rb_node_in, parent, p);
         rb_insert_color(&he->rb_node_in, hists->entries_in);
 out:
@@ -915,7 +913,7 @@ hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
                 if (perf_hpp__should_skip(fmt))
                         continue;
 
-                cmp = fmt->cmp(left, right);
+                cmp = fmt->cmp(fmt, left, right);
                 if (cmp)
                         break;
         }
@@ -933,7 +931,7 @@ hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
                 if (perf_hpp__should_skip(fmt))
                         continue;
 
-                cmp = fmt->collapse(left, right);
+                cmp = fmt->collapse(fmt, left, right);
                 if (cmp)
                         break;
         }
@@ -941,7 +939,7 @@ hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
         return cmp;
 }
 
-void hist_entry__free(struct hist_entry *he)
+void hist_entry__delete(struct hist_entry *he)
 {
         zfree(&he->branch_info);
         zfree(&he->mem_info);
@@ -981,7 +979,7 @@ static bool hists__collapse_insert_entry(struct hists *hists __maybe_unused,
                                                 iter->callchain,
                                                 he->callchain);
                         }
-                        hist_entry__free(he);
+                        hist_entry__delete(he);
                         return false;
                 }
 
@@ -1063,7 +1061,7 @@ static int hist_entry__sort(struct hist_entry *a, struct hist_entry *b)
                 if (perf_hpp__should_skip(fmt))
                         continue;
 
-                cmp = fmt->sort(a, b);
+                cmp = fmt->sort(fmt, a, b);
                 if (cmp)
                         break;
         }
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 46bd50344f85..2b690d028907 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -119,7 +119,7 @@ int64_t hist_entry__collapse(struct hist_entry *left, struct hist_entry *right);
 int hist_entry__transaction_len(void);
 int hist_entry__sort_snprintf(struct hist_entry *he, char *bf, size_t size,
                               struct hists *hists);
-void hist_entry__free(struct hist_entry *);
+void hist_entry__delete(struct hist_entry *he);
 
 void hists__output_resort(struct hists *hists, struct ui_progress *prog);
 void hists__collapse_resort(struct hists *hists, struct ui_progress *prog);
@@ -195,9 +195,12 @@ struct perf_hpp_fmt {
                      struct hist_entry *he);
         int (*entry)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
                      struct hist_entry *he);
-        int64_t (*cmp)(struct hist_entry *a, struct hist_entry *b);
-        int64_t (*collapse)(struct hist_entry *a, struct hist_entry *b);
-        int64_t (*sort)(struct hist_entry *a, struct hist_entry *b);
+        int64_t (*cmp)(struct perf_hpp_fmt *fmt,
+                       struct hist_entry *a, struct hist_entry *b);
+        int64_t (*collapse)(struct perf_hpp_fmt *fmt,
+                            struct hist_entry *a, struct hist_entry *b);
+        int64_t (*sort)(struct perf_hpp_fmt *fmt,
+                        struct hist_entry *a, struct hist_entry *b);
 
         struct list_head list;
         struct list_head sort_list;
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index 6951a9d42339..0e42438b1e59 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -116,6 +116,22 @@ struct thread;
 #define map__for_each_symbol(map, pos, n)       \
         dso__for_each_symbol(map->dso, pos, n, map->type)
 
+/* map__for_each_symbol_with_name - iterate over the symbols in the given map
+ *                                  that have the given name
+ *
+ * @map: the 'struct map *' in which symbols itereated
+ * @sym_name: the symbol name
+ * @pos: the 'struct symbol *' to use as a loop cursor
+ * @filter: to use when loading the DSO
+ */
+#define __map__for_each_symbol_by_name(map, sym_name, pos, filter)      \
+        for (pos = map__find_symbol_by_name(map, sym_name, filter);     \
+             pos && strcmp(pos->name, sym_name) == 0;           \
+             pos = symbol__next_by_name(pos))
+
+#define map__for_each_symbol_by_name(map, sym_name, pos)                \
+        __map__for_each_symbol_by_name(map, sym_name, (pos), NULL)
+
 typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
 
 void map__init(struct map *map, enum map_type type,
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 77b43fe43d55..7f8ec6ce2823 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -526,7 +526,7 @@ do {					\
 }
 
 int parse_events_add_breakpoint(struct list_head *list, int *idx,
-                                void *ptr, char *type)
+                                void *ptr, char *type, u64 len)
 {
         struct perf_event_attr attr;
 
@@ -536,14 +536,15 @@ int parse_events_add_breakpoint(struct list_head *list, int *idx,
         if (parse_breakpoint_type(type, &attr))
                 return -EINVAL;
 
-        /*
-         * We should find a nice way to override the access length
-         * Provide some defaults for now
-         */
-        if (attr.bp_type == HW_BREAKPOINT_X)
-                attr.bp_len = sizeof(long);
-        else
-                attr.bp_len = HW_BREAKPOINT_LEN_4;
+        /* Provide some defaults if len is not specified */
+        if (!len) {
+                if (attr.bp_type == HW_BREAKPOINT_X)
+                        len = sizeof(long);
+                else
+                        len = HW_BREAKPOINT_LEN_4;
+        }
+
+        attr.bp_len = len;
 
         attr.type = PERF_TYPE_BREAKPOINT;
         attr.sample_period = 1;
@@ -1121,7 +1122,7 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
                 return;
 
         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
-                if (subsys_glob != NULL && 
+                if (subsys_glob != NULL &&
                     !strglobmatch(sys_dirent.d_name, subsys_glob))
                         continue;
 
@@ -1132,7 +1133,7 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
                         continue;
 
                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
-                        if (event_glob != NULL && 
+                        if (event_glob != NULL &&
                             !strglobmatch(evt_dirent.d_name, event_glob))
                                 continue;
 
@@ -1305,7 +1306,7 @@ static void print_symbol_events(const char *event_glob, unsigned type,
 
         for (i = 0; i < max; i++, syms++) {
 
-                if (event_glob != NULL && 
+                if (event_glob != NULL &&
                     !(strglobmatch(syms->symbol, event_glob) ||
                       (syms->alias && strglobmatch(syms->alias, event_glob))))
                         continue;
@@ -1366,7 +1367,7 @@ void print_events(const char *event_glob, bool name_only)
                 printf("\n");
 
                 printf("  %-50s [%s]\n",
-                       "mem:<addr>[:access]",
+                       "mem:<addr>[/len][:access]",
                         event_type_descriptors[PERF_TYPE_BREAKPOINT]);
                 printf("\n");
         }
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index db2cf78ff0f3..ff6e1fa4111e 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -71,6 +71,7 @@ struct parse_events_term {
         int type_val;
         int type_term;
         struct list_head list;
+        bool used;
 };
 
 struct parse_events_evlist {
@@ -104,7 +105,7 @@ int parse_events_add_numeric(struct list_head *list, int *idx,
 int parse_events_add_cache(struct list_head *list, int *idx,
                            char *type, char *op_result1, char *op_result2);
 int parse_events_add_breakpoint(struct list_head *list, int *idx,
-                                void *ptr, char *type);
+                                void *ptr, char *type, u64 len);
 int parse_events_add_pmu(struct list_head *list, int *idx,
                          char *pmu , struct list_head *head_config);
 enum perf_pmu_event_symbol_type
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index 906630bbf8eb..94eacb6c1ef7 100644
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -159,6 +159,7 @@ branch_type		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE
 <mem>{
 {modifier_bp}           { return str(yyscanner, PE_MODIFIER_BP); }
 :                       { return ':'; }
+"/"                     { return '/'; }
 {num_dec}               { return value(yyscanner, 10); }
 {num_hex}               { return value(yyscanner, 16); }
         /*
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index 93c4c9fbc922..72def077dbbf 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -326,6 +326,28 @@ PE_NAME_CACHE_TYPE
 }
 
 event_legacy_mem:
+PE_PREFIX_MEM PE_VALUE '/' PE_VALUE ':' PE_MODIFIER_BP sep_dc
+{
+        struct parse_events_evlist *data = _data;
+        struct list_head *list;
+
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
+                                             (void *) $2, $6, $4));
+        $$ = list;
+}
+|
+PE_PREFIX_MEM PE_VALUE '/' PE_VALUE sep_dc
+{
+        struct parse_events_evlist *data = _data;
+        struct list_head *list;
+
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
+                                             (void *) $2, NULL, $4));
+        $$ = list;
+}
+|
 PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
 {
         struct parse_events_evlist *data = _data;
@@ -333,7 +355,7 @@ PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
 
         ALLOC_LIST(list);
         ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
-                                             (void *) $2, $4));
+                                             (void *) $2, $4, 0));
         $$ = list;
 }
 |
@@ -344,7 +366,7 @@ PE_PREFIX_MEM PE_VALUE sep_dc
 
         ALLOC_LIST(list);
         ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
-                                             (void *) $2, NULL));
+                                             (void *) $2, NULL, 0));
         $$ = list;
 }
 
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
index f62dee7bd924..4a015f77e2b5 100644
--- a/tools/perf/util/parse-options.c
+++ b/tools/perf/util/parse-options.c
@@ -46,7 +46,7 @@ static int get_value(struct parse_opt_ctx_t *p,
                 return opterror(opt, "is not usable", flags);
 
         if (opt->flags & PARSE_OPT_EXCLUSIVE) {
-                if (p->excl_opt) {
+                if (p->excl_opt && p->excl_opt != opt) {
                         char msg[128];
 
                         if (((flags & OPT_SHORT) && p->excl_opt->short_name) ||
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index 5c9c4947cfb4..48411674da0f 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -551,31 +551,68 @@ static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
 }
 
 /*
+ * Term is a string term, and might be a param-term. Try to look up it's value
+ * in the remaining terms.
+ * - We have a term like "base-or-format-term=param-term",
+ * - We need to find the value supplied for "param-term" (with param-term named
+ *   in a config string) later on in the term list.
+ */
+static int pmu_resolve_param_term(struct parse_events_term *term,
+                                  struct list_head *head_terms,
+                                  __u64 *value)
+{
+        struct parse_events_term *t;
+
+        list_for_each_entry(t, head_terms, list) {
+                if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
+                        if (!strcmp(t->config, term->config)) {
+                                t->used = true;
+                                *value = t->val.num;
+                                return 0;
+                        }
+                }
+        }
+
+        if (verbose)
+                printf("Required parameter '%s' not specified\n", term->config);
+
+        return -1;
+}
+
+/*
  * Setup one of config[12] attr members based on the
  * user input data - term parameter.
  */
 static int pmu_config_term(struct list_head *formats,
                            struct perf_event_attr *attr,
                            struct parse_events_term *term,
+                           struct list_head *head_terms,
                            bool zero)
 {
         struct perf_pmu_format *format;
         __u64 *vp;
+        __u64 val;
+
+        /*
+         * If this is a parameter we've already used for parameterized-eval,
+         * skip it in normal eval.
+         */
+        if (term->used)
+                return 0;
 
         /*
-         * Support only for hardcoded and numnerial terms.
          * Hardcoded terms should be already in, so nothing
          * to be done for them.
          */
         if (parse_events__is_hardcoded_term(term))
                 return 0;
 
-        if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM)
-                return -EINVAL;
-
         format = pmu_find_format(formats, term->config);
-        if (!format)
+        if (!format) {
+                if (verbose)
+                        printf("Invalid event/parameter '%s'\n", term->config);
                 return -EINVAL;
+        }
 
         switch (format->value) {
         case PERF_PMU_FORMAT_VALUE_CONFIG:
@@ -592,11 +629,25 @@ static int pmu_config_term(struct list_head *formats,
         }
 
         /*
-         * XXX If we ever decide to go with string values for
-         * non-hardcoded terms, here's the place to translate
-         * them into value.
+         * Either directly use a numeric term, or try to translate string terms
+         * using event parameters.
          */
-        pmu_format_value(format->bits, term->val.num, vp, zero);
+        if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
+                val = term->val.num;
+        else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
+                if (strcmp(term->val.str, "?")) {
+                        if (verbose)
+                                pr_info("Invalid sysfs entry %s=%s\n",
+                                                term->config, term->val.str);
+                        return -EINVAL;
+                }
+
+                if (pmu_resolve_param_term(term, head_terms, &val))
+                        return -EINVAL;
+        } else
+                return -EINVAL;
+
+        pmu_format_value(format->bits, val, vp, zero);
         return 0;
 }
 
@@ -607,9 +658,10 @@ int perf_pmu__config_terms(struct list_head *formats,
 {
         struct parse_events_term *term;
 
-        list_for_each_entry(term, head_terms, list)
-                if (pmu_config_term(formats, attr, term, zero))
+        list_for_each_entry(term, head_terms, list) {
+                if (pmu_config_term(formats, attr, term, head_terms, zero))
                         return -EINVAL;
+        }
 
         return 0;
 }
@@ -767,10 +819,36 @@ void perf_pmu__set_format(unsigned long *bits, long from, long to)
                 set_bit(b, bits);
 }
 
+static int sub_non_neg(int a, int b)
+{
+        if (b > a)
+                return 0;
+        return a - b;
+}
+
 static char *format_alias(char *buf, int len, struct perf_pmu *pmu,
                           struct perf_pmu_alias *alias)
 {
-        snprintf(buf, len, "%s/%s/", pmu->name, alias->name);
+        struct parse_events_term *term;
+        int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name);
+
+        list_for_each_entry(term, &alias->terms, list) {
+                if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
+                        used += snprintf(buf + used, sub_non_neg(len, used),
+                                        ",%s=%s", term->config,
+                                        term->val.str);
+        }
+
+        if (sub_non_neg(len, used) > 0) {
+                buf[used] = '/';
+                used++;
+        }
+        if (sub_non_neg(len, used) > 0) {
+                buf[used] = '\0';
+                used++;
+        } else
+                buf[len - 1] = '\0';
+
         return buf;
 }
 
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 94a717bf007d..919937eb0be2 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -446,7 +446,7 @@ static int post_process_probe_trace_events(struct probe_trace_event *tevs,
         }
 
         for (i = 0; i < ntevs; i++) {
-                if (tevs[i].point.address) {
+                if (tevs[i].point.address && !tevs[i].point.retprobe) {
                         tmp = strdup(reloc_sym->name);
                         if (!tmp)
                                 return -ENOMEM;
@@ -2193,18 +2193,17 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
         return ret;
 }
 
-static char *looking_function_name;
-static int num_matched_functions;
-
-static int probe_function_filter(struct map *map __maybe_unused,
-                                      struct symbol *sym)
+static int find_probe_functions(struct map *map, char *name)
 {
-        if ((sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL) &&
-            strcmp(looking_function_name, sym->name) == 0) {
-                num_matched_functions++;
-                return 0;
+        int found = 0;
+        struct symbol *sym;
+
+        map__for_each_symbol_by_name(map, name, sym) {
+                if (sym->binding == STB_GLOBAL || sym->binding == STB_LOCAL)
+                        found++;
         }
-        return 1;
+
+        return found;
 }
 
 #define strdup_or_goto(str, label)      \
@@ -2222,10 +2221,10 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
         struct kmap *kmap = NULL;
         struct ref_reloc_sym *reloc_sym = NULL;
         struct symbol *sym;
-        struct rb_node *nd;
         struct probe_trace_event *tev;
         struct perf_probe_point *pp = &pev->point;
         struct probe_trace_point *tp;
+        int num_matched_functions;
         int ret, i;
 
         /* Init maps of given executable or kernel */
@@ -2242,10 +2241,8 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
          * Load matched symbols: Since the different local symbols may have
          * same name but different addresses, this lists all the symbols.
          */
-        num_matched_functions = 0;
-        looking_function_name = pp->function;
-        ret = map__load(map, probe_function_filter);
-        if (ret || num_matched_functions == 0) {
+        num_matched_functions = find_probe_functions(map, pp->function);
+        if (num_matched_functions == 0) {
                 pr_err("Failed to find symbol %s in %s\n", pp->function,
                         target ? : "kernel");
                 ret = -ENOENT;
@@ -2257,7 +2254,7 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
                 goto out;
         }
 
-        if (!pev->uprobes) {
+        if (!pev->uprobes && !pp->retprobe) {
                 kmap = map__kmap(map);
                 reloc_sym = kmap->ref_reloc_sym;
                 if (!reloc_sym) {
@@ -2275,7 +2272,8 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
         }
 
         ret = 0;
-        map__for_each_symbol(map, sym, nd) {
+
+        map__for_each_symbol_by_name(map, pp->function, sym) {
                 tev = (*tevs) + ret;
                 tp = &tev->point;
                 if (ret == num_matched_functions) {
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index 3dda85ca50c1..d906d0ad5d40 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -768,7 +768,7 @@ static PyObject *pyrf_evlist__get_pollfd(struct pyrf_evlist *pevlist,
                         Py_DECREF(file);
                         goto free_list;
                 }
-                        
+
                 Py_DECREF(file);
         }
 
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index d808a328f4dc..0c815a40a6e8 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -89,7 +89,7 @@ static void handler_call_die(const char *handler_name)
 
 /*
  * Insert val into into the dictionary and decrement the reference counter.
- * This is necessary for dictionaries since PyDict_SetItemString() does not 
+ * This is necessary for dictionaries since PyDict_SetItemString() does not
  * steal a reference, as opposed to PyTuple_SetItem().
  */
 static void pydict_set_item_string_decref(PyObject *dict, const char *key, PyObject *val)
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 5f0e05a76c05..0baf75f12b7c 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -274,7 +274,7 @@ void perf_tool__fill_defaults(struct perf_tool *tool)
         if (tool->id_index == NULL)
                 tool->id_index = process_id_index_stub;
 }
- 
+
 static void swap_sample_id_all(union perf_event *event, void *data)
 {
         void *end = (void *) event + event->header.size;
@@ -1251,9 +1251,9 @@ fetch_mmaped_event(struct perf_session *session,
 #define NUM_MMAPS 128
 #endif
 
-int __perf_session__process_events(struct perf_session *session,
-                                   u64 data_offset, u64 data_size,
-                                   u64 file_size, struct perf_tool *tool)
+static int __perf_session__process_events(struct perf_session *session,
+                                          u64 data_offset, u64 data_size,
+                                          u64 file_size, struct perf_tool *tool)
 {
         int fd = perf_data_file__fd(session->file);
         u64 head, page_offset, file_offset, file_pos, size;
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index dc26ebf60fe4..6d663dc76404 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -49,9 +49,6 @@ int perf_session__peek_event(struct perf_session *session, off_t file_offset,
                              union perf_event **event_ptr,
                              struct perf_sample *sample);
 
-int __perf_session__process_events(struct perf_session *session,
-                                   u64 data_offset, u64 data_size, u64 size,
-                                   struct perf_tool *tool);
 int perf_session__process_events(struct perf_session *session,
                                  struct perf_tool *tool);
 
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 9139dda9f9a3..7a39c1ed8d37 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1304,6 +1304,37 @@ static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
         return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
 }
 
+static int64_t __sort__hpp_cmp(struct perf_hpp_fmt *fmt,
+                               struct hist_entry *a, struct hist_entry *b)
+{
+        struct hpp_sort_entry *hse;
+
+        hse = container_of(fmt, struct hpp_sort_entry, hpp);
+        return hse->se->se_cmp(a, b);
+}
+
+static int64_t __sort__hpp_collapse(struct perf_hpp_fmt *fmt,
+                                    struct hist_entry *a, struct hist_entry *b)
+{
+        struct hpp_sort_entry *hse;
+        int64_t (*collapse_fn)(struct hist_entry *, struct hist_entry *);
+
+        hse = container_of(fmt, struct hpp_sort_entry, hpp);
+        collapse_fn = hse->se->se_collapse ?: hse->se->se_cmp;
+        return collapse_fn(a, b);
+}
+
+static int64_t __sort__hpp_sort(struct perf_hpp_fmt *fmt,
+                                struct hist_entry *a, struct hist_entry *b)
+{
+        struct hpp_sort_entry *hse;
+        int64_t (*sort_fn)(struct hist_entry *, struct hist_entry *);
+
+        hse = container_of(fmt, struct hpp_sort_entry, hpp);
+        sort_fn = hse->se->se_sort ?: hse->se->se_cmp;
+        return sort_fn(a, b);
+}
+
 static struct hpp_sort_entry *
 __sort_dimension__alloc_hpp(struct sort_dimension *sd)
 {
@@ -1322,9 +1353,9 @@ __sort_dimension__alloc_hpp(struct sort_dimension *sd)
         hse->hpp.entry = __sort__hpp_entry;
         hse->hpp.color = NULL;
 
-        hse->hpp.cmp = sd->entry->se_cmp;
-        hse->hpp.collapse = sd->entry->se_collapse ? : sd->entry->se_cmp;
-        hse->hpp.sort = sd->entry->se_sort ? : hse->hpp.collapse;
+        hse->hpp.cmp = __sort__hpp_cmp;
+        hse->hpp.collapse = __sort__hpp_collapse;
+        hse->hpp.sort = __sort__hpp_sort;
 
         INIT_LIST_HEAD(&hse->hpp.list);
         INIT_LIST_HEAD(&hse->hpp.sort_list);
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 06fcd1bf98b6..b24f9d8727a8 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -574,13 +574,16 @@ static int decompress_kmodule(struct dso *dso, const char *name,
         const char *ext = strrchr(name, '.');
         char tmpbuf[] = "/tmp/perf-kmod-XXXXXX";
 
-        if ((type != DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP &&
-             type != DSO_BINARY_TYPE__GUEST_KMODULE_COMP) ||
-            type != dso->symtab_type)
+        if (type != DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP &&
+            type != DSO_BINARY_TYPE__GUEST_KMODULE_COMP &&
+            type != DSO_BINARY_TYPE__BUILD_ID_CACHE)
                 return -1;
 
-        if (!ext || !is_supported_compression(ext + 1))
-                return -1;
+        if (!ext || !is_supported_compression(ext + 1)) {
+                ext = strrchr(dso->name, '.');
+                if (!ext || !is_supported_compression(ext + 1))
+                        return -1;
+        }
 
         fd = mkstemp(tmpbuf);
         if (fd < 0)
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index c24c5b83156c..a69066865a55 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -396,6 +396,7 @@ static struct symbol *symbols__find_by_name(struct rb_root *symbols,
                                             const char *name)
 {
         struct rb_node *n;
+        struct symbol_name_rb_node *s;
 
         if (symbols == NULL)
                 return NULL;
@@ -403,7 +404,6 @@ static struct symbol *symbols__find_by_name(struct rb_root *symbols,
         n = symbols->rb_node;
 
         while (n) {
-                struct symbol_name_rb_node *s;
                 int cmp;
 
                 s = rb_entry(n, struct symbol_name_rb_node, rb_node);
@@ -414,10 +414,24 @@ static struct symbol *symbols__find_by_name(struct rb_root *symbols,
                 else if (cmp > 0)
                         n = n->rb_right;
                 else
-                        return &s->sym;
+                        break;
         }
 
-        return NULL;
+        if (n == NULL)
+                return NULL;
+
+        /* return first symbol that has same name (if any) */
+        for (n = rb_prev(n); n; n = rb_prev(n)) {
+                struct symbol_name_rb_node *tmp;
+
+                tmp = rb_entry(n, struct symbol_name_rb_node, rb_node);
+                if (strcmp(tmp->sym.name, s->sym.name))
+                        break;
+
+                s = tmp;
+        }
+
+        return &s->sym;
 }
 
 struct symbol *dso__find_symbol(struct dso *dso,
@@ -436,6 +450,17 @@ struct symbol *dso__next_symbol(struct symbol *sym)
         return symbols__next(sym);
 }
 
+struct symbol *symbol__next_by_name(struct symbol *sym)
+{
+        struct symbol_name_rb_node *s = container_of(sym, struct symbol_name_rb_node, sym);
+        struct rb_node *n = rb_next(&s->rb_node);
+
+        return n ? &rb_entry(n, struct symbol_name_rb_node, rb_node)->sym : NULL;
+}
+
+ /*
+  * Teturns first symbol that matched with @name.
+  */
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
                                         const char *name)
 {
@@ -660,7 +685,7 @@ static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta,
         struct machine *machine = kmaps->machine;
         struct map *curr_map = map;
         struct symbol *pos;
-        int count = 0, moved = 0;       
+        int count = 0, moved = 0;
         struct rb_root *root = &dso->symbols[map->type];
         struct rb_node *next = rb_first(root);
         int kernel_range = 0;
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 9d602e9c6f59..1650dcb3a67b 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -231,6 +231,7 @@ struct symbol *dso__find_symbol(struct dso *dso, enum map_type type,
                                 u64 addr);
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
                                         const char *name);
+struct symbol *symbol__next_by_name(struct symbol *sym);
 
 struct symbol *dso__first_symbol(struct dso *dso, enum map_type type);
 struct symbol *dso__next_symbol(struct symbol *sym);
diff --git a/tools/perf/util/unwind-libunwind.c b/tools/perf/util/unwind-libunwind.c
index 6edf535f65c2..e3c40a520a25 100644
--- a/tools/perf/util/unwind-libunwind.c
+++ b/tools/perf/util/unwind-libunwind.c
@@ -266,14 +266,17 @@ static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine,
                                      u64 *fde_count)
 {
         int ret = -EINVAL, fd;
-        u64 offset;
+        u64 offset = dso->data.frame_offset;
 
-        fd = dso__data_fd(dso, machine);
-        if (fd < 0)
-                return -EINVAL;
+        if (offset == 0) {
+                fd = dso__data_fd(dso, machine);
+                if (fd < 0)
+                        return -EINVAL;
 
-        /* Check the .eh_frame section for unwinding info */
-        offset = elf_section_offset(fd, ".eh_frame_hdr");
+                /* Check the .eh_frame section for unwinding info */
+                offset = elf_section_offset(fd, ".eh_frame_hdr");
+                dso->data.frame_offset = offset;
+        }
 
         if (offset)
                 ret = unwind_spec_ehframe(dso, machine, offset,
@@ -287,14 +290,20 @@ static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine,
 static int read_unwind_spec_debug_frame(struct dso *dso,
                                         struct machine *machine, u64 *offset)
 {
-        int fd = dso__data_fd(dso, machine);
+        int fd;
+        u64 ofs = dso->data.frame_offset;
 
-        if (fd < 0)
-                return -EINVAL;
+        if (ofs == 0) {
+                fd = dso__data_fd(dso, machine);
+                if (fd < 0)
+                        return -EINVAL;
 
-        /* Check the .debug_frame section for unwinding info */
-        *offset = elf_section_offset(fd, ".debug_frame");
+                /* Check the .debug_frame section for unwinding info */
+                ofs = elf_section_offset(fd, ".debug_frame");
+                dso->data.frame_offset = ofs;
+        }
 
+        *offset = ofs;
         if (*offset)
                 return 0;
 
diff --git a/tools/power/acpi/common/cmfsize.c b/tools/power/acpi/common/cmfsize.c
index f4b953354ff7..eec688041500 100644
--- a/tools/power/acpi/common/cmfsize.c
+++ b/tools/power/acpi/common/cmfsize.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/acpi/common/getopt.c b/tools/power/acpi/common/getopt.c
index 2f0f34a36db4..5da129e10aa2 100644
--- a/tools/power/acpi/common/getopt.c
+++ b/tools/power/acpi/common/getopt.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/acpi/os_specific/service_layers/oslibcfs.c b/tools/power/acpi/os_specific/service_layers/oslibcfs.c
index c13ff9c51d74..b51e40a9a120 100644
--- a/tools/power/acpi/os_specific/service_layers/oslibcfs.c
+++ b/tools/power/acpi/os_specific/service_layers/oslibcfs.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c b/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c
index 0dc2485dedf5..92f1fd700344 100644
--- a/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c
+++ b/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/acpi/os_specific/service_layers/osunixdir.c b/tools/power/acpi/os_specific/service_layers/osunixdir.c
index 733f9e490fc4..e153fcb12b1a 100644
--- a/tools/power/acpi/os_specific/service_layers/osunixdir.c
+++ b/tools/power/acpi/os_specific/service_layers/osunixdir.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/acpi/os_specific/service_layers/osunixmap.c b/tools/power/acpi/os_specific/service_layers/osunixmap.c
index 99b47b6194a3..3853a7350440 100644
--- a/tools/power/acpi/os_specific/service_layers/osunixmap.c
+++ b/tools/power/acpi/os_specific/service_layers/osunixmap.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/acpi/os_specific/service_layers/osunixxf.c b/tools/power/acpi/os_specific/service_layers/osunixxf.c
index 7ccb073f8316..6858c0893c91 100644
--- a/tools/power/acpi/os_specific/service_layers/osunixxf.c
+++ b/tools/power/acpi/os_specific/service_layers/osunixxf.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/acpi/tools/acpidump/acpidump.h b/tools/power/acpi/tools/acpidump/acpidump.h
index a2d37d610639..84bdef0136cb 100644
--- a/tools/power/acpi/tools/acpidump/acpidump.h
+++ b/tools/power/acpi/tools/acpidump/acpidump.h
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/acpi/tools/acpidump/apdump.c b/tools/power/acpi/tools/acpidump/apdump.c
index 24d32968802d..c736adf5fb55 100644
--- a/tools/power/acpi/tools/acpidump/apdump.c
+++ b/tools/power/acpi/tools/acpidump/apdump.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/acpi/tools/acpidump/apfiles.c b/tools/power/acpi/tools/acpidump/apfiles.c
index d470046a6d81..8f2fe168228e 100644
--- a/tools/power/acpi/tools/acpidump/apfiles.c
+++ b/tools/power/acpi/tools/acpidump/apfiles.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/acpi/tools/acpidump/apmain.c b/tools/power/acpi/tools/acpidump/apmain.c
index 853b4da22c3e..d0ba6535f5af 100644
--- a/tools/power/acpi/tools/acpidump/apmain.c
+++ b/tools/power/acpi/tools/acpidump/apmain.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2014, Intel Corp.
+ * Copyright (C) 2000 - 2015, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/tools/power/cpupower/Makefile b/tools/power/cpupower/Makefile
index 2e2ba2efa0d9..3ed7c0476d48 100644
--- a/tools/power/cpupower/Makefile
+++ b/tools/power/cpupower/Makefile
@@ -209,7 +209,7 @@ $(OUTPUT)%.o: %.c
 
 $(OUTPUT)cpupower: $(UTIL_OBJS) $(OUTPUT)libcpupower.so.$(LIB_MAJ)
         $(ECHO) "  CC      " $@
-        $(QUIET) $(CC) $(CFLAGS) $(LDFLAGS) $(UTIL_OBJS) -lcpupower -lrt -lpci -L$(OUTPUT) -o $@
+        $(QUIET) $(CC) $(CFLAGS) $(LDFLAGS) $(UTIL_OBJS) -lcpupower -Wl,-rpath=./ -lrt -lpci -L$(OUTPUT) -o $@
         $(QUIET) $(STRIPCMD) $@
 
 $(OUTPUT)po/$(PACKAGE).pot: $(UTIL_SRC)
diff --git a/tools/power/x86/turbostat/turbostat.8 b/tools/power/x86/turbostat/turbostat.8
index 56bfb523c5bb..feea7ad9500b 100644
--- a/tools/power/x86/turbostat/turbostat.8
+++ b/tools/power/x86/turbostat/turbostat.8
@@ -9,40 +9,50 @@ turbostat \- Report processor frequency and idle statistics
 .br
 .B turbostat
 .RB [ Options ]
-.RB [ "\-i interval_sec" ]
+.RB [ "\--interval seconds" ]
 .SH DESCRIPTION
 \fBturbostat \fP reports processor topology, frequency,
-idle power-state statistics, temperature and power on modern X86 processors.
-Either \fBcommand\fP is forked and statistics are printed
-upon its completion, or statistics are printed periodically.
-
-\fBturbostat \fP
-must be run on root, and
-minimally requires that the processor
-supports an "invariant" TSC, plus the APERF and MPERF MSRs.
-Additional information is reported depending on hardware counter support.
-
+idle power-state statistics, temperature and power on X86 processors.
+There are two ways to invoke turbostat.
+The first method is to supply a
+\fBcommand\fP, which is forked and statistics are printed
+upon its completion.
+The second method is to omit the command,
+and turbostat displays statistics every 5 seconds.
+The 5-second interval can be changed using the --interval option.
+
+Some information is not available on older processors.
 .SS Options
-The \fB-p\fP option limits output to the 1st thread in 1st core of each package.
+\fB--Counter MSR#\fP shows the delta of the specified 64-bit MSR counter.
+.PP
+\fB--counter MSR#\fP shows the delta of the specified 32-bit MSR counter.
+.PP
+\fB--Dump\fP displays the raw counter values.
+.PP
+\fB--debug\fP displays additional system configuration information.  Invoking this parameter
+more than once may also enable internal turbostat debug information.
+.PP
+\fB--interval seconds\fP overrides the default 5-second measurement interval.
+.PP
+\fB--help\fP displays usage for the most common parameters.
 .PP
-The \fB-P\fP option limits output to the 1st thread in each Package.
+\fB--Joules\fP displays energy in Joules, rather than dividing Joules by time to print power in Watts.
 .PP
-The \fB-S\fP option limits output to a 1-line System Summary for each interval.
+\fB--MSR MSR#\fP shows the specified 64-bit MSR value.
 .PP
-The \fB-v\fP option increases verbosity.
+\fB--msr MSR#\fP shows the specified 32-bit MSR value.
 .PP
-The \fB-c MSR#\fP option includes the delta of the specified 32-bit MSR counter.
+\fB--Package\fP limits output to the system summary plus the 1st thread in each Package.
 .PP
-The \fB-C MSR#\fP option includes the delta of the specified 64-bit MSR counter.
+\fB--processor\fP limits output to the system summary plus the 1st thread in each processor of each package.  Ie. it skips hyper-threaded siblings.
 .PP
-The \fB-m MSR#\fP option includes the the specified 32-bit MSR value.
+\fB--Summary\fP limits output to a 1-line System Summary for each interval.
 .PP
-The \fB-M MSR#\fP option includes the the specified 64-bit MSR value.
+\fB--TCC temperature\fP sets the Thermal Control Circuit temperature for systems which do not export that value.  This is used for making sense of the Digital Thermal Sensor outputs, as they return degrees Celsius below the TCC activation temperature.
 .PP
-The \fB-i interval_sec\fP option prints statistics every \fiinterval_sec\fP seconds.
-The default is 5 seconds.
+\fB--version\fP displays the version.
 .PP
-The \fBcommand\fP parameter forks \fBcommand\fP and upon its exit,
+The \fBcommand\fP parameter forks \fBcommand\fP, and upon its exit,
 displays the statistics gathered since it was forked.
 .PP
 .SH FIELD DESCRIPTIONS
@@ -52,7 +62,7 @@ displays the statistics gathered since it was forked.
 \fBCPU\fP Linux CPU (logical processor) number.
 Note that multiple CPUs per core indicate support for Intel(R) Hyper-Threading Technology.
 \fBAVG_MHz\fP number of cycles executed divided by time elapsed.
-\fB%Buzy\fP percent of the interval that the CPU retired instructions, aka. % of time in "C0" state.
+\fB%Busy\fP percent of the interval that the CPU retired instructions, aka. % of time in "C0" state.
 \fBBzy_MHz\fP average clock rate while the CPU was busy (in "c0" state).
 \fBTSC_MHz\fP average MHz that the TSC ran during the entire interval.
 \fBCPU%c1, CPU%c3, CPU%c6, CPU%c7\fP show the percentage residency in hardware core idle states.
@@ -68,7 +78,7 @@ Note that multiple CPUs per core indicate support for Intel(R) Hyper-Threading T
 .fi
 .PP
 .SH EXAMPLE
-Without any parameters, turbostat prints out counters ever 5 seconds.
+Without any parameters, turbostat displays statistics ever 5 seconds.
 (override interval with "-i sec" option, or specify a command
 for turbostat to fork).
 
@@ -91,19 +101,19 @@ Subsequent rows show per-CPU statistics.
        3       3       3    0.20    1596    3492       0    0.44    0.00   99.37    0.00      23
        3       7       5    0.31    1596    3492       0    0.33
 .fi
-.SH VERBOSE EXAMPLE
-The "-v" option adds verbosity to the output:
+.SH DEBUG EXAMPLE
+The "--debug" option prints additional system information before measurements:
 
 .nf
-[root@ivy]# turbostat -v
-turbostat v3.0 November 23, 2012 - Len Brown <lenb@kernel.org>
+turbostat version 4.0 10-Feb, 2015 - Len Brown <lenb@kernel.org>
 CPUID(0): GenuineIntel 13 CPUID levels; family:model:stepping 0x6:3a:9 (6:58:9)
 CPUID(6): APERF, DTS, PTM, EPB
-RAPL: 851 sec. Joule Counter Range
+RAPL: 851 sec. Joule Counter Range, at 77 Watts
 cpu0: MSR_NHM_PLATFORM_INFO: 0x81010f0012300
 16 * 100 = 1600 MHz max efficiency
 35 * 100 = 3500 MHz TSC frequency
-cpu0: MSR_NHM_SNB_PKG_CST_CFG_CTL: 0x1e008402 (UNdemote-C3, UNdemote-C1, demote-C3, demote-C1, locked: pkg-cstate-limit=2: pc6-noret)
+cpu0: MSR_IA32_POWER_CTL: 0x0014005d (C1E auto-promotion: DISabled)
+cpu0: MSR_NHM_SNB_PKG_CST_CFG_CTL: 0x1e008402 (UNdemote-C3, UNdemote-C1, demote-C3, demote-C1, locked: pkg-cstate-limit=2: pc6n)
 cpu0: MSR_NHM_TURBO_RATIO_LIMIT: 0x25262727
 37 * 100 = 3700 MHz max turbo 4 active cores
 38 * 100 = 3800 MHz max turbo 3 active cores
@@ -112,9 +122,9 @@ cpu0: MSR_NHM_TURBO_RATIO_LIMIT: 0x25262727
 cpu0: MSR_IA32_ENERGY_PERF_BIAS: 0x00000006 (balanced)
 cpu0: MSR_RAPL_POWER_UNIT: 0x000a1003 (0.125000 Watts, 0.000015 Joules, 0.000977 sec.)
 cpu0: MSR_PKG_POWER_INFO: 0x01e00268 (77 W TDP, RAPL 60 - 0 W, 0.000000 sec.)
-cpu0: MSR_PKG_POWER_LIMIT: 0x830000148268 (UNlocked)
+cpu0: MSR_PKG_POWER_LIMIT: 0x30000148268 (UNlocked)
 cpu0: PKG Limit #1: ENabled (77.000000 Watts, 1.000000 sec, clamp DISabled)
-cpu0: PKG Limit #2: ENabled (96.000000 Watts, 0.000977* sec, clamp DISabled)
+cpu0: PKG Limit #2: DISabled (96.000000 Watts, 0.000977* sec, clamp DISabled)
 cpu0: MSR_PP0_POLICY: 0
 cpu0: MSR_PP0_POWER_LIMIT: 0x00000000 (UNlocked)
 cpu0: Cores Limit: DISabled (0.000000 Watts, 0.000977 sec, clamp DISabled)
@@ -123,19 +133,20 @@ cpu0: MSR_PP1_POWER_LIMIT: 0x00000000 (UNlocked)
 cpu0: GFX Limit: DISabled (0.000000 Watts, 0.000977 sec, clamp DISabled)
 cpu0: MSR_IA32_TEMPERATURE_TARGET: 0x00691400 (105 C)
 cpu0: MSR_IA32_PACKAGE_THERM_STATUS: 0x884e0000 (27 C)
-cpu0: MSR_IA32_THERM_STATUS: 0x88560000 (19 C +/- 1)
-cpu1: MSR_IA32_THERM_STATUS: 0x88560000 (19 C +/- 1)
-cpu2: MSR_IA32_THERM_STATUS: 0x88540000 (21 C +/- 1)
+cpu0: MSR_IA32_THERM_STATUS: 0x88580000 (17 C +/- 1)
+cpu1: MSR_IA32_THERM_STATUS: 0x885a0000 (15 C +/- 1)
+cpu2: MSR_IA32_THERM_STATUS: 0x88570000 (18 C +/- 1)
 cpu3: MSR_IA32_THERM_STATUS: 0x884e0000 (27 C +/- 1)
  ...
 .fi
 The \fBmax efficiency\fP frequency, a.k.a. Low Frequency Mode, is the frequency
-available at the minimum package voltage.  The \fBTSC frequency\fP is the nominal
-maximum frequency of the processor if turbo-mode were not available.  This frequency
+available at the minimum package voltage.  The \fBTSC frequency\fP is the base
+frequency of the processor -- this should match the brand string
+in /proc/cpuinfo.  This base frequency
 should be sustainable on all CPUs indefinitely, given nominal power and cooling.
 The remaining rows show what maximum turbo frequency is possible
-depending on the number of idle cores.  Note that this information is
-not available on all processors.
+depending on the number of idle cores.  Note that not all information is
+available on all processors.
 .SH FORK EXAMPLE
 If turbostat is invoked with a command, it will fork that command
 and output the statistics gathered when the command exits.
@@ -176,6 +187,11 @@ not including any non-busy idle time.
 
 .B "turbostat "
 must be run as root.
+Alternatively, non-root users can be enabled to run turbostat this way:
+
+# setcap cap_sys_rawio=ep ./turbostat
+
+# chmod +r /dev/cpu/*/msr
 
 .B "turbostat "
 reads hardware counters, but doesn't write them.
@@ -184,15 +200,33 @@ multiple invocations of itself.
 
 \fBturbostat \fP
 may work poorly on Linux-2.6.20 through 2.6.29,
-as \fBacpi-cpufreq \fPperiodically cleared the APERF and MPERF
+as \fBacpi-cpufreq \fPperiodically cleared the APERF and MPERF MSRs
 in those kernels.
 
-If the TSC column does not make sense, then
-the other numbers will also make no sense.
-Turbostat is lightweight, and its data collection is not atomic.
-These issues are usually caused by an extremely short measurement
-interval (much less than 1 second), or system activity that prevents
-turbostat from being able to run on all CPUS to quickly collect data.
+AVG_MHz = APERF_delta/measurement_interval.  This is the actual
+number of elapsed cycles divided by the entire sample interval --
+including idle time.  Note that this calculation is resilient
+to systems lacking a non-stop TSC.
+
+TSC_MHz = TSC_delta/measurement_interval.
+On a system with an invariant TSC, this value will be constant
+and will closely match the base frequency value shown
+in the brand string in /proc/cpuinfo.  On a system where
+the TSC stops in idle, TSC_MHz will drop
+below the processor's base frequency.
+
+%Busy = MPERF_delta/TSC_delta
+
+Bzy_MHz = TSC_delta/APERF_delta/MPERF_delta/measurement_interval
+
+Note that these calculations depend on TSC_delta, so they
+are not reliable during intervals when TSC_MHz is not running at the base frequency.
+
+Turbostat data collection is not atomic.
+Extremely short measurement intervals (much less than 1 second),
+or system activity that prevents turbostat from being able
+to run on all CPUS to quickly collect data, will result in
+inconsistent results.
 
 The APERF, MPERF MSRs are defined to count non-halted cycles.
 Although it is not guaranteed by the architecture, turbostat assumes
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index 5b1b807265a1..2d089cac8580 100644
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -33,24 +33,29 @@
 #include <signal.h>
 #include <sys/time.h>
 #include <stdlib.h>
+#include <getopt.h>
 #include <dirent.h>
 #include <string.h>
 #include <ctype.h>
 #include <sched.h>
 #include <cpuid.h>
+#include <linux/capability.h>
+#include <errno.h>
 
 char *proc_stat = "/proc/stat";
-unsigned int interval_sec = 5;  /* set with -i interval_sec */
-unsigned int verbose;           /* set with -v */
-unsigned int rapl_verbose;      /* set with -R */
-unsigned int rapl_joules;       /* set with -J */
-unsigned int thermal_verbose;   /* set with -T */
-unsigned int summary_only;      /* set with -S */
-unsigned int dump_only;         /* set with -s */
+unsigned int interval_sec = 5;
+unsigned int debug;
+unsigned int rapl_joules;
+unsigned int summary_only;
+unsigned int dump_only;
 unsigned int skip_c0;
 unsigned int skip_c1;
 unsigned int do_nhm_cstates;
 unsigned int do_snb_cstates;
+unsigned int do_pc2;
+unsigned int do_pc3;
+unsigned int do_pc6;
+unsigned int do_pc7;
 unsigned int do_c8_c9_c10;
 unsigned int do_slm_cstates;
 unsigned int use_c1_residency_msr;
@@ -59,8 +64,8 @@ unsigned int has_epb;
 unsigned int units = 1000000;   /* MHz etc */
 unsigned int genuine_intel;
 unsigned int has_invariant_tsc;
-unsigned int do_nehalem_platform_info;
-unsigned int do_nehalem_turbo_ratio_limit;
+unsigned int do_nhm_platform_info;
+unsigned int do_nhm_turbo_ratio_limit;
 unsigned int do_ivt_turbo_ratio_limit;
 unsigned int extra_msr_offset32;
 unsigned int extra_msr_offset64;
@@ -81,6 +86,9 @@ unsigned int tcc_activation_temp;
 unsigned int tcc_activation_temp_override;
 double rapl_power_units, rapl_energy_units, rapl_time_units;
 double rapl_joule_counter_range;
+unsigned int do_core_perf_limit_reasons;
+unsigned int do_gfx_perf_limit_reasons;
+unsigned int do_ring_perf_limit_reasons;
 
 #define RAPL_PKG                (1 << 0)
                                         /* 0x610 MSR_PKG_POWER_LIMIT */
@@ -251,15 +259,13 @@ int get_msr(int cpu, off_t offset, unsigned long long *msr)
         sprintf(pathname, "/dev/cpu/%d/msr", cpu);
         fd = open(pathname, O_RDONLY);
         if (fd < 0)
-                return -1;
+                err(-1, "%s open failed, try chown or chmod +r /dev/cpu/*/msr, or run as root", pathname);
 
         retval = pread(fd, msr, sizeof *msr, offset);
         close(fd);
 
-        if (retval != sizeof *msr) {
-                fprintf(stderr, "%s offset 0x%llx read failed\n", pathname, (unsigned long long)offset);
-                return -1;
-        }
+        if (retval != sizeof *msr)
+                err(-1, "%s offset 0x%llx read failed", pathname, (unsigned long long)offset);
 
         return 0;
 }
@@ -281,7 +287,7 @@ void print_header(void)
                 outp += sprintf(outp, "     CPU");
         if (has_aperf)
                 outp += sprintf(outp, " Avg_MHz");
-        if (do_nhm_cstates)
+        if (has_aperf)
                 outp += sprintf(outp, "   %%Busy");
         if (has_aperf)
                 outp += sprintf(outp, " Bzy_MHz");
@@ -310,13 +316,13 @@ void print_header(void)
         if (do_ptm)
                 outp += sprintf(outp, "  PkgTmp");
 
-        if (do_snb_cstates)
+        if (do_pc2)
                 outp += sprintf(outp, " Pkg%%pc2");
-        if (do_nhm_cstates && !do_slm_cstates)
+        if (do_pc3)
                 outp += sprintf(outp, " Pkg%%pc3");
-        if (do_nhm_cstates && !do_slm_cstates)
+        if (do_pc6)
                 outp += sprintf(outp, " Pkg%%pc6");
-        if (do_snb_cstates)
+        if (do_pc7)
                 outp += sprintf(outp, " Pkg%%pc7");
         if (do_c8_c9_c10) {
                 outp += sprintf(outp, " Pkg%%pc8");
@@ -337,7 +343,7 @@ void print_header(void)
                         outp += sprintf(outp, "   PKG_%%");
                 if (do_rapl & RAPL_DRAM_PERF_STATUS)
                         outp += sprintf(outp, "   RAM_%%");
-        } else {
+        } else if (do_rapl && rapl_joules) {
                 if (do_rapl & RAPL_PKG)
                         outp += sprintf(outp, "   Pkg_J");
                 if (do_rapl & RAPL_CORES)
@@ -391,9 +397,12 @@ int dump_counters(struct thread_data *t, struct core_data *c,
         if (p) {
                 outp += sprintf(outp, "package: %d\n", p->package_id);
                 outp += sprintf(outp, "pc2: %016llX\n", p->pc2);
-                outp += sprintf(outp, "pc3: %016llX\n", p->pc3);
-                outp += sprintf(outp, "pc6: %016llX\n", p->pc6);
-                outp += sprintf(outp, "pc7: %016llX\n", p->pc7);
+                if (do_pc3)
+                        outp += sprintf(outp, "pc3: %016llX\n", p->pc3);
+                if (do_pc6)
+                        outp += sprintf(outp, "pc6: %016llX\n", p->pc6);
+                if (do_pc7)
+                        outp += sprintf(outp, "pc7: %016llX\n", p->pc7);
                 outp += sprintf(outp, "pc8: %016llX\n", p->pc8);
                 outp += sprintf(outp, "pc9: %016llX\n", p->pc9);
                 outp += sprintf(outp, "pc10: %016llX\n", p->pc10);
@@ -457,25 +466,25 @@ int format_counters(struct thread_data *t, struct core_data *c,
                         outp += sprintf(outp, "%8d", t->cpu_id);
         }
 
-        /* AvgMHz */
+        /* Avg_MHz */
         if (has_aperf)
                 outp += sprintf(outp, "%8.0f",
                         1.0 / units * t->aperf / interval_float);
 
-        /* %c0 */
-        if (do_nhm_cstates) {
+        /* %Busy */
+        if (has_aperf) {
                 if (!skip_c0)
                         outp += sprintf(outp, "%8.2f", 100.0 * t->mperf/t->tsc);
                 else
                         outp += sprintf(outp, "********");
         }
 
-        /* BzyMHz */
+        /* Bzy_MHz */
         if (has_aperf)
                 outp += sprintf(outp, "%8.0f",
                         1.0 * t->tsc / units * t->aperf / t->mperf / interval_float);
 
-        /* TSC */
+        /* TSC_MHz */
         outp += sprintf(outp, "%8.0f", 1.0 * t->tsc/units/interval_float);
 
         /* SMI */
@@ -525,13 +534,13 @@ int format_counters(struct thread_data *t, struct core_data *c,
         if (do_ptm)
                 outp += sprintf(outp, "%8d", p->pkg_temp_c);
 
-        if (do_snb_cstates)
+        if (do_pc2)
                 outp += sprintf(outp, "%8.2f", 100.0 * p->pc2/t->tsc);
-        if (do_nhm_cstates && !do_slm_cstates)
+        if (do_pc3)
                 outp += sprintf(outp, "%8.2f", 100.0 * p->pc3/t->tsc);
-        if (do_nhm_cstates && !do_slm_cstates)
+        if (do_pc6)
                 outp += sprintf(outp, "%8.2f", 100.0 * p->pc6/t->tsc);
-        if (do_snb_cstates)
+        if (do_pc7)
                 outp += sprintf(outp, "%8.2f", 100.0 * p->pc7/t->tsc);
         if (do_c8_c9_c10) {
                 outp += sprintf(outp, "%8.2f", 100.0 * p->pc8/t->tsc);
@@ -561,7 +570,7 @@ int format_counters(struct thread_data *t, struct core_data *c,
                         outp += sprintf(outp, fmt8, 100.0 * p->rapl_pkg_perf_status * rapl_time_units / interval_float);
                 if (do_rapl & RAPL_DRAM_PERF_STATUS)
                         outp += sprintf(outp, fmt8, 100.0 * p->rapl_dram_perf_status * rapl_time_units / interval_float);
-        } else {
+        } else if (do_rapl && rapl_joules) {
                 if (do_rapl & RAPL_PKG)
                         outp += sprintf(outp, fmt8,
                                         p->energy_pkg * rapl_energy_units);
@@ -578,8 +587,8 @@ int format_counters(struct thread_data *t, struct core_data *c,
                         outp += sprintf(outp, fmt8, 100.0 * p->rapl_pkg_perf_status * rapl_time_units / interval_float);
                 if (do_rapl & RAPL_DRAM_PERF_STATUS)
                         outp += sprintf(outp, fmt8, 100.0 * p->rapl_dram_perf_status * rapl_time_units / interval_float);
-        outp += sprintf(outp, fmt8, interval_float);
 
+                outp += sprintf(outp, fmt8, interval_float);
         }
 done:
         outp += sprintf(outp, "\n");
@@ -628,9 +637,12 @@ void
 delta_package(struct pkg_data *new, struct pkg_data *old)
 {
         old->pc2 = new->pc2 - old->pc2;
-        old->pc3 = new->pc3 - old->pc3;
-        old->pc6 = new->pc6 - old->pc6;
-        old->pc7 = new->pc7 - old->pc7;
+        if (do_pc3)
+                old->pc3 = new->pc3 - old->pc3;
+        if (do_pc6)
+                old->pc6 = new->pc6 - old->pc6;
+        if (do_pc7)
+                old->pc7 = new->pc7 - old->pc7;
         old->pc8 = new->pc8 - old->pc8;
         old->pc9 = new->pc9 - old->pc9;
         old->pc10 = new->pc10 - old->pc10;
@@ -670,24 +682,26 @@ delta_thread(struct thread_data *new, struct thread_data *old,
 
         old->c1 = new->c1 - old->c1;
 
-        if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
-                old->aperf = new->aperf - old->aperf;
-                old->mperf = new->mperf - old->mperf;
-        } else {
+        if (has_aperf) {
+                if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
+                        old->aperf = new->aperf - old->aperf;
+                        old->mperf = new->mperf - old->mperf;
+                } else {
 
-                if (!aperf_mperf_unstable) {
-                        fprintf(stderr, "%s: APERF or MPERF went backwards *\n", progname);
-                        fprintf(stderr, "* Frequency results do not cover entire interval *\n");
-                        fprintf(stderr, "* fix this by running Linux-2.6.30 or later *\n");
+                        if (!aperf_mperf_unstable) {
+                                fprintf(stderr, "%s: APERF or MPERF went backwards *\n", progname);
+                                fprintf(stderr, "* Frequency results do not cover entire interval *\n");
+                                fprintf(stderr, "* fix this by running Linux-2.6.30 or later *\n");
 
-                        aperf_mperf_unstable = 1;
+                                aperf_mperf_unstable = 1;
+                        }
+                        /*
+                         * mperf delta is likely a huge "positive" number
+                         * can not use it for calculating c0 time
+                         */
+                        skip_c0 = 1;
+                        skip_c1 = 1;
                 }
-                /*
-                 * mperf delta is likely a huge "positive" number
-                 * can not use it for calculating c0 time
-                 */
-                skip_c0 = 1;
-                skip_c1 = 1;
         }
 
 
@@ -712,7 +726,7 @@ delta_thread(struct thread_data *new, struct thread_data *old,
         }
 
         if (old->mperf == 0) {
-                if (verbose > 1) fprintf(stderr, "cpu%d MPERF 0!\n", old->cpu_id);
+                if (debug > 1) fprintf(stderr, "cpu%d MPERF 0!\n", old->cpu_id);
                 old->mperf = 1; /* divide by 0 protection */
         }
 
@@ -769,9 +783,12 @@ void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data
         c->core_temp_c = 0;
 
         p->pc2 = 0;
-        p->pc3 = 0;
-        p->pc6 = 0;
-        p->pc7 = 0;
+        if (do_pc3)
+                p->pc3 = 0;
+        if (do_pc6)
+                p->pc6 = 0;
+        if (do_pc7)
+                p->pc7 = 0;
         p->pc8 = 0;
         p->pc9 = 0;
         p->pc10 = 0;
@@ -810,9 +827,12 @@ int sum_counters(struct thread_data *t, struct core_data *c,
                 return 0;
 
         average.packages.pc2 += p->pc2;
-        average.packages.pc3 += p->pc3;
-        average.packages.pc6 += p->pc6;
-        average.packages.pc7 += p->pc7;
+        if (do_pc3)
+                average.packages.pc3 += p->pc3;
+        if (do_pc6)
+                average.packages.pc6 += p->pc6;
+        if (do_pc7)
+                average.packages.pc7 += p->pc7;
         average.packages.pc8 += p->pc8;
         average.packages.pc9 += p->pc9;
         average.packages.pc10 += p->pc10;
@@ -854,9 +874,12 @@ void compute_average(struct thread_data *t, struct core_data *c,
         average.cores.c7 /= topo.num_cores;
 
         average.packages.pc2 /= topo.num_packages;
-        average.packages.pc3 /= topo.num_packages;
-        average.packages.pc6 /= topo.num_packages;
-        average.packages.pc7 /= topo.num_packages;
+        if (do_pc3)
+                average.packages.pc3 /= topo.num_packages;
+        if (do_pc6)
+                average.packages.pc6 /= topo.num_packages;
+        if (do_pc7)
+                average.packages.pc7 /= topo.num_packages;
 
         average.packages.pc8 /= topo.num_packages;
         average.packages.pc9 /= topo.num_packages;
@@ -956,18 +979,18 @@ int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
         if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
                 return 0;
 
-        if (do_nhm_cstates && !do_slm_cstates) {
+        if (do_pc3)
                 if (get_msr(cpu, MSR_PKG_C3_RESIDENCY, &p->pc3))
                         return -9;
+        if (do_pc6)
                 if (get_msr(cpu, MSR_PKG_C6_RESIDENCY, &p->pc6))
                         return -10;
-        }
-        if (do_snb_cstates) {
+        if (do_pc2)
                 if (get_msr(cpu, MSR_PKG_C2_RESIDENCY, &p->pc2))
                         return -11;
+        if (do_pc7)
                 if (get_msr(cpu, MSR_PKG_C7_RESIDENCY, &p->pc7))
                         return -12;
-        }
         if (do_c8_c9_c10) {
                 if (get_msr(cpu, MSR_PKG_C8_RESIDENCY, &p->pc8))
                         return -13;
@@ -1014,12 +1037,43 @@ int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
         return 0;
 }
 
+/*
+ * MSR_PKG_CST_CONFIG_CONTROL decoding for pkg_cstate_limit:
+ * If you change the values, note they are used both in comparisons
+ * (>= PCL__7) and to index pkg_cstate_limit_strings[].
+ */
+
+#define PCLUKN 0 /* Unknown */
+#define PCLRSV 1 /* Reserved */
+#define PCL__0 2 /* PC0 */
+#define PCL__1 3 /* PC1 */
+#define PCL__2 4 /* PC2 */
+#define PCL__3 5 /* PC3 */
+#define PCL__4 6 /* PC4 */
+#define PCL__6 7 /* PC6 */
+#define PCL_6N 8 /* PC6 No Retention */
+#define PCL_6R 9 /* PC6 Retention */
+#define PCL__7 10 /* PC7 */
+#define PCL_7S 11 /* PC7 Shrink */
+#define PCLUNL 12 /* Unlimited */
+
+int pkg_cstate_limit = PCLUKN;
+char *pkg_cstate_limit_strings[] = { "reserved", "unknown", "pc0", "pc1", "pc2",
+        "pc3", "pc4", "pc6", "pc6n", "pc6r", "pc7", "pc7s", "unlimited"};
+
+int nhm_pkg_cstate_limits[8] = {PCL__0, PCL__1, PCL__3, PCL__6, PCL__7, PCLRSV, PCLRSV, PCLUNL};
+int snb_pkg_cstate_limits[8] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCL__7, PCL_7S, PCLRSV, PCLUNL};
+int hsw_pkg_cstate_limits[8] = {PCL__0, PCL__2, PCL__3, PCL__6, PCL__7, PCL_7S, PCLRSV, PCLUNL};
+int slv_pkg_cstate_limits[8] = {PCL__0, PCL__1, PCLRSV, PCLRSV, PCL__4, PCLRSV, PCL__6, PCL__7};
+int amt_pkg_cstate_limits[8] = {PCL__0, PCL__1, PCL__2, PCLRSV, PCLRSV, PCLRSV, PCL__6, PCL__7};
+int phi_pkg_cstate_limits[8] = {PCL__0, PCL__2, PCL_6N, PCL_6R, PCLRSV, PCLRSV, PCLRSV, PCLUNL};
+
 void print_verbose_header(void)
 {
         unsigned long long msr;
         unsigned int ratio;
 
-        if (!do_nehalem_platform_info)
+        if (!do_nhm_platform_info)
                 return;
 
         get_msr(0, MSR_NHM_PLATFORM_INFO, &msr);
@@ -1093,46 +1147,16 @@ print_nhm_turbo_ratio_limits:
 
         fprintf(stderr, "cpu0: MSR_NHM_SNB_PKG_CST_CFG_CTL: 0x%08llx", msr);
 
-        fprintf(stderr, " (%s%s%s%s%slocked: pkg-cstate-limit=%d: ",
+        fprintf(stderr, " (%s%s%s%s%slocked: pkg-cstate-limit=%d: %s)\n",
                 (msr & SNB_C3_AUTO_UNDEMOTE) ? "UNdemote-C3, " : "",
                 (msr & SNB_C1_AUTO_UNDEMOTE) ? "UNdemote-C1, " : "",
                 (msr & NHM_C3_AUTO_DEMOTE) ? "demote-C3, " : "",
                 (msr & NHM_C1_AUTO_DEMOTE) ? "demote-C1, " : "",
                 (msr & (1 << 15)) ? "" : "UN",
-                (unsigned int)msr & 7);
-
-
-        switch(msr & 0x7) {
-        case 0:
-                fprintf(stderr, do_slm_cstates ? "no pkg states" : "pc0");
-                break;
-        case 1:
-                fprintf(stderr, do_slm_cstates ? "no pkg states" : do_snb_cstates ? "pc2" : "pc0");
-                break;
-        case 2:
-                fprintf(stderr, do_slm_cstates ? "invalid" : do_snb_cstates ? "pc6-noret" : "pc3");
-                break;
-        case 3:
-                fprintf(stderr, do_slm_cstates ? "invalid" : "pc6");
-                break;
-        case 4:
-                fprintf(stderr, do_slm_cstates ? "pc4" : "pc7");
-                break;
-        case 5:
-                fprintf(stderr, do_slm_cstates ? "invalid" : do_snb_cstates ? "pc7s" : "invalid");
-                break;
-        case 6:
-                fprintf(stderr, do_slm_cstates ? "pc6" : "invalid");
-                break;
-        case 7:
-                fprintf(stderr, do_slm_cstates ? "pc7" : "unlimited");
-                break;
-        default:
-                fprintf(stderr, "invalid");
-        }
-        fprintf(stderr, ")\n");
+                (unsigned int)msr & 7,
+                pkg_cstate_limit_strings[pkg_cstate_limit]);
 
-        if (!do_nehalem_turbo_ratio_limit)
+        if (!do_nhm_turbo_ratio_limit)
                 return;
 
         get_msr(0, MSR_NHM_TURBO_RATIO_LIMIT, &msr);
@@ -1178,6 +1202,7 @@ print_nhm_turbo_ratio_limits:
         if (ratio)
                 fprintf(stderr, "%d * %.0f = %.0f MHz max turbo 1 active cores\n",
                         ratio, bclk, ratio * bclk);
+
 }
 
 void free_all_buffers(void)
@@ -1458,18 +1483,66 @@ void check_dev_msr()
         struct stat sb;
 
         if (stat("/dev/cpu/0/msr", &sb))
-                err(-5, "no /dev/cpu/0/msr\n"
-                    "Try \"# modprobe msr\"");
+                err(-5, "no /dev/cpu/0/msr, Try \"# modprobe msr\" ");
 }
 
-void check_super_user()
+void check_permissions()
 {
-        if (getuid() != 0)
-                errx(-6, "must be root");
+        struct __user_cap_header_struct cap_header_data;
+        cap_user_header_t cap_header = &cap_header_data;
+        struct __user_cap_data_struct cap_data_data;
+        cap_user_data_t cap_data = &cap_data_data;
+        extern int capget(cap_user_header_t hdrp, cap_user_data_t datap);
+        int do_exit = 0;
+
+        /* check for CAP_SYS_RAWIO */
+        cap_header->pid = getpid();
+        cap_header->version = _LINUX_CAPABILITY_VERSION;
+        if (capget(cap_header, cap_data) < 0)
+                err(-6, "capget(2) failed");
+
+        if ((cap_data->effective & (1 << CAP_SYS_RAWIO)) == 0) {
+                do_exit++;
+                warnx("capget(CAP_SYS_RAWIO) failed,"
+                        " try \"# setcap cap_sys_rawio=ep %s\"", progname);
+        }
+
+        /* test file permissions */
+        if (euidaccess("/dev/cpu/0/msr", R_OK)) {
+                do_exit++;
+                warn("/dev/cpu/0/msr open failed, try chown or chmod +r /dev/cpu/*/msr");
+        }
+
+        /* if all else fails, thell them to be root */
+        if (do_exit)
+                if (getuid() != 0)
+                        warnx("... or simply run as root");
+
+        if (do_exit)
+                exit(-6);
 }
 
-int has_nehalem_turbo_ratio_limit(unsigned int family, unsigned int model)
+/*
+ * NHM adds support for additional MSRs:
+ *
+ * MSR_SMI_COUNT                   0x00000034
+ *
+ * MSR_NHM_PLATFORM_INFO           0x000000ce
+ * MSR_NHM_SNB_PKG_CST_CFG_CTL     0x000000e2
+ *
+ * MSR_PKG_C3_RESIDENCY            0x000003f8
+ * MSR_PKG_C6_RESIDENCY            0x000003f9
+ * MSR_CORE_C3_RESIDENCY           0x000003fc
+ * MSR_CORE_C6_RESIDENCY           0x000003fd
+ *
+ * Side effect:
+ * sets global pkg_cstate_limit to decode MSR_NHM_SNB_PKG_CST_CFG_CTL
+ */
+int probe_nhm_msrs(unsigned int family, unsigned int model)
 {
+        unsigned long long msr;
+        int *pkg_cstate_limits;
+
         if (!genuine_intel)
                 return 0;
 
@@ -1482,24 +1555,54 @@ int has_nehalem_turbo_ratio_limit(unsigned int family, unsigned int model)
         case 0x1F:      /* Core i7 and i5 Processor - Nehalem */
         case 0x25:      /* Westmere Client - Clarkdale, Arrandale */
         case 0x2C:      /* Westmere EP - Gulftown */
+        case 0x2E:      /* Nehalem-EX Xeon - Beckton */
+        case 0x2F:      /* Westmere-EX Xeon - Eagleton */
+                pkg_cstate_limits = nhm_pkg_cstate_limits;
+                break;
         case 0x2A:      /* SNB */
         case 0x2D:      /* SNB Xeon */
         case 0x3A:      /* IVB */
         case 0x3E:      /* IVB Xeon */
+                pkg_cstate_limits = snb_pkg_cstate_limits;
+                break;
         case 0x3C:      /* HSW */
         case 0x3F:      /* HSX */
         case 0x45:      /* HSW */
         case 0x46:      /* HSW */
-        case 0x37:      /* BYT */
-        case 0x4D:      /* AVN */
         case 0x3D:      /* BDW */
+        case 0x47:      /* BDW */
         case 0x4F:      /* BDX */
         case 0x56:      /* BDX-DE */
-                return 1;
+                pkg_cstate_limits = hsw_pkg_cstate_limits;
+                break;
+        case 0x37:      /* BYT */
+        case 0x4D:      /* AVN */
+                pkg_cstate_limits = slv_pkg_cstate_limits;
+                break;
+        case 0x4C:      /* AMT */
+                pkg_cstate_limits = amt_pkg_cstate_limits;
+                break;
+        case 0x57:      /* PHI */
+                pkg_cstate_limits = phi_pkg_cstate_limits;
+                break;
+        default:
+                return 0;
+        }
+        get_msr(0, MSR_NHM_SNB_PKG_CST_CFG_CTL, &msr);
+
+        pkg_cstate_limit = pkg_cstate_limits[msr & 0x7];
+
+        return 1;
+}
+int has_nhm_turbo_ratio_limit(unsigned int family, unsigned int model)
+{
+        switch (model) {
+        /* Nehalem compatible, but do not include turbo-ratio limit support */
         case 0x2E:      /* Nehalem-EX Xeon - Beckton */
         case 0x2F:      /* Westmere-EX Xeon - Eagleton */
-        default:
                 return 0;
+        default:
+                return 1;
         }
 }
 int has_ivt_turbo_ratio_limit(unsigned int family, unsigned int model)
@@ -1564,6 +1667,103 @@ int print_epb(struct thread_data *t, struct core_data *c, struct pkg_data *p)
         return 0;
 }
 
+/*
+ * print_perf_limit()
+ */
+int print_perf_limit(struct thread_data *t, struct core_data *c, struct pkg_data *p)
+{
+        unsigned long long msr;
+        int cpu;
+
+        cpu = t->cpu_id;
+
+        /* per-package */
+        if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE) || !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
+                return 0;
+
+        if (cpu_migrate(cpu)) {
+                fprintf(stderr, "Could not migrate to CPU %d\n", cpu);
+                return -1;
+        }
+
+        if (do_core_perf_limit_reasons) {
+                get_msr(cpu, MSR_CORE_PERF_LIMIT_REASONS, &msr);
+                fprintf(stderr, "cpu%d: MSR_CORE_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
+                fprintf(stderr, " (Active: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)",
+                        (msr & 1 << 0) ? "PROCHOT, " : "",
+                        (msr & 1 << 1) ? "ThermStatus, " : "",
+                        (msr & 1 << 2) ? "bit2, " : "",
+                        (msr & 1 << 4) ? "Graphics, " : "",
+                        (msr & 1 << 5) ? "Auto-HWP, " : "",
+                        (msr & 1 << 6) ? "VR-Therm, " : "",
+                        (msr & 1 << 8) ? "Amps, " : "",
+                        (msr & 1 << 9) ? "CorePwr, " : "",
+                        (msr & 1 << 10) ? "PkgPwrL1, " : "",
+                        (msr & 1 << 11) ? "PkgPwrL2, " : "",
+                        (msr & 1 << 12) ? "MultiCoreTurbo, " : "",
+                        (msr & 1 << 13) ? "Transitions, " : "",
+                        (msr & 1 << 14) ? "bit14, " : "",
+                        (msr & 1 << 15) ? "bit15, " : "");
+                fprintf(stderr, " (Logged: %s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
+                        (msr & 1 << 16) ? "PROCHOT, " : "",
+                        (msr & 1 << 17) ? "ThermStatus, " : "",
+                        (msr & 1 << 18) ? "bit18, " : "",
+                        (msr & 1 << 20) ? "Graphics, " : "",
+                        (msr & 1 << 21) ? "Auto-HWP, " : "",
+                        (msr & 1 << 22) ? "VR-Therm, " : "",
+                        (msr & 1 << 24) ? "Amps, " : "",
+                        (msr & 1 << 25) ? "CorePwr, " : "",
+                        (msr & 1 << 26) ? "PkgPwrL1, " : "",
+                        (msr & 1 << 27) ? "PkgPwrL2, " : "",
+                        (msr & 1 << 28) ? "MultiCoreTurbo, " : "",
+                        (msr & 1 << 29) ? "Transitions, " : "",
+                        (msr & 1 << 30) ? "bit30, " : "",
+                        (msr & 1 << 31) ? "bit31, " : "");
+
+        }
+        if (do_gfx_perf_limit_reasons) {
+                get_msr(cpu, MSR_GFX_PERF_LIMIT_REASONS, &msr);
+                fprintf(stderr, "cpu%d: MSR_GFX_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
+                fprintf(stderr, " (Active: %s%s%s%s%s%s%s%s)",
+                        (msr & 1 << 0) ? "PROCHOT, " : "",
+                        (msr & 1 << 1) ? "ThermStatus, " : "",
+                        (msr & 1 << 4) ? "Graphics, " : "",
+                        (msr & 1 << 6) ? "VR-Therm, " : "",
+                        (msr & 1 << 8) ? "Amps, " : "",
+                        (msr & 1 << 9) ? "GFXPwr, " : "",
+                        (msr & 1 << 10) ? "PkgPwrL1, " : "",
+                        (msr & 1 << 11) ? "PkgPwrL2, " : "");
+                fprintf(stderr, " (Logged: %s%s%s%s%s%s%s%s)\n",
+                        (msr & 1 << 16) ? "PROCHOT, " : "",
+                        (msr & 1 << 17) ? "ThermStatus, " : "",
+                        (msr & 1 << 20) ? "Graphics, " : "",
+                        (msr & 1 << 22) ? "VR-Therm, " : "",
+                        (msr & 1 << 24) ? "Amps, " : "",
+                        (msr & 1 << 25) ? "GFXPwr, " : "",
+                        (msr & 1 << 26) ? "PkgPwrL1, " : "",
+                        (msr & 1 << 27) ? "PkgPwrL2, " : "");
+        }
+        if (do_ring_perf_limit_reasons) {
+                get_msr(cpu, MSR_RING_PERF_LIMIT_REASONS, &msr);
+                fprintf(stderr, "cpu%d: MSR_RING_PERF_LIMIT_REASONS, 0x%08llx", cpu, msr);
+                fprintf(stderr, " (Active: %s%s%s%s%s%s)",
+                        (msr & 1 << 0) ? "PROCHOT, " : "",
+                        (msr & 1 << 1) ? "ThermStatus, " : "",
+                        (msr & 1 << 6) ? "VR-Therm, " : "",
+                        (msr & 1 << 8) ? "Amps, " : "",
+                        (msr & 1 << 10) ? "PkgPwrL1, " : "",
+                        (msr & 1 << 11) ? "PkgPwrL2, " : "");
+                fprintf(stderr, " (Logged: %s%s%s%s%s%s)\n",
+                        (msr & 1 << 16) ? "PROCHOT, " : "",
+                        (msr & 1 << 17) ? "ThermStatus, " : "",
+                        (msr & 1 << 22) ? "VR-Therm, " : "",
+                        (msr & 1 << 24) ? "Amps, " : "",
+                        (msr & 1 << 26) ? "PkgPwrL1, " : "",
+                        (msr & 1 << 27) ? "PkgPwrL2, " : "");
+        }
+        return 0;
+}
+
 #define RAPL_POWER_GRANULARITY  0x7FFF  /* 15 bit power granularity */
 #define RAPL_TIME_GRANULARITY   0x3F /* 6 bit time granularity */
 
@@ -1609,6 +1809,7 @@ void rapl_probe(unsigned int family, unsigned int model)
         case 0x45:      /* HSW */
         case 0x46:      /* HSW */
         case 0x3D:      /* BDW */
+        case 0x47:      /* BDW */
                 do_rapl = RAPL_PKG | RAPL_CORES | RAPL_CORE_POLICY | RAPL_GFX | RAPL_PKG_POWER_INFO;
                 break;
         case 0x3F:      /* HSX */
@@ -1647,12 +1848,33 @@ void rapl_probe(unsigned int family, unsigned int model)
         tdp = get_tdp(model);
 
         rapl_joule_counter_range = 0xFFFFFFFF * rapl_energy_units / tdp;
-        if (verbose)
+        if (debug)
                 fprintf(stderr, "RAPL: %.0f sec. Joule Counter Range, at %.0f Watts\n", rapl_joule_counter_range, tdp);
 
         return;
 }
 
+void perf_limit_reasons_probe(family, model)
+{
+        if (!genuine_intel)
+                return;
+
+        if (family != 6)
+                return;
+
+        switch (model) {
+        case 0x3C:      /* HSW */
+        case 0x45:      /* HSW */
+        case 0x46:      /* HSW */
+                do_gfx_perf_limit_reasons = 1;
+        case 0x3F:      /* HSX */
+                do_core_perf_limit_reasons = 1;
+                do_ring_perf_limit_reasons = 1;
+        default:
+                return;
+        }
+}
+
 int print_thermal(struct thread_data *t, struct core_data *c, struct pkg_data *p)
 {
         unsigned long long msr;
@@ -1751,7 +1973,7 @@ int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
         if (get_msr(cpu, MSR_RAPL_POWER_UNIT, &msr))
                 return -1;
 
-        if (verbose) {
+        if (debug) {
                 fprintf(stderr, "cpu%d: MSR_RAPL_POWER_UNIT: 0x%08llx "
                         "(%f Watts, %f Joules, %f sec.)\n", cpu, msr,
                         rapl_power_units, rapl_energy_units, rapl_time_units);
@@ -1808,7 +2030,7 @@ int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
                 print_power_limit_msr(cpu, msr, "DRAM Limit");
         }
         if (do_rapl & RAPL_CORE_POLICY) {
-                if (verbose) {
+                if (debug) {
                         if (get_msr(cpu, MSR_PP0_POLICY, &msr))
                                 return -7;
 
@@ -1816,7 +2038,7 @@ int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
                 }
         }
         if (do_rapl & RAPL_CORES) {
-                if (verbose) {
+                if (debug) {
 
                         if (get_msr(cpu, MSR_PP0_POWER_LIMIT, &msr))
                                 return -9;
@@ -1826,7 +2048,7 @@ int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
                 }
         }
         if (do_rapl & RAPL_GFX) {
-                if (verbose) {
+                if (debug) {
                         if (get_msr(cpu, MSR_PP1_POLICY, &msr))
                                 return -8;
 
@@ -1842,8 +2064,15 @@ int print_rapl(struct thread_data *t, struct core_data *c, struct pkg_data *p)
         return 0;
 }
 
+/*
+ * SNB adds support for additional MSRs:
+ *
+ * MSR_PKG_C7_RESIDENCY            0x000003fa
+ * MSR_CORE_C7_RESIDENCY           0x000003fe
+ * MSR_PKG_C2_RESIDENCY            0x0000060d
+ */
 
-int is_snb(unsigned int family, unsigned int model)
+int has_snb_msrs(unsigned int family, unsigned int model)
 {
         if (!genuine_intel)
                 return 0;
@@ -1858,6 +2087,7 @@ int is_snb(unsigned int family, unsigned int model)
         case 0x45:      /* HSW */
         case 0x46:      /* HSW */
         case 0x3D:      /* BDW */
+        case 0x47:      /* BDW */
         case 0x4F:      /* BDX */
         case 0x56:      /* BDX-DE */
                 return 1;
@@ -1865,7 +2095,14 @@ int is_snb(unsigned int family, unsigned int model)
         return 0;
 }
 
-int has_c8_c9_c10(unsigned int family, unsigned int model)
+/*
+ * HSW adds support for additional MSRs:
+ *
+ * MSR_PKG_C8_RESIDENCY            0x00000630
+ * MSR_PKG_C9_RESIDENCY            0x00000631
+ * MSR_PKG_C10_RESIDENCY           0x00000632
+ */
+int has_hsw_msrs(unsigned int family, unsigned int model)
 {
         if (!genuine_intel)
                 return 0;
@@ -1917,7 +2154,7 @@ double slm_bclk(void)
 
 double discover_bclk(unsigned int family, unsigned int model)
 {
-        if (is_snb(family, model))
+        if (has_snb_msrs(family, model))
                 return 100.00;
         else if (is_slm(family, model))
                 return slm_bclk();
@@ -1965,7 +2202,7 @@ int set_temperature_target(struct thread_data *t, struct core_data *c, struct pk
         }
 
         /* Temperature Target MSR is Nehalem and newer only */
-        if (!do_nehalem_platform_info)
+        if (!do_nhm_platform_info)
                 goto guess;
 
         if (get_msr(0, MSR_IA32_TEMPERATURE_TARGET, &msr))
@@ -1973,7 +2210,7 @@ int set_temperature_target(struct thread_data *t, struct core_data *c, struct pk
 
         target_c_local = (msr >> 16) & 0xFF;
 
-        if (verbose)
+        if (debug)
                 fprintf(stderr, "cpu%d: MSR_IA32_TEMPERATURE_TARGET: 0x%08llx (%d C)\n",
                         cpu, msr, target_c_local);
 
@@ -2003,7 +2240,7 @@ void check_cpuid()
         if (ebx == 0x756e6547 && edx == 0x49656e69 && ecx == 0x6c65746e)
                 genuine_intel = 1;
 
-        if (verbose)
+        if (debug)
                 fprintf(stderr, "CPUID(0): %.4s%.4s%.4s ",
                         (char *)&ebx, (char *)&edx, (char *)&ecx);
 
@@ -2014,7 +2251,7 @@ void check_cpuid()
         if (family == 6 || family == 0xf)
                 model += ((fms >> 16) & 0xf) << 4;
 
-        if (verbose)
+        if (debug)
                 fprintf(stderr, "%d CPUID levels; family:model:stepping 0x%x:%x:%x (%d:%d:%d)\n",
                         max_level, family, model, stepping, family, model, stepping);
 
@@ -2029,18 +2266,15 @@ void check_cpuid()
         ebx = ecx = edx = 0;
         __get_cpuid(0x80000000, &max_level, &ebx, &ecx, &edx);
 
-        if (max_level < 0x80000007)
-                errx(1, "CPUID: no invariant TSC (max_level 0x%x)", max_level);
+        if (max_level >= 0x80000007) {
 
-        /*
-         * Non-Stop TSC is advertised by CPUID.EAX=0x80000007: EDX.bit8
-         * this check is valid for both Intel and AMD
-         */
-        __get_cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
-        has_invariant_tsc = edx & (1 << 8);
-
-        if (!has_invariant_tsc)
-                errx(1, "No invariant TSC");
+                /*
+                 * Non-Stop TSC is advertised by CPUID.EAX=0x80000007: EDX.bit8
+                 * this check is valid for both Intel and AMD
+                 */
+                __get_cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
+                has_invariant_tsc = edx & (1 << 8);
+        }
 
         /*
          * APERF/MPERF is advertised by CPUID.EAX=0x6: ECX.bit0
@@ -2053,36 +2287,51 @@ void check_cpuid()
         do_ptm = eax & (1 << 6);
         has_epb = ecx & (1 << 3);
 
-        if (verbose)
-                fprintf(stderr, "CPUID(6): %s%s%s%s\n",
-                        has_aperf ? "APERF" : "No APERF!",
-                        do_dts ? ", DTS" : "",
-                        do_ptm ? ", PTM": "",
-                        has_epb ? ", EPB": "");
-
-        if (!has_aperf)
-                errx(-1, "No APERF");
-
-        do_nehalem_platform_info = genuine_intel && has_invariant_tsc;
-        do_nhm_cstates = genuine_intel; /* all Intel w/ non-stop TSC have NHM counters */
-        do_smi = do_nhm_cstates;
-        do_snb_cstates = is_snb(family, model);
-        do_c8_c9_c10 = has_c8_c9_c10(family, model);
+        if (debug)
+                fprintf(stderr, "CPUID(6): %sAPERF, %sDTS, %sPTM, %sEPB\n",
+                        has_aperf ? "" : "No ",
+                        do_dts ? "" : "No ",
+                        do_ptm ? "" : "No ",
+                        has_epb ? "" : "No ");
+
+        do_nhm_platform_info = do_nhm_cstates = do_smi = probe_nhm_msrs(family, model);
+        do_snb_cstates = has_snb_msrs(family, model);
+        do_pc2 = do_snb_cstates && (pkg_cstate_limit >= PCL__2);
+        do_pc3 = (pkg_cstate_limit >= PCL__3);
+        do_pc6 = (pkg_cstate_limit >= PCL__6);
+        do_pc7 = do_snb_cstates && (pkg_cstate_limit >= PCL__7);
+        do_c8_c9_c10 = has_hsw_msrs(family, model);
         do_slm_cstates = is_slm(family, model);
         bclk = discover_bclk(family, model);
 
-        do_nehalem_turbo_ratio_limit = has_nehalem_turbo_ratio_limit(family, model);
+        do_nhm_turbo_ratio_limit = do_nhm_platform_info && has_nhm_turbo_ratio_limit(family, model);
         do_ivt_turbo_ratio_limit = has_ivt_turbo_ratio_limit(family, model);
         rapl_probe(family, model);
+        perf_limit_reasons_probe(family, model);
 
         return;
 }
 
 
-void usage()
+void help()
 {
-        errx(1, "%s: [-v][-R][-T][-p|-P|-S][-c MSR#][-C MSR#][-m MSR#][-M MSR#][-i interval_sec | command ...]\n",
-             progname);
+        fprintf(stderr,
+        "Usage: turbostat [OPTIONS][(--interval seconds) | COMMAND ...]\n"
+        "\n"
+        "Turbostat forks the specified COMMAND and prints statistics\n"
+        "when COMMAND completes.\n"
+        "If no COMMAND is specified, turbostat wakes every 5-seconds\n"
+        "to print statistics, until interrupted.\n"
+        "--debug        run in \"debug\" mode\n"
+        "--interval sec Override default 5-second measurement interval\n"
+        "--help         print this help message\n"
+        "--counter msr  print 32-bit counter at address \"msr\"\n"
+        "--Counter msr  print 64-bit Counter at address \"msr\"\n"
+        "--msr msr      print 32-bit value at address \"msr\"\n"
+        "--MSR msr      print 64-bit Value at address \"msr\"\n"
+        "--version      print version information\n"
+        "\n"
+        "For more help, run \"man turbostat\"\n");
 }
 
 
@@ -2121,7 +2370,7 @@ void topology_probe()
         if (!summary_only && topo.num_cpus > 1)
                 show_cpu = 1;
 
-        if (verbose > 1)
+        if (debug > 1)
                 fprintf(stderr, "num_cpus %d max_cpu_num %d\n", topo.num_cpus, topo.max_cpu_num);
 
         cpus = calloc(1, (topo.max_cpu_num  + 1) * sizeof(struct cpu_topology));
@@ -2156,7 +2405,7 @@ void topology_probe()
                 int siblings;
 
                 if (cpu_is_not_present(i)) {
-                        if (verbose > 1)
+                        if (debug > 1)
                                 fprintf(stderr, "cpu%d NOT PRESENT\n", i);
                         continue;
                 }
@@ -2171,26 +2420,26 @@ void topology_probe()
                 siblings = get_num_ht_siblings(i);
                 if (siblings > max_siblings)
                         max_siblings = siblings;
-                if (verbose > 1)
+                if (debug > 1)
                         fprintf(stderr, "cpu %d pkg %d core %d\n",
                                 i, cpus[i].physical_package_id, cpus[i].core_id);
         }
         topo.num_cores_per_pkg = max_core_id + 1;
-        if (verbose > 1)
+        if (debug > 1)
                 fprintf(stderr, "max_core_id %d, sizing for %d cores per package\n",
                         max_core_id, topo.num_cores_per_pkg);
         if (!summary_only && topo.num_cores_per_pkg > 1)
                 show_core = 1;
 
         topo.num_packages = max_package_id + 1;
-        if (verbose > 1)
+        if (debug > 1)
                 fprintf(stderr, "max_package_id %d, sizing for %d packages\n",
                         max_package_id, topo.num_packages);
         if (!summary_only && topo.num_packages > 1)
                 show_pkg = 1;
 
         topo.num_threads_per_core = max_siblings;
-        if (verbose > 1)
+        if (debug > 1)
                 fprintf(stderr, "max_siblings %d\n", max_siblings);
 
         free(cpus);
@@ -2299,25 +2548,27 @@ void setup_all_buffers(void)
 
 void turbostat_init()
 {
-        check_cpuid();
-
         check_dev_msr();
-        check_super_user();
+        check_permissions();
+        check_cpuid();
 
         setup_all_buffers();
 
-        if (verbose)
+        if (debug)
                 print_verbose_header();
 
-        if (verbose)
+        if (debug)
                 for_all_cpus(print_epb, ODD_COUNTERS);
 
-        if (verbose)
+        if (debug)
+                for_all_cpus(print_perf_limit, ODD_COUNTERS);
+
+        if (debug)
                 for_all_cpus(print_rapl, ODD_COUNTERS);
 
         for_all_cpus(set_temperature_target, ODD_COUNTERS);
 
-        if (verbose)
+        if (debug)
                 for_all_cpus(print_thermal, ODD_COUNTERS);
 }
 
@@ -2382,56 +2633,82 @@ int get_and_dump_counters(void)
         return status;
 }
 
+void print_version() {
+        fprintf(stderr, "turbostat version 4.1 10-Feb, 2015"
+                " - Len Brown <lenb@kernel.org>\n");
+}
+
 void cmdline(int argc, char **argv)
 {
         int opt;
+        int option_index = 0;
+        static struct option long_options[] = {
+                {"Counter",     required_argument,      0, 'C'},
+                {"counter",     required_argument,      0, 'c'},
+                {"Dump",        no_argument,            0, 'D'},
+                {"debug",       no_argument,            0, 'd'},
+                {"interval",    required_argument,      0, 'i'},
+                {"help",        no_argument,            0, 'h'},
+                {"Joules",      no_argument,            0, 'J'},
+                {"MSR",         required_argument,      0, 'M'},
+                {"msr",         required_argument,      0, 'm'},
+                {"Package",     no_argument,            0, 'p'},
+                {"processor",   no_argument,            0, 'p'},
+                {"Summary",     no_argument,            0, 'S'},
+                {"TCC",         required_argument,      0, 'T'},
+                {"version",     no_argument,            0, 'v' },
+                {0,             0,                      0,  0 }
+        };
 
         progname = argv[0];
 
-        while ((opt = getopt(argc, argv, "+pPsSvi:c:C:m:M:RJT:")) != -1) {
+        while ((opt = getopt_long_only(argc, argv, "C:c:Ddhi:JM:m:PpST:v",
+                                long_options, &option_index)) != -1) {
                 switch (opt) {
-                case 'p':
-                        show_core_only++;
+                case 'C':
+                        sscanf(optarg, "%x", &extra_delta_offset64);
                         break;
-                case 'P':
-                        show_pkg_only++;
+                case 'c':
+                        sscanf(optarg, "%x", &extra_delta_offset32);
                         break;
-                case 's':
+                case 'D':
                         dump_only++;
                         break;
-                case 'S':
-                        summary_only++;
-                        break;
-                case 'v':
-                        verbose++;
+                case 'd':
+                        debug++;
                         break;
+                case 'h':
+                default:
+                        help();
+                        exit(1);
                 case 'i':
                         interval_sec = atoi(optarg);
                         break;
-                case 'c':
-                        sscanf(optarg, "%x", &extra_delta_offset32);
+                case 'J':
+                        rapl_joules++;
                         break;
-                case 'C':
-                        sscanf(optarg, "%x", &extra_delta_offset64);
+                case 'M':
+                        sscanf(optarg, "%x", &extra_msr_offset64);
                         break;
                 case 'm':
                         sscanf(optarg, "%x", &extra_msr_offset32);
                         break;
-                case 'M':
-                        sscanf(optarg, "%x", &extra_msr_offset64);
+                case 'P':
+                        show_pkg_only++;
                         break;
-                case 'R':
-                        rapl_verbose++;
+                case 'p':
+                        show_core_only++;
+                        break;
+                case 'S':
+                        summary_only++;
                         break;
                 case 'T':
                         tcc_activation_temp_override = atoi(optarg);
                         break;
-                case 'J':
-                        rapl_joules++;
+                case 'v':
+                        print_version();
+                        exit(0);
                         break;
-
-                default:
-                        usage();
                 }
         }
 }
@@ -2440,9 +2717,8 @@ int main(int argc, char **argv)
 {
         cmdline(argc, argv);
 
-        if (verbose)
-                fprintf(stderr, "turbostat v3.7 Feb 6, 2014"
-                        " - Len Brown <lenb@kernel.org>\n");
+        if (debug)
+                print_version();
 
         turbostat_init();
 
diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl
index b9cd036f0442..d08e214ec6e7 100755
--- a/tools/testing/ktest/ktest.pl
+++ b/tools/testing/ktest/ktest.pl
@@ -178,6 +178,7 @@ my $checkout;
 my $localversion;
 my $iteration = 0;
 my $successes = 0;
+my $stty_orig;
 
 my $bisect_good;
 my $bisect_bad;
@@ -197,6 +198,11 @@ my $patchcheck_start;
 my $patchcheck_cherry;
 my $patchcheck_end;
 
+my $build_time;
+my $install_time;
+my $reboot_time;
+my $test_time;
+
 # set when a test is something other that just building or install
 # which would require more options.
 my $buildonly = 1;
@@ -554,6 +560,66 @@ sub get_mandatory_config {
     }
 }
 
+sub show_time {
+    my ($time) = @_;
+
+    my $hours = 0;
+    my $minutes = 0;
+
+    if ($time > 3600) {
+        $hours = int($time / 3600);
+        $time -= $hours * 3600;
+    }
+    if ($time > 60) {
+        $minutes = int($time / 60);
+        $time -= $minutes * 60;
+    }
+
+    if ($hours > 0) {
+        doprint "$hours hour";
+        doprint "s" if ($hours > 1);
+        doprint " ";
+    }
+
+    if ($minutes > 0) {
+        doprint "$minutes minute";
+        doprint "s" if ($minutes > 1);
+        doprint " ";
+    }
+
+    doprint "$time second";
+    doprint "s" if ($time != 1);
+}
+
+sub print_times {
+    doprint "\n";
+    if ($build_time) {
+        doprint "Build time:   ";
+        show_time($build_time);
+        doprint "\n";
+    }
+    if ($install_time) {
+        doprint "Install time: ";
+        show_time($install_time);
+        doprint "\n";
+    }
+    if ($reboot_time) {
+        doprint "Reboot time:  ";
+        show_time($reboot_time);
+        doprint "\n";
+    }
+    if ($test_time) {
+        doprint "Test time:    ";
+        show_time($test_time);
+        doprint "\n";
+    }
+    # reset for iterations like bisect
+    $build_time = 0;
+    $install_time = 0;
+    $reboot_time = 0;
+    $test_time = 0;
+}
+
 sub get_mandatory_configs {
     get_mandatory_config("MACHINE");
     get_mandatory_config("BUILD_DIR");
@@ -1341,23 +1407,83 @@ sub dodie {
         print " See $opt{LOG_FILE} for more info.\n";
     }
 
+    if ($monitor_cnt) {
+            # restore terminal settings
+            system("stty $stty_orig");
+    }
+
     die @_, "\n";
 }
 
+sub create_pty {
+    my ($ptm, $pts) = @_;
+    my $tmp;
+    my $TIOCSPTLCK = 0x40045431;
+    my $TIOCGPTN = 0x80045430;
+
+    sysopen($ptm, "/dev/ptmx", O_RDWR | O_NONBLOCK) or
+        dodie "Cant open /dev/ptmx";
+
+    # unlockpt()
+    $tmp = pack("i", 0);
+    ioctl($ptm, $TIOCSPTLCK, $tmp) or
+        dodie "ioctl TIOCSPTLCK for /dev/ptmx failed";
+
+    # ptsname()
+    ioctl($ptm, $TIOCGPTN, $tmp) or
+        dodie "ioctl TIOCGPTN for /dev/ptmx failed";
+    $tmp = unpack("i", $tmp);
+
+    sysopen($pts, "/dev/pts/$tmp", O_RDWR | O_NONBLOCK) or
+        dodie "Can't open /dev/pts/$tmp";
+}
+
+sub exec_console {
+    my ($ptm, $pts) = @_;
+
+    close($ptm);
+
+    close(\*STDIN);
+    close(\*STDOUT);
+    close(\*STDERR);
+
+    open(\*STDIN, '<&', $pts);
+    open(\*STDOUT, '>&', $pts);
+    open(\*STDERR, '>&', $pts);
+
+    close($pts);
+
+    exec $console or
+        die "Can't open console $console";
+}
+
 sub open_console {
-    my ($fp) = @_;
+    my ($ptm) = @_;
+    my $pts = \*PTSFD;
+    my $pid;
 
-    my $flags;
+    # save terminal settings
+    $stty_orig = `stty -g`;
 
-    my $pid = open($fp, "$console|") or
-        dodie "Can't open console $console";
+    # place terminal in cbreak mode so that stdin can be read one character at
+    # a time without having to wait for a newline
+    system("stty -icanon -echo -icrnl");
 
-    $flags = fcntl($fp, F_GETFL, 0) or
-        dodie "Can't get flags for the socket: $!";
-    $flags = fcntl($fp, F_SETFL, $flags | O_NONBLOCK) or
-        dodie "Can't set flags for the socket: $!";
+    create_pty($ptm, $pts);
+
+    $pid = fork;
+
+    if (!$pid) {
+        # child
+        exec_console($ptm, $pts)
+    }
+
+    # parent
+    close($pts);
 
     return $pid;
+
+    open(PTSFD, "Stop perl from warning about single use of PTSFD");
 }
 
 sub close_console {
@@ -1368,6 +1494,9 @@ sub close_console {
 
     print "closing!\n";
     close($fp);
+
+    # restore terminal settings
+    system("stty $stty_orig");
 }
 
 sub start_monitor {
@@ -1519,6 +1648,8 @@ sub fail {
             $name = " ($test_name)";
         }
 
+        print_times;
+
         doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
         doprint "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n";
         doprint "KTEST RESULT: TEST $i$name Failed: ", @_, "\n";
@@ -1534,10 +1665,14 @@ sub fail {
 
 sub run_command {
     my ($command, $redirect) = @_;
+    my $start_time;
+    my $end_time;
     my $dolog = 0;
     my $dord = 0;
     my $pid;
 
+    $start_time = time;
+
     $command =~ s/\$SSH_USER/$ssh_user/g;
     $command =~ s/\$MACHINE/$machine/g;
 
@@ -1570,6 +1705,15 @@ sub run_command {
     close(LOG) if ($dolog);
     close(RD)  if ($dord);
 
+    $end_time = time;
+    my $delta = $end_time - $start_time;
+
+    if ($delta == 1) {
+        doprint "[1 second] ";
+    } else {
+        doprint "[$delta seconds] ";
+    }
+
     if ($failed) {
         doprint "FAILED!\n";
     } else {
@@ -1694,7 +1838,9 @@ sub wait_for_input
 {
     my ($fp, $time) = @_;
     my $rin;
-    my $ready;
+    my $rout;
+    my $nr;
+    my $buf;
     my $line;
     my $ch;
 
@@ -1704,21 +1850,36 @@ sub wait_for_input
 
     $rin = '';
     vec($rin, fileno($fp), 1) = 1;
-    ($ready, $time) = select($rin, undef, undef, $time);
+    vec($rin, fileno(\*STDIN), 1) = 1;
 
-    $line = "";
+    while (1) {
+        $nr = select($rout=$rin, undef, undef, $time);
 
-    # try to read one char at a time
-    while (sysread $fp, $ch, 1) {
-        $line .= $ch;
-        last if ($ch eq "\n");
-    }
+        if ($nr <= 0) {
+            return undef;
+        }
 
-    if (!length($line)) {
-        return undef;
-    }
+        # copy data from stdin to the console
+        if (vec($rout, fileno(\*STDIN), 1) == 1) {
+            sysread(\*STDIN, $buf, 1000);
+            syswrite($fp, $buf, 1000);
+            next;
+        }
 
-    return $line;
+        $line = "";
+
+        # try to read one char at a time
+        while (sysread $fp, $ch, 1) {
+            $line .= $ch;
+            last if ($ch eq "\n");
+        }
+
+        if (!length($line)) {
+            return undef;
+        }
+
+        return $line;
+    }
 }
 
 sub reboot_to {
@@ -1766,6 +1927,8 @@ sub monitor {
     my $skip_call_trace = 0;
     my $loops;
 
+    my $start_time = time;
+
     wait_for_monitor 5;
 
     my $line;
@@ -1890,6 +2053,9 @@ sub monitor {
         }
     }
 
+    my $end_time = time;
+    $reboot_time = $end_time - $start_time;
+
     close(DMESG);
 
     if ($bug) {
@@ -1938,6 +2104,8 @@ sub install {
 
     return if ($no_install);
 
+    my $start_time = time;
+
     if (defined($pre_install)) {
         my $cp_pre_install = eval_kernel_version $pre_install;
         run_command "$cp_pre_install" or
@@ -1969,6 +2137,8 @@ sub install {
     if (!$install_mods) {
         do_post_install;
         doprint "No modules needed\n";
+        my $end_time = time;
+        $install_time = $end_time - $start_time;
         return;
     }
 
@@ -1996,6 +2166,9 @@ sub install {
     run_ssh "rm -f /tmp/$modtar";
 
     do_post_install;
+
+    my $end_time = time;
+    $install_time = $end_time - $start_time;
 }
 
 sub get_version {
@@ -2008,7 +2181,7 @@ sub get_version {
     $have_version = 1;
 }
 
-sub start_monitor_and_boot {
+sub start_monitor_and_install {
     # Make sure the stable kernel has finished booting
 
     # Install bisects, don't need console
@@ -2208,6 +2381,8 @@ sub build {
 
     unlink $buildlog;
 
+    my $start_time = time;
+
     # Failed builds should not reboot the target
     my $save_no_reboot = $no_reboot;
     $no_reboot = 1;
@@ -2293,6 +2468,9 @@ sub build {
 
     $no_reboot = $save_no_reboot;
 
+    my $end_time = time;
+    $build_time = $end_time - $start_time;
+
     return 1;
 }
 
@@ -2323,6 +2501,8 @@ sub success {
         $name = " ($test_name)";
     }
 
+    print_times;
+
     doprint "\n\n*******************************************\n";
     doprint     "*******************************************\n";
     doprint     "KTEST RESULT: TEST $i$name SUCCESS!!!!         **\n";
@@ -2383,6 +2563,8 @@ sub do_run_test {
     my $bug = 0;
     my $bug_ignored = 0;
 
+    my $start_time = time;
+
     wait_for_monitor 1;
 
     doprint "run test $run_test\n";
@@ -2449,6 +2631,9 @@ sub do_run_test {
     waitpid $child_pid, 0;
     $child_exit = $?;
 
+    my $end_time = time;
+    $test_time = $end_time - $start_time;
+
     if (!$bug && $in_bisect) {
         if (defined($bisect_ret_good)) {
             if ($child_exit == $bisect_ret_good) {
@@ -2549,7 +2734,7 @@ sub run_bisect_test {
         dodie "Failed on build" if $failed;
 
         # Now boot the box
-        start_monitor_and_boot or $failed = 1;
+        start_monitor_and_install or $failed = 1;
 
         if ($type ne "boot") {
             if ($failed && $bisect_skip) {
@@ -2755,6 +2940,7 @@ sub bisect {
     do {
         $result = run_bisect $type;
         $test = run_git_bisect "git bisect $result";
+        print_times;
     } while ($test);
 
     run_command "git bisect log" or
@@ -3168,6 +3354,7 @@ sub config_bisect {
 
     do {
         $ret = run_config_bisect \%good_configs, \%bad_configs;
+        print_times;
     } while (!$ret);
 
     return $ret if ($ret < 0);
@@ -3260,7 +3447,7 @@ sub patchcheck {
         my $sha1 = $item;
         $sha1 =~ s/^([[:xdigit:]]+).*/$1/;
 
-        doprint "\nProcessing commit $item\n\n";
+        doprint "\nProcessing commit \"$item\"\n\n";
 
         run_command "git checkout $sha1" or
             die "Failed to checkout $sha1";
@@ -3291,16 +3478,18 @@ sub patchcheck {
 
         my $failed = 0;
 
-        start_monitor_and_boot or $failed = 1;
+        start_monitor_and_install or $failed = 1;
 
         if (!$failed && $type ne "boot"){
             do_run_test or $failed = 1;
         }
         end_monitor;
-        return 0 if ($failed);
-
+        if ($failed) {
+            print_times;
+            return 0;
+        }
         patchcheck_reboot;
-
+        print_times;
     }
     $in_patchcheck = 0;
     success $i;
@@ -3753,7 +3942,7 @@ sub make_min_config {
         my $failed = 0;
         build "oldconfig" or $failed = 1;
         if (!$failed) {
-                start_monitor_and_boot or $failed = 1;
+                start_monitor_and_install or $failed = 1;
 
                 if ($type eq "test" && !$failed) {
                     do_run_test or $failed = 1;
@@ -4000,6 +4189,11 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
 
     $iteration = $i;
 
+    $build_time = 0;
+    $install_time = 0;
+    $reboot_time = 0;
+    $test_time = 0;
+
     undef %force_config;
 
     my $makecmd = set_test_option("MAKE_CMD", $i);
@@ -4157,15 +4351,20 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
 
     if ($test_type ne "build") {
         my $failed = 0;
-        start_monitor_and_boot or $failed = 1;
+        start_monitor_and_install or $failed = 1;
 
         if (!$failed && $test_type ne "boot" && defined($run_test)) {
             do_run_test or $failed = 1;
         }
         end_monitor;
-        next if ($failed);
+        if ($failed) {
+            print_times;
+            next;
+        }
     }
 
+    print_times;
+
     success $i;
 }
 
diff --git a/tools/testing/selftests/powerpc/Makefile b/tools/testing/selftests/powerpc/Makefile
index f6ff90a76bd7..1d5e7ad2c460 100644
--- a/tools/testing/selftests/powerpc/Makefile
+++ b/tools/testing/selftests/powerpc/Makefile
@@ -13,7 +13,7 @@ CFLAGS := -Wall -O2 -flto -Wall -Werror -DGIT_VERSION='"$(GIT_VERSION)"' -I$(CUR
 
 export CC CFLAGS
 
-TARGETS = pmu copyloops mm tm primitives
+TARGETS = pmu copyloops mm tm primitives stringloops
 
 endif
 
diff --git a/tools/testing/selftests/powerpc/copyloops/.gitignore b/tools/testing/selftests/powerpc/copyloops/.gitignore
new file mode 100644
index 000000000000..25a192f62c4d
--- /dev/null
+++ b/tools/testing/selftests/powerpc/copyloops/.gitignore
@@ -0,0 +1,4 @@
+copyuser_64
+copyuser_power7
+memcpy_64
+memcpy_power7
diff --git a/tools/testing/selftests/powerpc/mm/.gitignore b/tools/testing/selftests/powerpc/mm/.gitignore
new file mode 100644
index 000000000000..b43ade0ec861
--- /dev/null
+++ b/tools/testing/selftests/powerpc/mm/.gitignore
@@ -0,0 +1,3 @@
+hugetlb_vs_thp_test
+subpage_prot
+tempfile
diff --git a/tools/testing/selftests/powerpc/mm/Makefile b/tools/testing/selftests/powerpc/mm/Makefile
index 357ccbd6bad9..a14c538dd7f8 100644
--- a/tools/testing/selftests/powerpc/mm/Makefile
+++ b/tools/testing/selftests/powerpc/mm/Makefile
@@ -1,9 +1,9 @@
 noarg:
         $(MAKE) -C ../
 
-PROGS := hugetlb_vs_thp_test
+PROGS := hugetlb_vs_thp_test subpage_prot
 
-all: $(PROGS)
+all: $(PROGS) tempfile
 
 $(PROGS): ../harness.c
 
@@ -12,7 +12,10 @@ run_tests: all
                 ./$$PROG; \
         done;
 
+tempfile:
+        dd if=/dev/zero of=tempfile bs=64k count=1
+
 clean:
-        rm -f $(PROGS)
+        rm -f $(PROGS) tempfile
 
 .PHONY: all run_tests clean
diff --git a/tools/testing/selftests/powerpc/mm/subpage_prot.c b/tools/testing/selftests/powerpc/mm/subpage_prot.c
new file mode 100644
index 000000000000..440180ff8089
--- /dev/null
+++ b/tools/testing/selftests/powerpc/mm/subpage_prot.c
@@ -0,0 +1,220 @@
+/*
+ * Copyright IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2.1 of the GNU Lesser General Public License
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/ptrace.h>
+#include <sys/syscall.h>
+#include <ucontext.h>
+#include <unistd.h>
+
+#include "utils.h"
+
+char *file_name;
+
+int in_test;
+volatile int faulted;
+volatile void *dar;
+int errors;
+
+static void segv(int signum, siginfo_t *info, void *ctxt_v)
+{
+        ucontext_t *ctxt = (ucontext_t *)ctxt_v;
+        struct pt_regs *regs = ctxt->uc_mcontext.regs;
+
+        if (!in_test) {
+                fprintf(stderr, "Segfault outside of test !\n");
+                exit(1);
+        }
+
+        faulted = 1;
+        dar = (void *)regs->dar;
+        regs->nip += 4;
+}
+
+static inline void do_read(const volatile void *addr)
+{
+        int ret;
+
+        asm volatile("lwz %0,0(%1); twi 0,%0,0; isync;\n"
+                     : "=r" (ret) : "r" (addr) : "memory");
+}
+
+static inline void do_write(const volatile void *addr)
+{
+        int val = 0x1234567;
+
+        asm volatile("stw %0,0(%1); sync; \n"
+                     : : "r" (val), "r" (addr) : "memory");
+}
+
+static inline void check_faulted(void *addr, long page, long subpage, int write)
+{
+        int want_fault = (subpage == ((page + 3) % 16));
+
+        if (write)
+                want_fault |= (subpage == ((page + 1) % 16));
+
+        if (faulted != want_fault) {
+                printf("Failed at 0x%p (p=%ld,sp=%ld,w=%d), want=%s, got=%s !\n",
+                       addr, page, subpage, write,
+                       want_fault ? "fault" : "pass",
+                       faulted ? "fault" : "pass");
+                ++errors;
+        }
+
+        if (faulted) {
+                if (dar != addr) {
+                        printf("Fault expected at 0x%p and happened at 0x%p !\n",
+                               addr, dar);
+                }
+                faulted = 0;
+                asm volatile("sync" : : : "memory");
+        }
+}
+
+static int run_test(void *addr, unsigned long size)
+{
+        unsigned int *map;
+        long i, j, pages, err;
+
+        pages = size / 0x10000;
+        map = malloc(pages * 4);
+        assert(map);
+
+        /*
+         * for each page, mark subpage i % 16 read only and subpage
+         * (i + 3) % 16 inaccessible
+         */
+        for (i = 0; i < pages; i++) {
+                map[i] = (0x40000000 >> (((i + 1) * 2) % 32)) |
+                        (0xc0000000 >> (((i + 3) * 2) % 32));
+        }
+
+        err = syscall(__NR_subpage_prot, addr, size, map);
+        if (err) {
+                perror("subpage_perm");
+                return 1;
+        }
+        free(map);
+
+        in_test = 1;
+        errors = 0;
+        for (i = 0; i < pages; i++) {
+                for (j = 0; j < 16; j++, addr += 0x1000) {
+                        do_read(addr);
+                        check_faulted(addr, i, j, 0);
+                        do_write(addr);
+                        check_faulted(addr, i, j, 1);
+                }
+        }
+
+        in_test = 0;
+        if (errors) {
+                printf("%d errors detected\n", errors);
+                return 1;
+        }
+
+        return 0;
+}
+
+int test_anon(void)
+{
+        unsigned long align;
+        struct sigaction act = {
+                .sa_sigaction = segv,
+                .sa_flags = SA_SIGINFO
+        };
+        void *mallocblock;
+        unsigned long mallocsize;
+
+        if (getpagesize() != 0x10000) {
+                fprintf(stderr, "Kernel page size must be 64K!\n");
+                return 1;
+        }
+
+        sigaction(SIGSEGV, &act, NULL);
+
+        mallocsize = 4 * 16 * 1024 * 1024;
+
+        FAIL_IF(posix_memalign(&mallocblock, 64 * 1024, mallocsize));
+
+        align = (unsigned long)mallocblock;
+        if (align & 0xffff)
+                align = (align | 0xffff) + 1;
+
+        mallocblock = (void *)align;
+
+        printf("allocated malloc block of 0x%lx bytes at 0x%p\n",
+               mallocsize, mallocblock);
+
+        printf("testing malloc block...\n");
+
+        return run_test(mallocblock, mallocsize);
+}
+
+int test_file(void)
+{
+        struct sigaction act = {
+                .sa_sigaction = segv,
+                .sa_flags = SA_SIGINFO
+        };
+        void *fileblock;
+        off_t filesize;
+        int fd;
+
+        fd = open(file_name, O_RDWR);
+        if (fd == -1) {
+                perror("failed to open file");
+                return 1;
+        }
+        sigaction(SIGSEGV, &act, NULL);
+
+        filesize = lseek(fd, 0, SEEK_END);
+        if (filesize & 0xffff)
+                filesize &= ~0xfffful;
+
+        fileblock = mmap(NULL, filesize, PROT_READ | PROT_WRITE,
+                         MAP_SHARED, fd, 0);
+        if (fileblock == MAP_FAILED) {
+                perror("failed to map file");
+                return 1;
+        }
+        printf("allocated %s for 0x%lx bytes at 0x%p\n",
+               file_name, filesize, fileblock);
+
+        printf("testing file map...\n");
+
+        return run_test(fileblock, filesize);
+}
+
+int main(int argc, char *argv[])
+{
+        test_harness(test_anon, "subpage_prot_anon");
+
+        if (argc > 1)
+                file_name = argv[1];
+        else
+                file_name = "tempfile";
+
+        test_harness(test_file, "subpage_prot_file");
+
+        return 0;
+}
diff --git a/tools/testing/selftests/powerpc/pmu/.gitignore b/tools/testing/selftests/powerpc/pmu/.gitignore
new file mode 100644
index 000000000000..e748f336eed3
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/.gitignore
@@ -0,0 +1,3 @@
+count_instructions
+l3_bank_test
+per_event_excludes
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/.gitignore b/tools/testing/selftests/powerpc/pmu/ebb/.gitignore
new file mode 100644
index 000000000000..42bddbed8b64
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/ebb/.gitignore
@@ -0,0 +1,22 @@
+reg_access_test
+event_attributes_test
+cycles_test
+cycles_with_freeze_test
+pmc56_overflow_test
+ebb_vs_cpu_event_test
+cpu_event_vs_ebb_test
+cpu_event_pinned_vs_ebb_test
+task_event_vs_ebb_test
+task_event_pinned_vs_ebb_test
+multi_ebb_procs_test
+multi_counter_test
+pmae_handling_test
+close_clears_pmcc_test
+instruction_count_test
+fork_cleanup_test
+ebb_on_child_test
+ebb_on_willing_child_test
+back_to_back_ebbs_test
+lost_exception_test
+no_handler_test
+cycles_with_mmcr2_test
diff --git a/tools/testing/selftests/powerpc/primitives/.gitignore b/tools/testing/selftests/powerpc/primitives/.gitignore
new file mode 100644
index 000000000000..4cc4e31bed1d
--- /dev/null
+++ b/tools/testing/selftests/powerpc/primitives/.gitignore
@@ -0,0 +1 @@
+load_unaligned_zeropad
diff --git a/tools/testing/selftests/powerpc/stringloops/.gitignore b/tools/testing/selftests/powerpc/stringloops/.gitignore
new file mode 100644
index 000000000000..0b43da74ee46
--- /dev/null
+++ b/tools/testing/selftests/powerpc/stringloops/.gitignore
@@ -0,0 +1 @@
+memcmp
diff --git a/tools/testing/selftests/powerpc/stringloops/Makefile b/tools/testing/selftests/powerpc/stringloops/Makefile
new file mode 100644
index 000000000000..506d77346477
--- /dev/null
+++ b/tools/testing/selftests/powerpc/stringloops/Makefile
@@ -0,0 +1,20 @@
+# The loops are all 64-bit code
+CFLAGS += -m64
+CFLAGS += -I$(CURDIR)
+
+PROGS := memcmp
+EXTRA_SOURCES := memcmp_64.S ../harness.c
+
+all: $(PROGS)
+
+$(PROGS): $(EXTRA_SOURCES)
+
+run_tests: all
+        @-for PROG in $(PROGS); do \
+                ./$$PROG; \
+        done;
+
+clean:
+        rm -f $(PROGS) *.o
+
+.PHONY: all run_tests clean
diff --git a/tools/testing/selftests/powerpc/stringloops/asm/ppc_asm.h b/tools/testing/selftests/powerpc/stringloops/asm/ppc_asm.h
new file mode 100644
index 000000000000..11bece87e880
--- /dev/null
+++ b/tools/testing/selftests/powerpc/stringloops/asm/ppc_asm.h
@@ -0,0 +1,7 @@
+#include <ppc-asm.h>
+
+#ifndef r1
+#define r1 sp
+#endif
+
+#define _GLOBAL(A) FUNC_START(test_ ## A)
diff --git a/tools/testing/selftests/powerpc/stringloops/memcmp.c b/tools/testing/selftests/powerpc/stringloops/memcmp.c
new file mode 100644
index 000000000000..17417dd70708
--- /dev/null
+++ b/tools/testing/selftests/powerpc/stringloops/memcmp.c
@@ -0,0 +1,103 @@
+#include <malloc.h>
+#include <stdlib.h>
+#include <string.h>
+#include "../utils.h"
+
+#define SIZE 256
+#define ITERATIONS 10000
+
+int test_memcmp(const void *s1, const void *s2, size_t n);
+
+/* test all offsets and lengths */
+static void test_one(char *s1, char *s2)
+{
+        unsigned long offset, size;
+
+        for (offset = 0; offset < SIZE; offset++) {
+                for (size = 0; size < (SIZE-offset); size++) {
+                        int x, y;
+                        unsigned long i;
+
+                        y = memcmp(s1+offset, s2+offset, size);
+                        x = test_memcmp(s1+offset, s2+offset, size);
+
+                        if (((x ^ y) < 0) &&    /* Trick to compare sign */
+                                ((x | y) != 0)) { /* check for zero */
+                                printf("memcmp returned %d, should have returned %d (offset %ld size %ld)\n", x, y, offset, size);
+
+                                for (i = offset; i < offset+size; i++)
+                                        printf("%02x ", s1[i]);
+                                printf("\n");
+
+                                for (i = offset; i < offset+size; i++)
+                                        printf("%02x ", s2[i]);
+                                printf("\n");
+                                abort();
+                        }
+                }
+        }
+}
+
+static int testcase(void)
+{
+        char *s1;
+        char *s2;
+        unsigned long i;
+
+        s1 = memalign(128, SIZE);
+        if (!s1) {
+                perror("memalign");
+                exit(1);
+        }
+
+        s2 = memalign(128, SIZE);
+        if (!s2) {
+                perror("memalign");
+                exit(1);
+        }
+
+        srandom(1);
+
+        for (i = 0; i < ITERATIONS; i++) {
+                unsigned long j;
+                unsigned long change;
+
+                for (j = 0; j < SIZE; j++)
+                        s1[j] = random();
+
+                memcpy(s2, s1, SIZE);
+
+                /* change one byte */
+                change = random() % SIZE;
+                s2[change] = random() & 0xff;
+
+                test_one(s1, s2);
+        }
+
+        srandom(1);
+
+        for (i = 0; i < ITERATIONS; i++) {
+                unsigned long j;
+                unsigned long change;
+
+                for (j = 0; j < SIZE; j++)
+                        s1[j] = random();
+
+                memcpy(s2, s1, SIZE);
+
+                /* change multiple bytes, 1/8 of total */
+                for (j = 0; j < SIZE / 8; j++) {
+                        change = random() % SIZE;
+                        s2[change] = random() & 0xff;
+                }
+
+                test_one(s1, s2);
+        }
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(testcase, "memcmp");
+}
diff --git a/tools/testing/selftests/powerpc/stringloops/memcmp_64.S b/tools/testing/selftests/powerpc/stringloops/memcmp_64.S
new file mode 120000
index 000000000000..9bc87e438ae9
--- /dev/null
+++ b/tools/testing/selftests/powerpc/stringloops/memcmp_64.S
@@ -0,0 +1 @@
+../../../../../arch/powerpc/lib/memcmp_64.S
\ No newline at end of file
diff --git a/tools/testing/selftests/powerpc/tm/.gitignore b/tools/testing/selftests/powerpc/tm/.gitignore
new file mode 100644
index 000000000000..33d02cc54a3e
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/.gitignore
@@ -0,0 +1 @@
+tm-resched-dscr
diff --git a/tools/testing/selftests/rcutorture/bin/cpus2use.sh b/tools/testing/selftests/rcutorture/bin/cpus2use.sh
index abe14b7f36e9..bb99cde3f5f9 100755
--- a/tools/testing/selftests/rcutorture/bin/cpus2use.sh
+++ b/tools/testing/selftests/rcutorture/bin/cpus2use.sh
@@ -24,7 +24,7 @@
 
 ncpus=`grep '^processor' /proc/cpuinfo | wc -l`
 idlecpus=`mpstat | tail -1 | \
-        awk -v ncpus=$ncpus '{ print ncpus * ($7 + $12) / 100 }'`
+        awk -v ncpus=$ncpus '{ print ncpus * ($7 + $NF) / 100 }'`
 awk -v ncpus=$ncpus -v idlecpus=$idlecpus < /dev/null '
 BEGIN {
         cpus2use = idlecpus;
diff --git a/tools/testing/selftests/rcutorture/bin/kvm-recheck-rcu.sh b/tools/testing/selftests/rcutorture/bin/kvm-recheck-rcu.sh
index d6cc07fc137f..559e01ac86be 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-recheck-rcu.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-recheck-rcu.sh
@@ -30,6 +30,7 @@ else
         echo Unreadable results directory: $i
         exit 1
 fi
+. tools/testing/selftests/rcutorture/bin/functions.sh
 
 configfile=`echo $i | sed -e 's/^.*\///'`
 ngps=`grep ver: $i/console.log 2> /dev/null | tail -1 | sed -e 's/^.* ver: //' -e 's/ .*$//'`
@@ -48,4 +49,21 @@ else
                 title="$title ($ngpsps per second)"
         fi
         echo $title
+        nclosecalls=`grep --binary-files=text 'torture: Reader Batch' $i/console.log | tail -1 | awk '{for (i=NF-8;i<=NF;i++) sum+=$i; } END {print sum}'`
+        if test -z "$nclosecalls"
+        then
+                exit 0
+        fi
+        if test "$nclosecalls" -eq 0
+        then
+                exit 0
+        fi
+        # Compute number of close calls per tenth of an hour
+        nclosecalls10=`awk -v nclosecalls=$nclosecalls -v dur=$dur 'BEGIN { print int(nclosecalls * 36000 / dur) }' < /dev/null`
+        if test $nclosecalls10 -gt 5 -a $nclosecalls -gt 1
+        then
+                print_bug $nclosecalls "Reader Batch close calls in" $(($dur/60)) minute run: $i
+        else
+                print_warning $nclosecalls "Reader Batch close calls in" $(($dur/60)) minute run: $i
+        fi
 fi
diff --git a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
index 8ca9f21f2efc..5236e073919d 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
@@ -8,9 +8,9 @@
 #
 # Usage: kvm-test-1-run.sh config builddir resdir minutes qemu-args boot_args
 #
-# qemu-args defaults to "-nographic", along with arguments specifying the
-#                       number of CPUs and other options generated from
-#                       the underlying CPU architecture.
+# qemu-args defaults to "-enable-kvm -soundhw pcspk -nographic", along with
+#                       arguments specifying the number of CPUs and other
+#                       options generated from the underlying CPU architecture.
 # boot_args defaults to value returned by the per_version_boot_params
 #                       shell function.
 #
@@ -138,7 +138,7 @@ then
 fi
 
 # Generate -smp qemu argument.
-qemu_args="-nographic $qemu_args"
+qemu_args="-enable-kvm -soundhw pcspk -nographic $qemu_args"
 cpu_count=`configNR_CPUS.sh $config_template`
 cpu_count=`configfrag_boot_cpus "$boot_args" "$config_template" "$cpu_count"`
 vcpus=`identify_qemu_vcpus`
@@ -168,6 +168,7 @@ then
         touch $resdir/buildonly
         exit 0
 fi
+echo "NOTE: $QEMU either did not run or was interactive" > $builddir/console.log
 echo $QEMU $qemu_args -m 512 -kernel $resdir/bzImage -append \"$qemu_append $boot_args\" > $resdir/qemu-cmd
 ( $QEMU $qemu_args -m 512 -kernel $resdir/bzImage -append "$qemu_append $boot_args"; echo $? > $resdir/qemu-retval ) &
 qemu_pid=$!
diff --git a/tools/testing/selftests/rcutorture/bin/parse-build.sh b/tools/testing/selftests/rcutorture/bin/parse-build.sh
index 499d1e598e42..a6b57622c2e5 100755
--- a/tools/testing/selftests/rcutorture/bin/parse-build.sh
+++ b/tools/testing/selftests/rcutorture/bin/parse-build.sh
@@ -26,12 +26,15 @@
 #
 # Authors: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
 
-T=$1
+F=$1
 title=$2
+T=/tmp/parse-build.sh.$$
+trap 'rm -rf $T' 0
+mkdir $T
 
 . functions.sh
 
-if grep -q CC < $T
+if grep -q CC < $F
 then
         :
 else
@@ -39,18 +42,21 @@ else
         exit 1
 fi
 
-if grep -q "error:" < $T
+if grep -q "error:" < $F
 then
         print_bug $title build errors:
-        grep "error:" < $T
+        grep "error:" < $F
         exit 2
 fi
-exit 0
 
-if egrep -q "rcu[^/]*\.c.*warning:|rcu.*\.h.*warning:" < $T
+grep warning: < $F > $T/warnings
+grep "include/linux/*rcu*\.h:" $T/warnings > $T/hwarnings
+grep "kernel/rcu/[^/]*:" $T/warnings > $T/cwarnings
+cat $T/hwarnings $T/cwarnings > $T/rcuwarnings
+if test -s $T/rcuwarnings
 then
         print_warning $title build errors:
-        egrep "rcu[^/]*\.c.*warning:|rcu.*\.h.*warning:" < $T
+        cat $T/rcuwarnings
         exit 2
 fi
 exit 0
diff --git a/tools/testing/selftests/rcutorture/bin/parse-console.sh b/tools/testing/selftests/rcutorture/bin/parse-console.sh
index f962ba4cf68b..d8f35cf116be 100755
--- a/tools/testing/selftests/rcutorture/bin/parse-console.sh
+++ b/tools/testing/selftests/rcutorture/bin/parse-console.sh
@@ -36,7 +36,7 @@ if grep -Pq '\x00' < $file
 then
         print_warning Console output contains nul bytes, old qemu still running?
 fi
-egrep 'Badness|WARNING:|Warn|BUG|===========|Call Trace:|Oops:' < $file | grep -v 'ODEBUG: ' | grep -v 'Warning: unable to open an initial console' > $T
+egrep 'Badness|WARNING:|Warn|BUG|===========|Call Trace:|Oops:|Stall ended before state dump start' < $file | grep -v 'ODEBUG: ' | grep -v 'Warning: unable to open an initial console' > $T
 if test -s $T
 then
         print_warning Assertion failure in $file $title
diff --git a/tools/usb/ffs-aio-example/multibuff/host_app/test.c b/tools/usb/ffs-aio-example/multibuff/host_app/test.c
index daa3abe6bebd..2cbcce6e8dd7 100644
--- a/tools/usb/ffs-aio-example/multibuff/host_app/test.c
+++ b/tools/usb/ffs-aio-example/multibuff/host_app/test.c
@@ -33,11 +33,6 @@
 #define VENDOR  0x1d6b
 #define PRODUCT 0x0105
 
-/* endpoints indexes */
-
-#define EP_BULK_IN      (1 | LIBUSB_ENDPOINT_IN)
-#define EP_BULK_OUT     (2 | LIBUSB_ENDPOINT_OUT)
-
 #define BUF_LEN         8192
 
 /*
@@ -159,14 +154,21 @@ void test_exit(struct test_state *state)
 int main(void)
 {
         struct test_state state;
+        struct libusb_config_descriptor *conf;
+        struct libusb_interface_descriptor const *iface;
+        unsigned char addr;
 
         if (test_init(&state))
                 return 1;
 
+        libusb_get_config_descriptor(state.found, 0, &conf);
+        iface = &conf->interface[0].altsetting[0];
+        addr = iface->endpoint[0].bEndpointAddress;
+
         while (1) {
                 static unsigned char buffer[BUF_LEN];
                 int bytes;
-                libusb_bulk_transfer(state.handle, EP_BULK_IN, buffer, BUF_LEN,
+                libusb_bulk_transfer(state.handle, addr, buffer, BUF_LEN,
                                      &bytes, 500);
         }
         test_exit(&state);
diff --git a/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c b/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c
index adc310a6d489..1f44a29818bf 100644
--- a/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c
+++ b/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c
@@ -103,12 +103,14 @@ static const struct {
                         .bDescriptorType = USB_DT_ENDPOINT,
                         .bEndpointAddress = 1 | USB_DIR_IN,
                         .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        .wMaxPacketSize = htole16(512),
                 },
                 .bulk_source = {
                         .bLength = sizeof(descriptors.hs_descs.bulk_source),
                         .bDescriptorType = USB_DT_ENDPOINT,
                         .bEndpointAddress = 2 | USB_DIR_OUT,
                         .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        .wMaxPacketSize = htole16(512),
                 },
         },
 };
diff --git a/tools/usb/ffs-aio-example/simple/host_app/test.c b/tools/usb/ffs-aio-example/simple/host_app/test.c
index acd6332811f3..aed86ffff280 100644
--- a/tools/usb/ffs-aio-example/simple/host_app/test.c
+++ b/tools/usb/ffs-aio-example/simple/host_app/test.c
@@ -33,11 +33,6 @@
 #define VENDOR  0x1d6b
 #define PRODUCT 0x0105
 
-/* endpoints indexes */
-
-#define EP_BULK_IN      (1 | LIBUSB_ENDPOINT_IN)
-#define EP_BULK_OUT     (2 | LIBUSB_ENDPOINT_OUT)
-
 #define BUF_LEN         8192
 
 /*
@@ -159,16 +154,24 @@ void test_exit(struct test_state *state)
 int main(void)
 {
         struct test_state state;
+        struct libusb_config_descriptor *conf;
+        struct libusb_interface_descriptor const *iface;
+        unsigned char in_addr, out_addr;
 
         if (test_init(&state))
                 return 1;
 
+        libusb_get_config_descriptor(state.found, 0, &conf);
+        iface = &conf->interface[0].altsetting[0];
+        in_addr = iface->endpoint[0].bEndpointAddress;
+        out_addr = iface->endpoint[1].bEndpointAddress;
+
         while (1) {
                 static unsigned char buffer[BUF_LEN];
                 int bytes;
-                libusb_bulk_transfer(state.handle, EP_BULK_IN, buffer, BUF_LEN,
+                libusb_bulk_transfer(state.handle, in_addr, buffer, BUF_LEN,
                                      &bytes, 500);
-                libusb_bulk_transfer(state.handle, EP_BULK_OUT, buffer, BUF_LEN,
+                libusb_bulk_transfer(state.handle, out_addr, buffer, BUF_LEN,
                                      &bytes, 500);
         }
         test_exit(&state);
diff --git a/tools/vm/page-types.c b/tools/vm/page-types.c
index 264fbc297e0b..8bdf16b8ba60 100644
--- a/tools/vm/page-types.c
+++ b/tools/vm/page-types.c
@@ -133,6 +133,7 @@ static const char * const page_flag_names[] = {
         [KPF_KSM]               = "x:ksm",
         [KPF_THP]               = "t:thp",
         [KPF_BALLOON]           = "o:balloon",
+        [KPF_ZERO_PAGE]         = "z:zero_page",
 
         [KPF_RESERVED]          = "r:reserved",
         [KPF_MLOCKED]           = "m:mlocked",