Merge branch 'next' into for-linus

Merge first round of changes for 3.13 merge window.

181 files changed, 10904 insertions, 2850 deletions

diff --git a/tools/hv/hv_kvp_daemon.c b/tools/hv/hv_kvp_daemon.c
index 5a1f6489d185..8fd9ec66121c 100644
--- a/tools/hv/hv_kvp_daemon.c
+++ b/tools/hv/hv_kvp_daemon.c
@@ -79,8 +79,6 @@ enum {
         DNS
 };
 
-static char kvp_send_buffer[4096];
-static char kvp_recv_buffer[4096 * 2];
 static struct sockaddr_nl addr;
 static int in_hand_shake = 1;
 
@@ -127,7 +125,8 @@ static void kvp_acquire_lock(int pool)
         fl.l_pid = getpid();
 
         if (fcntl(kvp_file_info[pool].fd, F_SETLKW, &fl) == -1) {
-                syslog(LOG_ERR, "Failed to acquire the lock pool: %d", pool);
+                syslog(LOG_ERR, "Failed to acquire the lock pool: %d; error: %d %s", pool,
+                                errno, strerror(errno));
                 exit(EXIT_FAILURE);
         }
 }
@@ -138,8 +137,8 @@ static void kvp_release_lock(int pool)
         fl.l_pid = getpid();
 
         if (fcntl(kvp_file_info[pool].fd, F_SETLK, &fl) == -1) {
-                perror("fcntl");
-                syslog(LOG_ERR, "Failed to release the lock pool: %d", pool);
+                syslog(LOG_ERR, "Failed to release the lock pool: %d; error: %d %s", pool,
+                                errno, strerror(errno));
                 exit(EXIT_FAILURE);
         }
 }
@@ -157,8 +156,9 @@ static void kvp_update_file(int pool)
 
         filep = fopen(kvp_file_info[pool].fname, "we");
         if (!filep) {
+                syslog(LOG_ERR, "Failed to open file, pool: %d; error: %d %s", pool,
+                                errno, strerror(errno));
                 kvp_release_lock(pool);
-                syslog(LOG_ERR, "Failed to open file, pool: %d", pool);
                 exit(EXIT_FAILURE);
         }
 
@@ -188,8 +188,9 @@ static void kvp_update_mem_state(int pool)
 
         filep = fopen(kvp_file_info[pool].fname, "re");
         if (!filep) {
+                syslog(LOG_ERR, "Failed to open file, pool: %d; error: %d %s", pool,
+                                errno, strerror(errno));
                 kvp_release_lock(pool);
-                syslog(LOG_ERR, "Failed to open file, pool: %d", pool);
                 exit(EXIT_FAILURE);
         }
         for (;;) {
@@ -240,7 +241,8 @@ static int kvp_file_init(void)
 
         if (access(KVP_CONFIG_LOC, F_OK)) {
                 if (mkdir(KVP_CONFIG_LOC, 0755 /* rwxr-xr-x */)) {
-                        syslog(LOG_ERR, " Failed to create %s", KVP_CONFIG_LOC);
+                        syslog(LOG_ERR, "Failed to create '%s'; error: %d %s", KVP_CONFIG_LOC,
+                                        errno, strerror(errno));
                         exit(EXIT_FAILURE);
                 }
         }
@@ -257,12 +259,15 @@ static int kvp_file_init(void)
 
 
                 filep = fopen(fname, "re");
-                if (!filep)
+                if (!filep) {
+                        close(fd);
                         return 1;
+                }
 
                 record = malloc(alloc_unit * num_blocks);
                 if (record == NULL) {
                         fclose(filep);
+                        close(fd);
                         return 1;
                 }
                 for (;;) {
@@ -286,6 +291,7 @@ static int kvp_file_init(void)
                                                 num_blocks);
                                 if (record == NULL) {
                                         fclose(filep);
+                                        close(fd);
                                         return 1;
                                 }
                                 continue;
@@ -765,7 +771,9 @@ static void kvp_process_ipconfig_file(char *cmd,
                         break;
 
                 x = strchr(p, '\n');
-                *x = '\0';
+                if (x)
+                        *x = '\0';
+
                 strcat(config_buf, p);
                 strcat(config_buf, ";");
         }
@@ -1016,9 +1024,10 @@ kvp_get_ip_info(int family, char *if_name, int op,
 
                                 if (sn_offset == 0)
                                         strcpy(sn_str, cidr_mask);
-                                else
+                                else {
+                                        strcat((char *)ip_buffer->sub_net, ";");
                                         strcat(sn_str, cidr_mask);
-                                strcat((char *)ip_buffer->sub_net, ";");
+                                }
                                 sn_offset += strlen(sn_str) + 1;
                         }
 
@@ -1274,7 +1283,8 @@ static int kvp_set_ip_info(char *if_name, struct hv_kvp_ipaddr_value *new_val)
         file = fopen(if_file, "w");
 
         if (file == NULL) {
-                syslog(LOG_ERR, "Failed to open config file");
+                syslog(LOG_ERR, "Failed to open config file; error: %d %s",
+                                errno, strerror(errno));
                 return HV_E_FAIL;
         }
 
@@ -1289,6 +1299,7 @@ static int kvp_set_ip_info(char *if_name, struct hv_kvp_ipaddr_value *new_val)
         }
 
         error = kvp_write_file(file, "HWADDR", "", mac_addr);
+        free(mac_addr);
         if (error)
                 goto setval_error;
 
@@ -1334,7 +1345,6 @@ static int kvp_set_ip_info(char *if_name, struct hv_kvp_ipaddr_value *new_val)
                 goto setval_error;
 
 setval_done:
-        free(mac_addr);
         fclose(file);
 
         /*
@@ -1343,12 +1353,15 @@ setval_done:
          */
 
         snprintf(cmd, sizeof(cmd), "%s %s", "hv_set_ifconfig", if_file);
-        system(cmd);
+        if (system(cmd)) {
+                syslog(LOG_ERR, "Failed to execute cmd '%s'; error: %d %s",
+                                cmd, errno, strerror(errno));
+                return HV_E_FAIL;
+        }
         return 0;
 
 setval_error:
         syslog(LOG_ERR, "Failed to write config file");
-        free(mac_addr);
         fclose(file);
         return error;
 }
@@ -1379,23 +1392,18 @@ kvp_get_domain_name(char *buffer, int length)
 static int
 netlink_send(int fd, struct cn_msg *msg)
 {
-        struct nlmsghdr *nlh;
+        struct nlmsghdr nlh = { .nlmsg_type = NLMSG_DONE };
         unsigned int size;
         struct msghdr message;
-        char buffer[64];
         struct iovec iov[2];
 
-        size = NLMSG_SPACE(sizeof(struct cn_msg) + msg->len);
+        size = sizeof(struct cn_msg) + msg->len;
 
-        nlh = (struct nlmsghdr *)buffer;
-        nlh->nlmsg_seq = 0;
-        nlh->nlmsg_pid = getpid();
-        nlh->nlmsg_type = NLMSG_DONE;
-        nlh->nlmsg_len = NLMSG_LENGTH(size - sizeof(*nlh));
-        nlh->nlmsg_flags = 0;
+        nlh.nlmsg_pid = getpid();
+        nlh.nlmsg_len = NLMSG_LENGTH(size);
 
-        iov[0].iov_base = nlh;
-        iov[0].iov_len = sizeof(*nlh);
+        iov[0].iov_base = &nlh;
+        iov[0].iov_len = sizeof(nlh);
 
         iov[1].iov_base = msg;
         iov[1].iov_len = size;
@@ -1425,10 +1433,22 @@ int main(void)
         int     pool;
         char    *if_name;
         struct hv_kvp_ipaddr_value *kvp_ip_val;
+        char *kvp_send_buffer;
+        char *kvp_recv_buffer;
+        size_t kvp_recv_buffer_len;
 
-        daemon(1, 0);
+        if (daemon(1, 0))
+                return 1;
         openlog("KVP", 0, LOG_USER);
         syslog(LOG_INFO, "KVP starting; pid is:%d", getpid());
+
+        kvp_recv_buffer_len = NLMSG_HDRLEN + sizeof(struct cn_msg) + sizeof(struct hv_kvp_msg);
+        kvp_send_buffer = calloc(1, kvp_recv_buffer_len);
+        kvp_recv_buffer = calloc(1, kvp_recv_buffer_len);
+        if (!(kvp_send_buffer && kvp_recv_buffer)) {
+                syslog(LOG_ERR, "Failed to allocate netlink buffers");
+                exit(EXIT_FAILURE);
+        }
         /*
          * Retrieve OS release information.
          */
@@ -1441,7 +1461,8 @@ int main(void)
 
         fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
         if (fd < 0) {
-                syslog(LOG_ERR, "netlink socket creation failed; error:%d", fd);
+                syslog(LOG_ERR, "netlink socket creation failed; error: %d %s", errno,
+                                strerror(errno));
                 exit(EXIT_FAILURE);
         }
         addr.nl_family = AF_NETLINK;
@@ -1452,12 +1473,18 @@ int main(void)
 
         error = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
         if (error < 0) {
-                syslog(LOG_ERR, "bind failed; error:%d", error);
+                syslog(LOG_ERR, "bind failed; error: %d %s", errno, strerror(errno));
                 close(fd);
                 exit(EXIT_FAILURE);
         }
         nl_group = CN_KVP_IDX;
-        setsockopt(fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &nl_group, sizeof(nl_group));
+
+        if (setsockopt(fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &nl_group, sizeof(nl_group)) < 0) {
+                syslog(LOG_ERR, "setsockopt failed; error: %d %s", errno, strerror(errno));
+                close(fd);
+                exit(EXIT_FAILURE);
+        }
+
         /*
          * Register ourselves with the kernel.
          */
@@ -1472,7 +1499,7 @@ int main(void)
 
         len = netlink_send(fd, message);
         if (len < 0) {
-                syslog(LOG_ERR, "netlink_send failed; error:%d", len);
+                syslog(LOG_ERR, "netlink_send failed; error: %d %s", errno, strerror(errno));
                 close(fd);
                 exit(EXIT_FAILURE);
         }
@@ -1484,9 +1511,18 @@ int main(void)
                 socklen_t addr_l = sizeof(addr);
                 pfd.events = POLLIN;
                 pfd.revents = 0;
-                poll(&pfd, 1, -1);
 
-                len = recvfrom(fd, kvp_recv_buffer, sizeof(kvp_recv_buffer), 0,
+                if (poll(&pfd, 1, -1) < 0) {
+                        syslog(LOG_ERR, "poll failed; error: %d %s", errno, strerror(errno));
+                        if (errno == EINVAL) {
+                                close(fd);
+                                exit(EXIT_FAILURE);
+                        }
+                        else
+                                continue;
+                }
+
+                len = recvfrom(fd, kvp_recv_buffer, kvp_recv_buffer_len, 0,
                                 addr_p, &addr_l);
 
                 if (len < 0) {
@@ -1695,7 +1731,8 @@ kvp_done:
 
                 len = netlink_send(fd, incoming_cn_msg);
                 if (len < 0) {
-                        syslog(LOG_ERR, "net_link send failed; error:%d", len);
+                        syslog(LOG_ERR, "net_link send failed; error: %d %s", errno,
+                                        strerror(errno));
                         exit(EXIT_FAILURE);
                 }
         }
diff --git a/tools/hv/hv_vss_daemon.c b/tools/hv/hv_vss_daemon.c
index fea03a3edaf4..8611962c672c 100644
--- a/tools/hv/hv_vss_daemon.c
+++ b/tools/hv/hv_vss_daemon.c
@@ -38,8 +38,6 @@
 #include <linux/netlink.h>
 #include <syslog.h>
 
-static char vss_recv_buffer[4096];
-static char vss_send_buffer[4096];
 static struct sockaddr_nl addr;
 
 #ifndef SOL_NETLINK
@@ -107,23 +105,18 @@ static int vss_operate(int operation)
 
 static int netlink_send(int fd, struct cn_msg *msg)
 {
-        struct nlmsghdr *nlh;
+        struct nlmsghdr nlh = { .nlmsg_type = NLMSG_DONE };
         unsigned int size;
         struct msghdr message;
-        char buffer[64];
         struct iovec iov[2];
 
-        size = NLMSG_SPACE(sizeof(struct cn_msg) + msg->len);
+        size = sizeof(struct cn_msg) + msg->len;
 
-        nlh = (struct nlmsghdr *)buffer;
-        nlh->nlmsg_seq = 0;
-        nlh->nlmsg_pid = getpid();
-        nlh->nlmsg_type = NLMSG_DONE;
-        nlh->nlmsg_len = NLMSG_LENGTH(size - sizeof(*nlh));
-        nlh->nlmsg_flags = 0;
+        nlh.nlmsg_pid = getpid();
+        nlh.nlmsg_len = NLMSG_LENGTH(size);
 
-        iov[0].iov_base = nlh;
-        iov[0].iov_len = sizeof(*nlh);
+        iov[0].iov_base = &nlh;
+        iov[0].iov_len = sizeof(nlh);
 
         iov[1].iov_base = msg;
         iov[1].iov_len = size;
@@ -147,6 +140,9 @@ int main(void)
         struct cn_msg   *incoming_cn_msg;
         int     op;
         struct hv_vss_msg *vss_msg;
+        char *vss_send_buffer;
+        char *vss_recv_buffer;
+        size_t vss_recv_buffer_len;
 
         if (daemon(1, 0))
                 return 1;
@@ -154,9 +150,18 @@ int main(void)
         openlog("Hyper-V VSS", 0, LOG_USER);
         syslog(LOG_INFO, "VSS starting; pid is:%d", getpid());
 
+        vss_recv_buffer_len = NLMSG_HDRLEN + sizeof(struct cn_msg) + sizeof(struct hv_vss_msg);
+        vss_send_buffer = calloc(1, vss_recv_buffer_len);
+        vss_recv_buffer = calloc(1, vss_recv_buffer_len);
+        if (!(vss_send_buffer && vss_recv_buffer)) {
+                syslog(LOG_ERR, "Failed to allocate netlink buffers");
+                exit(EXIT_FAILURE);
+        }
+
         fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
         if (fd < 0) {
-                syslog(LOG_ERR, "netlink socket creation failed; error:%d", fd);
+                syslog(LOG_ERR, "netlink socket creation failed; error:%d %s",
+                                errno, strerror(errno));
                 exit(EXIT_FAILURE);
         }
         addr.nl_family = AF_NETLINK;
@@ -167,12 +172,16 @@ int main(void)
 
         error = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
         if (error < 0) {
-                syslog(LOG_ERR, "bind failed; error:%d", error);
+                syslog(LOG_ERR, "bind failed; error:%d %s", errno, strerror(errno));
                 close(fd);
                 exit(EXIT_FAILURE);
         }
         nl_group = CN_VSS_IDX;
-        setsockopt(fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &nl_group, sizeof(nl_group));
+        if (setsockopt(fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &nl_group, sizeof(nl_group)) < 0) {
+                syslog(LOG_ERR, "setsockopt failed; error:%d %s", errno, strerror(errno));
+                close(fd);
+                exit(EXIT_FAILURE);
+        }
         /*
          * Register ourselves with the kernel.
          */
@@ -187,7 +196,7 @@ int main(void)
 
         len = netlink_send(fd, message);
         if (len < 0) {
-                syslog(LOG_ERR, "netlink_send failed; error:%d", len);
+                syslog(LOG_ERR, "netlink_send failed; error:%d %s", errno, strerror(errno));
                 close(fd);
                 exit(EXIT_FAILURE);
         }
@@ -199,9 +208,18 @@ int main(void)
                 socklen_t addr_l = sizeof(addr);
                 pfd.events = POLLIN;
                 pfd.revents = 0;
-                poll(&pfd, 1, -1);
 
-                len = recvfrom(fd, vss_recv_buffer, sizeof(vss_recv_buffer), 0,
+                if (poll(&pfd, 1, -1) < 0) {
+                        syslog(LOG_ERR, "poll failed; error:%d %s", errno, strerror(errno));
+                        if (errno == EINVAL) {
+                                close(fd);
+                                exit(EXIT_FAILURE);
+                        }
+                        else
+                                continue;
+                }
+
+                len = recvfrom(fd, vss_recv_buffer, vss_recv_buffer_len, 0,
                                 addr_p, &addr_l);
 
                 if (len < 0) {
@@ -241,7 +259,8 @@ int main(void)
                 vss_msg->error = error;
                 len = netlink_send(fd, incoming_cn_msg);
                 if (len < 0) {
-                        syslog(LOG_ERR, "net_link send failed; error:%d", len);
+                        syslog(LOG_ERR, "net_link send failed; error:%d %s",
+                                        errno, strerror(errno));
                         exit(EXIT_FAILURE);
                 }
         }
diff --git a/tools/include/tools/be_byteshift.h b/tools/include/tools/be_byteshift.h
index f4912e2668ba..84c17d836578 100644
--- a/tools/include/tools/be_byteshift.h
+++ b/tools/include/tools/be_byteshift.h
@@ -1,68 +1,68 @@
 #ifndef _TOOLS_BE_BYTESHIFT_H
 #define _TOOLS_BE_BYTESHIFT_H
 
-#include <linux/types.h>
+#include <stdint.h>
 
-static inline __u16 __get_unaligned_be16(const __u8 *p)
+static inline uint16_t __get_unaligned_be16(const uint8_t *p)
 {
         return p[0] << 8 | p[1];
 }
 
-static inline __u32 __get_unaligned_be32(const __u8 *p)
+static inline uint32_t __get_unaligned_be32(const uint8_t *p)
 {
         return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
 }
 
-static inline __u64 __get_unaligned_be64(const __u8 *p)
+static inline uint64_t __get_unaligned_be64(const uint8_t *p)
 {
-        return (__u64)__get_unaligned_be32(p) << 32 |
+        return (uint64_t)__get_unaligned_be32(p) << 32 |
                __get_unaligned_be32(p + 4);
 }
 
-static inline void __put_unaligned_be16(__u16 val, __u8 *p)
+static inline void __put_unaligned_be16(uint16_t val, uint8_t *p)
 {
         *p++ = val >> 8;
         *p++ = val;
 }
 
-static inline void __put_unaligned_be32(__u32 val, __u8 *p)
+static inline void __put_unaligned_be32(uint32_t val, uint8_t *p)
 {
         __put_unaligned_be16(val >> 16, p);
         __put_unaligned_be16(val, p + 2);
 }
 
-static inline void __put_unaligned_be64(__u64 val, __u8 *p)
+static inline void __put_unaligned_be64(uint64_t val, uint8_t *p)
 {
         __put_unaligned_be32(val >> 32, p);
         __put_unaligned_be32(val, p + 4);
 }
 
-static inline __u16 get_unaligned_be16(const void *p)
+static inline uint16_t get_unaligned_be16(const void *p)
 {
-        return __get_unaligned_be16((const __u8 *)p);
+        return __get_unaligned_be16((const uint8_t *)p);
 }
 
-static inline __u32 get_unaligned_be32(const void *p)
+static inline uint32_t get_unaligned_be32(const void *p)
 {
-        return __get_unaligned_be32((const __u8 *)p);
+        return __get_unaligned_be32((const uint8_t *)p);
 }
 
-static inline __u64 get_unaligned_be64(const void *p)
+static inline uint64_t get_unaligned_be64(const void *p)
 {
-        return __get_unaligned_be64((const __u8 *)p);
+        return __get_unaligned_be64((const uint8_t *)p);
 }
 
-static inline void put_unaligned_be16(__u16 val, void *p)
+static inline void put_unaligned_be16(uint16_t val, void *p)
 {
         __put_unaligned_be16(val, p);
 }
 
-static inline void put_unaligned_be32(__u32 val, void *p)
+static inline void put_unaligned_be32(uint32_t val, void *p)
 {
         __put_unaligned_be32(val, p);
 }
 
-static inline void put_unaligned_be64(__u64 val, void *p)
+static inline void put_unaligned_be64(uint64_t val, void *p)
 {
         __put_unaligned_be64(val, p);
 }
diff --git a/tools/include/tools/le_byteshift.h b/tools/include/tools/le_byteshift.h
index c99d45a68bda..8fe9f2488ec7 100644
--- a/tools/include/tools/le_byteshift.h
+++ b/tools/include/tools/le_byteshift.h
@@ -1,68 +1,68 @@
 #ifndef _TOOLS_LE_BYTESHIFT_H
 #define _TOOLS_LE_BYTESHIFT_H
 
-#include <linux/types.h>
+#include <stdint.h>
 
-static inline __u16 __get_unaligned_le16(const __u8 *p)
+static inline uint16_t __get_unaligned_le16(const uint8_t *p)
 {
         return p[0] | p[1] << 8;
 }
 
-static inline __u32 __get_unaligned_le32(const __u8 *p)
+static inline uint32_t __get_unaligned_le32(const uint8_t *p)
 {
         return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24;
 }
 
-static inline __u64 __get_unaligned_le64(const __u8 *p)
+static inline uint64_t __get_unaligned_le64(const uint8_t *p)
 {
-        return (__u64)__get_unaligned_le32(p + 4) << 32 |
+        return (uint64_t)__get_unaligned_le32(p + 4) << 32 |
                __get_unaligned_le32(p);
 }
 
-static inline void __put_unaligned_le16(__u16 val, __u8 *p)
+static inline void __put_unaligned_le16(uint16_t val, uint8_t *p)
 {
         *p++ = val;
         *p++ = val >> 8;
 }
 
-static inline void __put_unaligned_le32(__u32 val, __u8 *p)
+static inline void __put_unaligned_le32(uint32_t val, uint8_t *p)
 {
         __put_unaligned_le16(val >> 16, p + 2);
         __put_unaligned_le16(val, p);
 }
 
-static inline void __put_unaligned_le64(__u64 val, __u8 *p)
+static inline void __put_unaligned_le64(uint64_t val, uint8_t *p)
 {
         __put_unaligned_le32(val >> 32, p + 4);
         __put_unaligned_le32(val, p);
 }
 
-static inline __u16 get_unaligned_le16(const void *p)
+static inline uint16_t get_unaligned_le16(const void *p)
 {
-        return __get_unaligned_le16((const __u8 *)p);
+        return __get_unaligned_le16((const uint8_t *)p);
 }
 
-static inline __u32 get_unaligned_le32(const void *p)
+static inline uint32_t get_unaligned_le32(const void *p)
 {
-        return __get_unaligned_le32((const __u8 *)p);
+        return __get_unaligned_le32((const uint8_t *)p);
 }
 
-static inline __u64 get_unaligned_le64(const void *p)
+static inline uint64_t get_unaligned_le64(const void *p)
 {
-        return __get_unaligned_le64((const __u8 *)p);
+        return __get_unaligned_le64((const uint8_t *)p);
 }
 
-static inline void put_unaligned_le16(__u16 val, void *p)
+static inline void put_unaligned_le16(uint16_t val, void *p)
 {
         __put_unaligned_le16(val, p);
 }
 
-static inline void put_unaligned_le32(__u32 val, void *p)
+static inline void put_unaligned_le32(uint32_t val, void *p)
 {
         __put_unaligned_le32(val, p);
 }
 
-static inline void put_unaligned_le64(__u64 val, void *p)
+static inline void put_unaligned_le64(uint64_t val, void *p)
 {
         __put_unaligned_le64(val, p);
 }
diff --git a/tools/lguest/Makefile b/tools/lguest/Makefile
index 0ac34206f7a7..97bca4871ea3 100644
--- a/tools/lguest/Makefile
+++ b/tools/lguest/Makefile
@@ -1,5 +1,4 @@
 # This creates the demonstration utility "lguest" which runs a Linux guest.
-# Missing headers?  Add "-I../../../include -I../../../arch/x86/include"
 CFLAGS:=-m32 -Wall -Wmissing-declarations -Wmissing-prototypes -O3 -U_FORTIFY_SOURCE
 
 all: lguest
diff --git a/tools/lguest/lguest.c b/tools/lguest/lguest.c
index 07a03452c227..32cf2ce15d69 100644
--- a/tools/lguest/lguest.c
+++ b/tools/lguest/lguest.c
@@ -42,14 +42,10 @@
 #include <pwd.h>
 #include <grp.h>
 
-#include <linux/virtio_config.h>
-#include <linux/virtio_net.h>
-#include <linux/virtio_blk.h>
-#include <linux/virtio_console.h>
-#include <linux/virtio_rng.h>
-#include <linux/virtio_ring.h>
-#include <asm/bootparam.h>
-#include "../../include/linux/lguest_launcher.h"
+#ifndef VIRTIO_F_ANY_LAYOUT
+#define VIRTIO_F_ANY_LAYOUT             27
+#endif
+
 /*L:110
  * We can ignore the 43 include files we need for this program, but I do want
  * to draw attention to the use of kernel-style types.
@@ -65,6 +61,15 @@ typedef uint16_t u16;
 typedef uint8_t u8;
 /*:*/
 
+#include <linux/virtio_config.h>
+#include <linux/virtio_net.h>
+#include <linux/virtio_blk.h>
+#include <linux/virtio_console.h>
+#include <linux/virtio_rng.h>
+#include <linux/virtio_ring.h>
+#include <asm/bootparam.h>
+#include "../../include/linux/lguest_launcher.h"
+
 #define BRIDGE_PFX "bridge:"
 #ifndef SIOCBRADDIF
 #define SIOCBRADDIF     0x89a2          /* add interface to bridge      */
@@ -177,7 +182,8 @@ static struct termios orig_term;
  * in precise order.
  */
 #define wmb() __asm__ __volatile__("" : : : "memory")
-#define mb() __asm__ __volatile__("" : : : "memory")
+#define rmb() __asm__ __volatile__("lock; addl $0,0(%%esp)" : : : "memory")
+#define mb() __asm__ __volatile__("lock; addl $0,0(%%esp)" : : : "memory")
 
 /* Wrapper for the last available index.  Makes it easier to change. */
 #define lg_last_avail(vq)       ((vq)->last_avail_idx)
@@ -676,6 +682,12 @@ static unsigned wait_for_vq_desc(struct virtqueue *vq,
                 errx(1, "Guest moved used index from %u to %u",
                      last_avail, vq->vring.avail->idx);
 
+        /* 
+         * Make sure we read the descriptor number *after* we read the ring
+         * update; don't let the cpu or compiler change the order.
+         */
+        rmb();
+
         /*
          * Grab the next descriptor number they're advertising, and increment
          * the index we've seen.
@@ -695,6 +707,12 @@ static unsigned wait_for_vq_desc(struct virtqueue *vq,
         i = head;
 
         /*
+         * We have to read the descriptor after we read the descriptor number,
+         * but there's a data dependency there so the CPU shouldn't reorder
+         * that: no rmb() required.
+         */
+
+        /*
          * If this is an indirect entry, then this buffer contains a descriptor
          * table which we handle as if it's any normal descriptor chain.
          */
@@ -1530,6 +1548,8 @@ static void setup_tun_net(char *arg)
         add_feature(dev, VIRTIO_NET_F_HOST_ECN);
         /* We handle indirect ring entries */
         add_feature(dev, VIRTIO_RING_F_INDIRECT_DESC);
+        /* We're compliant with the damn spec. */
+        add_feature(dev, VIRTIO_F_ANY_LAYOUT);
         set_config(dev, sizeof(conf), &conf);
 
         /* We don't need the socket any more; setup is done. */
diff --git a/tools/lib/lk/Makefile b/tools/lib/lk/Makefile
index 926cbf3efc7f..3dba0a4aebbf 100644
--- a/tools/lib/lk/Makefile
+++ b/tools/lib/lk/Makefile
@@ -1,5 +1,8 @@
 include ../../scripts/Makefile.include
 
+CC = $(CROSS_COMPILE)gcc
+AR = $(CROSS_COMPILE)ar
+
 # guard against environment variables
 LIB_H=
 LIB_OBJS=
@@ -11,7 +14,7 @@ LIB_OBJS += $(OUTPUT)debugfs.o
 LIBFILE = liblk.a
 
 CFLAGS = -ggdb3 -Wall -Wextra -std=gnu99 -Werror -O6 -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS) -fPIC
-EXTLIBS = -lpthread -lrt -lelf -lm
+EXTLIBS = -lelf -lpthread -lrt -lm
 ALL_CFLAGS = $(CFLAGS) $(BASIC_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
 ALL_LDFLAGS = $(LDFLAGS)
 
diff --git a/tools/lib/lk/debugfs.c b/tools/lib/lk/debugfs.c
index 099e7cd022e4..7c4347962353 100644
--- a/tools/lib/lk/debugfs.c
+++ b/tools/lib/lk/debugfs.c
@@ -5,7 +5,6 @@
 #include <stdbool.h>
 #include <sys/vfs.h>
 #include <sys/mount.h>
-#include <linux/magic.h>
 #include <linux/kernel.h>
 
 #include "debugfs.h"
diff --git a/tools/lib/traceevent/Makefile b/tools/lib/traceevent/Makefile
index 0b0a90787db6..ca6cb779876a 100644
--- a/tools/lib/traceevent/Makefile
+++ b/tools/lib/traceevent/Makefile
@@ -39,13 +39,8 @@ bindir_relative = bin
 bindir = $(prefix)/$(bindir_relative)
 man_dir = $(prefix)/share/man
 man_dir_SQ = '$(subst ','\'',$(man_dir))'
-html_install = $(prefix)/share/kernelshark/html
-html_install_SQ = '$(subst ','\'',$(html_install))'
-img_install = $(prefix)/share/kernelshark/html/images
-img_install_SQ = '$(subst ','\'',$(img_install))'
 
-export man_dir man_dir_SQ html_install html_install_SQ INSTALL
-export img_install img_install_SQ
+export man_dir man_dir_SQ INSTALL
 export DESTDIR DESTDIR_SQ
 
 # copy a bit from Linux kbuild
@@ -65,7 +60,7 @@ ifeq ($(BUILD_SRC),)
 ifneq ($(BUILD_OUTPUT),)
 
 define build_output
-        $(if $(VERBOSE:1=),@)$(MAKE) -C $(BUILD_OUTPUT)         \
+        $(if $(VERBOSE:1=),@)+$(MAKE) -C $(BUILD_OUTPUT)        \
         BUILD_SRC=$(CURDIR) -f $(CURDIR)/Makefile $1
 endef
 
@@ -76,10 +71,7 @@ $(if $(BUILD_OUTPUT),, \
 
 all: sub-make
 
-gui: force
-        $(call build_output, all_cmd)
-
-$(filter-out gui,$(MAKECMDGOALS)): sub-make
+$(MAKECMDGOALS): sub-make
 
 sub-make: force
         $(call build_output, $(MAKECMDGOALS))
@@ -189,6 +181,7 @@ $(obj)/%.o: $(src)/%.c
         $(Q)$(call do_compile)
 
 PEVENT_LIB_OBJS = event-parse.o trace-seq.o parse-filter.o parse-utils.o
+PEVENT_LIB_OBJS += kbuffer-parse.o
 
 ALL_OBJS = $(PEVENT_LIB_OBJS)
 
@@ -258,9 +251,6 @@ define check_deps
                 $(RM) $@.$$$$
 endef
 
-$(gui_deps): ks_version.h
-$(non_gui_deps): tc_version.h
-
 $(all_deps): .%.d: $(src)/%.c
         $(Q)$(call check_deps)
 
@@ -300,7 +290,7 @@ define do_install
         $(INSTALL) $1 '$(DESTDIR_SQ)$2'
 endef
 
-install_lib: all_cmd install_plugins install_python
+install_lib: all_cmd
         $(Q)$(call do_install,$(LIB_FILE),$(bindir_SQ))
 
 install: install_lib
diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index 82b0606dcb8a..d1c2a6a4cd32 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -5450,10 +5450,9 @@ int pevent_register_print_function(struct pevent *pevent,
  * If @id is >= 0, then it is used to find the event.
  * else @sys_name and @event_name are used.
  */
-int pevent_register_event_handler(struct pevent *pevent,
-                                  int id, char *sys_name, char *event_name,
-                                  pevent_event_handler_func func,
-                                  void *context)
+int pevent_register_event_handler(struct pevent *pevent, int id,
+                                  const char *sys_name, const char *event_name,
+                                  pevent_event_handler_func func, void *context)
 {
         struct event_format *event;
         struct event_handler *handle;
diff --git a/tools/lib/traceevent/event-parse.h b/tools/lib/traceevent/event-parse.h
index 7be7e89533e4..c37b2026d04a 100644
--- a/tools/lib/traceevent/event-parse.h
+++ b/tools/lib/traceevent/event-parse.h
@@ -69,6 +69,7 @@ struct trace_seq {
 };
 
 void trace_seq_init(struct trace_seq *s);
+void trace_seq_reset(struct trace_seq *s);
 void trace_seq_destroy(struct trace_seq *s);
 
 extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
@@ -399,6 +400,7 @@ struct pevent {
 
         int cpus;
         int long_size;
+        int page_size;
 
         struct cmdline *cmdlines;
         struct cmdline_list *cmdlist;
@@ -561,7 +563,8 @@ int pevent_print_num_field(struct trace_seq *s, const char *fmt,
                            struct event_format *event, const char *name,
                            struct pevent_record *record, int err);
 
-int pevent_register_event_handler(struct pevent *pevent, int id, char *sys_name, char *event_name,
+int pevent_register_event_handler(struct pevent *pevent, int id,
+                                  const char *sys_name, const char *event_name,
                                   pevent_event_handler_func func, void *context);
 int pevent_register_print_function(struct pevent *pevent,
                                    pevent_func_handler func,
@@ -619,6 +622,16 @@ static inline void pevent_set_long_size(struct pevent *pevent, int long_size)
         pevent->long_size = long_size;
 }
 
+static inline int pevent_get_page_size(struct pevent *pevent)
+{
+        return pevent->page_size;
+}
+
+static inline void pevent_set_page_size(struct pevent *pevent, int _page_size)
+{
+        pevent->page_size = _page_size;
+}
+
 static inline int pevent_is_file_bigendian(struct pevent *pevent)
 {
         return pevent->file_bigendian;
diff --git a/tools/lib/traceevent/kbuffer-parse.c b/tools/lib/traceevent/kbuffer-parse.c
new file mode 100644
index 000000000000..dcc665228c71
--- /dev/null
+++ b/tools/lib/traceevent/kbuffer-parse.c
@@ -0,0 +1,732 @@
+/*
+ * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "kbuffer.h"
+
+#define MISSING_EVENTS (1 << 31)
+#define MISSING_STORED (1 << 30)
+
+#define COMMIT_MASK ((1 << 27) - 1)
+
+enum {
+        KBUFFER_FL_HOST_BIG_ENDIAN      = (1<<0),
+        KBUFFER_FL_BIG_ENDIAN           = (1<<1),
+        KBUFFER_FL_LONG_8               = (1<<2),
+        KBUFFER_FL_OLD_FORMAT           = (1<<3),
+};
+
+#define ENDIAN_MASK (KBUFFER_FL_HOST_BIG_ENDIAN | KBUFFER_FL_BIG_ENDIAN)
+
+/** kbuffer
+ * @timestamp           - timestamp of current event
+ * @lost_events         - # of lost events between this subbuffer and previous
+ * @flags               - special flags of the kbuffer
+ * @subbuffer           - pointer to the sub-buffer page
+ * @data                - pointer to the start of data on the sub-buffer page
+ * @index               - index from @data to the @curr event data
+ * @curr                - offset from @data to the start of current event
+ *                         (includes metadata)
+ * @next                - offset from @data to the start of next event
+ * @size                - The size of data on @data
+ * @start               - The offset from @subbuffer where @data lives
+ *
+ * @read_4              - Function to read 4 raw bytes (may swap)
+ * @read_8              - Function to read 8 raw bytes (may swap)
+ * @read_long           - Function to read a long word (4 or 8 bytes with needed swap)
+ */
+struct kbuffer {
+        unsigned long long      timestamp;
+        long long               lost_events;
+        unsigned long           flags;
+        void                    *subbuffer;
+        void                    *data;
+        unsigned int            index;
+        unsigned int            curr;
+        unsigned int            next;
+        unsigned int            size;
+        unsigned int            start;
+
+        unsigned int (*read_4)(void *ptr);
+        unsigned long long (*read_8)(void *ptr);
+        unsigned long long (*read_long)(struct kbuffer *kbuf, void *ptr);
+        int (*next_event)(struct kbuffer *kbuf);
+};
+
+static void *zmalloc(size_t size)
+{
+        return calloc(1, size);
+}
+
+static int host_is_bigendian(void)
+{
+        unsigned char str[] = { 0x1, 0x2, 0x3, 0x4 };
+        unsigned int *ptr;
+
+        ptr = (unsigned int *)str;
+        return *ptr == 0x01020304;
+}
+
+static int do_swap(struct kbuffer *kbuf)
+{
+        return ((kbuf->flags & KBUFFER_FL_HOST_BIG_ENDIAN) + kbuf->flags) &
+                ENDIAN_MASK;
+}
+
+static unsigned long long __read_8(void *ptr)
+{
+        unsigned long long data = *(unsigned long long *)ptr;
+
+        return data;
+}
+
+static unsigned long long __read_8_sw(void *ptr)
+{
+        unsigned long long data = *(unsigned long long *)ptr;
+        unsigned long long swap;
+
+        swap = ((data & 0xffULL) << 56) |
+                ((data & (0xffULL << 8)) << 40) |
+                ((data & (0xffULL << 16)) << 24) |
+                ((data & (0xffULL << 24)) << 8) |
+                ((data & (0xffULL << 32)) >> 8) |
+                ((data & (0xffULL << 40)) >> 24) |
+                ((data & (0xffULL << 48)) >> 40) |
+                ((data & (0xffULL << 56)) >> 56);
+
+        return swap;
+}
+
+static unsigned int __read_4(void *ptr)
+{
+        unsigned int data = *(unsigned int *)ptr;
+
+        return data;
+}
+
+static unsigned int __read_4_sw(void *ptr)
+{
+        unsigned int data = *(unsigned int *)ptr;
+        unsigned int swap;
+
+        swap = ((data & 0xffULL) << 24) |
+                ((data & (0xffULL << 8)) << 8) |
+                ((data & (0xffULL << 16)) >> 8) |
+                ((data & (0xffULL << 24)) >> 24);
+
+        return swap;
+}
+
+static unsigned long long read_8(struct kbuffer *kbuf, void *ptr)
+{
+        return kbuf->read_8(ptr);
+}
+
+static unsigned int read_4(struct kbuffer *kbuf, void *ptr)
+{
+        return kbuf->read_4(ptr);
+}
+
+static unsigned long long __read_long_8(struct kbuffer *kbuf, void *ptr)
+{
+        return kbuf->read_8(ptr);
+}
+
+static unsigned long long __read_long_4(struct kbuffer *kbuf, void *ptr)
+{
+        return kbuf->read_4(ptr);
+}
+
+static unsigned long long read_long(struct kbuffer *kbuf, void *ptr)
+{
+        return kbuf->read_long(kbuf, ptr);
+}
+
+static int calc_index(struct kbuffer *kbuf, void *ptr)
+{
+        return (unsigned long)ptr - (unsigned long)kbuf->data;
+}
+
+static int __next_event(struct kbuffer *kbuf);
+
+/**
+ * kbuffer_alloc - allocat a new kbuffer
+ * @size;       enum to denote size of word
+ * @endian:     enum to denote endianness
+ *
+ * Allocates and returns a new kbuffer.
+ */
+struct kbuffer *
+kbuffer_alloc(enum kbuffer_long_size size, enum kbuffer_endian endian)
+{
+        struct kbuffer *kbuf;
+        int flags = 0;
+
+        switch (size) {
+        case KBUFFER_LSIZE_4:
+                break;
+        case KBUFFER_LSIZE_8:
+                flags |= KBUFFER_FL_LONG_8;
+                break;
+        default:
+                return NULL;
+        }
+
+        switch (endian) {
+        case KBUFFER_ENDIAN_LITTLE:
+                break;
+        case KBUFFER_ENDIAN_BIG:
+                flags |= KBUFFER_FL_BIG_ENDIAN;
+                break;
+        default:
+                return NULL;
+        }
+
+        kbuf = zmalloc(sizeof(*kbuf));
+        if (!kbuf)
+                return NULL;
+
+        kbuf->flags = flags;
+
+        if (host_is_bigendian())
+                kbuf->flags |= KBUFFER_FL_HOST_BIG_ENDIAN;
+
+        if (do_swap(kbuf)) {
+                kbuf->read_8 = __read_8_sw;
+                kbuf->read_4 = __read_4_sw;
+        } else {
+                kbuf->read_8 = __read_8;
+                kbuf->read_4 = __read_4;
+        }
+
+        if (kbuf->flags & KBUFFER_FL_LONG_8)
+                kbuf->read_long = __read_long_8;
+        else
+                kbuf->read_long = __read_long_4;
+
+        /* May be changed by kbuffer_set_old_format() */
+        kbuf->next_event = __next_event;
+
+        return kbuf;
+}
+
+/** kbuffer_free - free an allocated kbuffer
+ * @kbuf:       The kbuffer to free
+ *
+ * Can take NULL as a parameter.
+ */
+void kbuffer_free(struct kbuffer *kbuf)
+{
+        free(kbuf);
+}
+
+static unsigned int type4host(struct kbuffer *kbuf,
+                              unsigned int type_len_ts)
+{
+        if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
+                return (type_len_ts >> 29) & 3;
+        else
+                return type_len_ts & 3;
+}
+
+static unsigned int len4host(struct kbuffer *kbuf,
+                             unsigned int type_len_ts)
+{
+        if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
+                return (type_len_ts >> 27) & 7;
+        else
+                return (type_len_ts >> 2) & 7;
+}
+
+static unsigned int type_len4host(struct kbuffer *kbuf,
+                                  unsigned int type_len_ts)
+{
+        if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
+                return (type_len_ts >> 27) & ((1 << 5) - 1);
+        else
+                return type_len_ts & ((1 << 5) - 1);
+}
+
+static unsigned int ts4host(struct kbuffer *kbuf,
+                            unsigned int type_len_ts)
+{
+        if (kbuf->flags & KBUFFER_FL_BIG_ENDIAN)
+                return type_len_ts & ((1 << 27) - 1);
+        else
+                return type_len_ts >> 5;
+}
+
+/*
+ * Linux 2.6.30 and earlier (not much ealier) had a different
+ * ring buffer format. It should be obsolete, but we handle it anyway.
+ */
+enum old_ring_buffer_type {
+        OLD_RINGBUF_TYPE_PADDING,
+        OLD_RINGBUF_TYPE_TIME_EXTEND,
+        OLD_RINGBUF_TYPE_TIME_STAMP,
+        OLD_RINGBUF_TYPE_DATA,
+};
+
+static unsigned int old_update_pointers(struct kbuffer *kbuf)
+{
+        unsigned long long extend;
+        unsigned int type_len_ts;
+        unsigned int type;
+        unsigned int len;
+        unsigned int delta;
+        unsigned int length;
+        void *ptr = kbuf->data + kbuf->curr;
+
+        type_len_ts = read_4(kbuf, ptr);
+        ptr += 4;
+
+        type = type4host(kbuf, type_len_ts);
+        len = len4host(kbuf, type_len_ts);
+        delta = ts4host(kbuf, type_len_ts);
+
+        switch (type) {
+        case OLD_RINGBUF_TYPE_PADDING:
+                kbuf->next = kbuf->size;
+                return 0;
+
+        case OLD_RINGBUF_TYPE_TIME_EXTEND:
+                extend = read_4(kbuf, ptr);
+                extend <<= TS_SHIFT;
+                extend += delta;
+                delta = extend;
+                ptr += 4;
+                break;
+
+        case OLD_RINGBUF_TYPE_TIME_STAMP:
+                /* should never happen! */
+                kbuf->curr = kbuf->size;
+                kbuf->next = kbuf->size;
+                kbuf->index = kbuf->size;
+                return -1;
+        default:
+                if (len)
+                        length = len * 4;
+                else {
+                        length = read_4(kbuf, ptr);
+                        length -= 4;
+                        ptr += 4;
+                }
+                break;
+        }
+
+        kbuf->timestamp += delta;
+        kbuf->index = calc_index(kbuf, ptr);
+        kbuf->next = kbuf->index + length;
+
+        return type;
+}
+
+static int __old_next_event(struct kbuffer *kbuf)
+{
+        int type;
+
+        do {
+                kbuf->curr = kbuf->next;
+                if (kbuf->next >= kbuf->size)
+                        return -1;
+                type = old_update_pointers(kbuf);
+        } while (type == OLD_RINGBUF_TYPE_TIME_EXTEND || type == OLD_RINGBUF_TYPE_PADDING);
+
+        return 0;
+}
+
+static unsigned int
+translate_data(struct kbuffer *kbuf, void *data, void **rptr,
+               unsigned long long *delta, int *length)
+{
+        unsigned long long extend;
+        unsigned int type_len_ts;
+        unsigned int type_len;
+
+        type_len_ts = read_4(kbuf, data);
+        data += 4;
+
+        type_len = type_len4host(kbuf, type_len_ts);
+        *delta = ts4host(kbuf, type_len_ts);
+
+        switch (type_len) {
+        case KBUFFER_TYPE_PADDING:
+                *length = read_4(kbuf, data);
+                data += *length;
+                break;
+
+        case KBUFFER_TYPE_TIME_EXTEND:
+                extend = read_4(kbuf, data);
+                data += 4;
+                extend <<= TS_SHIFT;
+                extend += *delta;
+                *delta = extend;
+                *length = 0;
+                break;
+
+        case KBUFFER_TYPE_TIME_STAMP:
+                data += 12;
+                *length = 0;
+                break;
+        case 0:
+                *length = read_4(kbuf, data) - 4;
+                *length = (*length + 3) & ~3;
+                data += 4;
+                break;
+        default:
+                *length = type_len * 4;
+                break;
+        }
+
+        *rptr = data;
+
+        return type_len;
+}
+
+static unsigned int update_pointers(struct kbuffer *kbuf)
+{
+        unsigned long long delta;
+        unsigned int type_len;
+        int length;
+        void *ptr = kbuf->data + kbuf->curr;
+
+        type_len = translate_data(kbuf, ptr, &ptr, &delta, &length);
+
+        kbuf->timestamp += delta;
+        kbuf->index = calc_index(kbuf, ptr);
+        kbuf->next = kbuf->index + length;
+
+        return type_len;
+}
+
+/**
+ * kbuffer_translate_data - read raw data to get a record
+ * @swap:       Set to 1 if bytes in words need to be swapped when read
+ * @data:       The raw data to read
+ * @size:       Address to store the size of the event data.
+ *
+ * Returns a pointer to the event data. To determine the entire
+ * record size (record metadata + data) just add the difference between
+ * @data and the returned value to @size.
+ */
+void *kbuffer_translate_data(int swap, void *data, unsigned int *size)
+{
+        unsigned long long delta;
+        struct kbuffer kbuf;
+        int type_len;
+        int length;
+        void *ptr;
+
+        if (swap) {
+                kbuf.read_8 = __read_8_sw;
+                kbuf.read_4 = __read_4_sw;
+                kbuf.flags = host_is_bigendian() ? 0 : KBUFFER_FL_BIG_ENDIAN;
+        } else {
+                kbuf.read_8 = __read_8;
+                kbuf.read_4 = __read_4;
+                kbuf.flags = host_is_bigendian() ? KBUFFER_FL_BIG_ENDIAN: 0;
+        }
+
+        type_len = translate_data(&kbuf, data, &ptr, &delta, &length);
+        switch (type_len) {
+        case KBUFFER_TYPE_PADDING:
+        case KBUFFER_TYPE_TIME_EXTEND:
+        case KBUFFER_TYPE_TIME_STAMP:
+                return NULL;
+        };
+
+        *size = length;
+
+        return ptr;
+}
+
+static int __next_event(struct kbuffer *kbuf)
+{
+        int type;
+
+        do {
+                kbuf->curr = kbuf->next;
+                if (kbuf->next >= kbuf->size)
+                        return -1;
+                type = update_pointers(kbuf);
+        } while (type == KBUFFER_TYPE_TIME_EXTEND || type == KBUFFER_TYPE_PADDING);
+
+        return 0;
+}
+
+static int next_event(struct kbuffer *kbuf)
+{
+        return kbuf->next_event(kbuf);
+}
+
+/**
+ * kbuffer_next_event - increment the current pointer
+ * @kbuf:       The kbuffer to read
+ * @ts:         Address to store the next record's timestamp (may be NULL to ignore)
+ *
+ * Increments the pointers into the subbuffer of the kbuffer to point to the
+ * next event so that the next kbuffer_read_event() will return a
+ * new event.
+ *
+ * Returns the data of the next event if a new event exists on the subbuffer,
+ * NULL otherwise.
+ */
+void *kbuffer_next_event(struct kbuffer *kbuf, unsigned long long *ts)
+{
+        int ret;
+
+        if (!kbuf || !kbuf->subbuffer)
+                return NULL;
+
+        ret = next_event(kbuf);
+        if (ret < 0)
+                return NULL;
+
+        if (ts)
+                *ts = kbuf->timestamp;
+
+        return kbuf->data + kbuf->index;
+}
+
+/**
+ * kbuffer_load_subbuffer - load a new subbuffer into the kbuffer
+ * @kbuf:       The kbuffer to load
+ * @subbuffer:  The subbuffer to load into @kbuf.
+ *
+ * Load a new subbuffer (page) into @kbuf. This will reset all
+ * the pointers and update the @kbuf timestamp. The next read will
+ * return the first event on @subbuffer.
+ *
+ * Returns 0 on succes, -1 otherwise.
+ */
+int kbuffer_load_subbuffer(struct kbuffer *kbuf, void *subbuffer)
+{
+        unsigned long long flags;
+        void *ptr = subbuffer;
+
+        if (!kbuf || !subbuffer)
+                return -1;
+
+        kbuf->subbuffer = subbuffer;
+
+        kbuf->timestamp = read_8(kbuf, ptr);
+        ptr += 8;
+
+        kbuf->curr = 0;
+
+        if (kbuf->flags & KBUFFER_FL_LONG_8)
+                kbuf->start = 16;
+        else
+                kbuf->start = 12;
+
+        kbuf->data = subbuffer + kbuf->start;
+
+        flags = read_long(kbuf, ptr);
+        kbuf->size = (unsigned int)flags & COMMIT_MASK;
+
+        if (flags & MISSING_EVENTS) {
+                if (flags & MISSING_STORED) {
+                        ptr = kbuf->data + kbuf->size;
+                        kbuf->lost_events = read_long(kbuf, ptr);
+                } else
+                        kbuf->lost_events = -1;
+        } else
+                kbuf->lost_events = 0;
+
+        kbuf->index = 0;
+        kbuf->next = 0;
+
+        next_event(kbuf);
+
+        return 0;
+}
+
+/**
+ * kbuffer_read_event - read the next event in the kbuffer subbuffer
+ * @kbuf:       The kbuffer to read from
+ * @ts:         The address to store the timestamp of the event (may be NULL to ignore)
+ *
+ * Returns a pointer to the data part of the current event.
+ * NULL if no event is left on the subbuffer.
+ */
+void *kbuffer_read_event(struct kbuffer *kbuf, unsigned long long *ts)
+{
+        if (!kbuf || !kbuf->subbuffer)
+                return NULL;
+
+        if (kbuf->curr >= kbuf->size)
+                return NULL;
+
+        if (ts)
+                *ts = kbuf->timestamp;
+        return kbuf->data + kbuf->index;
+}
+
+/**
+ * kbuffer_timestamp - Return the timestamp of the current event
+ * @kbuf:       The kbuffer to read from
+ *
+ * Returns the timestamp of the current (next) event.
+ */
+unsigned long long kbuffer_timestamp(struct kbuffer *kbuf)
+{
+        return kbuf->timestamp;
+}
+
+/**
+ * kbuffer_read_at_offset - read the event that is at offset
+ * @kbuf:       The kbuffer to read from
+ * @offset:     The offset into the subbuffer
+ * @ts:         The address to store the timestamp of the event (may be NULL to ignore)
+ *
+ * The @offset must be an index from the @kbuf subbuffer beginning.
+ * If @offset is bigger than the stored subbuffer, NULL will be returned.
+ *
+ * Returns the data of the record that is at @offset. Note, @offset does
+ * not need to be the start of the record, the offset just needs to be
+ * in the record (or beginning of it).
+ *
+ * Note, the kbuf timestamp and pointers are updated to the
+ * returned record. That is, kbuffer_read_event() will return the same
+ * data and timestamp, and kbuffer_next_event() will increment from
+ * this record.
+ */
+void *kbuffer_read_at_offset(struct kbuffer *kbuf, int offset,
+                             unsigned long long *ts)
+{
+        void *data;
+
+        if (offset < kbuf->start)
+                offset = 0;
+        else
+                offset -= kbuf->start;
+
+        /* Reset the buffer */
+        kbuffer_load_subbuffer(kbuf, kbuf->subbuffer);
+
+        while (kbuf->curr < offset) {
+                data = kbuffer_next_event(kbuf, ts);
+                if (!data)
+                        break;
+        }
+
+        return data;
+}
+
+/**
+ * kbuffer_subbuffer_size - the size of the loaded subbuffer
+ * @kbuf:       The kbuffer to read from
+ *
+ * Returns the size of the subbuffer. Note, this size is
+ * where the last event resides. The stored subbuffer may actually be
+ * bigger due to padding and such.
+ */
+int kbuffer_subbuffer_size(struct kbuffer *kbuf)
+{
+        return kbuf->size;
+}
+
+/**
+ * kbuffer_curr_index - Return the index of the record
+ * @kbuf:       The kbuffer to read from
+ *
+ * Returns the index from the start of the data part of
+ * the subbuffer to the current location. Note this is not
+ * from the start of the subbuffer. An index of zero will
+ * point to the first record. Use kbuffer_curr_offset() for
+ * the actually offset (that can be used by kbuffer_read_at_offset())
+ */
+int kbuffer_curr_index(struct kbuffer *kbuf)
+{
+        return kbuf->curr;
+}
+
+/**
+ * kbuffer_curr_offset - Return the offset of the record
+ * @kbuf:       The kbuffer to read from
+ *
+ * Returns the offset from the start of the subbuffer to the
+ * current location.
+ */
+int kbuffer_curr_offset(struct kbuffer *kbuf)
+{
+        return kbuf->curr + kbuf->start;
+}
+
+/**
+ * kbuffer_event_size - return the size of the event data
+ * @kbuf:       The kbuffer to read
+ *
+ * Returns the size of the event data (the payload not counting
+ * the meta data of the record) of the current event.
+ */
+int kbuffer_event_size(struct kbuffer *kbuf)
+{
+        return kbuf->next - kbuf->index;
+}
+
+/**
+ * kbuffer_curr_size - return the size of the entire record
+ * @kbuf:       The kbuffer to read
+ *
+ * Returns the size of the entire record (meta data and payload)
+ * of the current event.
+ */
+int kbuffer_curr_size(struct kbuffer *kbuf)
+{
+        return kbuf->next - kbuf->curr;
+}
+
+/**
+ * kbuffer_missed_events - return the # of missed events from last event.
+ * @kbuf:       The kbuffer to read from
+ *
+ * Returns the # of missed events (if recorded) before the current
+ * event. Note, only events on the beginning of a subbuffer can
+ * have missed events, all other events within the buffer will be
+ * zero.
+ */
+int kbuffer_missed_events(struct kbuffer *kbuf)
+{
+        /* Only the first event can have missed events */
+        if (kbuf->curr)
+                return 0;
+
+        return kbuf->lost_events;
+}
+
+/**
+ * kbuffer_set_old_forma - set the kbuffer to use the old format parsing
+ * @kbuf:       The kbuffer to set
+ *
+ * This is obsolete (or should be). The first kernels to use the
+ * new ring buffer had a slightly different ring buffer format
+ * (2.6.30 and earlier). It is still somewhat supported by kbuffer,
+ * but should not be counted on in the future.
+ */
+void kbuffer_set_old_format(struct kbuffer *kbuf)
+{
+        kbuf->flags |= KBUFFER_FL_OLD_FORMAT;
+
+        kbuf->next_event = __old_next_event;
+}
diff --git a/tools/lib/traceevent/kbuffer.h b/tools/lib/traceevent/kbuffer.h
new file mode 100644
index 000000000000..c831f64b17a0
--- /dev/null
+++ b/tools/lib/traceevent/kbuffer.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2012 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#ifndef _KBUFFER_H
+#define _KBUFFER_H
+
+#ifndef TS_SHIFT
+#define TS_SHIFT                27
+#endif
+
+enum kbuffer_endian {
+        KBUFFER_ENDIAN_BIG,
+        KBUFFER_ENDIAN_LITTLE,
+};
+
+enum kbuffer_long_size {
+        KBUFFER_LSIZE_4,
+        KBUFFER_LSIZE_8,
+};
+
+enum {
+        KBUFFER_TYPE_PADDING            = 29,
+        KBUFFER_TYPE_TIME_EXTEND        = 30,
+        KBUFFER_TYPE_TIME_STAMP         = 31,
+};
+
+struct kbuffer;
+
+struct kbuffer *kbuffer_alloc(enum kbuffer_long_size size, enum kbuffer_endian endian);
+void kbuffer_free(struct kbuffer *kbuf);
+int kbuffer_load_subbuffer(struct kbuffer *kbuf, void *subbuffer);
+void *kbuffer_read_event(struct kbuffer *kbuf, unsigned long long *ts);
+void *kbuffer_next_event(struct kbuffer *kbuf, unsigned long long *ts);
+unsigned long long kbuffer_timestamp(struct kbuffer *kbuf);
+
+void *kbuffer_translate_data(int swap, void *data, unsigned int *size);
+
+void *kbuffer_read_at_offset(struct kbuffer *kbuf, int offset, unsigned long long *ts);
+
+int kbuffer_curr_index(struct kbuffer *kbuf);
+
+int kbuffer_curr_offset(struct kbuffer *kbuf);
+int kbuffer_curr_size(struct kbuffer *kbuf);
+int kbuffer_event_size(struct kbuffer *kbuf);
+int kbuffer_missed_events(struct kbuffer *kbuf);
+int kbuffer_subbuffer_size(struct kbuffer *kbuf);
+
+void kbuffer_set_old_format(struct kbuffer *kbuf);
+
+#endif /* _K_BUFFER_H */
diff --git a/tools/lib/traceevent/trace-seq.c b/tools/lib/traceevent/trace-seq.c
index a57db805136a..d7f2e68bc5b9 100644
--- a/tools/lib/traceevent/trace-seq.c
+++ b/tools/lib/traceevent/trace-seq.c
@@ -49,6 +49,19 @@ void trace_seq_init(struct trace_seq *s)
 }
 
 /**
+ * trace_seq_reset - re-initialize the trace_seq structure
+ * @s: a pointer to the trace_seq structure to reset
+ */
+void trace_seq_reset(struct trace_seq *s)
+{
+        if (!s)
+                return;
+        TRACE_SEQ_CHECK(s);
+        s->len = 0;
+        s->readpos = 0;
+}
+
+/**
  * trace_seq_destroy - free up memory of a trace_seq
  * @s: a pointer to the trace_seq to free the buffer
  *
diff --git a/tools/perf/Documentation/Makefile b/tools/perf/Documentation/Makefile
index eb30044a922a..5a37a7c84e69 100644
--- a/tools/perf/Documentation/Makefile
+++ b/tools/perf/Documentation/Makefile
@@ -1,12 +1,6 @@
+include ../../scripts/Makefile.include
 include ../config/utilities.mak
 
-OUTPUT := ./
-ifeq ("$(origin O)", "command line")
-  ifneq ($(O),)
-        OUTPUT := $(O)/
-  endif
-endif
-
 MAN1_TXT= \
         $(filter-out $(addsuffix .txt, $(ARTICLES) $(SP_ARTICLES)), \
                 $(wildcard perf-*.txt)) \
@@ -150,7 +144,7 @@ NO_SUBDIR = :
 endif
 
 ifneq ($(findstring $(MAKEFLAGS),s),s)
-ifndef V
+ifneq ($(V),1)
         QUIET_ASCIIDOC  = @echo '   ' ASCIIDOC $@;
         QUIET_XMLTO     = @echo '   ' XMLTO $@;
         QUIET_DB2TEXI   = @echo '   ' DB2TEXI $@;
@@ -277,7 +271,7 @@ $(MAN_HTML): $(OUTPUT)%.html : %.txt
 
 $(OUTPUT)%.1 $(OUTPUT)%.5 $(OUTPUT)%.7 : $(OUTPUT)%.xml
         $(QUIET_XMLTO)$(RM) $@ && \
-        $(XMLTO) -o $(OUTPUT) -m $(MANPAGE_XSL) $(XMLTO_EXTRA) man $<
+        $(XMLTO) -o $(OUTPUT). -m $(MANPAGE_XSL) $(XMLTO_EXTRA) man $<
 
 $(OUTPUT)%.xml : %.txt
         $(QUIET_ASCIIDOC)$(RM) $@+ $@ && \
diff --git a/tools/perf/Documentation/examples.txt b/tools/perf/Documentation/examples.txt
index 77f952762426..a4e392156488 100644
--- a/tools/perf/Documentation/examples.txt
+++ b/tools/perf/Documentation/examples.txt
@@ -66,7 +66,7 @@ Furthermore, these tracepoints can be used to sample the workload as
 well. For example the page allocations done by a 'git gc' can be
 captured the following way:
 
- titan:~/git> perf record -f -e kmem:mm_page_alloc -c 1 ./git gc
+ titan:~/git> perf record -e kmem:mm_page_alloc -c 1 ./git gc
  Counting objects: 1148, done.
  Delta compression using up to 2 threads.
  Compressing objects: 100% (450/450), done.
@@ -120,7 +120,7 @@ Furthermore, call-graph sampling can be done too, of page
 allocations - to see precisely what kind of page allocations there
 are:
 
- titan:~/git> perf record -f -g -e kmem:mm_page_alloc -c 1 ./git gc
+ titan:~/git> perf record -g -e kmem:mm_page_alloc -c 1 ./git gc
  Counting objects: 1148, done.
  Delta compression using up to 2 threads.
  Compressing objects: 100% (450/450), done.
diff --git a/tools/perf/Documentation/perf-archive.txt b/tools/perf/Documentation/perf-archive.txt
index fae174dc7d01..5032a142853e 100644
--- a/tools/perf/Documentation/perf-archive.txt
+++ b/tools/perf/Documentation/perf-archive.txt
@@ -13,7 +13,7 @@ SYNOPSIS
 DESCRIPTION
 -----------
 This command runs runs perf-buildid-list --with-hits, and collects the files
-with the buildids found so that analisys of perf.data contents can be possible
+with the buildids found so that analysis of perf.data contents can be possible
 on another machine.
 
 
diff --git a/tools/perf/Documentation/perf-diff.txt b/tools/perf/Documentation/perf-diff.txt
index 5b3123d5721f..fdfceee0ffd0 100644
--- a/tools/perf/Documentation/perf-diff.txt
+++ b/tools/perf/Documentation/perf-diff.txt
@@ -3,17 +3,17 @@ perf-diff(1)
 
 NAME
 ----
-perf-diff - Read two perf.data files and display the differential profile
+perf-diff - Read perf.data files and display the differential profile
 
 SYNOPSIS
 --------
 [verse]
-'perf diff' [oldfile] [newfile]
+'perf diff' [baseline file] [data file1] [[data file2] ... ]
 
 DESCRIPTION
 -----------
-This command displays the performance difference amongst two perf.data files
-captured via perf record.
+This command displays the performance difference amongst two or more perf.data
+files captured via perf record.
 
 If no parameters are passed it will assume perf.data.old and perf.data.
 
@@ -75,8 +75,6 @@ OPTIONS
 -c::
 --compute::
         Differential computation selection - delta,ratio,wdiff (default is delta).
-        If '+' is specified as a first character, the output is sorted based
-        on the computation results.
         See COMPARISON METHODS section for more info.
 
 -p::
@@ -87,6 +85,63 @@ OPTIONS
 --formula::
         Show formula for given computation.
 
+-o::
+--order::
+       Specify compute sorting column number.
+
+COMPARISON
+----------
+The comparison is governed by the baseline file. The baseline perf.data
+file is iterated for samples. All other perf.data files specified on
+the command line are searched for the baseline sample pair. If the pair
+is found, specified computation is made and result is displayed.
+
+All samples from non-baseline perf.data files, that do not match any
+baseline entry, are displayed with empty space within baseline column
+and possible computation results (delta) in their related column.
+
+Example files samples:
+- file A with samples f1, f2, f3, f4,    f6
+- file B with samples     f2,     f4, f5
+- file C with samples f1, f2,         f5
+
+Example output:
+  x - computation takes place for pair
+  b - baseline sample percentage
+
+- perf diff A B C
+
+  baseline/A compute/B compute/C  samples
+  ---------------------------------------
+  b                    x          f1
+  b          x         x          f2
+  b                               f3
+  b          x                    f4
+  b                               f6
+             x         x          f5
+
+- perf diff B A C
+
+  baseline/B compute/A compute/C  samples
+  ---------------------------------------
+  b          x         x          f2
+  b          x                    f4
+  b                    x          f5
+             x         x          f1
+             x                    f3
+             x                    f6
+
+- perf diff C B A
+
+  baseline/C compute/B compute/A  samples
+  ---------------------------------------
+  b                    x          f1
+  b          x         x          f2
+  b          x                    f5
+                       x          f3
+             x         x          f4
+                       x          f6
+
 COMPARISON METHODS
 ------------------
 delta
@@ -96,7 +151,7 @@ If specified the 'Delta' column is displayed with value 'd' computed as:
   d = A->period_percent - B->period_percent
 
 with:
-  - A/B being matching hist entry from first/second file specified
+  - A/B being matching hist entry from data/baseline file specified
     (or perf.data/perf.data.old) respectively.
 
   - period_percent being the % of the hist entry period value within
@@ -109,24 +164,26 @@ If specified the 'Ratio' column is displayed with value 'r' computed as:
   r = A->period / B->period
 
 with:
-  - A/B being matching hist entry from first/second file specified
+  - A/B being matching hist entry from data/baseline file specified
     (or perf.data/perf.data.old) respectively.
 
   - period being the hist entry period value
 
-wdiff
-~~~~~
+wdiff:WEIGHT-B,WEIGHT-A
+~~~~~~~~~~~~~~~~~~~~~~~
 If specified the 'Weighted diff' column is displayed with value 'd' computed as:
 
    d = B->period * WEIGHT-A - A->period * WEIGHT-B
 
-  - A/B being matching hist entry from first/second file specified
+  - A/B being matching hist entry from data/baseline file specified
     (or perf.data/perf.data.old) respectively.
 
   - period being the hist entry period value
 
   - WEIGHT-A/WEIGHT-B being user suplied weights in the the '-c' option
     behind ':' separator like '-c wdiff:1,2'.
+    - WIEGHT-A being the weight of the data file
+    - WIEGHT-B being the weight of the baseline data file
 
 SEE ALSO
 --------
diff --git a/tools/perf/Documentation/perf-kvm.txt b/tools/perf/Documentation/perf-kvm.txt
index 326f2cb333cb..ac84db2d2334 100644
--- a/tools/perf/Documentation/perf-kvm.txt
+++ b/tools/perf/Documentation/perf-kvm.txt
@@ -13,6 +13,7 @@ SYNOPSIS
         {top|record|report|diff|buildid-list}
 'perf kvm' [--host] [--guest] [--guestkallsyms=<path> --guestmodules=<path>
         | --guestvmlinux=<path>] {top|record|report|diff|buildid-list|stat}
+'perf kvm stat [record|report|live] [<options>]
 
 DESCRIPTION
 -----------
@@ -50,6 +51,10 @@ There are a couple of variants of perf kvm:
   'perf kvm stat report' reports statistical data which includes events
   handled time, samples, and so on.
 
+  'perf kvm stat live' reports statistical data in a live mode (similar to
+  record + report but with statistical data updated live at a given display
+  rate).
+
 OPTIONS
 -------
 -i::
@@ -85,13 +90,50 @@ STAT REPORT OPTIONS
 --vcpu=<value>::
        analyze events which occures on this vcpu. (default: all vcpus)
 
---events=<value>::
-       events to be analyzed. Possible values: vmexit, mmio, ioport.
+--event=<value>::
+       event to be analyzed. Possible values: vmexit, mmio, ioport.
        (default: vmexit)
 -k::
 --key=<value>::
        Sorting key. Possible values: sample (default, sort by samples
        number), time (sort by average time).
+-p::
+--pid=::
+    Analyze events only for given process ID(s) (comma separated list).
+
+STAT LIVE OPTIONS
+-----------------
+-d::
+--display::
+        Time in seconds between display updates
+
+-m::
+--mmap-pages=::
+    Number of mmap data pages. Must be a power of two.
+
+-a::
+--all-cpus::
+        System-wide collection from all CPUs.
+
+-p::
+--pid=::
+    Analyze events only for given process ID(s) (comma separated list).
+
+--vcpu=<value>::
+       analyze events which occures on this vcpu. (default: all vcpus)
+
+
+--event=<value>::
+       event to be analyzed. Possible values: vmexit, mmio, ioport.
+       (default: vmexit)
+
+-k::
+--key=<value>::
+       Sorting key. Possible values: sample (default, sort by samples
+       number), time (sort by average time).
+
+--duration=<value>::
+       Show events other than HLT that take longer than duration usecs.
 
 SEE ALSO
 --------
diff --git a/tools/perf/Documentation/perf-list.txt b/tools/perf/Documentation/perf-list.txt
index d1e39dc8c810..6fce6a622206 100644
--- a/tools/perf/Documentation/perf-list.txt
+++ b/tools/perf/Documentation/perf-list.txt
@@ -8,7 +8,7 @@ perf-list - List all symbolic event types
 SYNOPSIS
 --------
 [verse]
-'perf list' [hw|sw|cache|tracepoint|event_glob]
+'perf list' [hw|sw|cache|tracepoint|pmu|event_glob]
 
 DESCRIPTION
 -----------
@@ -29,6 +29,8 @@ counted. The following modifiers exist:
  G - guest counting (in KVM guests)
  H - host counting (not in KVM guests)
  p - precise level
+ S - read sample value (PERF_SAMPLE_READ)
+ D - pin the event to the PMU
 
 The 'p' modifier can be used for specifying how precise the instruction
 address should be. The 'p' modifier can be specified multiple times:
@@ -104,6 +106,8 @@ To limit the list use:
   'subsys_glob:event_glob' to filter by tracepoint subsystems such as sched,
   block, etc.
 
+. 'pmu' to print the kernel supplied PMU events.
+
 . If none of the above is matched, it will apply the supplied glob to all
   events, printing the ones that match.
 
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index d4da111ef53d..e297b74471b8 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -65,16 +65,10 @@ OPTIONS
 -r::
 --realtime=::
         Collect data with this RT SCHED_FIFO priority.
+
 -D::
 --no-delay::
         Collect data without buffering.
--A::
---append::
-        Append to the output file to do incremental profiling.
-
--f::
---force::
-        Overwrite existing data file. (deprecated)
 
 -c::
 --count=::
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index 7d5f4f38aa52..2b8097ee39d8 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -115,7 +115,7 @@ OPTIONS
 --dump-raw-trace::
         Dump raw trace in ASCII.
 
--g [type,min[,limit],order]::
+-g [type,min[,limit],order[,key]]::
 --call-graph::
         Display call chains using type, min percent threshold, optional print
         limit and order.
@@ -129,12 +129,21 @@ OPTIONS
         - callee: callee based call graph.
         - caller: inverted caller based call graph.
 
-        Default: fractal,0.5,callee.
+        key can be:
+        - function: compare on functions
+        - address: compare on individual code addresses
+
+        Default: fractal,0.5,callee,function.
 
 -G::
 --inverted::
         alias for inverted caller based call graph.
 
+--ignore-callees=<regex>::
+        Ignore callees of the function(s) matching the given regex.
+        This has the effect of collecting the callers of each such
+        function into one place in the call-graph tree.
+
 --pretty=<key>::
         Pretty printing style.  key: normal, raw
 
@@ -210,6 +219,10 @@ OPTIONS
         Demangle symbol names to human readable form. It's enabled by default,
         disable with --no-demangle.
 
+--percent-limit::
+        Do not show entries which have an overhead under that percent.
+        (Default: 0).
+
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-annotate[1]
diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
index 2fe87fb558f0..73c9759005a3 100644
--- a/tools/perf/Documentation/perf-stat.txt
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -132,6 +132,11 @@ is a useful mode to detect imbalance between physical cores.  To enable this mod
 use --per-core in addition to -a. (system-wide).  The output includes the
 core number and the number of online logical processors on that physical processor.
 
+-D msecs::
+--initial-delay msecs::
+After starting the program, wait msecs before measuring. This is useful to
+filter out the startup phase of the program, which is often very different.
+
 EXAMPLES
 --------
 
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index 9f1a2fe54757..58d6598a9686 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -155,6 +155,15 @@ Default is to monitor all CPUS.
 
         Default: fractal,0.5,callee.
 
+--ignore-callees=<regex>::
+        Ignore callees of the function(s) matching the given regex.
+        This has the effect of collecting the callers of each such
+        function into one place in the call-graph tree.
+
+--percent-limit::
+        Do not show entries which have an overhead under that percent.
+        (Default: 0).
+
 INTERACTIVE PROMPTING KEYS
 --------------------------
 
diff --git a/tools/perf/Documentation/perf-trace.txt b/tools/perf/Documentation/perf-trace.txt
index 68718ccdd178..daccd2c0a48f 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -23,25 +23,45 @@ analysis phases.
 OPTIONS
 -------
 
+-a::
 --all-cpus::
         System-wide collection from all CPUs.
 
+-e::
+--expr::
+        List of events to show, currently only syscall names.
+        Prefixing with ! shows all syscalls but the ones specified.  You may
+        need to escape it.
+
+-o::
+--output=::
+        Output file name.
+
 -p::
 --pid=::
         Record events on existing process ID (comma separated list).
 
+-t::
 --tid=::
         Record events on existing thread ID (comma separated list).
 
+-u::
 --uid=::
         Record events in threads owned by uid. Name or number.
 
+-v::
+--verbose=::
+        Verbosity level.
+
+-i::
 --no-inherit::
         Child tasks do not inherit counters.
 
+-m::
 --mmap-pages=::
         Number of mmap data pages. Must be a power of two.
 
+-C::
 --cpu::
 Collect samples only on the list of CPUs provided. Multiple CPUs can be provided as a
 comma-separated list with no space: 0,1. Ranges of CPUs are specified with -: 0-2.
@@ -54,6 +74,10 @@ the thread executes on the designated CPUs. Default is to monitor all CPUs.
 --sched:
         Accrue thread runtime and provide a summary at the end of the session.
 
+-i
+--input
+        Process events from a given perf data file.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script[1]
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index b0f164b133d9..3a0ff7fb71b6 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -51,189 +51,63 @@ include config/utilities.mak
 # Define NO_BACKTRACE if you do not want stack backtrace debug feature
 #
 # Define NO_LIBNUMA if you do not want numa perf benchmark
+#
+# Define NO_LIBAUDIT if you do not want libaudit support
+#
+# Define NO_LIBBIONIC if you do not want bionic support
 
-$(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
-        @$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
-
-uname_M := $(shell uname -m 2>/dev/null || echo not)
-
-ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
-                                  -e s/arm.*/arm/ -e s/sa110/arm/ \
-                                  -e s/s390x/s390/ -e s/parisc64/parisc/ \
-                                  -e s/ppc.*/powerpc/ -e s/mips.*/mips/ \
-                                  -e s/sh[234].*/sh/ -e s/aarch64.*/arm64/ )
-NO_PERF_REGS := 1
-
-CC = $(CROSS_COMPILE)gcc
-AR = $(CROSS_COMPILE)ar
-
-# Additional ARCH settings for x86
-ifeq ($(ARCH),i386)
-        override ARCH := x86
-        NO_PERF_REGS := 0
-        LIBUNWIND_LIBS = -lunwind -lunwind-x86
-endif
-ifeq ($(ARCH),x86_64)
-        override ARCH := x86
-        IS_X86_64 := 0
-        ifeq (, $(findstring m32,$(EXTRA_CFLAGS)))
-                IS_X86_64 := $(shell echo __x86_64__ | ${CC} -E -x c - | tail -n 1)
-        endif
-        ifeq (${IS_X86_64}, 1)
-                RAW_ARCH := x86_64
-                ARCH_CFLAGS := -DARCH_X86_64
-                ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S ../../arch/x86/lib/memset_64.S
-        endif
-        NO_PERF_REGS := 0
-        LIBUNWIND_LIBS = -lunwind -lunwind-x86_64
-endif
-
-# Treat warnings as errors unless directed not to
-ifneq ($(WERROR),0)
-        CFLAGS_WERROR := -Werror
-endif
-
-ifeq ("$(origin DEBUG)", "command line")
-  PERF_DEBUG = $(DEBUG)
-endif
-ifndef PERF_DEBUG
-  CFLAGS_OPTIMIZE = -O6
+ifeq ($(srctree),)
+srctree := $(patsubst %/,%,$(dir $(shell pwd)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+#$(info Determined 'srctree' to be $(srctree))
 endif
 
-ifdef PARSER_DEBUG
-        PARSER_DEBUG_BISON  := -t
-        PARSER_DEBUG_FLEX   := -d
-        PARSER_DEBUG_CFLAGS := -DPARSER_DEBUG
+ifneq ($(objtree),)
+#$(info Determined 'objtree' to be $(objtree))
 endif
 
-ifdef NO_NEWT
-        NO_SLANG=1
+ifneq ($(OUTPUT),)
+#$(info Determined 'OUTPUT' to be $(OUTPUT))
 endif
 
-CFLAGS = -fno-omit-frame-pointer -ggdb3 -funwind-tables -Wall -Wextra -std=gnu99 $(CFLAGS_WERROR) $(CFLAGS_OPTIMIZE) $(EXTRA_WARNINGS) $(EXTRA_CFLAGS) $(PARSER_DEBUG_CFLAGS)
-EXTLIBS = -lpthread -lrt -lelf -lm
-ALL_CFLAGS = $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
-ALL_LDFLAGS = $(LDFLAGS)
-STRIP ?= strip
-
-# Among the variables below, these:
-#   perfexecdir
-#   template_dir
-#   mandir
-#   infodir
-#   htmldir
-#   ETC_PERFCONFIG (but not sysconfdir)
-# can be specified as a relative path some/where/else;
-# this is interpreted as relative to $(prefix) and "perf" at
-# runtime figures out where they are based on the path to the executable.
-# This can help installing the suite in a relocatable way.
-
-# Make the path relative to DESTDIR, not to prefix
-ifndef DESTDIR
-prefix = $(HOME)
-endif
-bindir_relative = bin
-bindir = $(prefix)/$(bindir_relative)
-mandir = share/man
-infodir = share/info
-perfexecdir = libexec/perf-core
-sharedir = $(prefix)/share
-template_dir = share/perf-core/templates
-htmldir = share/doc/perf-doc
-ifeq ($(prefix),/usr)
-sysconfdir = /etc
-ETC_PERFCONFIG = $(sysconfdir)/perfconfig
-else
-sysconfdir = $(prefix)/etc
-ETC_PERFCONFIG = etc/perfconfig
-endif
-lib = lib
+$(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
+        @$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
 
-export prefix bindir sharedir sysconfdir
+CC = $(CROSS_COMPILE)gcc
+AR = $(CROSS_COMPILE)ar
 
-RM = rm -f
-MKDIR = mkdir
-FIND = find
+RM      = rm -f
+MKDIR   = mkdir
+FIND    = find
 INSTALL = install
-FLEX = flex
-BISON= bison
-
-# sparse is architecture-neutral, which means that we need to tell it
-# explicitly what architecture to check for. Fix this up for yours..
-SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
-
-ifneq ($(MAKECMDGOALS),clean)
-ifneq ($(MAKECMDGOALS),tags)
--include config/feature-tests.mak
-
-ifeq ($(call get-executable,$(FLEX)),)
-        dummy := $(error Error: $(FLEX) is missing on this system, please install it)
-endif
+FLEX    = flex
+BISON   = bison
+STRIP   = strip
 
-ifeq ($(call get-executable,$(BISON)),)
-        dummy := $(error Error: $(BISON) is missing on this system, please install it)
-endif
-
-ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -fstack-protector-all,-fstack-protector-all),y)
-        CFLAGS := $(CFLAGS) -fstack-protector-all
-endif
+LK_DIR          = $(srctree)/tools/lib/lk/
+TRACE_EVENT_DIR = $(srctree)/tools/lib/traceevent/
 
-ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -Wstack-protector,-Wstack-protector),y)
-       CFLAGS := $(CFLAGS) -Wstack-protector
-endif
+# include config/Makefile by default and rule out
+# non-config cases
+config := 1
 
-ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -Wvolatile-register-var,-Wvolatile-register-var),y)
-       CFLAGS := $(CFLAGS) -Wvolatile-register-var
-endif
+NON_CONFIG_TARGETS := clean TAGS tags cscope help
 
-ifndef PERF_DEBUG
-        ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -D_FORTIFY_SOURCE=2,-D_FORTIFY_SOURCE=2),y)
-                CFLAGS := $(CFLAGS) -D_FORTIFY_SOURCE=2
-        endif
+ifdef MAKECMDGOALS
+ifeq ($(filter-out $(NON_CONFIG_TARGETS),$(MAKECMDGOALS)),)
+  config := 0
 endif
-
-### --- END CONFIGURATION SECTION ---
-
-ifeq ($(srctree),)
-srctree := $(patsubst %/,%,$(dir $(shell pwd)))
-srctree := $(patsubst %/,%,$(dir $(srctree)))
-#$(info Determined 'srctree' to be $(srctree))
 endif
 
-ifneq ($(objtree),)
-#$(info Determined 'objtree' to be $(objtree))
+ifeq ($(config),1)
+include config/Makefile
 endif
 
-ifneq ($(OUTPUT),)
-#$(info Determined 'OUTPUT' to be $(OUTPUT))
-endif
+export prefix bindir sharedir sysconfdir
 
-BASIC_CFLAGS = \
-        -Iutil/include \
-        -Iarch/$(ARCH)/include \
-        $(if $(objtree),-I$(objtree)/arch/$(ARCH)/include/generated/uapi) \
-        -I$(srctree)/arch/$(ARCH)/include/uapi \
-        -I$(srctree)/arch/$(ARCH)/include \
-        $(if $(objtree),-I$(objtree)/include/generated/uapi) \
-        -I$(srctree)/include/uapi \
-        -I$(srctree)/include \
-        -I$(OUTPUT)util \
-        -Iutil \
-        -I. \
-        -I$(TRACE_EVENT_DIR) \
-        -I../lib/ \
-        -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
-
-BASIC_LDFLAGS =
-
-ifeq ($(call try-cc,$(SOURCE_BIONIC),$(CFLAGS),bionic),y)
-        BIONIC := 1
-        EXTLIBS := $(filter-out -lrt,$(EXTLIBS))
-        EXTLIBS := $(filter-out -lpthread,$(EXTLIBS))
-        BASIC_CFLAGS += -I.
-endif
-endif # MAKECMDGOALS != tags
-endif # MAKECMDGOALS != clean
+# sparse is architecture-neutral, which means that we need to tell it
+# explicitly what architecture to check for. Fix this up for yours..
+SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
 
 # Guard against environment variables
 BUILTIN_OBJS =
@@ -247,20 +121,16 @@ SCRIPT_SH += perf-archive.sh
 grep-libs = $(filter -l%,$(1))
 strip-libs = $(filter-out -l%,$(1))
 
-LK_DIR = ../lib/lk/
-TRACE_EVENT_DIR = ../lib/traceevent/
-
-LK_PATH=$(LK_DIR)
-
 ifneq ($(OUTPUT),)
-        TE_PATH=$(OUTPUT)
+  TE_PATH=$(OUTPUT)
 ifneq ($(subdir),)
-        LK_PATH=$(OUTPUT)$(LK_DIR)
+  LK_PATH=$(OUTPUT)/../lib/lk/
 else
-        LK_PATH=$(OUTPUT)
+  LK_PATH=$(OUTPUT)
 endif
 else
-        TE_PATH=$(TRACE_EVENT_DIR)
+  TE_PATH=$(TRACE_EVENT_DIR)
+  LK_PATH=$(LK_DIR)
 endif
 
 LIBTRACEEVENT = $(TE_PATH)libtraceevent.a
@@ -278,10 +148,10 @@ export PYTHON_EXTBUILD_LIB PYTHON_EXTBUILD_TMP
 python-clean := rm -rf $(PYTHON_EXTBUILD) $(OUTPUT)python/perf.so
 
 PYTHON_EXT_SRCS := $(shell grep -v ^\# util/python-ext-sources)
-PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py $(LIBTRACEEVENT)
+PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py $(LIBTRACEEVENT) $(LIBLK)
 
 $(OUTPUT)python/perf.so: $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS)
-        $(QUIET_GEN)CFLAGS='$(BASIC_CFLAGS)' $(PYTHON_WORD) util/setup.py \
+        $(QUIET_GEN)CFLAGS='$(CFLAGS)' $(PYTHON_WORD) util/setup.py \
           --quiet build_ext; \
         mkdir -p $(OUTPUT)python && \
         cp $(PYTHON_EXTBUILD_LIB)perf.so $(OUTPUT)python/
@@ -296,8 +166,6 @@ SCRIPTS = $(patsubst %.sh,%,$(SCRIPT_SH))
 #
 PROGRAMS += $(OUTPUT)perf
 
-LANG_BINDINGS =
-
 # what 'all' will build and 'install' will install, in perfexecdir
 ALL_PROGRAMS = $(PROGRAMS) $(SCRIPTS)
 
@@ -306,10 +174,10 @@ OTHER_PROGRAMS = $(OUTPUT)perf
 
 # Set paths to tools early so that they can be used for version tests.
 ifndef SHELL_PATH
-        SHELL_PATH = /bin/sh
+  SHELL_PATH = /bin/sh
 endif
 ifndef PERL_PATH
-        PERL_PATH = /usr/bin/perl
+  PERL_PATH = /usr/bin/perl
 endif
 
 export PERL_PATH
@@ -413,7 +281,7 @@ LIB_H += util/cpumap.h
 LIB_H += util/top.h
 LIB_H += $(ARCH_INCLUDE)
 LIB_H += util/cgroup.h
-LIB_H += $(TRACE_EVENT_DIR)event-parse.h
+LIB_H += $(LIB_INCLUDE)traceevent/event-parse.h
 LIB_H += util/target.h
 LIB_H += util/rblist.h
 LIB_H += util/intlist.h
@@ -492,6 +360,7 @@ LIB_OBJS += $(OUTPUT)util/rblist.o
 LIB_OBJS += $(OUTPUT)util/intlist.o
 LIB_OBJS += $(OUTPUT)util/vdso.o
 LIB_OBJS += $(OUTPUT)util/stat.o
+LIB_OBJS += $(OUTPUT)util/record.o
 
 LIB_OBJS += $(OUTPUT)ui/setup.o
 LIB_OBJS += $(OUTPUT)ui/helpline.o
@@ -521,6 +390,12 @@ LIB_OBJS += $(OUTPUT)tests/bp_signal.o
 LIB_OBJS += $(OUTPUT)tests/bp_signal_overflow.o
 LIB_OBJS += $(OUTPUT)tests/task-exit.o
 LIB_OBJS += $(OUTPUT)tests/sw-clock.o
+ifeq ($(ARCH),x86)
+LIB_OBJS += $(OUTPUT)tests/perf-time-to-tsc.o
+endif
+LIB_OBJS += $(OUTPUT)tests/code-reading.o
+LIB_OBJS += $(OUTPUT)tests/sample-parsing.o
+LIB_OBJS += $(OUTPUT)tests/parse-no-sample-id-all.o
 
 BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
 BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
@@ -557,79 +432,14 @@ BUILTIN_OBJS += $(OUTPUT)builtin-mem.o
 
 PERFLIBS = $(LIB_FILE) $(LIBLK) $(LIBTRACEEVENT)
 
-#
-# Platform specific tweaks
-#
-ifneq ($(MAKECMDGOALS),clean)
-ifneq ($(MAKECMDGOALS),tags)
-
 # We choose to avoid "if .. else if .. else .. endif endif"
 # because maintaining the nesting to match is a pain.  If
 # we had "elif" things would have been much nicer...
 
-ifdef NO_LIBELF
-        NO_DWARF := 1
-        NO_DEMANGLE := 1
-        NO_LIBUNWIND := 1
-else
-FLAGS_LIBELF=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
-ifneq ($(call try-cc,$(SOURCE_LIBELF),$(FLAGS_LIBELF),libelf),y)
-        FLAGS_GLIBC=$(ALL_CFLAGS) $(ALL_LDFLAGS)
-        ifeq ($(call try-cc,$(SOURCE_GLIBC),$(FLAGS_GLIBC),glibc),y)
-                LIBC_SUPPORT := 1
-        endif
-        ifeq ($(BIONIC),1)
-                LIBC_SUPPORT := 1
-        endif
-        ifeq ($(LIBC_SUPPORT),1)
-                msg := $(warning No libelf found, disables 'probe' tool, please install elfutils-libelf-devel/libelf-dev);
-
-                NO_LIBELF := 1
-                NO_DWARF := 1
-                NO_DEMANGLE := 1
-        else
-                msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]/glibc-static);
-        endif
-else
-        # for linking with debug library, run like:
-        # make DEBUG=1 LIBDW_DIR=/opt/libdw/
-        ifdef LIBDW_DIR
-                LIBDW_CFLAGS  := -I$(LIBDW_DIR)/include
-                LIBDW_LDFLAGS := -L$(LIBDW_DIR)/lib
-        endif
-
-        FLAGS_DWARF=$(ALL_CFLAGS) $(LIBDW_CFLAGS) -ldw -lelf $(LIBDW_LDFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
-        ifneq ($(call try-cc,$(SOURCE_DWARF),$(FLAGS_DWARF),libdw),y)
-                msg := $(warning No libdw.h found or old libdw.h found or elfutils is older than 0.138, disables dwarf support. Please install new elfutils-devel/libdw-dev);
-                NO_DWARF := 1
-        endif # Dwarf support
-endif # SOURCE_LIBELF
-endif # NO_LIBELF
-
-# There's only x86 (both 32 and 64) support for CFI unwind so far
-ifneq ($(ARCH),x86)
-        NO_LIBUNWIND := 1
-endif
-
-ifndef NO_LIBUNWIND
-# for linking with debug library, run like:
-# make DEBUG=1 LIBUNWIND_DIR=/opt/libunwind/
-ifdef LIBUNWIND_DIR
-        LIBUNWIND_CFLAGS  := -I$(LIBUNWIND_DIR)/include
-        LIBUNWIND_LDFLAGS := -L$(LIBUNWIND_DIR)/lib
-endif
-
-FLAGS_UNWIND=$(LIBUNWIND_CFLAGS) $(ALL_CFLAGS) $(LIBUNWIND_LDFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) $(LIBUNWIND_LIBS)
-ifneq ($(call try-cc,$(SOURCE_LIBUNWIND),$(FLAGS_UNWIND),libunwind),y)
-        msg := $(warning No libunwind found, disabling post unwind support. Please install libunwind-dev[el] >= 0.99);
-        NO_LIBUNWIND := 1
-endif # Libunwind support
-endif # NO_LIBUNWIND
-
 -include arch/$(ARCH)/Makefile
 
 ifneq ($(OUTPUT),)
-        BASIC_CFLAGS += -I$(OUTPUT)
+  CFLAGS += -I$(OUTPUT)
 endif
 
 ifdef NO_LIBELF
@@ -647,281 +457,75 @@ BUILTIN_OBJS := $(filter-out $(OUTPUT)builtin-probe.o,$(BUILTIN_OBJS))
 LIB_OBJS += $(OUTPUT)util/symbol-minimal.o
 
 else # NO_LIBELF
-BASIC_CFLAGS += -DLIBELF_SUPPORT
-
-FLAGS_LIBELF=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
-ifeq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_LIBELF),-DLIBELF_MMAP),y)
-        BASIC_CFLAGS += -DLIBELF_MMAP
-endif
-
 ifndef NO_DWARF
-ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)
-        msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);
-else
-        BASIC_CFLAGS := -DDWARF_SUPPORT $(LIBDW_CFLAGS) $(BASIC_CFLAGS)
-        BASIC_LDFLAGS := $(LIBDW_LDFLAGS) $(BASIC_LDFLAGS)
-        EXTLIBS += -lelf -ldw
-        LIB_OBJS += $(OUTPUT)util/probe-finder.o
-        LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
-endif # PERF_HAVE_DWARF_REGS
+  LIB_OBJS += $(OUTPUT)util/probe-finder.o
+  LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
 endif # NO_DWARF
 endif # NO_LIBELF
 
 ifndef NO_LIBUNWIND
-        BASIC_CFLAGS += -DLIBUNWIND_SUPPORT
-        EXTLIBS += $(LIBUNWIND_LIBS)
-        BASIC_CFLAGS := $(LIBUNWIND_CFLAGS) $(BASIC_CFLAGS)
-        BASIC_LDFLAGS := $(LIBUNWIND_LDFLAGS) $(BASIC_LDFLAGS)
-        LIB_OBJS += $(OUTPUT)util/unwind.o
+  LIB_OBJS += $(OUTPUT)util/unwind.o
 endif
+LIB_OBJS += $(OUTPUT)tests/keep-tracking.o
 
 ifndef NO_LIBAUDIT
-        FLAGS_LIBAUDIT = $(ALL_CFLAGS) $(ALL_LDFLAGS) -laudit
-        ifneq ($(call try-cc,$(SOURCE_LIBAUDIT),$(FLAGS_LIBAUDIT),libaudit),y)
-                msg := $(warning No libaudit.h found, disables 'trace' tool, please install audit-libs-devel or libaudit-dev);
-        else
-                BASIC_CFLAGS += -DLIBAUDIT_SUPPORT
-                BUILTIN_OBJS += $(OUTPUT)builtin-trace.o
-                EXTLIBS += -laudit
-        endif
+  BUILTIN_OBJS += $(OUTPUT)builtin-trace.o
 endif
 
 ifndef NO_SLANG
-        FLAGS_SLANG=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -I/usr/include/slang -lslang
-        ifneq ($(call try-cc,$(SOURCE_SLANG),$(FLAGS_SLANG),libslang),y)
-                msg := $(warning slang not found, disables TUI support. Please install slang-devel or libslang-dev);
-        else
-                # Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
-                BASIC_CFLAGS += -I/usr/include/slang
-                BASIC_CFLAGS += -DSLANG_SUPPORT
-                EXTLIBS += -lslang
-                LIB_OBJS += $(OUTPUT)ui/browser.o
-                LIB_OBJS += $(OUTPUT)ui/browsers/annotate.o
-                LIB_OBJS += $(OUTPUT)ui/browsers/hists.o
-                LIB_OBJS += $(OUTPUT)ui/browsers/map.o
-                LIB_OBJS += $(OUTPUT)ui/browsers/scripts.o
-                LIB_OBJS += $(OUTPUT)ui/tui/setup.o
-                LIB_OBJS += $(OUTPUT)ui/tui/util.o
-                LIB_OBJS += $(OUTPUT)ui/tui/helpline.o
-                LIB_OBJS += $(OUTPUT)ui/tui/progress.o
-                LIB_H += ui/browser.h
-                LIB_H += ui/browsers/map.h
-                LIB_H += ui/keysyms.h
-                LIB_H += ui/libslang.h
-        endif
+  LIB_OBJS += $(OUTPUT)ui/browser.o
+  LIB_OBJS += $(OUTPUT)ui/browsers/annotate.o
+  LIB_OBJS += $(OUTPUT)ui/browsers/hists.o
+  LIB_OBJS += $(OUTPUT)ui/browsers/map.o
+  LIB_OBJS += $(OUTPUT)ui/browsers/scripts.o
+  LIB_OBJS += $(OUTPUT)ui/tui/setup.o
+  LIB_OBJS += $(OUTPUT)ui/tui/util.o
+  LIB_OBJS += $(OUTPUT)ui/tui/helpline.o
+  LIB_OBJS += $(OUTPUT)ui/tui/progress.o
+  LIB_H += ui/browser.h
+  LIB_H += ui/browsers/map.h
+  LIB_H += ui/keysyms.h
+  LIB_H += ui/libslang.h
 endif
 
 ifndef NO_GTK2
-        FLAGS_GTK2=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) $(shell pkg-config --libs --cflags gtk+-2.0 2>/dev/null)
-        ifneq ($(call try-cc,$(SOURCE_GTK2),$(FLAGS_GTK2),gtk2),y)
-                msg := $(warning GTK2 not found, disables GTK2 support. Please install gtk2-devel or libgtk2.0-dev);
-        else
-                ifeq ($(call try-cc,$(SOURCE_GTK2_INFOBAR),$(FLAGS_GTK2),-DHAVE_GTK_INFO_BAR),y)
-                        BASIC_CFLAGS += -DHAVE_GTK_INFO_BAR
-                endif
-                BASIC_CFLAGS += -DGTK2_SUPPORT
-                BASIC_CFLAGS += $(shell pkg-config --cflags gtk+-2.0 2>/dev/null)
-                EXTLIBS += $(shell pkg-config --libs gtk+-2.0 2>/dev/null)
-                LIB_OBJS += $(OUTPUT)ui/gtk/browser.o
-                LIB_OBJS += $(OUTPUT)ui/gtk/hists.o
-                LIB_OBJS += $(OUTPUT)ui/gtk/setup.o
-                LIB_OBJS += $(OUTPUT)ui/gtk/util.o
-                LIB_OBJS += $(OUTPUT)ui/gtk/helpline.o
-                LIB_OBJS += $(OUTPUT)ui/gtk/progress.o
-                LIB_OBJS += $(OUTPUT)ui/gtk/annotate.o
-        endif
-endif
-
-ifdef NO_LIBPERL
-        BASIC_CFLAGS += -DNO_LIBPERL
-else
-       PERL_EMBED_LDOPTS = $(shell perl -MExtUtils::Embed -e ldopts 2>/dev/null)
-       PERL_EMBED_LDFLAGS = $(call strip-libs,$(PERL_EMBED_LDOPTS))
-       PERL_EMBED_LIBADD = $(call grep-libs,$(PERL_EMBED_LDOPTS))
-        PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`
-        FLAGS_PERL_EMBED=$(PERL_EMBED_CCOPTS) $(PERL_EMBED_LDOPTS)
-
-        ifneq ($(call try-cc,$(SOURCE_PERL_EMBED),$(FLAGS_PERL_EMBED),perl),y)
-                BASIC_CFLAGS += -DNO_LIBPERL
-        else
-               ALL_LDFLAGS += $(PERL_EMBED_LDFLAGS)
-               EXTLIBS += $(PERL_EMBED_LIBADD)
-                LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-perl.o
-                LIB_OBJS += $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o
-        endif
+  LIB_OBJS += $(OUTPUT)ui/gtk/browser.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/hists.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/setup.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/util.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/helpline.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/progress.o
+  LIB_OBJS += $(OUTPUT)ui/gtk/annotate.o
 endif
 
-disable-python = $(eval $(disable-python_code))
-define disable-python_code
-  BASIC_CFLAGS += -DNO_LIBPYTHON
-  $(if $(1),$(warning No $(1) was found))
-  $(warning Python support will not be built)
-endef
-
-override PYTHON := \
-  $(call get-executable-or-default,PYTHON,python)
-
-ifndef PYTHON
-  $(call disable-python,python interpreter)
-else
-
-  PYTHON_WORD := $(call shell-wordify,$(PYTHON))
-
-  ifdef NO_LIBPYTHON
-    $(call disable-python)
-  else
-
-    override PYTHON_CONFIG := \
-      $(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON)-config)
-
-    ifndef PYTHON_CONFIG
-      $(call disable-python,python-config tool)
-    else
-
-      PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
-
-      PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
-      PYTHON_EMBED_LDFLAGS := $(call strip-libs,$(PYTHON_EMBED_LDOPTS))
-      PYTHON_EMBED_LIBADD := $(call grep-libs,$(PYTHON_EMBED_LDOPTS))
-      PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
-      FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
-
-      ifneq ($(call try-cc,$(SOURCE_PYTHON_EMBED),$(FLAGS_PYTHON_EMBED),python),y)
-        $(call disable-python,Python.h (for Python 2.x))
-      else
-
-        ifneq ($(call try-cc,$(SOURCE_PYTHON_VERSION),$(FLAGS_PYTHON_EMBED),python version),y)
-          $(warning Python 3 is not yet supported; please set)
-          $(warning PYTHON and/or PYTHON_CONFIG appropriately.)
-          $(warning If you also have Python 2 installed, then)
-          $(warning try something like:)
-          $(warning $(and ,))
-          $(warning $(and ,)  make PYTHON=python2)
-          $(warning $(and ,))
-          $(warning Otherwise, disable Python support entirely:)
-          $(warning $(and ,))
-          $(warning $(and ,)  make NO_LIBPYTHON=1)
-          $(warning $(and ,))
-          $(error   $(and ,))
-        else
-          ALL_LDFLAGS += $(PYTHON_EMBED_LDFLAGS)
-          EXTLIBS += $(PYTHON_EMBED_LIBADD)
-          LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-python.o
-          LIB_OBJS += $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o
-          LANG_BINDINGS += $(OUTPUT)python/perf.so
-        endif
-
-      endif
-    endif
-  endif
+ifndef NO_LIBPERL
+  LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-perl.o
+  LIB_OBJS += $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o
 endif
 
-ifdef NO_DEMANGLE
-        BASIC_CFLAGS += -DNO_DEMANGLE
-else
-        ifdef HAVE_CPLUS_DEMANGLE
-                EXTLIBS += -liberty
-                BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
-        else
-                FLAGS_BFD=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -DPACKAGE='perf' -lbfd
-                has_bfd := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD),libbfd)
-                ifeq ($(has_bfd),y)
-                        EXTLIBS += -lbfd
-                else
-                        FLAGS_BFD_IBERTY=$(FLAGS_BFD) -liberty
-                        has_bfd_iberty := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY),liberty)
-                        ifeq ($(has_bfd_iberty),y)
-                                EXTLIBS += -lbfd -liberty
-                        else
-                                FLAGS_BFD_IBERTY_Z=$(FLAGS_BFD_IBERTY) -lz
-                                has_bfd_iberty_z := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY_Z),libz)
-                                ifeq ($(has_bfd_iberty_z),y)
-                                        EXTLIBS += -lbfd -liberty -lz
-                                else
-                                        FLAGS_CPLUS_DEMANGLE=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -liberty
-                                        has_cplus_demangle := $(call try-cc,$(SOURCE_CPLUS_DEMANGLE),$(FLAGS_CPLUS_DEMANGLE),demangle)
-                                        ifeq ($(has_cplus_demangle),y)
-                                                EXTLIBS += -liberty
-                                                BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
-                                        else
-                                                msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
-                                                BASIC_CFLAGS += -DNO_DEMANGLE
-                                        endif
-                                endif
-                        endif
-                endif
-        endif
+ifndef NO_LIBPYTHON
+  LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-python.o
+  LIB_OBJS += $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o
 endif
 
 ifeq ($(NO_PERF_REGS),0)
-        ifeq ($(ARCH),x86)
-                LIB_H += arch/x86/include/perf_regs.h
-        endif
-        BASIC_CFLAGS += -DHAVE_PERF_REGS
-endif
-
-ifndef NO_STRLCPY
-        ifeq ($(call try-cc,$(SOURCE_STRLCPY),,-DHAVE_STRLCPY),y)
-                BASIC_CFLAGS += -DHAVE_STRLCPY
-        endif
-endif
-
-ifndef NO_ON_EXIT
-        ifeq ($(call try-cc,$(SOURCE_ON_EXIT),,-DHAVE_ON_EXIT),y)
-                BASIC_CFLAGS += -DHAVE_ON_EXIT
-        endif
-endif
-
-ifndef NO_BACKTRACE
-       ifeq ($(call try-cc,$(SOURCE_BACKTRACE),,-DBACKTRACE_SUPPORT),y)
-               BASIC_CFLAGS += -DBACKTRACE_SUPPORT
-       endif
+  ifeq ($(ARCH),x86)
+    LIB_H += arch/x86/include/perf_regs.h
+  endif
 endif
 
 ifndef NO_LIBNUMA
-        FLAGS_LIBNUMA = $(ALL_CFLAGS) $(ALL_LDFLAGS) -lnuma
-        ifneq ($(call try-cc,$(SOURCE_LIBNUMA),$(FLAGS_LIBNUMA),libnuma),y)
-                msg := $(warning No numa.h found, disables 'perf bench numa mem' benchmark, please install numa-libs-devel or libnuma-dev);
-        else
-                BASIC_CFLAGS += -DLIBNUMA_SUPPORT
-                BUILTIN_OBJS += $(OUTPUT)bench/numa.o
-                EXTLIBS += -lnuma
-        endif
+  BUILTIN_OBJS += $(OUTPUT)bench/numa.o
 endif
 
 ifdef ASCIIDOC8
-        export ASCIIDOC8
+  export ASCIIDOC8
 endif
 
-endif # MAKECMDGOALS != tags
-endif # MAKECMDGOALS != clean
-
-# Shell quote (do not use $(call) to accommodate ancient setups);
-
-ETC_PERFCONFIG_SQ = $(subst ','\'',$(ETC_PERFCONFIG))
-
-DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
-bindir_SQ = $(subst ','\'',$(bindir))
-bindir_relative_SQ = $(subst ','\'',$(bindir_relative))
-mandir_SQ = $(subst ','\'',$(mandir))
-infodir_SQ = $(subst ','\'',$(infodir))
-perfexecdir_SQ = $(subst ','\'',$(perfexecdir))
-template_dir_SQ = $(subst ','\'',$(template_dir))
-htmldir_SQ = $(subst ','\'',$(htmldir))
-prefix_SQ = $(subst ','\'',$(prefix))
-sysconfdir_SQ = $(subst ','\'',$(sysconfdir))
-
-SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))
-
 LIBS = -Wl,--whole-archive $(PERFLIBS) -Wl,--no-whole-archive -Wl,--start-group $(EXTLIBS) -Wl,--end-group
 
-ALL_CFLAGS += $(BASIC_CFLAGS)
-ALL_CFLAGS += $(ARCH_CFLAGS)
-ALL_LDFLAGS += $(BASIC_LDFLAGS)
-
 export INSTALL SHELL_PATH
 
-
 ### Build rules
 
 SHELL = $(SHELL_PATH)
@@ -939,20 +543,20 @@ strip: $(PROGRAMS) $(OUTPUT)perf
 $(OUTPUT)perf.o: perf.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -include $(OUTPUT)PERF-VERSION-FILE \
                 '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
-                $(ALL_CFLAGS) -c $(filter %.c,$^) -o $@
+                $(CFLAGS) -c $(filter %.c,$^) -o $@
 
 $(OUTPUT)perf: $(OUTPUT)perf.o $(BUILTIN_OBJS) $(PERFLIBS)
-        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) $(OUTPUT)perf.o \
+        $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $(OUTPUT)perf.o \
                $(BUILTIN_OBJS) $(LIBS) -o $@
 
 $(OUTPUT)builtin-help.o: builtin-help.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
                 '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
                 '-DPERF_MAN_PATH="$(mandir_SQ)"' \
                 '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
 
 $(OUTPUT)builtin-timechart.o: builtin-timechart.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
                 '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
                 '-DPERF_MAN_PATH="$(mandir_SQ)"' \
                 '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
@@ -977,77 +581,77 @@ $(OUTPUT)perf.o perf.spec \
 # over the general rule for .o
 
 $(OUTPUT)util/%-flex.o: $(OUTPUT)util/%-flex.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(ALL_CFLAGS) -w $<
+        $(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(CFLAGS) -w $<
 
 $(OUTPUT)util/%-bison.o: $(OUTPUT)util/%-bison.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(ALL_CFLAGS) -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w $<
+        $(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(CFLAGS) -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w $<
 
 $(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
 $(OUTPUT)%.i: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -E $(ALL_CFLAGS) $<
+        $(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
 $(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -S $(ALL_CFLAGS) $<
+        $(QUIET_CC)$(CC) -o $@ -S $(CFLAGS) $<
 $(OUTPUT)%.o: %.S
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
 $(OUTPUT)%.s: %.S
-        $(QUIET_CC)$(CC) -o $@ -E $(ALL_CFLAGS) $<
+        $(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
 
 $(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
                 '-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
                 '-DPREFIX="$(prefix_SQ)"' \
                 $<
 
 $(OUTPUT)tests/attr.o: tests/attr.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
                 '-DBINDIR="$(bindir_SQ)"' -DPYTHON='"$(PYTHON_WORD)"' \
                 $<
 
 $(OUTPUT)tests/python-use.o: tests/python-use.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
                 -DPYTHONPATH='"$(OUTPUT)python"' \
                 -DPYTHON='"$(PYTHON_WORD)"' \
                 $<
 
 $(OUTPUT)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
 $(OUTPUT)ui/browser.o: ui/browser.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)ui/browsers/annotate.o: ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)ui/browsers/hists.o: ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)ui/browsers/map.o: ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)ui/browsers/scripts.o: ui/browsers/scripts.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
 $(OUTPUT)util/parse-events.o: util/parse-events.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Wno-redundant-decls $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-redundant-decls $<
 
 $(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow -Wno-undef -Wno-switch-default $<
 
 $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs -Wno-undef -Wno-switch-default $<
 
 $(OUTPUT)util/scripting-engines/trace-event-python.o: util/scripting-engines/trace-event-python.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
 
 $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o: scripts/python/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
+        $(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 
 $(OUTPUT)perf-%: %.o $(PERFLIBS)
-        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)
+        $(QUIET_LINK)$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $(filter %.o,$^) $(LIBS)
 
 $(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
 $(patsubst perf-%,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.h)
@@ -1134,7 +738,7 @@ cscope:
         $(FIND) . -name '*.[hcS]' -print | xargs cscope -b
 
 ### Detect prefix changes
-TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\
+TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):\
              $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ)
 
 $(OUTPUT)PERF-CFLAGS: .FORCE-PERF-CFLAGS
@@ -1155,7 +759,7 @@ check: $(OUTPUT)common-cmds.h
         then \
                 for i in *.c */*.c; \
                 do \
-                        sparse $(ALL_CFLAGS) $(SPARSE_FLAGS) $$i || exit; \
+                        sparse $(CFLAGS) $(SPARSE_FLAGS) $$i || exit; \
                 done; \
         else \
                 exit 1; \
@@ -1163,27 +767,24 @@ check: $(OUTPUT)common-cmds.h
 
 ### Installation rules
 
-ifneq ($(filter /%,$(firstword $(perfexecdir))),)
-perfexec_instdir = $(perfexecdir)
-else
-perfexec_instdir = $(prefix)/$(perfexecdir)
-endif
-perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))
-
 install-bin: all
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'
         $(INSTALL) $(OUTPUT)perf '$(DESTDIR_SQ)$(bindir_SQ)'
+        $(INSTALL) $(OUTPUT)perf-archive -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
+ifndef NO_LIBPERL
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
-        $(INSTALL) $(OUTPUT)perf-archive -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
         $(INSTALL) scripts/perl/Perf-Trace-Util/lib/Perf/Trace/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'
         $(INSTALL) scripts/perl/*.pl -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl'
         $(INSTALL) scripts/perl/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
+endif
+ifndef NO_LIBPYTHON
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/Perf-Trace-Util/lib/Perf/Trace'
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
         $(INSTALL) scripts/python/Perf-Trace-Util/lib/Perf/Trace/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/Perf-Trace-Util/lib/Perf/Trace'
         $(INSTALL) scripts/python/*.py -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python'
         $(INSTALL) scripts/python/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
+endif
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(sysconfdir_SQ)/bash_completion.d'
         $(INSTALL) bash_completion '$(DESTDIR_SQ)$(sysconfdir_SQ)/bash_completion.d/perf'
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests'
diff --git a/tools/perf/arch/x86/Makefile b/tools/perf/arch/x86/Makefile
index 815841c04eb2..8801fe02f206 100644
--- a/tools/perf/arch/x86/Makefile
+++ b/tools/perf/arch/x86/Makefile
@@ -6,3 +6,5 @@ ifndef NO_LIBUNWIND
 LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/unwind.o
 endif
 LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/tsc.o
+LIB_H += arch/$(ARCH)/util/tsc.h
diff --git a/tools/perf/arch/x86/util/tsc.c b/tools/perf/arch/x86/util/tsc.c
new file mode 100644
index 000000000000..b2519e49424f
--- /dev/null
+++ b/tools/perf/arch/x86/util/tsc.c
@@ -0,0 +1,59 @@
+#include <stdbool.h>
+#include <errno.h>
+
+#include <linux/perf_event.h>
+
+#include "../../perf.h"
+#include "../../util/types.h"
+#include "../../util/debug.h"
+#include "tsc.h"
+
+u64 perf_time_to_tsc(u64 ns, struct perf_tsc_conversion *tc)
+{
+        u64 t, quot, rem;
+
+        t = ns - tc->time_zero;
+        quot = t / tc->time_mult;
+        rem  = t % tc->time_mult;
+        return (quot << tc->time_shift) +
+               (rem << tc->time_shift) / tc->time_mult;
+}
+
+u64 tsc_to_perf_time(u64 cyc, struct perf_tsc_conversion *tc)
+{
+        u64 quot, rem;
+
+        quot = cyc >> tc->time_shift;
+        rem  = cyc & ((1 << tc->time_shift) - 1);
+        return tc->time_zero + quot * tc->time_mult +
+               ((rem * tc->time_mult) >> tc->time_shift);
+}
+
+int perf_read_tsc_conversion(const struct perf_event_mmap_page *pc,
+                             struct perf_tsc_conversion *tc)
+{
+        bool cap_user_time_zero;
+        u32 seq;
+        int i = 0;
+
+        while (1) {
+                seq = pc->lock;
+                rmb();
+                tc->time_mult = pc->time_mult;
+                tc->time_shift = pc->time_shift;
+                tc->time_zero = pc->time_zero;
+                cap_user_time_zero = pc->cap_user_time_zero;
+                rmb();
+                if (pc->lock == seq && !(seq & 1))
+                        break;
+                if (++i > 10000) {
+                        pr_debug("failed to get perf_event_mmap_page lock\n");
+                        return -EINVAL;
+                }
+        }
+
+        if (!cap_user_time_zero)
+                return -EOPNOTSUPP;
+
+        return 0;
+}
diff --git a/tools/perf/arch/x86/util/tsc.h b/tools/perf/arch/x86/util/tsc.h
new file mode 100644
index 000000000000..a24dec81c795
--- /dev/null
+++ b/tools/perf/arch/x86/util/tsc.h
@@ -0,0 +1,20 @@
+#ifndef TOOLS_PERF_ARCH_X86_UTIL_TSC_H__
+#define TOOLS_PERF_ARCH_X86_UTIL_TSC_H__
+
+#include "../../util/types.h"
+
+struct perf_tsc_conversion {
+        u16 time_shift;
+        u32 time_mult;
+        u64 time_zero;
+};
+
+struct perf_event_mmap_page;
+
+int perf_read_tsc_conversion(const struct perf_event_mmap_page *pc,
+                             struct perf_tsc_conversion *tc);
+
+u64 perf_time_to_tsc(u64 ns, struct perf_tsc_conversion *tc);
+u64 tsc_to_perf_time(u64 cyc, struct perf_tsc_conversion *tc);
+
+#endif /* TOOLS_PERF_ARCH_X86_UTIL_TSC_H__ */
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index 93c83e3cb4a7..8cdca43016b2 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -111,12 +111,14 @@ static double timeval2double(struct timeval *ts)
 static void alloc_mem(void **dst, void **src, size_t length)
 {
         *dst = zalloc(length);
-        if (!dst)
+        if (!*dst)
                 die("memory allocation failed - maybe length is too large?\n");
 
         *src = zalloc(length);
-        if (!src)
+        if (!*src)
                 die("memory allocation failed - maybe length is too large?\n");
+        /* Make sure to always replace the zero pages even if MMAP_THRESH is crossed */
+        memset(*src, 0, length);
 }
 
 static u64 do_memcpy_cycle(memcpy_t fn, size_t len, bool prefault)
diff --git a/tools/perf/bench/mem-memset.c b/tools/perf/bench/mem-memset.c
index c6e4bc523492..4a2f12081964 100644
--- a/tools/perf/bench/mem-memset.c
+++ b/tools/perf/bench/mem-memset.c
@@ -111,7 +111,7 @@ static double timeval2double(struct timeval *ts)
 static void alloc_mem(void **dst, size_t length)
 {
         *dst = zalloc(length);
-        if (!dst)
+        if (!*dst)
                 die("memory allocation failed - maybe length is too large?\n");
 }
 
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index db491e9a812b..5ebd0c3b71b6 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -90,8 +90,7 @@ static int process_sample_event(struct perf_tool *tool,
         struct perf_annotate *ann = container_of(tool, struct perf_annotate, tool);
         struct addr_location al;
 
-        if (perf_event__preprocess_sample(event, machine, &al, sample,
-                                          symbol__annotate_init) < 0) {
+        if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
                 pr_warning("problem processing %d event, skipping it.\n",
                            event->header.type);
                 return -1;
@@ -195,6 +194,8 @@ static int __cmd_annotate(struct perf_annotate *ann)
         if (session == NULL)
                 return -ENOMEM;
 
+        machines__set_symbol_filter(&session->machines, symbol__annotate_init);
+
         if (ann->cpu_list) {
                 ret = perf_session__cpu_bitmap(session, ann->cpu_list,
                                                ann->cpu_bitmap);
@@ -276,6 +277,7 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                 .tool = {
                         .sample = process_sample_event,
                         .mmap   = perf_event__process_mmap,
+                        .mmap2  = perf_event__process_mmap2,
                         .comm   = perf_event__process_comm,
                         .exit   = perf_event__process_exit,
                         .fork   = perf_event__process_fork,
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index 2d0462d89a97..f28799e94f2a 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -18,15 +18,53 @@
 #include "util/util.h"
 
 #include <stdlib.h>
+#include <math.h>
 
-static char const *input_old = "perf.data.old",
-                  *input_new = "perf.data";
-static char       diff__default_sort_order[] = "dso,symbol";
-static bool  force;
+/* Diff command specific HPP columns. */
+enum {
+        PERF_HPP_DIFF__BASELINE,
+        PERF_HPP_DIFF__PERIOD,
+        PERF_HPP_DIFF__PERIOD_BASELINE,
+        PERF_HPP_DIFF__DELTA,
+        PERF_HPP_DIFF__RATIO,
+        PERF_HPP_DIFF__WEIGHTED_DIFF,
+        PERF_HPP_DIFF__FORMULA,
+
+        PERF_HPP_DIFF__MAX_INDEX
+};
+
+struct diff_hpp_fmt {
+        struct perf_hpp_fmt      fmt;
+        int                      idx;
+        char                    *header;
+        int                      header_width;
+};
+
+struct data__file {
+        struct perf_session     *session;
+        const char              *file;
+        int                      idx;
+        struct hists            *hists;
+        struct diff_hpp_fmt      fmt[PERF_HPP_DIFF__MAX_INDEX];
+};
+
+static struct data__file *data__files;
+static int data__files_cnt;
+
+#define data__for_each_file_start(i, d, s)      \
+        for (i = s, d = &data__files[s];        \
+             i < data__files_cnt;               \
+             i++, d = &data__files[i])
+
+#define data__for_each_file(i, d) data__for_each_file_start(i, d, 0)
+#define data__for_each_file_new(i, d) data__for_each_file_start(i, d, 1)
+
+static char diff__default_sort_order[] = "dso,symbol";
+static bool force;
 static bool show_period;
 static bool show_formula;
 static bool show_baseline_only;
-static bool sort_compute;
+static unsigned int sort_compute;
 
 static s64 compute_wdiff_w1;
 static s64 compute_wdiff_w2;
@@ -46,6 +84,47 @@ const char *compute_names[COMPUTE_MAX] = {
 
 static int compute;
 
+static int compute_2_hpp[COMPUTE_MAX] = {
+        [COMPUTE_DELTA]         = PERF_HPP_DIFF__DELTA,
+        [COMPUTE_RATIO]         = PERF_HPP_DIFF__RATIO,
+        [COMPUTE_WEIGHTED_DIFF] = PERF_HPP_DIFF__WEIGHTED_DIFF,
+};
+
+#define MAX_COL_WIDTH 70
+
+static struct header_column {
+        const char *name;
+        int width;
+} columns[PERF_HPP_DIFF__MAX_INDEX] = {
+        [PERF_HPP_DIFF__BASELINE] = {
+                .name  = "Baseline",
+        },
+        [PERF_HPP_DIFF__PERIOD] = {
+                .name  = "Period",
+                .width = 14,
+        },
+        [PERF_HPP_DIFF__PERIOD_BASELINE] = {
+                .name  = "Base period",
+                .width = 14,
+        },
+        [PERF_HPP_DIFF__DELTA] = {
+                .name  = "Delta",
+                .width = 7,
+        },
+        [PERF_HPP_DIFF__RATIO] = {
+                .name  = "Ratio",
+                .width = 14,
+        },
+        [PERF_HPP_DIFF__WEIGHTED_DIFF] = {
+                .name  = "Weighted diff",
+                .width = 14,
+        },
+        [PERF_HPP_DIFF__FORMULA] = {
+                .name  = "Formula",
+                .width = MAX_COL_WIDTH,
+        }
+};
+
 static int setup_compute_opt_wdiff(char *opt)
 {
         char *w1_str = opt;
@@ -109,13 +188,6 @@ static int setup_compute(const struct option *opt, const char *str,
                 return 0;
         }
 
-        if (*str == '+') {
-                sort_compute = true;
-                cstr = (char *) ++str;
-                if (!*str)
-                        return 0;
-        }
-
         option = strchr(str, ':');
         if (option) {
                 unsigned len = option++ - str;
@@ -145,42 +217,42 @@ static int setup_compute(const struct option *opt, const char *str,
         return -EINVAL;
 }
 
-double perf_diff__period_percent(struct hist_entry *he, u64 period)
+static double period_percent(struct hist_entry *he, u64 period)
 {
         u64 total = he->hists->stats.total_period;
         return (period * 100.0) / total;
 }
 
-double perf_diff__compute_delta(struct hist_entry *he, struct hist_entry *pair)
+static double compute_delta(struct hist_entry *he, struct hist_entry *pair)
 {
-        double new_percent = perf_diff__period_percent(he, he->stat.period);
-        double old_percent = perf_diff__period_percent(pair, pair->stat.period);
+        double old_percent = period_percent(he, he->stat.period);
+        double new_percent = period_percent(pair, pair->stat.period);
 
-        he->diff.period_ratio_delta = new_percent - old_percent;
-        he->diff.computed = true;
-        return he->diff.period_ratio_delta;
+        pair->diff.period_ratio_delta = new_percent - old_percent;
+        pair->diff.computed = true;
+        return pair->diff.period_ratio_delta;
 }
 
-double perf_diff__compute_ratio(struct hist_entry *he, struct hist_entry *pair)
+static double compute_ratio(struct hist_entry *he, struct hist_entry *pair)
 {
-        double new_period = he->stat.period;
-        double old_period = pair->stat.period;
+        double old_period = he->stat.period ?: 1;
+        double new_period = pair->stat.period;
 
-        he->diff.computed = true;
-        he->diff.period_ratio = new_period / old_period;
-        return he->diff.period_ratio;
+        pair->diff.computed = true;
+        pair->diff.period_ratio = new_period / old_period;
+        return pair->diff.period_ratio;
 }
 
-s64 perf_diff__compute_wdiff(struct hist_entry *he, struct hist_entry *pair)
+static s64 compute_wdiff(struct hist_entry *he, struct hist_entry *pair)
 {
-        u64 new_period = he->stat.period;
-        u64 old_period = pair->stat.period;
+        u64 old_period = he->stat.period;
+        u64 new_period = pair->stat.period;
 
-        he->diff.computed = true;
-        he->diff.wdiff = new_period * compute_wdiff_w2 -
-                         old_period * compute_wdiff_w1;
+        pair->diff.computed = true;
+        pair->diff.wdiff = new_period * compute_wdiff_w2 -
+                           old_period * compute_wdiff_w1;
 
-        return he->diff.wdiff;
+        return pair->diff.wdiff;
 }
 
 static int formula_delta(struct hist_entry *he, struct hist_entry *pair,
@@ -189,15 +261,15 @@ static int formula_delta(struct hist_entry *he, struct hist_entry *pair,
         return scnprintf(buf, size,
                          "(%" PRIu64 " * 100 / %" PRIu64 ") - "
                          "(%" PRIu64 " * 100 / %" PRIu64 ")",
-                          he->stat.period, he->hists->stats.total_period,
-                          pair->stat.period, pair->hists->stats.total_period);
+                          pair->stat.period, pair->hists->stats.total_period,
+                          he->stat.period, he->hists->stats.total_period);
 }
 
 static int formula_ratio(struct hist_entry *he, struct hist_entry *pair,
                          char *buf, size_t size)
 {
-        double new_period = he->stat.period;
-        double old_period = pair->stat.period;
+        double old_period = he->stat.period;
+        double new_period = pair->stat.period;
 
         return scnprintf(buf, size, "%.0F / %.0F", new_period, old_period);
 }
@@ -205,16 +277,16 @@ static int formula_ratio(struct hist_entry *he, struct hist_entry *pair,
 static int formula_wdiff(struct hist_entry *he, struct hist_entry *pair,
                          char *buf, size_t size)
 {
-        u64 new_period = he->stat.period;
-        u64 old_period = pair->stat.period;
+        u64 old_period = he->stat.period;
+        u64 new_period = pair->stat.period;
 
         return scnprintf(buf, size,
                   "(%" PRIu64 " * " "%" PRId64 ") - (%" PRIu64 " * " "%" PRId64 ")",
                   new_period, compute_wdiff_w2, old_period, compute_wdiff_w1);
 }
 
-int perf_diff__formula(struct hist_entry *he, struct hist_entry *pair,
-                       char *buf, size_t size)
+static int formula_fprintf(struct hist_entry *he, struct hist_entry *pair,
+                           char *buf, size_t size)
 {
         switch (compute) {
         case COMPUTE_DELTA:
@@ -247,7 +319,7 @@ static int diff__process_sample_event(struct perf_tool *tool __maybe_unused,
 {
         struct addr_location al;
 
-        if (perf_event__preprocess_sample(event, machine, &al, sample, NULL) < 0) {
+        if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
                 pr_warning("problem processing %d event, skipping it.\n",
                            event->header.type);
                 return -1;
@@ -299,6 +371,29 @@ static void perf_evlist__collapse_resort(struct perf_evlist *evlist)
         }
 }
 
+static struct hist_entry*
+get_pair_data(struct hist_entry *he, struct data__file *d)
+{
+        if (hist_entry__has_pairs(he)) {
+                struct hist_entry *pair;
+
+                list_for_each_entry(pair, &he->pairs.head, pairs.node)
+                        if (pair->hists == d->hists)
+                                return pair;
+        }
+
+        return NULL;
+}
+
+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);
+
+        return get_pair_data(he, d);
+}
+
 static void hists__baseline_only(struct hists *hists)
 {
         struct rb_root *root;
@@ -323,25 +418,34 @@ static void hists__baseline_only(struct hists *hists)
 
 static void hists__precompute(struct hists *hists)
 {
-        struct rb_node *next = rb_first(&hists->entries);
+        struct rb_root *root;
+        struct rb_node *next;
 
+        if (sort__need_collapse)
+                root = &hists->entries_collapsed;
+        else
+                root = hists->entries_in;
+
+        next = rb_first(root);
         while (next != NULL) {
-                struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node);
-                struct hist_entry *pair = hist_entry__next_pair(he);
+                struct hist_entry *he, *pair;
+
+                he   = rb_entry(next, struct hist_entry, rb_node_in);
+                next = rb_next(&he->rb_node_in);
 
-                next = rb_next(&he->rb_node);
+                pair = get_pair_data(he, &data__files[sort_compute]);
                 if (!pair)
                         continue;
 
                 switch (compute) {
                 case COMPUTE_DELTA:
-                        perf_diff__compute_delta(he, pair);
+                        compute_delta(he, pair);
                         break;
                 case COMPUTE_RATIO:
-                        perf_diff__compute_ratio(he, pair);
+                        compute_ratio(he, pair);
                         break;
                 case COMPUTE_WEIGHTED_DIFF:
-                        perf_diff__compute_wdiff(he, pair);
+                        compute_wdiff(he, pair);
                         break;
                 default:
                         BUG_ON(1);
@@ -360,7 +464,7 @@ static int64_t cmp_doubles(double l, double r)
 }
 
 static int64_t
-hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
+__hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
                         int c)
 {
         switch (c) {
@@ -392,6 +496,36 @@ hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
         return 0;
 }
 
+static int64_t
+hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
+                        int c)
+{
+        bool pairs_left  = hist_entry__has_pairs(left);
+        bool pairs_right = hist_entry__has_pairs(right);
+        struct hist_entry *p_right, *p_left;
+
+        if (!pairs_left && !pairs_right)
+                return 0;
+
+        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]);
+
+        if (!p_left && !p_right)
+                return 0;
+
+        if (!p_left || !p_right)
+                return p_left ? -1 : 1;
+
+        /*
+         * We have 2 entries of same kind, let's
+         * make the data comparison.
+         */
+        return __hist_entry__cmp_compute(p_left, p_right, c);
+}
+
 static void insert_hist_entry_by_compute(struct rb_root *root,
                                          struct hist_entry *he,
                                          int c)
@@ -441,75 +575,121 @@ static void hists__compute_resort(struct hists *hists)
         }
 }
 
-static void hists__process(struct hists *old, struct hists *new)
+static void hists__process(struct hists *hists)
 {
-        hists__match(new, old);
-
         if (show_baseline_only)
-                hists__baseline_only(new);
-        else
-                hists__link(new, old);
+                hists__baseline_only(hists);
 
         if (sort_compute) {
-                hists__precompute(new);
-                hists__compute_resort(new);
+                hists__precompute(hists);
+                hists__compute_resort(hists);
         } else {
-                hists__output_resort(new);
+                hists__output_resort(hists);
         }
 
-        hists__fprintf(new, true, 0, 0, stdout);
+        hists__fprintf(hists, true, 0, 0, 0, stdout);
 }
 
-static int __cmd_diff(void)
+static void data__fprintf(void)
 {
-        int ret, i;
-#define older (session[0])
-#define newer (session[1])
-        struct perf_session *session[2];
-        struct perf_evlist *evlist_new, *evlist_old;
-        struct perf_evsel *evsel;
+        struct data__file *d;
+        int i;
+
+        fprintf(stdout, "# Data files:\n");
+
+        data__for_each_file(i, d)
+                fprintf(stdout, "#  [%d] %s %s\n",
+                        d->idx, d->file,
+                        !d->idx ? "(Baseline)" : "");
+
+        fprintf(stdout, "#\n");
+}
+
+static void data_process(void)
+{
+        struct perf_evlist *evlist_base = data__files[0].session->evlist;
+        struct perf_evsel *evsel_base;
         bool first = true;
 
-        older = perf_session__new(input_old, O_RDONLY, force, false,
-                                  &tool);
-        newer = perf_session__new(input_new, O_RDONLY, force, false,
-                                  &tool);
-        if (session[0] == NULL || session[1] == NULL)
-                return -ENOMEM;
+        list_for_each_entry(evsel_base, &evlist_base->entries, node) {
+                struct data__file *d;
+                int i;
 
-        for (i = 0; i < 2; ++i) {
-                ret = perf_session__process_events(session[i], &tool);
-                if (ret)
-                        goto out_delete;
-        }
+                data__for_each_file_new(i, d) {
+                        struct perf_evlist *evlist = d->session->evlist;
+                        struct perf_evsel *evsel;
 
-        evlist_old = older->evlist;
-        evlist_new = newer->evlist;
+                        evsel = evsel_match(evsel_base, evlist);
+                        if (!evsel)
+                                continue;
 
-        perf_evlist__collapse_resort(evlist_old);
-        perf_evlist__collapse_resort(evlist_new);
+                        d->hists = &evsel->hists;
 
-        list_for_each_entry(evsel, &evlist_new->entries, node) {
-                struct perf_evsel *evsel_old;
+                        hists__match(&evsel_base->hists, &evsel->hists);
 
-                evsel_old = evsel_match(evsel, evlist_old);
-                if (!evsel_old)
-                        continue;
+                        if (!show_baseline_only)
+                                hists__link(&evsel_base->hists,
+                                            &evsel->hists);
+                }
 
                 fprintf(stdout, "%s# Event '%s'\n#\n", first ? "" : "\n",
-                        perf_evsel__name(evsel));
+                        perf_evsel__name(evsel_base));
 
                 first = false;
 
-                hists__process(&evsel_old->hists, &evsel->hists);
+                if (verbose || data__files_cnt > 2)
+                        data__fprintf();
+
+                hists__process(&evsel_base->hists);
         }
+}
+
+static void data__free(struct data__file *d)
+{
+        int col;
+
+        for (col = 0; col < PERF_HPP_DIFF__MAX_INDEX; col++) {
+                struct diff_hpp_fmt *fmt = &d->fmt[col];
 
-out_delete:
-        for (i = 0; i < 2; ++i)
-                perf_session__delete(session[i]);
+                free(fmt->header);
+        }
+}
+
+static int __cmd_diff(void)
+{
+        struct data__file *d;
+        int ret = -EINVAL, i;
+
+        data__for_each_file(i, d) {
+                d->session = perf_session__new(d->file, O_RDONLY, force,
+                                               false, &tool);
+                if (!d->session) {
+                        pr_err("Failed to open %s\n", d->file);
+                        ret = -ENOMEM;
+                        goto out_delete;
+                }
+
+                ret = perf_session__process_events(d->session, &tool);
+                if (ret) {
+                        pr_err("Failed to process %s\n", d->file);
+                        goto out_delete;
+                }
+
+                perf_evlist__collapse_resort(d->session->evlist);
+        }
+
+        data_process();
+
+ out_delete:
+        data__for_each_file(i, d) {
+                if (d->session)
+                        perf_session__delete(d->session);
+
+                data__free(d);
+        }
+
+        free(data__files);
         return ret;
-#undef older
-#undef newer
 }
 
 static const char * const diff_usage[] = {
@@ -548,62 +728,310 @@ static const struct option options[] = {
                    "columns '.' is reserved."),
         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
                     "Look for files with symbols relative to this directory"),
+        OPT_UINTEGER('o', "order", &sort_compute, "Specify compute sorting."),
         OPT_END()
 };
 
-static void ui_init(void)
+static double baseline_percent(struct hist_entry *he)
 {
-        /*
-         * Display baseline/delta/ratio
-         * formula/periods columns.
-         */
-        perf_hpp__column_enable(PERF_HPP__BASELINE);
+        struct hists *hists = he->hists;
+        return 100.0 * he->stat.period / hists->stats.total_period;
+}
 
-        switch (compute) {
-        case COMPUTE_DELTA:
-                perf_hpp__column_enable(PERF_HPP__DELTA);
+static int hpp__color_baseline(struct perf_hpp_fmt *fmt,
+                               struct perf_hpp *hpp, struct hist_entry *he)
+{
+        struct diff_hpp_fmt *dfmt =
+                container_of(fmt, struct diff_hpp_fmt, fmt);
+        double percent = baseline_percent(he);
+        char pfmt[20] = " ";
+
+        if (!he->dummy) {
+                scnprintf(pfmt, 20, "%%%d.2f%%%%", dfmt->header_width - 1);
+                return percent_color_snprintf(hpp->buf, hpp->size,
+                                              pfmt, percent);
+        } else
+                return scnprintf(hpp->buf, hpp->size, "%*s",
+                                 dfmt->header_width, pfmt);
+}
+
+static int hpp__entry_baseline(struct hist_entry *he, char *buf, size_t size)
+{
+        double percent = baseline_percent(he);
+        const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%";
+        int ret = 0;
+
+        if (!he->dummy)
+                ret = scnprintf(buf, size, fmt, percent);
+
+        return ret;
+}
+
+static void
+hpp__entry_unpair(struct hist_entry *he, int idx, char *buf, size_t size)
+{
+        switch (idx) {
+        case PERF_HPP_DIFF__PERIOD_BASELINE:
+                scnprintf(buf, size, "%" PRIu64, he->stat.period);
                 break;
-        case COMPUTE_RATIO:
-                perf_hpp__column_enable(PERF_HPP__RATIO);
+
+        default:
                 break;
-        case COMPUTE_WEIGHTED_DIFF:
-                perf_hpp__column_enable(PERF_HPP__WEIGHTED_DIFF);
+        }
+}
+
+static void
+hpp__entry_pair(struct hist_entry *he, struct hist_entry *pair,
+                int idx, char *buf, size_t size)
+{
+        double diff;
+        double ratio;
+        s64 wdiff;
+
+        switch (idx) {
+        case PERF_HPP_DIFF__DELTA:
+                if (pair->diff.computed)
+                        diff = pair->diff.period_ratio_delta;
+                else
+                        diff = compute_delta(he, pair);
+
+                if (fabs(diff) >= 0.01)
+                        scnprintf(buf, size, "%+4.2F%%", diff);
+                break;
+
+        case PERF_HPP_DIFF__RATIO:
+                /* No point for ratio number if we are dummy.. */
+                if (he->dummy)
+                        break;
+
+                if (pair->diff.computed)
+                        ratio = pair->diff.period_ratio;
+                else
+                        ratio = compute_ratio(he, pair);
+
+                if (ratio > 0.0)
+                        scnprintf(buf, size, "%14.6F", ratio);
                 break;
+
+        case PERF_HPP_DIFF__WEIGHTED_DIFF:
+                /* No point for wdiff number if we are dummy.. */
+                if (he->dummy)
+                        break;
+
+                if (pair->diff.computed)
+                        wdiff = pair->diff.wdiff;
+                else
+                        wdiff = compute_wdiff(he, pair);
+
+                if (wdiff != 0)
+                        scnprintf(buf, size, "%14ld", wdiff);
+                break;
+
+        case PERF_HPP_DIFF__FORMULA:
+                formula_fprintf(he, pair, buf, size);
+                break;
+
+        case PERF_HPP_DIFF__PERIOD:
+                scnprintf(buf, size, "%" PRIu64, pair->stat.period);
+                break;
+
         default:
                 BUG_ON(1);
         };
+}
 
-        if (show_formula)
-                perf_hpp__column_enable(PERF_HPP__FORMULA);
+static void
+__hpp__entry_global(struct hist_entry *he, struct diff_hpp_fmt *dfmt,
+                    char *buf, size_t size)
+{
+        struct hist_entry *pair = get_pair_fmt(he, dfmt);
+        int idx = dfmt->idx;
+
+        /* baseline is special */
+        if (idx == PERF_HPP_DIFF__BASELINE)
+                hpp__entry_baseline(he, buf, size);
+        else {
+                if (pair)
+                        hpp__entry_pair(he, pair, idx, buf, size);
+                else
+                        hpp__entry_unpair(he, idx, buf, size);
+        }
+}
+
+static int hpp__entry_global(struct perf_hpp_fmt *_fmt, struct perf_hpp *hpp,
+                             struct hist_entry *he)
+{
+        struct diff_hpp_fmt *dfmt =
+                container_of(_fmt, struct diff_hpp_fmt, fmt);
+        char buf[MAX_COL_WIDTH] = " ";
+
+        __hpp__entry_global(he, dfmt, buf, MAX_COL_WIDTH);
 
-        if (show_period) {
-                perf_hpp__column_enable(PERF_HPP__PERIOD);
-                perf_hpp__column_enable(PERF_HPP__PERIOD_BASELINE);
+        if (symbol_conf.field_sep)
+                return scnprintf(hpp->buf, hpp->size, "%s", buf);
+        else
+                return scnprintf(hpp->buf, hpp->size, "%*s",
+                                 dfmt->header_width, buf);
+}
+
+static int hpp__header(struct perf_hpp_fmt *fmt,
+                       struct perf_hpp *hpp)
+{
+        struct diff_hpp_fmt *dfmt =
+                container_of(fmt, struct diff_hpp_fmt, fmt);
+
+        BUG_ON(!dfmt->header);
+        return scnprintf(hpp->buf, hpp->size, dfmt->header);
+}
+
+static int hpp__width(struct perf_hpp_fmt *fmt,
+                      struct perf_hpp *hpp __maybe_unused)
+{
+        struct diff_hpp_fmt *dfmt =
+                container_of(fmt, struct diff_hpp_fmt, fmt);
+
+        BUG_ON(dfmt->header_width <= 0);
+        return dfmt->header_width;
+}
+
+static void init_header(struct data__file *d, struct diff_hpp_fmt *dfmt)
+{
+#define MAX_HEADER_NAME 100
+        char buf_indent[MAX_HEADER_NAME];
+        char buf[MAX_HEADER_NAME];
+        const char *header = NULL;
+        int width = 0;
+
+        BUG_ON(dfmt->idx >= PERF_HPP_DIFF__MAX_INDEX);
+        header = columns[dfmt->idx].name;
+        width  = columns[dfmt->idx].width;
+
+        /* Only our defined HPP fmts should appear here. */
+        BUG_ON(!header);
+
+        if (data__files_cnt > 2)
+                scnprintf(buf, MAX_HEADER_NAME, "%s/%d", header, d->idx);
+
+#define NAME (data__files_cnt > 2 ? buf : header)
+        dfmt->header_width = width;
+        width = (int) strlen(NAME);
+        if (dfmt->header_width < width)
+                dfmt->header_width = width;
+
+        scnprintf(buf_indent, MAX_HEADER_NAME, "%*s",
+                  dfmt->header_width, NAME);
+
+        dfmt->header = strdup(buf_indent);
+#undef MAX_HEADER_NAME
+#undef NAME
+}
+
+static void data__hpp_register(struct data__file *d, int idx)
+{
+        struct diff_hpp_fmt *dfmt = &d->fmt[idx];
+        struct perf_hpp_fmt *fmt = &dfmt->fmt;
+
+        dfmt->idx = idx;
+
+        fmt->header = hpp__header;
+        fmt->width  = hpp__width;
+        fmt->entry  = hpp__entry_global;
+
+        /* TODO more colors */
+        if (idx == PERF_HPP_DIFF__BASELINE)
+                fmt->color = hpp__color_baseline;
+
+        init_header(d, dfmt);
+        perf_hpp__column_register(fmt);
+}
+
+static void ui_init(void)
+{
+        struct data__file *d;
+        int i;
+
+        data__for_each_file(i, d) {
+
+                /*
+                 * Baseline or compute realted columns:
+                 *
+                 *   PERF_HPP_DIFF__BASELINE
+                 *   PERF_HPP_DIFF__DELTA
+                 *   PERF_HPP_DIFF__RATIO
+                 *   PERF_HPP_DIFF__WEIGHTED_DIFF
+                 */
+                data__hpp_register(d, i ? compute_2_hpp[compute] :
+                                          PERF_HPP_DIFF__BASELINE);
+
+                /*
+                 * And the rest:
+                 *
+                 * PERF_HPP_DIFF__FORMULA
+                 * PERF_HPP_DIFF__PERIOD
+                 * PERF_HPP_DIFF__PERIOD_BASELINE
+                 */
+                if (show_formula && i)
+                        data__hpp_register(d, PERF_HPP_DIFF__FORMULA);
+
+                if (show_period)
+                        data__hpp_register(d, i ? PERF_HPP_DIFF__PERIOD :
+                                                  PERF_HPP_DIFF__PERIOD_BASELINE);
         }
 }
 
-int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused)
+static int data_init(int argc, const char **argv)
 {
-        sort_order = diff__default_sort_order;
-        argc = parse_options(argc, argv, options, diff_usage, 0);
+        struct data__file *d;
+        static const char *defaults[] = {
+                "perf.data.old",
+                "perf.data",
+        };
+        bool use_default = true;
+        int i;
+
+        data__files_cnt = 2;
+
         if (argc) {
-                if (argc > 2)
-                        usage_with_options(diff_usage, options);
-                if (argc == 2) {
-                        input_old = argv[0];
-                        input_new = argv[1];
-                } else
-                        input_new = argv[0];
+                if (argc == 1)
+                        defaults[1] = argv[0];
+                else {
+                        data__files_cnt = argc;
+                        use_default = false;
+                }
         } else if (symbol_conf.default_guest_vmlinux_name ||
                    symbol_conf.default_guest_kallsyms) {
-                input_old = "perf.data.host";
-                input_new = "perf.data.guest";
+                defaults[0] = "perf.data.host";
+                defaults[1] = "perf.data.guest";
+        }
+
+        if (sort_compute >= (unsigned int) data__files_cnt) {
+                pr_err("Order option out of limit.\n");
+                return -EINVAL;
+        }
+
+        data__files = zalloc(sizeof(*data__files) * data__files_cnt);
+        if (!data__files)
+                return -ENOMEM;
+
+        data__for_each_file(i, d) {
+                d->file = use_default ? defaults[i] : argv[i];
+                d->idx  = i;
         }
 
-        symbol_conf.exclude_other = false;
+        return 0;
+}
+
+int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused)
+{
+        sort_order = diff__default_sort_order;
+        argc = parse_options(argc, argv, options, diff_usage, 0);
+
         if (symbol__init() < 0)
                 return -1;
 
+        if (data_init(argc, argv) < 0)
+                return -1;
+
         ui_init();
 
         if (setup_sorting() < 0)
@@ -611,9 +1039,7 @@ int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused)
 
         setup_pager();
 
-        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", NULL);
-        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", NULL);
-        sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", NULL);
+        sort__setup_elide(NULL);
 
         return __cmd_diff();
 }
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index 84ad6abe4258..afe377b2884f 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -38,8 +38,7 @@ struct event_entry {
 };
 
 static int perf_event__repipe_synth(struct perf_tool *tool,
-                                    union perf_event *event,
-                                    struct machine *machine __maybe_unused)
+                                    union perf_event *event)
 {
         struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
         uint32_t size;
@@ -65,39 +64,28 @@ static int perf_event__repipe_op2_synth(struct perf_tool *tool,
                                         struct perf_session *session
                                         __maybe_unused)
 {
-        return perf_event__repipe_synth(tool, event, NULL);
+        return perf_event__repipe_synth(tool, event);
 }
 
-static int perf_event__repipe_event_type_synth(struct perf_tool *tool,
-                                               union perf_event *event)
-{
-        return perf_event__repipe_synth(tool, event, NULL);
-}
-
-static int perf_event__repipe_tracing_data_synth(union perf_event *event,
-                                                 struct perf_session *session
-                                                 __maybe_unused)
-{
-        return perf_event__repipe_synth(NULL, event, NULL);
-}
-
-static int perf_event__repipe_attr(union perf_event *event,
-                                   struct perf_evlist **pevlist __maybe_unused)
+static int perf_event__repipe_attr(struct perf_tool *tool,
+                                   union perf_event *event,
+                                   struct perf_evlist **pevlist)
 {
         int ret;
-        ret = perf_event__process_attr(event, pevlist);
+
+        ret = perf_event__process_attr(tool, event, pevlist);
         if (ret)
                 return ret;
 
-        return perf_event__repipe_synth(NULL, event, NULL);
+        return perf_event__repipe_synth(tool, event);
 }
 
 static int perf_event__repipe(struct perf_tool *tool,
                               union perf_event *event,
                               struct perf_sample *sample __maybe_unused,
-                              struct machine *machine)
+                              struct machine *machine __maybe_unused)
 {
-        return perf_event__repipe_synth(tool, event, machine);
+        return perf_event__repipe_synth(tool, event);
 }
 
 typedef int (*inject_handler)(struct perf_tool *tool,
@@ -119,7 +107,7 @@ static int perf_event__repipe_sample(struct perf_tool *tool,
 
         build_id__mark_dso_hit(tool, event, sample, evsel, machine);
 
-        return perf_event__repipe_synth(tool, event, machine);
+        return perf_event__repipe_synth(tool, event);
 }
 
 static int perf_event__repipe_mmap(struct perf_tool *tool,
@@ -135,6 +123,19 @@ static int perf_event__repipe_mmap(struct perf_tool *tool,
         return err;
 }
 
+static int perf_event__repipe_mmap2(struct perf_tool *tool,
+                                   union perf_event *event,
+                                   struct perf_sample *sample,
+                                   struct machine *machine)
+{
+        int err;
+
+        err = perf_event__process_mmap2(tool, event, sample, machine);
+        perf_event__repipe(tool, event, sample, machine);
+
+        return err;
+}
+
 static int perf_event__repipe_fork(struct perf_tool *tool,
                                    union perf_event *event,
                                    struct perf_sample *sample,
@@ -148,13 +149,14 @@ static int perf_event__repipe_fork(struct perf_tool *tool,
         return err;
 }
 
-static int perf_event__repipe_tracing_data(union perf_event *event,
+static int perf_event__repipe_tracing_data(struct perf_tool *tool,
+                                           union perf_event *event,
                                            struct perf_session *session)
 {
         int err;
 
-        perf_event__repipe_synth(NULL, event, NULL);
-        err = perf_event__process_tracing_data(event, session);
+        perf_event__repipe_synth(tool, event);
+        err = perf_event__process_tracing_data(tool, event, session);
 
         return err;
 }
@@ -209,7 +211,7 @@ static int perf_event__inject_buildid(struct perf_tool *tool,
 
         cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
-        thread = machine__findnew_thread(machine, event->ip.pid);
+        thread = machine__findnew_thread(machine, sample->pid, sample->pid);
         if (thread == NULL) {
                 pr_err("problem processing %d event, skipping it.\n",
                        event->header.type);
@@ -217,7 +219,7 @@ static int perf_event__inject_buildid(struct perf_tool *tool,
         }
 
         thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
-                              event->ip.ip, &al);
+                              sample->ip, &al);
 
         if (al.map != NULL) {
                 if (!al.map->dso->hit) {
@@ -312,13 +314,13 @@ found:
         sample_sw.period = sample->period;
         sample_sw.time   = sample->time;
         perf_event__synthesize_sample(event_sw, evsel->attr.sample_type,
-                                      &sample_sw, false);
+                                      evsel->attr.sample_regs_user,
+                                      evsel->attr.read_format, &sample_sw,
+                                      false);
         build_id__mark_dso_hit(tool, event_sw, &sample_sw, evsel, machine);
         return perf_event__repipe(tool, event_sw, &sample_sw, machine);
 }
 
-extern volatile int session_done;
-
 static void sig_handler(int sig __maybe_unused)
 {
         session_done = 1;
@@ -348,6 +350,7 @@ static int __cmd_inject(struct perf_inject *inject)
 
         if (inject->build_ids || inject->sched_stat) {
                 inject->tool.mmap         = perf_event__repipe_mmap;
+                inject->tool.mmap2        = perf_event__repipe_mmap2;
                 inject->tool.fork         = perf_event__repipe_fork;
                 inject->tool.tracing_data = perf_event__repipe_tracing_data;
         }
@@ -399,6 +402,7 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                 .tool = {
                         .sample         = perf_event__repipe_sample,
                         .mmap           = perf_event__repipe,
+                        .mmap2          = perf_event__repipe,
                         .comm           = perf_event__repipe,
                         .fork           = perf_event__repipe,
                         .exit           = perf_event__repipe,
@@ -407,8 +411,8 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                         .throttle       = perf_event__repipe,
                         .unthrottle     = perf_event__repipe,
                         .attr           = perf_event__repipe_attr,
-                        .event_type     = perf_event__repipe_event_type_synth,
-                        .tracing_data   = perf_event__repipe_tracing_data_synth,
+                        .tracing_data   = perf_event__repipe_op2_synth,
+                        .finished_round = perf_event__repipe_op2_synth,
                         .build_id       = perf_event__repipe_op2_synth,
                 },
                 .input_name  = "-",
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index 46878daca5cc..9b5f077fee5b 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -101,7 +101,7 @@ static int setup_cpunode_map(void)
 
         dir1 = opendir(PATH_SYS_NODE);
         if (!dir1)
-                return -1;
+                return 0;
 
         while ((dent1 = readdir(dir1)) != NULL) {
                 if (dent1->d_type != DT_DIR ||
@@ -305,7 +305,8 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                                 struct perf_evsel *evsel,
                                 struct machine *machine)
 {
-        struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
+        struct thread *thread = machine__findnew_thread(machine, sample->pid,
+                                                        sample->pid);
 
         if (thread == NULL) {
                 pr_debug("problem processing %d event, skipping it.\n",
@@ -313,7 +314,7 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                 return -1;
         }
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->tid);
 
         if (evsel->handler.func != NULL) {
                 tracepoint_handler f = evsel->handler.func;
@@ -708,7 +709,7 @@ static int parse_line_opt(const struct option *opt __maybe_unused,
 static int __cmd_record(int argc, const char **argv)
 {
         const char * const record_args[] = {
-        "record", "-a", "-R", "-f", "-c", "1",
+        "record", "-a", "-R", "-c", "1",
         "-e", "kmem:kmalloc",
         "-e", "kmem:kmalloc_node",
         "-e", "kmem:kfree",
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 533501e2b07c..935d52216c89 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -2,22 +2,26 @@
 #include "perf.h"
 
 #include "util/evsel.h"
+#include "util/evlist.h"
 #include "util/util.h"
 #include "util/cache.h"
 #include "util/symbol.h"
 #include "util/thread.h"
 #include "util/header.h"
 #include "util/session.h"
-
+#include "util/intlist.h"
 #include "util/parse-options.h"
 #include "util/trace-event.h"
 #include "util/debug.h"
 #include <lk/debugfs.h>
 #include "util/tool.h"
 #include "util/stat.h"
+#include "util/top.h"
 
 #include <sys/prctl.h>
+#include <sys/timerfd.h>
 
+#include <termios.h>
 #include <semaphore.h>
 #include <pthread.h>
 #include <math.h>
@@ -82,6 +86,8 @@ struct exit_reasons_table {
 
 struct perf_kvm_stat {
         struct perf_tool    tool;
+        struct perf_record_opts opts;
+        struct perf_evlist  *evlist;
         struct perf_session *session;
 
         const char *file_name;
@@ -96,10 +102,20 @@ struct perf_kvm_stat {
         struct kvm_events_ops *events_ops;
         key_cmp_fun compare;
         struct list_head kvm_events_cache[EVENTS_CACHE_SIZE];
+
         u64 total_time;
         u64 total_count;
+        u64 lost_events;
+        u64 duration;
+
+        const char *pid_str;
+        struct intlist *pid_list;
 
         struct rb_root result;
+
+        int timerfd;
+        unsigned int display_time;
+        bool live;
 };
 
 
@@ -320,6 +336,28 @@ static void init_kvm_event_record(struct perf_kvm_stat *kvm)
                 INIT_LIST_HEAD(&kvm->kvm_events_cache[i]);
 }
 
+static void clear_events_cache_stats(struct list_head *kvm_events_cache)
+{
+        struct list_head *head;
+        struct kvm_event *event;
+        unsigned int i;
+        int j;
+
+        for (i = 0; i < EVENTS_CACHE_SIZE; i++) {
+                head = &kvm_events_cache[i];
+                list_for_each_entry(event, head, hash_entry) {
+                        /* reset stats for event */
+                        event->total.time = 0;
+                        init_stats(&event->total.stats);
+
+                        for (j = 0; j < event->max_vcpu; ++j) {
+                                event->vcpu[j].time = 0;
+                                init_stats(&event->vcpu[j].stats);
+                        }
+                }
+        }
+}
+
 static int kvm_events_hash_fn(u64 key)
 {
         return key & (EVENTS_CACHE_SIZE - 1);
@@ -328,6 +366,7 @@ static int kvm_events_hash_fn(u64 key)
 static bool kvm_event_expand(struct kvm_event *event, int vcpu_id)
 {
         int old_max_vcpu = event->max_vcpu;
+        void *prev;
 
         if (vcpu_id < event->max_vcpu)
                 return true;
@@ -335,9 +374,11 @@ static bool kvm_event_expand(struct kvm_event *event, int vcpu_id)
         while (event->max_vcpu <= vcpu_id)
                 event->max_vcpu += DEFAULT_VCPU_NUM;
 
+        prev = event->vcpu;
         event->vcpu = realloc(event->vcpu,
                               event->max_vcpu * sizeof(*event->vcpu));
         if (!event->vcpu) {
+                free(prev);
                 pr_err("Not enough memory\n");
                 return false;
         }
@@ -433,7 +474,7 @@ static bool update_kvm_event(struct kvm_event *event, int vcpu_id,
 static bool handle_end_event(struct perf_kvm_stat *kvm,
                              struct vcpu_event_record *vcpu_record,
                              struct event_key *key,
-                             u64 timestamp)
+                             struct perf_sample *sample)
 {
         struct kvm_event *event;
         u64 time_begin, time_diff;
@@ -469,9 +510,25 @@ static bool handle_end_event(struct perf_kvm_stat *kvm,
         vcpu_record->last_event = NULL;
         vcpu_record->start_time = 0;
 
-        BUG_ON(timestamp < time_begin);
+        /* seems to happen once in a while during live mode */
+        if (sample->time < time_begin) {
+                pr_debug("End time before begin time; skipping event.\n");
+                return true;
+        }
+
+        time_diff = sample->time - time_begin;
+
+        if (kvm->duration && time_diff > kvm->duration) {
+                char decode[32];
+
+                kvm->events_ops->decode_key(kvm, &event->key, decode);
+                if (strcmp(decode, "HLT")) {
+                        pr_info("%" PRIu64 " VM %d, vcpu %d: %s event took %" PRIu64 "usec\n",
+                                 sample->time, sample->pid, vcpu_record->vcpu_id,
+                                 decode, time_diff/1000);
+                }
+        }
 
-        time_diff = timestamp - time_begin;
         return update_kvm_event(event, vcpu, time_diff);
 }
 
@@ -518,7 +575,7 @@ static bool handle_kvm_event(struct perf_kvm_stat *kvm,
                 return handle_begin_event(kvm, vcpu_record, &key, sample->time);
 
         if (kvm->events_ops->is_end_event(evsel, sample, &key))
-                return handle_end_event(kvm, vcpu_record, &key, sample->time);
+                return handle_end_event(kvm, vcpu_record, &key, sample);
 
         return true;
 }
@@ -547,6 +604,8 @@ static int compare_kvm_event_ ## func(struct kvm_event *one,		\
 GET_EVENT_KEY(time, time);
 COMPARE_EVENT_KEY(count, stats.n);
 COMPARE_EVENT_KEY(mean, stats.mean);
+GET_EVENT_KEY(max, stats.max);
+GET_EVENT_KEY(min, stats.min);
 
 #define DEF_SORT_NAME_KEY(name, compare_key)                            \
         { #name, compare_kvm_event_ ## compare_key }
@@ -636,43 +695,81 @@ static struct kvm_event *pop_from_result(struct rb_root *result)
         return container_of(node, struct kvm_event, rb);
 }
 
-static void print_vcpu_info(int vcpu)
+static void print_vcpu_info(struct perf_kvm_stat *kvm)
 {
+        int vcpu = kvm->trace_vcpu;
+
         pr_info("Analyze events for ");
 
+        if (kvm->live) {
+                if (kvm->opts.target.system_wide)
+                        pr_info("all VMs, ");
+                else if (kvm->opts.target.pid)
+                        pr_info("pid(s) %s, ", kvm->opts.target.pid);
+                else
+                        pr_info("dazed and confused on what is monitored, ");
+        }
+
         if (vcpu == -1)
                 pr_info("all VCPUs:\n\n");
         else
                 pr_info("VCPU %d:\n\n", vcpu);
 }
 
+static void show_timeofday(void)
+{
+        char date[64];
+        struct timeval tv;
+        struct tm ltime;
+
+        gettimeofday(&tv, NULL);
+        if (localtime_r(&tv.tv_sec, &ltime)) {
+                strftime(date, sizeof(date), "%H:%M:%S", &ltime);
+                pr_info("%s.%06ld", date, tv.tv_usec);
+        } else
+                pr_info("00:00:00.000000");
+
+        return;
+}
+
 static void print_result(struct perf_kvm_stat *kvm)
 {
         char decode[20];
         struct kvm_event *event;
         int vcpu = kvm->trace_vcpu;
 
+        if (kvm->live) {
+                puts(CONSOLE_CLEAR);
+                show_timeofday();
+        }
+
         pr_info("\n\n");
-        print_vcpu_info(vcpu);
+        print_vcpu_info(kvm);
         pr_info("%20s ", kvm->events_ops->name);
         pr_info("%10s ", "Samples");
         pr_info("%9s ", "Samples%");
 
         pr_info("%9s ", "Time%");
+        pr_info("%10s ", "Min Time");
+        pr_info("%10s ", "Max Time");
         pr_info("%16s ", "Avg time");
         pr_info("\n\n");
 
         while ((event = pop_from_result(&kvm->result))) {
-                u64 ecount, etime;
+                u64 ecount, etime, max, min;
 
                 ecount = get_event_count(event, vcpu);
                 etime = get_event_time(event, vcpu);
+                max = get_event_max(event, vcpu);
+                min = get_event_min(event, vcpu);
 
                 kvm->events_ops->decode_key(kvm, &event->key, decode);
                 pr_info("%20s ", decode);
                 pr_info("%10llu ", (unsigned long long)ecount);
                 pr_info("%8.2f%% ", (double)ecount / kvm->total_count * 100);
                 pr_info("%8.2f%% ", (double)etime / kvm->total_time * 100);
+                pr_info("%8" PRIu64 "us ", min / 1000);
+                pr_info("%8" PRIu64 "us ", max / 1000);
                 pr_info("%9.2fus ( +-%7.2f%% )", (double)etime / ecount/1e3,
                         kvm_event_rel_stddev(vcpu, event));
                 pr_info("\n");
@@ -680,6 +777,29 @@ static void print_result(struct perf_kvm_stat *kvm)
 
         pr_info("\nTotal Samples:%" PRIu64 ", Total events handled time:%.2fus.\n\n",
                 kvm->total_count, kvm->total_time / 1e3);
+
+        if (kvm->lost_events)
+                pr_info("\nLost events: %" PRIu64 "\n\n", kvm->lost_events);
+}
+
+static int process_lost_event(struct perf_tool *tool,
+                              union perf_event *event __maybe_unused,
+                              struct perf_sample *sample __maybe_unused,
+                              struct machine *machine __maybe_unused)
+{
+        struct perf_kvm_stat *kvm = container_of(tool, struct perf_kvm_stat, tool);
+
+        kvm->lost_events++;
+        return 0;
+}
+
+static bool skip_sample(struct perf_kvm_stat *kvm,
+                        struct perf_sample *sample)
+{
+        if (kvm->pid_list && intlist__find(kvm->pid_list, sample->pid) == NULL)
+                return true;
+
+        return false;
 }
 
 static int process_sample_event(struct perf_tool *tool,
@@ -688,10 +808,14 @@ static int process_sample_event(struct perf_tool *tool,
                                 struct perf_evsel *evsel,
                                 struct machine *machine)
 {
-        struct thread *thread = machine__findnew_thread(machine, sample->tid);
+        struct thread *thread;
         struct perf_kvm_stat *kvm = container_of(tool, struct perf_kvm_stat,
                                                  tool);
 
+        if (skip_sample(kvm, sample))
+                return 0;
+
+        thread = machine__findnew_thread(machine, sample->pid, sample->tid);
         if (thread == NULL) {
                 pr_debug("problem processing %d event, skipping it.\n",
                         event->header.type);
@@ -704,10 +828,20 @@ static int process_sample_event(struct perf_tool *tool,
         return 0;
 }
 
-static int get_cpu_isa(struct perf_session *session)
+static int cpu_isa_config(struct perf_kvm_stat *kvm)
 {
-        char *cpuid = session->header.env.cpuid;
-        int isa;
+        char buf[64], *cpuid;
+        int err, isa;
+
+        if (kvm->live) {
+                err = get_cpuid(buf, sizeof(buf));
+                if (err != 0) {
+                        pr_err("Failed to look up CPU type (Intel or AMD)\n");
+                        return err;
+                }
+                cpuid = buf;
+        } else
+                cpuid = kvm->session->header.env.cpuid;
 
         if (strstr(cpuid, "Intel"))
                 isa = 1;
@@ -715,10 +849,361 @@ static int get_cpu_isa(struct perf_session *session)
                 isa = 0;
         else {
                 pr_err("CPU %s is not supported.\n", cpuid);
-                isa = -ENOTSUP;
+                return -ENOTSUP;
+        }
+
+        if (isa == 1) {
+                kvm->exit_reasons = vmx_exit_reasons;
+                kvm->exit_reasons_size = ARRAY_SIZE(vmx_exit_reasons);
+                kvm->exit_reasons_isa = "VMX";
+        }
+
+        return 0;
+}
+
+static bool verify_vcpu(int vcpu)
+{
+        if (vcpu != -1 && vcpu < 0) {
+                pr_err("Invalid vcpu:%d.\n", vcpu);
+                return false;
+        }
+
+        return true;
+}
+
+/* keeping the max events to a modest level to keep
+ * the processing of samples per mmap smooth.
+ */
+#define PERF_KVM__MAX_EVENTS_PER_MMAP  25
+
+static s64 perf_kvm__mmap_read_idx(struct perf_kvm_stat *kvm, int idx,
+                                   u64 *mmap_time)
+{
+        union perf_event *event;
+        struct perf_sample sample;
+        s64 n = 0;
+        int err;
+
+        *mmap_time = ULLONG_MAX;
+        while ((event = perf_evlist__mmap_read(kvm->evlist, idx)) != NULL) {
+                err = perf_evlist__parse_sample(kvm->evlist, event, &sample);
+                if (err) {
+                        pr_err("Failed to parse sample\n");
+                        return -1;
+                }
+
+                err = perf_session_queue_event(kvm->session, event, &sample, 0);
+                if (err) {
+                        pr_err("Failed to enqueue sample: %d\n", err);
+                        return -1;
+                }
+
+                /* save time stamp of our first sample for this mmap */
+                if (n == 0)
+                        *mmap_time = sample.time;
+
+                /* limit events per mmap handled all at once */
+                n++;
+                if (n == PERF_KVM__MAX_EVENTS_PER_MMAP)
+                        break;
+        }
+
+        return n;
+}
+
+static int perf_kvm__mmap_read(struct perf_kvm_stat *kvm)
+{
+        int i, err, throttled = 0;
+        s64 n, ntotal = 0;
+        u64 flush_time = ULLONG_MAX, mmap_time;
+
+        for (i = 0; i < kvm->evlist->nr_mmaps; i++) {
+                n = perf_kvm__mmap_read_idx(kvm, i, &mmap_time);
+                if (n < 0)
+                        return -1;
+
+                /* flush time is going to be the minimum of all the individual
+                 * mmap times. Essentially, we flush all the samples queued up
+                 * from the last pass under our minimal start time -- that leaves
+                 * a very small race for samples to come in with a lower timestamp.
+                 * The ioctl to return the perf_clock timestamp should close the
+                 * race entirely.
+                 */
+                if (mmap_time < flush_time)
+                        flush_time = mmap_time;
+
+                ntotal += n;
+                if (n == PERF_KVM__MAX_EVENTS_PER_MMAP)
+                        throttled = 1;
+        }
+
+        /* flush queue after each round in which we processed events */
+        if (ntotal) {
+                kvm->session->ordered_samples.next_flush = flush_time;
+                err = kvm->tool.finished_round(&kvm->tool, NULL, kvm->session);
+                if (err) {
+                        if (kvm->lost_events)
+                                pr_info("\nLost events: %" PRIu64 "\n\n",
+                                        kvm->lost_events);
+                        return err;
+                }
+        }
+
+        return throttled;
+}
+
+static volatile int done;
+
+static void sig_handler(int sig __maybe_unused)
+{
+        done = 1;
+}
+
+static int perf_kvm__timerfd_create(struct perf_kvm_stat *kvm)
+{
+        struct itimerspec new_value;
+        int rc = -1;
+
+        kvm->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
+        if (kvm->timerfd < 0) {
+                pr_err("timerfd_create failed\n");
+                goto out;
+        }
+
+        new_value.it_value.tv_sec = kvm->display_time;
+        new_value.it_value.tv_nsec = 0;
+        new_value.it_interval.tv_sec = kvm->display_time;
+        new_value.it_interval.tv_nsec = 0;
+
+        if (timerfd_settime(kvm->timerfd, 0, &new_value, NULL) != 0) {
+                pr_err("timerfd_settime failed: %d\n", errno);
+                close(kvm->timerfd);
+                goto out;
+        }
+
+        rc = 0;
+out:
+        return rc;
+}
+
+static int perf_kvm__handle_timerfd(struct perf_kvm_stat *kvm)
+{
+        uint64_t c;
+        int rc;
+
+        rc = read(kvm->timerfd, &c, sizeof(uint64_t));
+        if (rc < 0) {
+                if (errno == EAGAIN)
+                        return 0;
+
+                pr_err("Failed to read timer fd: %d\n", errno);
+                return -1;
+        }
+
+        if (rc != sizeof(uint64_t)) {
+                pr_err("Error reading timer fd - invalid size returned\n");
+                return -1;
+        }
+
+        if (c != 1)
+                pr_debug("Missed timer beats: %" PRIu64 "\n", c-1);
+
+        /* update display */
+        sort_result(kvm);
+        print_result(kvm);
+
+        /* reset counts */
+        clear_events_cache_stats(kvm->kvm_events_cache);
+        kvm->total_count = 0;
+        kvm->total_time = 0;
+        kvm->lost_events = 0;
+
+        return 0;
+}
+
+static int fd_set_nonblock(int fd)
+{
+        long arg = 0;
+
+        arg = fcntl(fd, F_GETFL);
+        if (arg < 0) {
+                pr_err("Failed to get current flags for fd %d\n", fd);
+                return -1;
+        }
+
+        if (fcntl(fd, F_SETFL, arg | O_NONBLOCK) < 0) {
+                pr_err("Failed to set non-block option on fd %d\n", fd);
+                return -1;
+        }
+
+        return 0;
+}
+
+static
+int perf_kvm__handle_stdin(struct termios *tc_now, struct termios *tc_save)
+{
+        int c;
+
+        tcsetattr(0, TCSANOW, tc_now);
+        c = getc(stdin);
+        tcsetattr(0, TCSAFLUSH, tc_save);
+
+        if (c == 'q')
+                return 1;
+
+        return 0;
+}
+
+static int kvm_events_live_report(struct perf_kvm_stat *kvm)
+{
+        struct pollfd *pollfds = NULL;
+        int nr_fds, nr_stdin, ret, err = -EINVAL;
+        struct termios tc, save;
+
+        /* live flag must be set first */
+        kvm->live = true;
+
+        ret = cpu_isa_config(kvm);
+        if (ret < 0)
+                return ret;
+
+        if (!verify_vcpu(kvm->trace_vcpu) ||
+            !select_key(kvm) ||
+            !register_kvm_events_ops(kvm)) {
+                goto out;
+        }
+
+        init_kvm_event_record(kvm);
+
+        tcgetattr(0, &save);
+        tc = save;
+        tc.c_lflag &= ~(ICANON | ECHO);
+        tc.c_cc[VMIN] = 0;
+        tc.c_cc[VTIME] = 0;
+
+        signal(SIGINT, sig_handler);
+        signal(SIGTERM, sig_handler);
+
+        /* copy pollfds -- need to add timerfd and stdin */
+        nr_fds = kvm->evlist->nr_fds;
+        pollfds = zalloc(sizeof(struct pollfd) * (nr_fds + 2));
+        if (!pollfds) {
+                err = -ENOMEM;
+                goto out;
         }
+        memcpy(pollfds, kvm->evlist->pollfd,
+                sizeof(struct pollfd) * kvm->evlist->nr_fds);
+
+        /* add timer fd */
+        if (perf_kvm__timerfd_create(kvm) < 0) {
+                err = -1;
+                goto out;
+        }
+
+        pollfds[nr_fds].fd = kvm->timerfd;
+        pollfds[nr_fds].events = POLLIN;
+        nr_fds++;
+
+        pollfds[nr_fds].fd = fileno(stdin);
+        pollfds[nr_fds].events = POLLIN;
+        nr_stdin = nr_fds;
+        nr_fds++;
+        if (fd_set_nonblock(fileno(stdin)) != 0)
+                goto out;
+
+        /* everything is good - enable the events and process */
+        perf_evlist__enable(kvm->evlist);
+
+        while (!done) {
+                int rc;
+
+                rc = perf_kvm__mmap_read(kvm);
+                if (rc < 0)
+                        break;
+
+                err = perf_kvm__handle_timerfd(kvm);
+                if (err)
+                        goto out;
+
+                if (pollfds[nr_stdin].revents & POLLIN)
+                        done = perf_kvm__handle_stdin(&tc, &save);
+
+                if (!rc && !done)
+                        err = poll(pollfds, nr_fds, 100);
+        }
+
+        perf_evlist__disable(kvm->evlist);
+
+        if (err == 0) {
+                sort_result(kvm);
+                print_result(kvm);
+        }
+
+out:
+        if (kvm->timerfd >= 0)
+                close(kvm->timerfd);
+
+        if (pollfds)
+                free(pollfds);
 
-        return isa;
+        return err;
+}
+
+static int kvm_live_open_events(struct perf_kvm_stat *kvm)
+{
+        int err, rc = -1;
+        struct perf_evsel *pos;
+        struct perf_evlist *evlist = kvm->evlist;
+
+        perf_evlist__config(evlist, &kvm->opts);
+
+        /*
+         * Note: exclude_{guest,host} do not apply here.
+         *       This command processes KVM tracepoints from host only
+         */
+        list_for_each_entry(pos, &evlist->entries, node) {
+                struct perf_event_attr *attr = &pos->attr;
+
+                /* make sure these *are* set */
+                perf_evsel__set_sample_bit(pos, TID);
+                perf_evsel__set_sample_bit(pos, TIME);
+                perf_evsel__set_sample_bit(pos, CPU);
+                perf_evsel__set_sample_bit(pos, RAW);
+                /* make sure these are *not*; want as small a sample as possible */
+                perf_evsel__reset_sample_bit(pos, PERIOD);
+                perf_evsel__reset_sample_bit(pos, IP);
+                perf_evsel__reset_sample_bit(pos, CALLCHAIN);
+                perf_evsel__reset_sample_bit(pos, ADDR);
+                perf_evsel__reset_sample_bit(pos, READ);
+                attr->mmap = 0;
+                attr->comm = 0;
+                attr->task = 0;
+
+                attr->sample_period = 1;
+
+                attr->watermark = 0;
+                attr->wakeup_events = 1000;
+
+                /* will enable all once we are ready */
+                attr->disabled = 1;
+        }
+
+        err = perf_evlist__open(evlist);
+        if (err < 0) {
+                printf("Couldn't create the events: %s\n", strerror(errno));
+                goto out;
+        }
+
+        if (perf_evlist__mmap(evlist, kvm->opts.mmap_pages, false) < 0) {
+                ui__error("Failed to mmap the events: %s\n", strerror(errno));
+                perf_evlist__close(evlist);
+                goto out;
+        }
+
+        rc = 0;
+
+out:
+        return rc;
 }
 
 static int read_events(struct perf_kvm_stat *kvm)
@@ -746,28 +1231,24 @@ static int read_events(struct perf_kvm_stat *kvm)
          * Do not use 'isa' recorded in kvm_exit tracepoint since it is not
          * traced in the old kernel.
          */
-        ret = get_cpu_isa(kvm->session);
-
+        ret = cpu_isa_config(kvm);
         if (ret < 0)
                 return ret;
 
-        if (ret == 1) {
-                kvm->exit_reasons = vmx_exit_reasons;
-                kvm->exit_reasons_size = ARRAY_SIZE(vmx_exit_reasons);
-                kvm->exit_reasons_isa = "VMX";
-        }
-
         return perf_session__process_events(kvm->session, &kvm->tool);
 }
 
-static bool verify_vcpu(int vcpu)
+static int parse_target_str(struct perf_kvm_stat *kvm)
 {
-        if (vcpu != -1 && vcpu < 0) {
-                pr_err("Invalid vcpu:%d.\n", vcpu);
-                return false;
+        if (kvm->pid_str) {
+                kvm->pid_list = intlist__new(kvm->pid_str);
+                if (kvm->pid_list == NULL) {
+                        pr_err("Error parsing process id string\n");
+                        return -EINVAL;
+                }
         }
 
-        return true;
+        return 0;
 }
 
 static int kvm_events_report_vcpu(struct perf_kvm_stat *kvm)
@@ -775,6 +1256,9 @@ static int kvm_events_report_vcpu(struct perf_kvm_stat *kvm)
         int ret = -EINVAL;
         int vcpu = kvm->trace_vcpu;
 
+        if (parse_target_str(kvm) != 0)
+                goto exit;
+
         if (!verify_vcpu(vcpu))
                 goto exit;
 
@@ -798,16 +1282,11 @@ exit:
         return ret;
 }
 
-static const char * const record_args[] = {
-        "record",
-        "-R",
-        "-f",
-        "-m", "1024",
-        "-c", "1",
-        "-e", "kvm:kvm_entry",
-        "-e", "kvm:kvm_exit",
-        "-e", "kvm:kvm_mmio",
-        "-e", "kvm:kvm_pio",
+static const char * const kvm_events_tp[] = {
+        "kvm:kvm_entry",
+        "kvm:kvm_exit",
+        "kvm:kvm_mmio",
+        "kvm:kvm_pio",
 };
 
 #define STRDUP_FAIL_EXIT(s)             \
@@ -823,8 +1302,15 @@ kvm_events_record(struct perf_kvm_stat *kvm, int argc, const char **argv)
 {
         unsigned int rec_argc, i, j;
         const char **rec_argv;
+        const char * const record_args[] = {
+                "record",
+                "-R",
+                "-m", "1024",
+                "-c", "1",
+        };
 
-        rec_argc = ARRAY_SIZE(record_args) + argc + 2;
+        rec_argc = ARRAY_SIZE(record_args) + argc + 2 +
+                   2 * ARRAY_SIZE(kvm_events_tp);
         rec_argv = calloc(rec_argc + 1, sizeof(char *));
 
         if (rec_argv == NULL)
@@ -833,6 +1319,11 @@ kvm_events_record(struct perf_kvm_stat *kvm, int argc, const char **argv)
         for (i = 0; i < ARRAY_SIZE(record_args); i++)
                 rec_argv[i] = STRDUP_FAIL_EXIT(record_args[i]);
 
+        for (j = 0; j < ARRAY_SIZE(kvm_events_tp); j++) {
+                rec_argv[i++] = "-e";
+                rec_argv[i++] = STRDUP_FAIL_EXIT(kvm_events_tp[j]);
+        }
+
         rec_argv[i++] = STRDUP_FAIL_EXIT("-o");
         rec_argv[i++] = STRDUP_FAIL_EXIT(kvm->file_name);
 
@@ -853,6 +1344,8 @@ kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv)
                 OPT_STRING('k', "key", &kvm->sort_key, "sort-key",
                             "key for sorting: sample(sort by samples number)"
                             " time (sort by avg time)"),
+                OPT_STRING('p', "pid", &kvm->pid_str, "pid",
+                           "analyze events only for given process id(s)"),
                 OPT_END()
         };
 
@@ -875,6 +1368,190 @@ kvm_events_report(struct perf_kvm_stat *kvm, int argc, const char **argv)
         return kvm_events_report_vcpu(kvm);
 }
 
+static struct perf_evlist *kvm_live_event_list(void)
+{
+        struct perf_evlist *evlist;
+        char *tp, *name, *sys;
+        unsigned int j;
+        int err = -1;
+
+        evlist = perf_evlist__new();
+        if (evlist == NULL)
+                return NULL;
+
+        for (j = 0; j < ARRAY_SIZE(kvm_events_tp); j++) {
+
+                tp = strdup(kvm_events_tp[j]);
+                if (tp == NULL)
+                        goto out;
+
+                /* split tracepoint into subsystem and name */
+                sys = tp;
+                name = strchr(tp, ':');
+                if (name == NULL) {
+                        pr_err("Error parsing %s tracepoint: subsystem delimiter not found\n",
+                                kvm_events_tp[j]);
+                        free(tp);
+                        goto out;
+                }
+                *name = '\0';
+                name++;
+
+                if (perf_evlist__add_newtp(evlist, sys, name, NULL)) {
+                        pr_err("Failed to add %s tracepoint to the list\n", kvm_events_tp[j]);
+                        free(tp);
+                        goto out;
+                }
+
+                free(tp);
+        }
+
+        err = 0;
+
+out:
+        if (err) {
+                perf_evlist__delete(evlist);
+                evlist = NULL;
+        }
+
+        return evlist;
+}
+
+static int kvm_events_live(struct perf_kvm_stat *kvm,
+                           int argc, const char **argv)
+{
+        char errbuf[BUFSIZ];
+        int err;
+
+        const struct option live_options[] = {
+                OPT_STRING('p', "pid", &kvm->opts.target.pid, "pid",
+                        "record events on existing process id"),
+                OPT_UINTEGER('m', "mmap-pages", &kvm->opts.mmap_pages,
+                        "number of mmap data pages"),
+                OPT_INCR('v', "verbose", &verbose,
+                        "be more verbose (show counter open errors, etc)"),
+                OPT_BOOLEAN('a', "all-cpus", &kvm->opts.target.system_wide,
+                        "system-wide collection from all CPUs"),
+                OPT_UINTEGER('d', "display", &kvm->display_time,
+                        "time in seconds between display updates"),
+                OPT_STRING(0, "event", &kvm->report_event, "report event",
+                        "event for reporting: vmexit, mmio, ioport"),
+                OPT_INTEGER(0, "vcpu", &kvm->trace_vcpu,
+                        "vcpu id to report"),
+                OPT_STRING('k', "key", &kvm->sort_key, "sort-key",
+                        "key for sorting: sample(sort by samples number)"
+                        " time (sort by avg time)"),
+                OPT_U64(0, "duration", &kvm->duration,
+                    "show events other than HALT that take longer than duration usecs"),
+                OPT_END()
+        };
+        const char * const live_usage[] = {
+                "perf kvm stat live [<options>]",
+                NULL
+        };
+
+
+        /* event handling */
+        kvm->tool.sample = process_sample_event;
+        kvm->tool.comm   = perf_event__process_comm;
+        kvm->tool.exit   = perf_event__process_exit;
+        kvm->tool.fork   = perf_event__process_fork;
+        kvm->tool.lost   = process_lost_event;
+        kvm->tool.ordered_samples = true;
+        perf_tool__fill_defaults(&kvm->tool);
+
+        /* set defaults */
+        kvm->display_time = 1;
+        kvm->opts.user_interval = 1;
+        kvm->opts.mmap_pages = 512;
+        kvm->opts.target.uses_mmap = false;
+        kvm->opts.target.uid_str = NULL;
+        kvm->opts.target.uid = UINT_MAX;
+
+        symbol__init();
+        disable_buildid_cache();
+
+        use_browser = 0;
+        setup_browser(false);
+
+        if (argc) {
+                argc = parse_options(argc, argv, live_options,
+                                     live_usage, 0);
+                if (argc)
+                        usage_with_options(live_usage, live_options);
+        }
+
+        kvm->duration *= NSEC_PER_USEC;   /* convert usec to nsec */
+
+        /*
+         * target related setups
+         */
+        err = perf_target__validate(&kvm->opts.target);
+        if (err) {
+                perf_target__strerror(&kvm->opts.target, err, errbuf, BUFSIZ);
+                ui__warning("%s", errbuf);
+        }
+
+        if (perf_target__none(&kvm->opts.target))
+                kvm->opts.target.system_wide = true;
+
+
+        /*
+         * generate the event list
+         */
+        kvm->evlist = kvm_live_event_list();
+        if (kvm->evlist == NULL) {
+                err = -1;
+                goto out;
+        }
+
+        symbol_conf.nr_events = kvm->evlist->nr_entries;
+
+        if (perf_evlist__create_maps(kvm->evlist, &kvm->opts.target) < 0)
+                usage_with_options(live_usage, live_options);
+
+        /*
+         * perf session
+         */
+        kvm->session = perf_session__new(NULL, O_WRONLY, false, false, &kvm->tool);
+        if (kvm->session == NULL) {
+                err = -ENOMEM;
+                goto out;
+        }
+        kvm->session->evlist = kvm->evlist;
+        perf_session__set_id_hdr_size(kvm->session);
+
+
+        if (perf_target__has_task(&kvm->opts.target))
+                perf_event__synthesize_thread_map(&kvm->tool,
+                                                  kvm->evlist->threads,
+                                                  perf_event__process,
+                                                  &kvm->session->machines.host);
+        else
+                perf_event__synthesize_threads(&kvm->tool, perf_event__process,
+                                               &kvm->session->machines.host);
+
+
+        err = kvm_live_open_events(kvm);
+        if (err)
+                goto out;
+
+        err = kvm_events_live_report(kvm);
+
+out:
+        exit_browser(0);
+
+        if (kvm->session)
+                perf_session__delete(kvm->session);
+        kvm->session = NULL;
+        if (kvm->evlist) {
+                perf_evlist__delete_maps(kvm->evlist);
+                perf_evlist__delete(kvm->evlist);
+        }
+
+        return err;
+}
+
 static void print_kvm_stat_usage(void)
 {
         printf("Usage: perf kvm stat <command>\n\n");
@@ -882,6 +1559,7 @@ static void print_kvm_stat_usage(void)
         printf("# Available commands:\n");
         printf("\trecord: record kvm events\n");
         printf("\treport: report statistical data of kvm events\n");
+        printf("\tlive:   live reporting of statistical data of kvm events\n");
 
         printf("\nOtherwise, it is the alias of 'perf stat':\n");
 }
@@ -911,6 +1589,9 @@ static int kvm_cmd_stat(const char *file_name, int argc, const char **argv)
         if (!strncmp(argv[1], "rep", 3))
                 return kvm_events_report(&kvm, argc - 1 , argv + 1);
 
+        if (!strncmp(argv[1], "live", 4))
+                return kvm_events_live(&kvm, argc - 1 , argv + 1);
+
 perf_stat:
         return cmd_stat(argc, argv, NULL);
 }
diff --git a/tools/perf/builtin-list.c b/tools/perf/builtin-list.c
index 1948eceb517a..e79f423cc302 100644
--- a/tools/perf/builtin-list.c
+++ b/tools/perf/builtin-list.c
@@ -13,6 +13,7 @@
 
 #include "util/parse-events.h"
 #include "util/cache.h"
+#include "util/pmu.h"
 
 int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
 {
@@ -37,6 +38,8 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                         else if (strcmp(argv[i], "cache") == 0 ||
                                  strcmp(argv[i], "hwcache") == 0)
                                 print_hwcache_events(NULL, false);
+                        else if (strcmp(argv[i], "pmu") == 0)
+                                print_pmu_events(NULL, false);
                         else if (strcmp(argv[i], "--raw-dump") == 0)
                                 print_events(NULL, true);
                         else {
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index 425830069749..ee33ba2f05dd 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -805,7 +805,8 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                                 struct perf_evsel *evsel,
                                 struct machine *machine)
 {
-        struct thread *thread = machine__findnew_thread(machine, sample->tid);
+        struct thread *thread = machine__findnew_thread(machine, sample->pid,
+                                                        sample->tid);
 
         if (thread == NULL) {
                 pr_debug("problem processing %d event, skipping it.\n",
@@ -878,7 +879,7 @@ static int __cmd_report(void)
 static int __cmd_record(int argc, const char **argv)
 {
         const char *record_args[] = {
-                "record", "-R", "-f", "-m", "1024", "-c", "1",
+                "record", "-R", "-m", "1024", "-c", "1",
         };
         unsigned int rec_argc, i, j;
         const char **rec_argv;
diff --git a/tools/perf/builtin-mem.c b/tools/perf/builtin-mem.c
index a8ff6d264e50..253133a6251d 100644
--- a/tools/perf/builtin-mem.c
+++ b/tools/perf/builtin-mem.c
@@ -14,7 +14,6 @@ static const char	*mem_operation		= MEM_OPERATION_LOAD;
 struct perf_mem {
         struct perf_tool        tool;
         char const              *input_name;
-        symbol_filter_t         annotate_init;
         bool                    hide_unresolved;
         bool                    dump_raw;
         const char              *cpu_list;
@@ -69,8 +68,7 @@ dump_raw_samples(struct perf_tool *tool,
         struct addr_location al;
         const char *fmt;
 
-        if (perf_event__preprocess_sample(event, machine, &al, sample,
-                                mem->annotate_init) < 0) {
+        if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
                 fprintf(stderr, "problem processing %d event, skipping it.\n",
                                 event->header.type);
                 return -1;
@@ -96,7 +94,7 @@ dump_raw_samples(struct perf_tool *tool,
                 symbol_conf.field_sep,
                 sample->tid,
                 symbol_conf.field_sep,
-                event->ip.ip,
+                sample->ip,
                 symbol_conf.field_sep,
                 sample->addr,
                 symbol_conf.field_sep,
@@ -192,6 +190,7 @@ int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused)
                 .tool = {
                         .sample         = process_sample_event,
                         .mmap           = perf_event__process_mmap,
+                        .mmap2          = perf_event__process_mmap2,
                         .comm           = perf_event__process_comm,
                         .lost           = perf_event__process_lost,
                         .fork           = perf_event__process_fork,
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index cdf58ecc04b1..a41ac41546c9 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -61,11 +61,6 @@ static void __handle_on_exit_funcs(void)
 }
 #endif
 
-enum write_mode_t {
-        WRITE_FORCE,
-        WRITE_APPEND
-};
-
 struct perf_record {
         struct perf_tool        tool;
         struct perf_record_opts opts;
@@ -77,12 +72,8 @@ struct perf_record {
         int                     output;
         unsigned int            page_size;
         int                     realtime_prio;
-        enum write_mode_t       write_mode;
         bool                    no_buildid;
         bool                    no_buildid_cache;
-        bool                    force;
-        bool                    file_new;
-        bool                    append_file;
         long                    samples;
         off_t                   post_processing_offset;
 };
@@ -198,26 +189,6 @@ static void perf_record__sig_exit(int exit_status __maybe_unused, void *arg)
                 return;
 
         signal(signr, SIG_DFL);
-        kill(getpid(), signr);
-}
-
-static bool perf_evlist__equal(struct perf_evlist *evlist,
-                               struct perf_evlist *other)
-{
-        struct perf_evsel *pos, *pair;
-
-        if (evlist->nr_entries != other->nr_entries)
-                return false;
-
-        pair = perf_evlist__first(other);
-
-        list_for_each_entry(pos, &evlist->entries, node) {
-                if (memcmp(&pos->attr, &pair->attr, sizeof(pos->attr) != 0))
-                        return false;
-                pair = perf_evsel__next(pair);
-        }
-
-        return true;
 }
 
 static int perf_record__open(struct perf_record *rec)
@@ -274,16 +245,7 @@ try_again:
                 goto out;
         }
 
-        if (rec->file_new)
-                session->evlist = evlist;
-        else {
-                if (!perf_evlist__equal(session->evlist, evlist)) {
-                        fprintf(stderr, "incompatible append\n");
-                        rc = -1;
-                        goto out;
-                }
-        }
-
+        session->evlist = evlist;
         perf_session__set_id_hdr_size(session);
 out:
         return rc;
@@ -404,6 +366,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
         signal(SIGCHLD, sig_handler);
         signal(SIGINT, sig_handler);
         signal(SIGUSR1, sig_handler);
+        signal(SIGTERM, sig_handler);
 
         if (!output_name) {
                 if (!fstat(STDOUT_FILENO, &st) && S_ISFIFO(st.st_mode))
@@ -415,23 +378,15 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                 if (!strcmp(output_name, "-"))
                         opts->pipe_output = true;
                 else if (!stat(output_name, &st) && st.st_size) {
-                        if (rec->write_mode == WRITE_FORCE) {
-                                char oldname[PATH_MAX];
-                                snprintf(oldname, sizeof(oldname), "%s.old",
-                                         output_name);
-                                unlink(oldname);
-                                rename(output_name, oldname);
-                        }
-                } else if (rec->write_mode == WRITE_APPEND) {
-                        rec->write_mode = WRITE_FORCE;
+                        char oldname[PATH_MAX];
+                        snprintf(oldname, sizeof(oldname), "%s.old",
+                                 output_name);
+                        unlink(oldname);
+                        rename(output_name, oldname);
                 }
         }
 
-        flags = O_CREAT|O_RDWR;
-        if (rec->write_mode == WRITE_APPEND)
-                rec->file_new = 0;
-        else
-                flags |= O_TRUNC;
+        flags = O_CREAT|O_RDWR|O_TRUNC;
 
         if (opts->pipe_output)
                 output = STDOUT_FILENO;
@@ -445,7 +400,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
         rec->output = output;
 
         session = perf_session__new(output_name, O_WRONLY,
-                                    rec->write_mode == WRITE_FORCE, false, NULL);
+                                    true, false, NULL);
         if (session == NULL) {
                 pr_err("Not enough memory for reading perf file header\n");
                 return -1;
@@ -465,12 +420,6 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
         if (!rec->opts.branch_stack)
                 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
 
-        if (!rec->file_new) {
-                err = perf_session__read_header(session, output);
-                if (err < 0)
-                        goto out_delete_session;
-        }
-
         if (forks) {
                 err = perf_evlist__prepare_workload(evsel_list, &opts->target,
                                                     argv, opts->pipe_output,
@@ -498,7 +447,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                 err = perf_header__write_pipe(output);
                 if (err < 0)
                         goto out_delete_session;
-        } else if (rec->file_new) {
+        } else {
                 err = perf_session__write_header(session, evsel_list,
                                                  output, false);
                 if (err < 0)
@@ -525,13 +474,6 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                         goto out_delete_session;
                 }
 
-                err = perf_event__synthesize_event_types(tool, process_synthesized_event,
-                                                         machine);
-                if (err < 0) {
-                        pr_err("Couldn't synthesize event_types.\n");
-                        goto out_delete_session;
-                }
-
                 if (have_tracepoints(&evsel_list->entries)) {
                         /*
                          * FIXME err <= 0 here actually means that
@@ -869,8 +811,6 @@ static struct perf_record record = {
                         .uses_mmap   = true,
                 },
         },
-        .write_mode = WRITE_FORCE,
-        .file_new   = true,
 };
 
 #define CALLCHAIN_HELP "do call-graph (stack chain/backtrace) recording: "
@@ -906,12 +846,8 @@ const struct option record_options[] = {
                     "collect raw sample records from all opened counters"),
         OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
                             "system-wide collection from all CPUs"),
-        OPT_BOOLEAN('A', "append", &record.append_file,
-                            "append to the output file to do incremental profiling"),
         OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
                     "list of cpus to monitor"),
-        OPT_BOOLEAN('f', "force", &record.force,
-                        "overwrite existing data file (deprecated)"),
         OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
         OPT_STRING('o', "output", &record.output_name, "file",
                     "output file name"),
@@ -961,7 +897,6 @@ const struct option record_options[] = {
 int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
 {
         int err = -ENOMEM;
-        struct perf_evsel *pos;
         struct perf_evlist *evsel_list;
         struct perf_record *rec = &record;
         char errbuf[BUFSIZ];
@@ -977,16 +912,6 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
         if (!argc && perf_target__none(&rec->opts.target))
                 usage_with_options(record_usage, record_options);
 
-        if (rec->force && rec->append_file) {
-                ui__error("Can't overwrite and append at the same time."
-                          " You need to choose between -f and -A");
-                usage_with_options(record_usage, record_options);
-        } else if (rec->append_file) {
-                rec->write_mode = WRITE_APPEND;
-        } else {
-                rec->write_mode = WRITE_FORCE;
-        }
-
         if (nr_cgroups && !rec->opts.target.system_wide) {
                 ui__error("cgroup monitoring only available in"
                           " system-wide mode\n");
@@ -1035,11 +960,6 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
         if (perf_evlist__create_maps(evsel_list, &rec->opts.target) < 0)
                 usage_with_options(record_usage, record_options);
 
-        list_for_each_entry(pos, &evsel_list->entries, node) {
-                if (perf_header__push_event(pos->attr.config, perf_evsel__name(pos)))
-                        goto out_free_fd;
-        }
-
         if (rec->opts.user_interval != ULLONG_MAX)
                 rec->opts.default_interval = rec->opts.user_interval;
         if (rec->opts.user_freq != UINT_MAX)
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index bd0ca81eeaca..72eae7498c09 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -49,9 +49,9 @@ struct perf_report {
         bool                    mem_mode;
         struct perf_read_values show_threads_values;
         const char              *pretty_printing_style;
-        symbol_filter_t         annotate_init;
         const char              *cpu_list;
         const char              *symbol_filter_str;
+        float                   min_percent;
         DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 };
 
@@ -61,6 +61,11 @@ static int perf_report_config(const char *var, const char *value, void *cb)
                 symbol_conf.event_group = perf_config_bool(var, value);
                 return 0;
         }
+        if (!strcmp(var, "report.percent-limit")) {
+                struct perf_report *rep = cb;
+                rep->min_percent = strtof(value, NULL);
+                return 0;
+        }
 
         return perf_default_config(var, value, cb);
 }
@@ -83,7 +88,7 @@ static int perf_report__add_mem_hist_entry(struct perf_tool *tool,
         if ((sort__has_parent || symbol_conf.use_callchain) &&
             sample->callchain) {
                 err = machine__resolve_callchain(machine, evsel, al->thread,
-                                                 sample, &parent);
+                                                 sample, &parent, al);
                 if (err)
                         return err;
         }
@@ -174,7 +179,7 @@ static int perf_report__add_branch_hist_entry(struct perf_tool *tool,
         if ((sort__has_parent || symbol_conf.use_callchain)
             && sample->callchain) {
                 err = machine__resolve_callchain(machine, evsel, al->thread,
-                                                 sample, &parent);
+                                                 sample, &parent, al);
                 if (err)
                         return err;
         }
@@ -187,6 +192,9 @@ static int perf_report__add_branch_hist_entry(struct perf_tool *tool,
         for (i = 0; i < sample->branch_stack->nr; i++) {
                 if (rep->hide_unresolved && !(bi[i].from.sym && bi[i].to.sym))
                         continue;
+
+                err = -ENOMEM;
+
                 /*
                  * The report shows the percentage of total branches captured
                  * and not events sampled. Thus we use a pseudo period of 1.
@@ -195,7 +203,6 @@ static int perf_report__add_branch_hist_entry(struct perf_tool *tool,
                                 &bi[i], 1, 1);
                 if (he) {
                         struct annotation *notes;
-                        err = -ENOMEM;
                         bx = he->branch_info;
                         if (bx->from.sym && use_browser == 1 && sort__has_sym) {
                                 notes = symbol__annotation(bx->from.sym);
@@ -226,11 +233,12 @@ static int perf_report__add_branch_hist_entry(struct perf_tool *tool,
                         }
                         evsel->hists.stats.total_period += 1;
                         hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE);
-                        err = 0;
                 } else
-                        return -ENOMEM;
+                        goto out;
         }
+        err = 0;
 out:
+        free(bi);
         return err;
 }
 
@@ -245,7 +253,7 @@ static int perf_evsel__add_hist_entry(struct perf_evsel *evsel,
 
         if ((sort__has_parent || symbol_conf.use_callchain) && sample->callchain) {
                 err = machine__resolve_callchain(machine, evsel, al->thread,
-                                                 sample, &parent);
+                                                 sample, &parent, al);
                 if (err)
                         return err;
         }
@@ -294,9 +302,9 @@ static int process_sample_event(struct perf_tool *tool,
 {
         struct perf_report *rep = container_of(tool, struct perf_report, tool);
         struct addr_location al;
+        int ret;
 
-        if (perf_event__preprocess_sample(event, machine, &al, sample,
-                                          rep->annotate_init) < 0) {
+        if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
                 fprintf(stderr, "problem processing %d event, skipping it.\n",
                         event->header.type);
                 return -1;
@@ -308,28 +316,25 @@ static int process_sample_event(struct perf_tool *tool,
         if (rep->cpu_list && !test_bit(sample->cpu, rep->cpu_bitmap))
                 return 0;
 
-        if (sort__branch_mode == 1) {
-                if (perf_report__add_branch_hist_entry(tool, &al, sample,
-                                                       evsel, machine)) {
+        if (sort__mode == SORT_MODE__BRANCH) {
+                ret = perf_report__add_branch_hist_entry(tool, &al, sample,
+                                                         evsel, machine);
+                if (ret < 0)
                         pr_debug("problem adding lbr entry, skipping event\n");
-                        return -1;
-                }
         } else if (rep->mem_mode == 1) {
-                if (perf_report__add_mem_hist_entry(tool, &al, sample,
-                                                    evsel, machine, event)) {
+                ret = perf_report__add_mem_hist_entry(tool, &al, sample,
+                                                      evsel, machine, event);
+                if (ret < 0)
                         pr_debug("problem adding mem entry, skipping event\n");
-                        return -1;
-                }
         } else {
                 if (al.map != NULL)
                         al.map->dso->hit = 1;
 
-                if (perf_evsel__add_hist_entry(evsel, &al, sample, machine)) {
+                ret = perf_evsel__add_hist_entry(evsel, &al, sample, machine);
+                if (ret < 0)
                         pr_debug("problem incrementing symbol period, skipping event\n");
-                        return -1;
-                }
         }
-        return 0;
+        return ret;
 }
 
 static int process_read_event(struct perf_tool *tool,
@@ -360,7 +365,7 @@ static int process_read_event(struct perf_tool *tool,
 static int perf_report__setup_sample_type(struct perf_report *rep)
 {
         struct perf_session *self = rep->session;
-        u64 sample_type = perf_evlist__sample_type(self->evlist);
+        u64 sample_type = perf_evlist__combined_sample_type(self->evlist);
 
         if (!self->fd_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {
                 if (sort__has_parent) {
@@ -384,7 +389,7 @@ static int perf_report__setup_sample_type(struct perf_report *rep)
                         }
         }
 
-        if (sort__branch_mode == 1) {
+        if (sort__mode == SORT_MODE__BRANCH) {
                 if (!self->fd_pipe &&
                     !(sample_type & PERF_SAMPLE_BRANCH_STACK)) {
                         ui__error("Selected -b but no branch data. "
@@ -396,8 +401,6 @@ static int perf_report__setup_sample_type(struct perf_report *rep)
         return 0;
 }
 
-extern volatile int session_done;
-
 static void sig_handler(int sig __maybe_unused)
 {
         session_done = 1;
@@ -455,7 +458,7 @@ static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
                         continue;
 
                 hists__fprintf_nr_sample_events(rep, hists, evname, stdout);
-                hists__fprintf(hists, true, 0, 0, stdout);
+                hists__fprintf(hists, true, 0, 0, rep->min_percent, stdout);
                 fprintf(stdout, "\n\n");
         }
 
@@ -490,7 +493,7 @@ static int __cmd_report(struct perf_report *rep)
                 ret = perf_session__cpu_bitmap(session, rep->cpu_list,
                                                rep->cpu_bitmap);
                 if (ret)
-                        goto out_delete;
+                        return ret;
         }
 
         if (use_browser <= 0)
@@ -501,11 +504,11 @@ static int __cmd_report(struct perf_report *rep)
 
         ret = perf_report__setup_sample_type(rep);
         if (ret)
-                goto out_delete;
+                return ret;
 
         ret = perf_session__process_events(session, &rep->tool);
         if (ret)
-                goto out_delete;
+                return ret;
 
         kernel_map = session->machines.host.vmlinux_maps[MAP__FUNCTION];
         kernel_kmap = map__kmap(kernel_map);
@@ -540,7 +543,7 @@ static int __cmd_report(struct perf_report *rep)
 
         if (dump_trace) {
                 perf_session__fprintf_nr_events(session, stdout);
-                goto out_delete;
+                return 0;
         }
 
         nr_samples = 0;
@@ -563,9 +566,12 @@ static int __cmd_report(struct perf_report *rep)
                 }
         }
 
+        if (session_done())
+                return 0;
+
         if (nr_samples == 0) {
                 ui__error("The %s file has no samples!\n", session->filename);
-                goto out_delete;
+                return 0;
         }
 
         list_for_each_entry(pos, &session->evlist->entries, node)
@@ -574,8 +580,8 @@ static int __cmd_report(struct perf_report *rep)
         if (use_browser > 0) {
                 if (use_browser == 1) {
                         ret = perf_evlist__tui_browse_hists(session->evlist,
-                                                        help,
-                                                        NULL,
+                                                        help, NULL,
+                                                        rep->min_percent,
                                                         &session->header.env);
                         /*
                          * Usually "ret" is the last pressed key, and we only
@@ -586,24 +592,11 @@ static int __cmd_report(struct perf_report *rep)
 
                 } else if (use_browser == 2) {
                         perf_evlist__gtk_browse_hists(session->evlist, help,
-                                                      NULL);
+                                                      NULL, rep->min_percent);
                 }
         } else
                 perf_evlist__tty_browse_hists(session->evlist, rep, help);
 
-out_delete:
-        /*
-         * Speed up the exit process, for large files this can
-         * take quite a while.
-         *
-         * XXX Enable this when using valgrind or if we ever
-         * librarize this command.
-         *
-         * Also experiment with obstacks to see how much speed
-         * up we'll get here.
-         *
-         * perf_session__delete(session);
-         */
         return ret;
 }
 
@@ -673,12 +666,23 @@ parse_callchain_opt(const struct option *opt, const char *arg, int unset)
         }
 
         /* get the call chain order */
-        if (!strcmp(tok2, "caller"))
+        if (!strncmp(tok2, "caller", strlen("caller")))
                 callchain_param.order = ORDER_CALLER;
-        else if (!strcmp(tok2, "callee"))
+        else if (!strncmp(tok2, "callee", strlen("callee")))
                 callchain_param.order = ORDER_CALLEE;
         else
                 return -1;
+
+        /* Get the sort key */
+        tok2 = strtok(NULL, ",");
+        if (!tok2)
+                goto setup;
+        if (!strncmp(tok2, "function", strlen("function")))
+                callchain_param.key = CCKEY_FUNCTION;
+        else if (!strncmp(tok2, "address", strlen("address")))
+                callchain_param.key = CCKEY_ADDRESS;
+        else
+                return -1;
 setup:
         if (callchain_register_param(&callchain_param) < 0) {
                 fprintf(stderr, "Can't register callchain params\n");
@@ -687,11 +691,41 @@ setup:
         return 0;
 }
 
+int
+report_parse_ignore_callees_opt(const struct option *opt __maybe_unused,
+                                const char *arg, int unset __maybe_unused)
+{
+        if (arg) {
+                int err = regcomp(&ignore_callees_regex, arg, REG_EXTENDED);
+                if (err) {
+                        char buf[BUFSIZ];
+                        regerror(err, &ignore_callees_regex, buf, sizeof(buf));
+                        pr_err("Invalid --ignore-callees regex: %s\n%s", arg, buf);
+                        return -1;
+                }
+                have_ignore_callees = 1;
+        }
+
+        return 0;
+}
+
 static int
 parse_branch_mode(const struct option *opt __maybe_unused,
                   const char *str __maybe_unused, int unset)
 {
-        sort__branch_mode = !unset;
+        int *branch_mode = opt->value;
+
+        *branch_mode = !unset;
+        return 0;
+}
+
+static int
+parse_percent_limit(const struct option *opt, const char *str,
+                    int unset __maybe_unused)
+{
+        struct perf_report *rep = opt->value;
+
+        rep->min_percent = strtof(str, NULL);
         return 0;
 }
 
@@ -700,6 +734,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
         struct perf_session *session;
         struct stat st;
         bool has_br_stack = false;
+        int branch_mode = -1;
         int ret = -1;
         char callchain_default_opt[] = "fractal,0.5,callee";
         const char * const report_usage[] = {
@@ -710,13 +745,13 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                 .tool = {
                         .sample          = process_sample_event,
                         .mmap            = perf_event__process_mmap,
+                        .mmap2           = perf_event__process_mmap2,
                         .comm            = perf_event__process_comm,
                         .exit            = perf_event__process_exit,
                         .fork            = perf_event__process_fork,
                         .lost            = perf_event__process_lost,
                         .read            = process_read_event,
                         .attr            = perf_event__process_attr,
-                        .event_type      = perf_event__process_event_type,
                         .tracing_data    = perf_event__process_tracing_data,
                         .build_id        = perf_event__process_build_id,
                         .ordered_samples = true,
@@ -760,10 +795,13 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other,
                     "Only display entries with parent-match"),
         OPT_CALLBACK_DEFAULT('g', "call-graph", &report, "output_type,min_percent[,print_limit],call_order",
-                     "Display callchains using output_type (graph, flat, fractal, or none) , min percent threshold, optional print limit and callchain order. "
-                     "Default: fractal,0.5,callee", &parse_callchain_opt, callchain_default_opt),
+                     "Display callchains using output_type (graph, flat, fractal, or none) , min percent threshold, optional print limit, callchain order, key (function or address). "
+                     "Default: fractal,0.5,callee,function", &parse_callchain_opt, callchain_default_opt),
         OPT_BOOLEAN('G', "inverted", &report.inverted_callchain,
                     "alias for inverted call graph"),
+        OPT_CALLBACK(0, "ignore-callees", NULL, "regex",
+                   "ignore callees of these functions in call graphs",
+                   report_parse_ignore_callees_opt),
         OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
                    "only consider symbols in these dsos"),
         OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
@@ -796,17 +834,19 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Show a column with the sum of periods"),
         OPT_BOOLEAN(0, "group", &symbol_conf.event_group,
                     "Show event group information together"),
-        OPT_CALLBACK_NOOPT('b', "branch-stack", &sort__branch_mode, "",
+        OPT_CALLBACK_NOOPT('b', "branch-stack", &branch_mode, "",
                     "use branch records for histogram filling", parse_branch_mode),
         OPT_STRING(0, "objdump", &objdump_path, "path",
                    "objdump binary to use for disassembly and annotations"),
         OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
                     "Disable symbol demangling"),
         OPT_BOOLEAN(0, "mem-mode", &report.mem_mode, "mem access profile"),
+        OPT_CALLBACK(0, "percent-limit", &report, "percent",
+                     "Don't show entries under that percent", parse_percent_limit),
         OPT_END()
         };
 
-        perf_config(perf_report_config, NULL);
+        perf_config(perf_report_config, &report);
 
         argc = parse_options(argc, argv, options, report_usage, 0);
 
@@ -831,7 +871,6 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                 setup_browser(true);
         else {
                 use_browser = 0;
-                perf_hpp__column_enable(PERF_HPP__OVERHEAD);
                 perf_hpp__init();
         }
 
@@ -846,11 +885,11 @@ repeat:
         has_br_stack = perf_header__has_feat(&session->header,
                                              HEADER_BRANCH_STACK);
 
-        if (sort__branch_mode == -1 && has_br_stack)
-                sort__branch_mode = 1;
+        if (branch_mode == -1 && has_br_stack)
+                sort__mode = SORT_MODE__BRANCH;
 
-        /* sort__branch_mode could be 0 if --no-branch-stack */
-        if (sort__branch_mode == 1) {
+        /* sort__mode could be NORMAL if --no-branch-stack */
+        if (sort__mode == SORT_MODE__BRANCH) {
                 /*
                  * if no sort_order is provided, then specify
                  * branch-mode specific order
@@ -861,10 +900,12 @@ repeat:
 
         }
         if (report.mem_mode) {
-                if (sort__branch_mode == 1) {
+                if (sort__mode == SORT_MODE__BRANCH) {
                         fprintf(stderr, "branch and mem mode incompatible\n");
                         goto error;
                 }
+                sort__mode = SORT_MODE__MEMORY;
+
                 /*
                  * if no sort_order is provided, then specify
                  * branch-mode specific order
@@ -883,7 +924,8 @@ repeat:
          */
         if (use_browser == 1 && sort__has_sym) {
                 symbol_conf.priv_size = sizeof(struct annotation);
-                report.annotate_init  = symbol__annotate_init;
+                machines__set_symbol_filter(&session->machines,
+                                            symbol__annotate_init);
                 /*
                  * For searching by name on the "Browse map details".
                  * providing it only in verbose mode not to bloat too
@@ -907,16 +949,7 @@ repeat:
         if (parent_pattern != default_parent_pattern) {
                 if (sort_dimension__add("parent") < 0)
                         goto error;
-
-                /*
-                 * Only show the parent fields if we explicitly
-                 * sort that way. If we only use parent machinery
-                 * for filtering, we don't want it.
-                 */
-                if (!strstr(sort_order, "parent"))
-                        sort_parent.elide = 1;
-        } else
-                symbol_conf.exclude_other = false;
+        }
 
         if (argc) {
                 /*
@@ -929,25 +962,7 @@ repeat:
                 report.symbol_filter_str = argv[0];
         }
 
-        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
-
-        if (sort__branch_mode == 1) {
-                sort_entry__setup_elide(&sort_dso_from, symbol_conf.dso_from_list, "dso_from", stdout);
-                sort_entry__setup_elide(&sort_dso_to, symbol_conf.dso_to_list, "dso_to", stdout);
-                sort_entry__setup_elide(&sort_sym_from, symbol_conf.sym_from_list, "sym_from", stdout);
-                sort_entry__setup_elide(&sort_sym_to, symbol_conf.sym_to_list, "sym_to", stdout);
-        } else {
-                if (report.mem_mode) {
-                        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "symbol_daddr", stdout);
-                        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso_daddr", stdout);
-                        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "mem", stdout);
-                        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "local_weight", stdout);
-                        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "tlb", stdout);
-                        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "snoop", stdout);
-                }
-                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
-                sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
-        }
+        sort__setup_elide(stdout);
 
         ret = __cmd_report(&report);
         if (ret == K_SWITCH_INPUT_DATA) {
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index 2da2a6ca22bf..d8c51b2f263f 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -109,8 +109,9 @@ struct trace_sched_handler {
         int (*wakeup_event)(struct perf_sched *sched, struct perf_evsel *evsel,
                             struct perf_sample *sample, struct machine *machine);
 
-        int (*fork_event)(struct perf_sched *sched, struct perf_evsel *evsel,
-                          struct perf_sample *sample);
+        /* PERF_RECORD_FORK event, not sched_process_fork tracepoint */
+        int (*fork_event)(struct perf_sched *sched, union perf_event *event,
+                          struct machine *machine);
 
         int (*migrate_task_event)(struct perf_sched *sched,
                                   struct perf_evsel *evsel,
@@ -717,22 +718,31 @@ static int replay_switch_event(struct perf_sched *sched,
         return 0;
 }
 
-static int replay_fork_event(struct perf_sched *sched, struct perf_evsel *evsel,
-                             struct perf_sample *sample)
+static int replay_fork_event(struct perf_sched *sched,
+                             union perf_event *event,
+                             struct machine *machine)
 {
-        const char *parent_comm = perf_evsel__strval(evsel, sample, "parent_comm"),
-                   *child_comm  = perf_evsel__strval(evsel, sample, "child_comm");
-        const u32 parent_pid  = perf_evsel__intval(evsel, sample, "parent_pid"),
-                  child_pid  = perf_evsel__intval(evsel, sample, "child_pid");
+        struct thread *child, *parent;
+
+        child = machine__findnew_thread(machine, event->fork.pid,
+                                        event->fork.tid);
+        parent = machine__findnew_thread(machine, event->fork.ppid,
+                                         event->fork.ptid);
+
+        if (child == NULL || parent == NULL) {
+                pr_debug("thread does not exist on fork event: child %p, parent %p\n",
+                                 child, parent);
+                return 0;
+        }
 
         if (verbose) {
-                printf("sched_fork event %p\n", evsel);
-                printf("... parent: %s/%d\n", parent_comm, parent_pid);
-                printf("...  child: %s/%d\n", child_comm, child_pid);
+                printf("fork event\n");
+                printf("... parent: %s/%d\n", parent->comm, parent->tid);
+                printf("...  child: %s/%d\n", child->comm, child->tid);
         }
 
-        register_pid(sched, parent_pid, parent_comm);
-        register_pid(sched, child_pid, child_comm);
+        register_pid(sched, parent->tid, parent->comm);
+        register_pid(sched, child->tid, child->comm);
         return 0;
 }
 
@@ -824,14 +834,6 @@ static int thread_atoms_insert(struct perf_sched *sched, struct thread *thread)
         return 0;
 }
 
-static int latency_fork_event(struct perf_sched *sched __maybe_unused,
-                              struct perf_evsel *evsel __maybe_unused,
-                              struct perf_sample *sample __maybe_unused)
-{
-        /* should insert the newcomer */
-        return 0;
-}
-
 static char sched_out_state(u64 prev_state)
 {
         const char *str = TASK_STATE_TO_CHAR_STR;
@@ -934,8 +936,8 @@ static int latency_switch_event(struct perf_sched *sched,
                 return -1;
         }
 
-        sched_out = machine__findnew_thread(machine, prev_pid);
-        sched_in = machine__findnew_thread(machine, next_pid);
+        sched_out = machine__findnew_thread(machine, 0, prev_pid);
+        sched_in = machine__findnew_thread(machine, 0, next_pid);
 
         out_events = thread_atoms_search(&sched->atom_root, sched_out, &sched->cmp_pid);
         if (!out_events) {
@@ -978,7 +980,7 @@ static int latency_runtime_event(struct perf_sched *sched,
 {
         const u32 pid      = perf_evsel__intval(evsel, sample, "pid");
         const u64 runtime  = perf_evsel__intval(evsel, sample, "runtime");
-        struct thread *thread = machine__findnew_thread(machine, pid);
+        struct thread *thread = machine__findnew_thread(machine, 0, pid);
         struct work_atoms *atoms = thread_atoms_search(&sched->atom_root, thread, &sched->cmp_pid);
         u64 timestamp = sample->time;
         int cpu = sample->cpu;
@@ -1016,7 +1018,7 @@ static int latency_wakeup_event(struct perf_sched *sched,
         if (!success)
                 return 0;
 
-        wakee = machine__findnew_thread(machine, pid);
+        wakee = machine__findnew_thread(machine, 0, pid);
         atoms = thread_atoms_search(&sched->atom_root, wakee, &sched->cmp_pid);
         if (!atoms) {
                 if (thread_atoms_insert(sched, wakee))
@@ -1070,12 +1072,12 @@ static int latency_migrate_task_event(struct perf_sched *sched,
         if (sched->profile_cpu == -1)
                 return 0;
 
-        migrant = machine__findnew_thread(machine, pid);
+        migrant = machine__findnew_thread(machine, 0, pid);
         atoms = thread_atoms_search(&sched->atom_root, migrant, &sched->cmp_pid);
         if (!atoms) {
                 if (thread_atoms_insert(sched, migrant))
                         return -1;
-                register_pid(sched, migrant->pid, migrant->comm);
+                register_pid(sched, migrant->tid, migrant->comm);
                 atoms = thread_atoms_search(&sched->atom_root, migrant, &sched->cmp_pid);
                 if (!atoms) {
                         pr_err("migration-event: Internal tree error");
@@ -1115,7 +1117,7 @@ static void output_lat_thread(struct perf_sched *sched, struct work_atoms *work_
         sched->all_runtime += work_list->total_runtime;
         sched->all_count   += work_list->nb_atoms;
 
-        ret = printf("  %s:%d ", work_list->thread->comm, work_list->thread->pid);
+        ret = printf("  %s:%d ", work_list->thread->comm, work_list->thread->tid);
 
         for (i = 0; i < 24 - ret; i++)
                 printf(" ");
@@ -1131,9 +1133,9 @@ static void output_lat_thread(struct perf_sched *sched, struct work_atoms *work_
 
 static int pid_cmp(struct work_atoms *l, struct work_atoms *r)
 {
-        if (l->thread->pid < r->thread->pid)
+        if (l->thread->tid < r->thread->tid)
                 return -1;
-        if (l->thread->pid > r->thread->pid)
+        if (l->thread->tid > r->thread->tid)
                 return 1;
 
         return 0;
@@ -1289,8 +1291,8 @@ static int map_switch_event(struct perf_sched *sched, struct perf_evsel *evsel,
                 return -1;
         }
 
-        sched_out = machine__findnew_thread(machine, prev_pid);
-        sched_in = machine__findnew_thread(machine, next_pid);
+        sched_out = machine__findnew_thread(machine, 0, prev_pid);
+        sched_in = machine__findnew_thread(machine, 0, next_pid);
 
         sched->curr_thread[this_cpu] = sched_in;
 
@@ -1321,7 +1323,7 @@ static int map_switch_event(struct perf_sched *sched, struct perf_evsel *evsel,
                         printf("*");
 
                 if (sched->curr_thread[cpu]) {
-                        if (sched->curr_thread[cpu]->pid)
+                        if (sched->curr_thread[cpu]->tid)
                                 printf("%2s ", sched->curr_thread[cpu]->shortname);
                         else
                                 printf(".  ");
@@ -1332,7 +1334,7 @@ static int map_switch_event(struct perf_sched *sched, struct perf_evsel *evsel,
         printf("  %12.6f secs ", (double)timestamp/1e9);
         if (new_shortname) {
                 printf("%s => %s:%d\n",
-                        sched_in->shortname, sched_in->comm, sched_in->pid);
+                        sched_in->shortname, sched_in->comm, sched_in->tid);
         } else {
                 printf("\n");
         }
@@ -1379,25 +1381,20 @@ static int process_sched_runtime_event(struct perf_tool *tool,
         return 0;
 }
 
-static int process_sched_fork_event(struct perf_tool *tool,
-                                    struct perf_evsel *evsel,
-                                    struct perf_sample *sample,
-                                    struct machine *machine __maybe_unused)
+static int perf_sched__process_fork_event(struct perf_tool *tool,
+                                          union perf_event *event,
+                                          struct perf_sample *sample,
+                                          struct machine *machine)
 {
         struct perf_sched *sched = container_of(tool, struct perf_sched, tool);
 
-        if (sched->tp_handler->fork_event)
-                return sched->tp_handler->fork_event(sched, evsel, sample);
+        /* run the fork event through the perf machineruy */
+        perf_event__process_fork(tool, event, sample, machine);
 
-        return 0;
-}
+        /* and then run additional processing needed for this command */
+        if (sched->tp_handler->fork_event)
+                return sched->tp_handler->fork_event(sched, event, machine);
 
-static int process_sched_exit_event(struct perf_tool *tool __maybe_unused,
-                                    struct perf_evsel *evsel,
-                                    struct perf_sample *sample __maybe_unused,
-                                    struct machine *machine __maybe_unused)
-{
-        pr_debug("sched_exit event %p\n", evsel);
         return 0;
 }
 
@@ -1425,15 +1422,8 @@ static int perf_sched__process_tracepoint_sample(struct perf_tool *tool __maybe_
                                                  struct perf_evsel *evsel,
                                                  struct machine *machine)
 {
-        struct thread *thread = machine__findnew_thread(machine, sample->tid);
         int err = 0;
 
-        if (thread == NULL) {
-                pr_debug("problem processing %s event, skipping it.\n",
-                         perf_evsel__name(evsel));
-                return -1;
-        }
-
         evsel->hists.stats.total_period += sample->period;
         hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE);
 
@@ -1445,7 +1435,7 @@ static int perf_sched__process_tracepoint_sample(struct perf_tool *tool __maybe_
         return err;
 }
 
-static int perf_sched__read_events(struct perf_sched *sched, bool destroy,
+static int perf_sched__read_events(struct perf_sched *sched,
                                    struct perf_session **psession)
 {
         const struct perf_evsel_str_handler handlers[] = {
@@ -1453,8 +1443,6 @@ static int perf_sched__read_events(struct perf_sched *sched, bool destroy,
                 { "sched:sched_stat_runtime", process_sched_runtime_event, },
                 { "sched:sched_wakeup",       process_sched_wakeup_event, },
                 { "sched:sched_wakeup_new",   process_sched_wakeup_event, },
-                { "sched:sched_process_fork", process_sched_fork_event, },
-                { "sched:sched_process_exit", process_sched_exit_event, },
                 { "sched:sched_migrate_task", process_sched_migrate_task_event, },
         };
         struct perf_session *session;
@@ -1480,11 +1468,10 @@ static int perf_sched__read_events(struct perf_sched *sched, bool destroy,
                 sched->nr_lost_chunks = session->stats.nr_events[PERF_RECORD_LOST];
         }
 
-        if (destroy)
-                perf_session__delete(session);
-
         if (psession)
                 *psession = session;
+        else
+                perf_session__delete(session);
 
         return 0;
 
@@ -1529,8 +1516,11 @@ static int perf_sched__lat(struct perf_sched *sched)
         struct perf_session *session;
 
         setup_pager();
-        if (perf_sched__read_events(sched, false, &session))
+
+        /* save session -- references to threads are held in work_list */
+        if (perf_sched__read_events(sched, &session))
                 return -1;
+
         perf_sched__sort_lat(sched);
 
         printf("\n ---------------------------------------------------------------------------------------------------------------\n");
@@ -1565,7 +1555,7 @@ static int perf_sched__map(struct perf_sched *sched)
         sched->max_cpu = sysconf(_SC_NPROCESSORS_CONF);
 
         setup_pager();
-        if (perf_sched__read_events(sched, true, NULL))
+        if (perf_sched__read_events(sched, NULL))
                 return -1;
         print_bad_events(sched);
         return 0;
@@ -1580,7 +1570,7 @@ static int perf_sched__replay(struct perf_sched *sched)
 
         test_calibrations(sched);
 
-        if (perf_sched__read_events(sched, true, NULL))
+        if (perf_sched__read_events(sched, NULL))
                 return -1;
 
         printf("nr_run_events:        %ld\n", sched->nr_run_events);
@@ -1632,7 +1622,6 @@ static int __cmd_record(int argc, const char **argv)
                 "record",
                 "-a",
                 "-R",
-                "-f",
                 "-m", "1024",
                 "-c", "1",
                 "-e", "sched:sched_switch",
@@ -1640,7 +1629,6 @@ static int __cmd_record(int argc, const char **argv)
                 "-e", "sched:sched_stat_sleep",
                 "-e", "sched:sched_stat_iowait",
                 "-e", "sched:sched_stat_runtime",
-                "-e", "sched:sched_process_exit",
                 "-e", "sched:sched_process_fork",
                 "-e", "sched:sched_wakeup",
                 "-e", "sched:sched_migrate_task",
@@ -1663,28 +1651,29 @@ static int __cmd_record(int argc, const char **argv)
         return cmd_record(i, rec_argv, NULL);
 }
 
+static const char default_sort_order[] = "avg, max, switch, runtime";
+static struct perf_sched sched = {
+        .tool = {
+                .sample          = perf_sched__process_tracepoint_sample,
+                .comm            = perf_event__process_comm,
+                .lost            = perf_event__process_lost,
+                .fork            = perf_sched__process_fork_event,
+                .ordered_samples = true,
+        },
+        .cmp_pid              = LIST_HEAD_INIT(sched.cmp_pid),
+        .sort_list            = LIST_HEAD_INIT(sched.sort_list),
+        .start_work_mutex     = PTHREAD_MUTEX_INITIALIZER,
+        .work_done_wait_mutex = PTHREAD_MUTEX_INITIALIZER,
+        .curr_pid             = { [0 ... MAX_CPUS - 1] = -1 },
+        .sort_order           = default_sort_order,
+        .replay_repeat        = 10,
+        .profile_cpu          = -1,
+        .next_shortname1      = 'A',
+        .next_shortname2      = '0',
+};
+
 int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
 {
-        const char default_sort_order[] = "avg, max, switch, runtime";
-        struct perf_sched sched = {
-                .tool = {
-                        .sample          = perf_sched__process_tracepoint_sample,
-                        .comm            = perf_event__process_comm,
-                        .lost            = perf_event__process_lost,
-                        .fork            = perf_event__process_fork,
-                        .ordered_samples = true,
-                },
-                .cmp_pid              = LIST_HEAD_INIT(sched.cmp_pid),
-                .sort_list            = LIST_HEAD_INIT(sched.sort_list),
-                .start_work_mutex     = PTHREAD_MUTEX_INITIALIZER,
-                .work_done_wait_mutex = PTHREAD_MUTEX_INITIALIZER,
-                .curr_pid             = { [0 ... MAX_CPUS - 1] = -1 },
-                .sort_order           = default_sort_order,
-                .replay_repeat        = 10,
-                .profile_cpu          = -1,
-                .next_shortname1      = 'A',
-                .next_shortname2      = '0',
-        };
         const struct option latency_options[] = {
         OPT_STRING('s', "sort", &sched.sort_order, "key[,key2...]",
                    "sort by key(s): runtime, switch, avg, max"),
@@ -1730,7 +1719,6 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
                 .wakeup_event       = latency_wakeup_event,
                 .switch_event       = latency_switch_event,
                 .runtime_event      = latency_runtime_event,
-                .fork_event         = latency_fork_event,
                 .migrate_task_event = latency_migrate_task_event,
         };
         struct trace_sched_handler map_ops  = {
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index 92d4658f56fb..9c333ff3dfeb 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -24,6 +24,7 @@ static u64			last_timestamp;
 static u64                      nr_unordered;
 extern const struct option      record_options[];
 static bool                     no_callchain;
+static bool                     latency_format;
 static bool                     system_wide;
 static const char               *cpu_list;
 static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
@@ -65,6 +66,7 @@ struct output_option {
 static struct {
         bool user_set;
         bool wildcard_set;
+        unsigned int print_ip_opts;
         u64 fields;
         u64 invalid_fields;
 } output[PERF_TYPE_MAX] = {
@@ -234,6 +236,7 @@ static int perf_session__check_output_opt(struct perf_session *session)
 {
         int j;
         struct perf_evsel *evsel;
+        struct perf_event_attr *attr;
 
         for (j = 0; j < PERF_TYPE_MAX; ++j) {
                 evsel = perf_session__find_first_evtype(session, j);
@@ -252,6 +255,24 @@ static int perf_session__check_output_opt(struct perf_session *session)
                 if (evsel && output[j].fields &&
                         perf_evsel__check_attr(evsel, session))
                         return -1;
+
+                if (evsel == NULL)
+                        continue;
+
+                attr = &evsel->attr;
+
+                output[j].print_ip_opts = 0;
+                if (PRINT_FIELD(IP))
+                        output[j].print_ip_opts |= PRINT_IP_OPT_IP;
+
+                if (PRINT_FIELD(SYM))
+                        output[j].print_ip_opts |= PRINT_IP_OPT_SYM;
+
+                if (PRINT_FIELD(DSO))
+                        output[j].print_ip_opts |= PRINT_IP_OPT_DSO;
+
+                if (PRINT_FIELD(SYMOFFSET))
+                        output[j].print_ip_opts |= PRINT_IP_OPT_SYMOFFSET;
         }
 
         return 0;
@@ -381,8 +402,8 @@ static void print_sample_bts(union perf_event *event,
                 else
                         printf("\n");
                 perf_evsel__print_ip(evsel, event, sample, machine,
-                                     PRINT_FIELD(SYM), PRINT_FIELD(DSO),
-                                     PRINT_FIELD(SYMOFFSET));
+                                     output[attr->type].print_ip_opts,
+                                     PERF_MAX_STACK_DEPTH);
         }
 
         printf(" => ");
@@ -396,10 +417,10 @@ static void print_sample_bts(union perf_event *event,
 
 static void process_event(union perf_event *event, struct perf_sample *sample,
                           struct perf_evsel *evsel, struct machine *machine,
-                          struct addr_location *al)
+                          struct thread *thread,
+                          struct addr_location *al __maybe_unused)
 {
         struct perf_event_attr *attr = &evsel->attr;
-        struct thread *thread = al->thread;
 
         if (output[attr->type].fields == 0)
                 return;
@@ -422,9 +443,10 @@ static void process_event(union perf_event *event, struct perf_sample *sample,
                         printf(" ");
                 else
                         printf("\n");
+
                 perf_evsel__print_ip(evsel, event, sample, machine,
-                                     PRINT_FIELD(SYM), PRINT_FIELD(DSO),
-                                     PRINT_FIELD(SYMOFFSET));
+                                     output[attr->type].print_ip_opts,
+                                     PERF_MAX_STACK_DEPTH);
         }
 
         printf("\n");
@@ -479,7 +501,8 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                                 struct machine *machine)
 {
         struct addr_location al;
-        struct thread *thread = machine__findnew_thread(machine, event->ip.tid);
+        struct thread *thread = machine__findnew_thread(machine, sample->pid,
+                                                        sample->tid);
 
         if (thread == NULL) {
                 pr_debug("problem processing %d event, skipping it.\n",
@@ -498,7 +521,7 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                 return 0;
         }
 
-        if (perf_event__preprocess_sample(event, machine, &al, sample, 0) < 0) {
+        if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
                 pr_err("problem processing %d event, skipping it.\n",
                        event->header.type);
                 return -1;
@@ -510,7 +533,7 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
         if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
                 return 0;
 
-        scripting_ops->process_event(event, sample, evsel, machine, &al);
+        scripting_ops->process_event(event, sample, evsel, machine, thread, &al);
 
         evsel->hists.stats.total_period += sample->period;
         return 0;
@@ -519,19 +542,17 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
 static struct perf_tool perf_script = {
         .sample          = process_sample_event,
         .mmap            = perf_event__process_mmap,
+        .mmap2           = perf_event__process_mmap2,
         .comm            = perf_event__process_comm,
         .exit            = perf_event__process_exit,
         .fork            = perf_event__process_fork,
         .attr            = perf_event__process_attr,
-        .event_type      = perf_event__process_event_type,
         .tracing_data    = perf_event__process_tracing_data,
         .build_id        = perf_event__process_build_id,
         .ordered_samples = true,
         .ordering_requires_timestamps = true,
 };
 
-extern volatile int session_done;
-
 static void sig_handler(int sig __maybe_unused)
 {
         session_done = 1;
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 7e910bab1097..f686d5ff594e 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -87,7 +87,7 @@ static int			run_count			=  1;
 static bool                     no_inherit                      = false;
 static bool                     scale                           =  true;
 static enum aggr_mode           aggr_mode                       = AGGR_GLOBAL;
-static pid_t                    child_pid                       = -1;
+static volatile pid_t           child_pid                       = -1;
 static bool                     null_run                        =  false;
 static int                      detailed_run                    =  0;
 static bool                     big_num                         =  true;
@@ -100,6 +100,7 @@ static const char		*pre_cmd			= NULL;
 static const char               *post_cmd                       = NULL;
 static bool                     sync_run                        = false;
 static unsigned int             interval                        = 0;
+static unsigned int             initial_delay                   = 0;
 static bool                     forever                         = false;
 static struct timespec          ref_time;
 static struct cpu_map           *aggr_map;
@@ -254,7 +255,8 @@ static int create_perf_stat_counter(struct perf_evsel *evsel)
         if (!perf_target__has_task(&target) &&
             perf_evsel__is_group_leader(evsel)) {
                 attr->disabled = 1;
-                attr->enable_on_exec = 1;
+                if (!initial_delay)
+                        attr->enable_on_exec = 1;
         }
 
         return perf_evsel__open_per_thread(evsel, evsel_list->threads);
@@ -414,6 +416,22 @@ static void print_interval(void)
                 list_for_each_entry(counter, &evsel_list->entries, node)
                         print_counter_aggr(counter, prefix);
         }
+
+        fflush(output);
+}
+
+static void handle_initial_delay(void)
+{
+        struct perf_evsel *counter;
+
+        if (initial_delay) {
+                const int ncpus = cpu_map__nr(evsel_list->cpus),
+                        nthreads = thread_map__nr(evsel_list->threads);
+
+                usleep(initial_delay * 1000);
+                list_for_each_entry(counter, &evsel_list->entries, node)
+                        perf_evsel__enable(counter, ncpus, nthreads);
+        }
 }
 
 static int __run_perf_stat(int argc, const char **argv)
@@ -486,6 +504,7 @@ static int __run_perf_stat(int argc, const char **argv)
 
         if (forks) {
                 perf_evlist__start_workload(evsel_list);
+                handle_initial_delay();
 
                 if (interval) {
                         while (!waitpid(child_pid, &status, WNOHANG)) {
@@ -497,6 +516,7 @@ static int __run_perf_stat(int argc, const char **argv)
                 if (WIFSIGNALED(status))
                         psignal(WTERMSIG(status), argv[0]);
         } else {
+                handle_initial_delay();
                 while (!done) {
                         nanosleep(&ts, NULL);
                         if (interval)
@@ -924,7 +944,7 @@ static void abs_printout(int cpu, int nr, struct perf_evsel *evsel, double avg)
 static void print_aggr(char *prefix)
 {
         struct perf_evsel *counter;
-        int cpu, s, s2, id, nr;
+        int cpu, cpu2, s, s2, id, nr;
         u64 ena, run, val;
 
         if (!(aggr_map || aggr_get_id))
@@ -936,7 +956,8 @@ static void print_aggr(char *prefix)
                         val = ena = run = 0;
                         nr = 0;
                         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                                s2 = aggr_get_id(evsel_list->cpus, cpu);
+                                cpu2 = perf_evsel__cpus(counter)->map[cpu];
+                                s2 = aggr_get_id(evsel_list->cpus, cpu2);
                                 if (s2 != id)
                                         continue;
                                 val += counter->counts->cpu[cpu].val;
@@ -948,7 +969,7 @@ static void print_aggr(char *prefix)
                                 fprintf(output, "%s", prefix);
 
                         if (run == 0 || ena == 0) {
-                                aggr_printout(counter, cpu, nr);
+                                aggr_printout(counter, id, nr);
 
                                 fprintf(output, "%*s%s%*s",
                                         csv_output ? 0 : 18,
@@ -1148,13 +1169,34 @@ static void skip_signal(int signo)
                 done = 1;
 
         signr = signo;
+        /*
+         * render child_pid harmless
+         * won't send SIGTERM to a random
+         * process in case of race condition
+         * and fast PID recycling
+         */
+        child_pid = -1;
 }
 
 static void sig_atexit(void)
 {
+        sigset_t set, oset;
+
+        /*
+         * avoid race condition with SIGCHLD handler
+         * in skip_signal() which is modifying child_pid
+         * goal is to avoid send SIGTERM to a random
+         * process
+         */
+        sigemptyset(&set);
+        sigaddset(&set, SIGCHLD);
+        sigprocmask(SIG_BLOCK, &set, &oset);
+
         if (child_pid != -1)
                 kill(child_pid, SIGTERM);
 
+        sigprocmask(SIG_SETMASK, &oset, NULL);
+
         if (signr == -1)
                 return;
 
@@ -1397,6 +1439,8 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
                      "aggregate counts per processor socket", AGGR_SOCKET),
         OPT_SET_UINT(0, "per-core", &aggr_mode,
                      "aggregate counts per physical processor core", AGGR_CORE),
+        OPT_UINTEGER('D', "delay", &initial_delay,
+                     "ms to wait before starting measurement after program start"),
         OPT_END()
         };
         const char * const stat_usage[] = {
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index ab4cf232b852..c2e02319347a 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -12,6 +12,8 @@
  * of the License.
  */
 
+#include <traceevent/event-parse.h>
+
 #include "builtin.h"
 
 #include "util/util.h"
@@ -19,6 +21,7 @@
 #include "util/color.h"
 #include <linux/list.h>
 #include "util/cache.h"
+#include "util/evlist.h"
 #include "util/evsel.h"
 #include <linux/rbtree.h>
 #include "util/symbol.h"
@@ -328,25 +331,6 @@ struct wakeup_entry {
         int   success;
 };
 
-/*
- * trace_flag_type is an enumeration that holds different
- * states when a trace occurs. These are:
- *  IRQS_OFF            - interrupts were disabled
- *  IRQS_NOSUPPORT      - arch does not support irqs_disabled_flags
- *  NEED_RESCED         - reschedule is requested
- *  HARDIRQ             - inside an interrupt handler
- *  SOFTIRQ             - inside a softirq handler
- */
-enum trace_flag_type {
-        TRACE_FLAG_IRQS_OFF             = 0x01,
-        TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
-        TRACE_FLAG_NEED_RESCHED         = 0x04,
-        TRACE_FLAG_HARDIRQ              = 0x08,
-        TRACE_FLAG_SOFTIRQ              = 0x10,
-};
-
-
-
 struct sched_switch {
         struct trace_entry te;
         char prev_comm[TASK_COMM_LEN];
@@ -479,6 +463,8 @@ static void sched_switch(int cpu, u64 timestamp, struct trace_entry *te)
         }
 }
 
+typedef int (*tracepoint_handler)(struct perf_evsel *evsel,
+                                  struct perf_sample *sample);
 
 static int process_sample_event(struct perf_tool *tool __maybe_unused,
                                 union perf_event *event __maybe_unused,
@@ -486,8 +472,6 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                                 struct perf_evsel *evsel,
                                 struct machine *machine __maybe_unused)
 {
-        struct trace_entry *te;
-
         if (evsel->attr.sample_type & PERF_SAMPLE_TIME) {
                 if (!first_time || first_time > sample->time)
                         first_time = sample->time;
@@ -495,69 +479,90 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
                         last_time = sample->time;
         }
 
-        te = (void *)sample->raw_data;
-        if ((evsel->attr.sample_type & PERF_SAMPLE_RAW) && sample->raw_size > 0) {
-                char *event_str;
-#ifdef SUPPORT_OLD_POWER_EVENTS
-                struct power_entry_old *peo;
-                peo = (void *)te;
-#endif
-                /*
-                 * FIXME: use evsel, its already mapped from id to perf_evsel,
-                 * remove perf_header__find_event infrastructure bits.
-                 * Mapping all these "power:cpu_idle" strings to the tracepoint
-                 * ID and then just comparing against evsel->attr.config.
-                 *
-                 * e.g.:
-                 *
-                 * if (evsel->attr.config == power_cpu_idle_id)
-                 */
-                event_str = perf_header__find_event(te->type);
-
-                if (!event_str)
-                        return 0;
-
-                if (sample->cpu > numcpus)
-                        numcpus = sample->cpu;
-
-                if (strcmp(event_str, "power:cpu_idle") == 0) {
-                        struct power_processor_entry *ppe = (void *)te;
-                        if (ppe->state == (u32)PWR_EVENT_EXIT)
-                                c_state_end(ppe->cpu_id, sample->time);
-                        else
-                                c_state_start(ppe->cpu_id, sample->time,
-                                              ppe->state);
-                }
-                else if (strcmp(event_str, "power:cpu_frequency") == 0) {
-                        struct power_processor_entry *ppe = (void *)te;
-                        p_state_change(ppe->cpu_id, sample->time, ppe->state);
-                }
+        if (sample->cpu > numcpus)
+                numcpus = sample->cpu;
+
+        if (evsel->handler.func != NULL) {
+                tracepoint_handler f = evsel->handler.func;
+                return f(evsel, sample);
+        }
+
+        return 0;
+}
+
+static int
+process_sample_cpu_idle(struct perf_evsel *evsel __maybe_unused,
+                        struct perf_sample *sample)
+{
+        struct power_processor_entry *ppe = sample->raw_data;
+
+        if (ppe->state == (u32) PWR_EVENT_EXIT)
+                c_state_end(ppe->cpu_id, sample->time);
+        else
+                c_state_start(ppe->cpu_id, sample->time, ppe->state);
+        return 0;
+}
+
+static int
+process_sample_cpu_frequency(struct perf_evsel *evsel __maybe_unused,
+                             struct perf_sample *sample)
+{
+        struct power_processor_entry *ppe = sample->raw_data;
+
+        p_state_change(ppe->cpu_id, sample->time, ppe->state);
+        return 0;
+}
+
+static int
+process_sample_sched_wakeup(struct perf_evsel *evsel __maybe_unused,
+                            struct perf_sample *sample)
+{
+        struct trace_entry *te = sample->raw_data;
+
+        sched_wakeup(sample->cpu, sample->time, sample->pid, te);
+        return 0;
+}
 
-                else if (strcmp(event_str, "sched:sched_wakeup") == 0)
-                        sched_wakeup(sample->cpu, sample->time, sample->pid, te);
+static int
+process_sample_sched_switch(struct perf_evsel *evsel __maybe_unused,
+                            struct perf_sample *sample)
+{
+        struct trace_entry *te = sample->raw_data;
 
-                else if (strcmp(event_str, "sched:sched_switch") == 0)
-                        sched_switch(sample->cpu, sample->time, te);
+        sched_switch(sample->cpu, sample->time, te);
+        return 0;
+}
 
 #ifdef SUPPORT_OLD_POWER_EVENTS
-                if (use_old_power_events) {
-                        if (strcmp(event_str, "power:power_start") == 0)
-                                c_state_start(peo->cpu_id, sample->time,
-                                              peo->value);
-
-                        else if (strcmp(event_str, "power:power_end") == 0)
-                                c_state_end(sample->cpu, sample->time);
-
-                        else if (strcmp(event_str,
-                                        "power:power_frequency") == 0)
-                                p_state_change(peo->cpu_id, sample->time,
-                                               peo->value);
-                }
-#endif
-        }
+static int
+process_sample_power_start(struct perf_evsel *evsel __maybe_unused,
+                           struct perf_sample *sample)
+{
+        struct power_entry_old *peo = sample->raw_data;
+
+        c_state_start(peo->cpu_id, sample->time, peo->value);
         return 0;
 }
 
+static int
+process_sample_power_end(struct perf_evsel *evsel __maybe_unused,
+                         struct perf_sample *sample)
+{
+        c_state_end(sample->cpu, sample->time);
+        return 0;
+}
+
+static int
+process_sample_power_frequency(struct perf_evsel *evsel __maybe_unused,
+                               struct perf_sample *sample)
+{
+        struct power_entry_old *peo = sample->raw_data;
+
+        p_state_change(peo->cpu_id, sample->time, peo->value);
+        return 0;
+}
+#endif /* SUPPORT_OLD_POWER_EVENTS */
+
 /*
  * After the last sample we need to wrap up the current C/P state
  * and close out each CPU for these.
@@ -974,6 +979,17 @@ static int __cmd_timechart(const char *output_name)
                 .sample          = process_sample_event,
                 .ordered_samples = true,
         };
+        const struct perf_evsel_str_handler power_tracepoints[] = {
+                { "power:cpu_idle",             process_sample_cpu_idle },
+                { "power:cpu_frequency",        process_sample_cpu_frequency },
+                { "sched:sched_wakeup",         process_sample_sched_wakeup },
+                { "sched:sched_switch",         process_sample_sched_switch },
+#ifdef SUPPORT_OLD_POWER_EVENTS
+                { "power:power_start",          process_sample_power_start },
+                { "power:power_end",            process_sample_power_end },
+                { "power:power_frequency",      process_sample_power_frequency },
+#endif
+        };
         struct perf_session *session = perf_session__new(input_name, O_RDONLY,
                                                          0, false, &perf_timechart);
         int ret = -EINVAL;
@@ -984,6 +1000,12 @@ static int __cmd_timechart(const char *output_name)
         if (!perf_session__has_traces(session, "timechart record"))
                 goto out_delete;
 
+        if (perf_session__set_tracepoints_handlers(session,
+                                                   power_tracepoints)) {
+                pr_err("Initializing session tracepoint handlers failed\n");
+                goto out_delete;
+        }
+
         ret = perf_session__process_events(session, &perf_timechart);
         if (ret)
                 goto out_delete;
@@ -1005,7 +1027,7 @@ static int __cmd_record(int argc, const char **argv)
 {
 #ifdef SUPPORT_OLD_POWER_EVENTS
         const char * const record_old_args[] = {
-                "record", "-a", "-R", "-f", "-c", "1",
+                "record", "-a", "-R", "-c", "1",
                 "-e", "power:power_start",
                 "-e", "power:power_end",
                 "-e", "power:power_frequency",
@@ -1014,7 +1036,7 @@ static int __cmd_record(int argc, const char **argv)
         };
 #endif
         const char * const record_new_args[] = {
-                "record", "-a", "-R", "-f", "-c", "1",
+                "record", "-a", "-R", "-c", "1",
                 "-e", "power:cpu_frequency",
                 "-e", "power:cpu_idle",
                 "-e", "sched:sched_wakeup",
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 67bdb9f14ad6..212214162bb2 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -40,6 +40,7 @@
 #include "util/xyarray.h"
 #include "util/sort.h"
 #include "util/intlist.h"
+#include "arch/common.h"
 
 #include "util/debug.h"
 
@@ -70,10 +71,11 @@
 
 static volatile int done;
 
+#define HEADER_LINE_NR  5
+
 static void perf_top__update_print_entries(struct perf_top *top)
 {
-        if (top->print_entries > 9)
-                top->print_entries -= 9;
+        top->print_entries = top->winsize.ws_row - HEADER_LINE_NR;
 }
 
 static void perf_top__sig_winch(int sig __maybe_unused,
@@ -82,13 +84,6 @@ static void perf_top__sig_winch(int sig __maybe_unused,
         struct perf_top *top = arg;
 
         get_term_dimensions(&top->winsize);
-        if (!top->print_entries
-            || (top->print_entries+4) > top->winsize.ws_row) {
-                top->print_entries = top->winsize.ws_row;
-        } else {
-                top->print_entries += 4;
-                top->winsize.ws_row = top->print_entries;
-        }
         perf_top__update_print_entries(top);
 }
 
@@ -108,7 +103,8 @@ static int perf_top__parse_source(struct perf_top *top, struct hist_entry *he)
         /*
          * We can't annotate with just /proc/kallsyms
          */
-        if (map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS) {
+        if (map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
+            !dso__is_kcore(map->dso)) {
                 pr_err("Can't annotate %s: No vmlinux file was found in the "
                        "path\n", sym->name);
                 sleep(1);
@@ -243,16 +239,17 @@ out_unlock:
         pthread_mutex_unlock(&notes->lock);
 }
 
-static const char               CONSOLE_CLEAR[] = "";
-
 static struct hist_entry *perf_evsel__add_hist_entry(struct perf_evsel *evsel,
                                                      struct addr_location *al,
                                                      struct perf_sample *sample)
 {
         struct hist_entry *he;
 
+        pthread_mutex_lock(&evsel->hists.lock);
         he = __hists__add_entry(&evsel->hists, al, NULL, sample->period,
                                 sample->weight);
+        pthread_mutex_unlock(&evsel->hists.lock);
+
         if (he == NULL)
                 return NULL;
 
@@ -290,16 +287,17 @@ static void perf_top__print_sym_table(struct perf_top *top)
                 return;
         }
 
-        hists__collapse_resort_threaded(&top->sym_evsel->hists);
-        hists__output_resort_threaded(&top->sym_evsel->hists);
-        hists__decay_entries_threaded(&top->sym_evsel->hists,
-                                      top->hide_user_symbols,
-                                      top->hide_kernel_symbols);
+        hists__collapse_resort(&top->sym_evsel->hists);
+        hists__output_resort(&top->sym_evsel->hists);
+        hists__decay_entries(&top->sym_evsel->hists,
+                             top->hide_user_symbols,
+                             top->hide_kernel_symbols);
         hists__output_recalc_col_len(&top->sym_evsel->hists,
-                                     top->winsize.ws_row - 3);
+                                     top->print_entries - printed);
         putchar('\n');
         hists__fprintf(&top->sym_evsel->hists, false,
-                       top->winsize.ws_row - 4 - printed, win_width, stdout);
+                       top->print_entries - printed, win_width,
+                       top->min_percent, stdout);
 }
 
 static void prompt_integer(int *target, const char *msg)
@@ -477,7 +475,6 @@ static bool perf_top__handle_keypress(struct perf_top *top, int c)
                                 perf_top__sig_winch(SIGWINCH, NULL, top);
                                 sigaction(SIGWINCH, &act, NULL);
                         } else {
-                                perf_top__sig_winch(SIGWINCH, NULL, top);
                                 signal(SIGWINCH, SIG_DFL);
                         }
                         break;
@@ -556,11 +553,11 @@ static void perf_top__sort_new_samples(void *arg)
         if (t->evlist->selected != NULL)
                 t->sym_evsel = t->evlist->selected;
 
-        hists__collapse_resort_threaded(&t->sym_evsel->hists);
-        hists__output_resort_threaded(&t->sym_evsel->hists);
-        hists__decay_entries_threaded(&t->sym_evsel->hists,
-                                      t->hide_user_symbols,
-                                      t->hide_kernel_symbols);
+        hists__collapse_resort(&t->sym_evsel->hists);
+        hists__output_resort(&t->sym_evsel->hists);
+        hists__decay_entries(&t->sym_evsel->hists,
+                             t->hide_user_symbols,
+                             t->hide_kernel_symbols);
 }
 
 static void *display_thread_tui(void *arg)
@@ -584,7 +581,7 @@ static void *display_thread_tui(void *arg)
         list_for_each_entry(pos, &top->evlist->entries, node)
                 pos->hists.uid_filter_str = top->record_opts.target.uid_str;
 
-        perf_evlist__tui_browse_hists(top->evlist, help, &hbt,
+        perf_evlist__tui_browse_hists(top->evlist, help, &hbt, top->min_percent,
                                       &top->session->header.env);
 
         done = 1;
@@ -692,7 +689,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
 {
         struct perf_top *top = container_of(tool, struct perf_top, tool);
         struct symbol *parent = NULL;
-        u64 ip = event->ip.ip;
+        u64 ip = sample->ip;
         struct addr_location al;
         int err;
 
@@ -702,10 +699,10 @@ static void perf_event__process_sample(struct perf_tool *tool,
                 if (!seen)
                         seen = intlist__new(NULL);
 
-                if (!intlist__has_entry(seen, event->ip.pid)) {
+                if (!intlist__has_entry(seen, sample->pid)) {
                         pr_err("Can't find guest [%d]'s kernel information\n",
-                                event->ip.pid);
-                        intlist__add(seen, event->ip.pid);
+                                sample->pid);
+                        intlist__add(seen, sample->pid);
                 }
                 return;
         }
@@ -719,8 +716,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
         if (event->header.misc & PERF_RECORD_MISC_EXACT_IP)
                 top->exact_samples++;
 
-        if (perf_event__preprocess_sample(event, machine, &al, sample,
-                                          symbol_filter) < 0 ||
+        if (perf_event__preprocess_sample(event, machine, &al, sample) < 0 ||
             al.filtered)
                 return;
 
@@ -775,8 +771,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
                     sample->callchain) {
                         err = machine__resolve_callchain(machine, evsel,
                                                          al.thread, sample,
-                                                         &parent);
-
+                                                         &parent, &al);
                         if (err)
                                 return;
                 }
@@ -794,7 +789,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
                                 return;
                 }
 
-                if (top->sort_has_symbols)
+                if (sort__has_sym)
                         perf_top__record_precise_ip(top, he, evsel->idx, ip);
         }
 
@@ -841,7 +836,8 @@ static void perf_top__mmap_read_idx(struct perf_top *top, int idx)
                         break;
                 case PERF_RECORD_MISC_GUEST_KERNEL:
                         ++top->guest_kernel_samples;
-                        machine = perf_session__find_machine(session, event->ip.pid);
+                        machine = perf_session__find_machine(session,
+                                                             sample.pid);
                         break;
                 case PERF_RECORD_MISC_GUEST_USER:
                         ++top->guest_us_samples;
@@ -912,9 +908,9 @@ out_err:
         return -1;
 }
 
-static int perf_top__setup_sample_type(struct perf_top *top)
+static int perf_top__setup_sample_type(struct perf_top *top __maybe_unused)
 {
-        if (!top->sort_has_symbols) {
+        if (!sort__has_sym) {
                 if (symbol_conf.use_callchain) {
                         ui__error("Selected -g but \"sym\" not present in --sort/-s.");
                         return -EINVAL;
@@ -942,6 +938,14 @@ static int __cmd_top(struct perf_top *top)
         if (top->session == NULL)
                 return -ENOMEM;
 
+        machines__set_symbol_filter(&top->session->machines, symbol_filter);
+
+        if (!objdump_path) {
+                ret = perf_session_env__lookup_objdump(&top->session->header.env);
+                if (ret)
+                        goto out_delete;
+        }
+
         ret = perf_top__setup_sample_type(top);
         if (ret)
                 goto out_delete;
@@ -1025,6 +1029,16 @@ parse_callchain_opt(const struct option *opt, const char *arg, int unset)
         return record_parse_callchain_opt(opt, arg, unset);
 }
 
+static int
+parse_percent_limit(const struct option *opt, const char *arg,
+                    int unset __maybe_unused)
+{
+        struct perf_top *top = opt->value;
+
+        top->min_percent = strtof(arg, NULL);
+        return 0;
+}
+
 int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
 {
         int status;
@@ -1095,6 +1109,9 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_CALLBACK_DEFAULT('G', "call-graph", &top.record_opts,
                              "mode[,dump_size]", record_callchain_help,
                              &parse_callchain_opt, "fp"),
+        OPT_CALLBACK(0, "ignore-callees", NULL, "regex",
+                   "ignore callees of these functions in call graphs",
+                   report_parse_ignore_callees_opt),
         OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
                     "Show a column with the sum of periods"),
         OPT_STRING(0, "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
@@ -1107,9 +1124,13 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Interleave source code with assembly code (default)"),
         OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw,
                     "Display raw encoding of assembly instructions (default)"),
+        OPT_STRING(0, "objdump", &objdump_path, "path",
+                    "objdump binary to use for disassembly and annotations"),
         OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
                    "Specify disassembler style (e.g. -M intel for intel syntax)"),
         OPT_STRING('u', "uid", &target->uid_str, "user", "user to profile"),
+        OPT_CALLBACK(0, "percent-limit", &top, "percent",
+                     "Don't show entries under that percent", parse_percent_limit),
         OPT_END()
         };
         const char * const top_usage[] = {
@@ -1121,8 +1142,6 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         if (top.evlist == NULL)
                 return -ENOMEM;
 
-        symbol_conf.exclude_other = false;
-
         argc = parse_options(argc, argv, options, top_usage, 0);
         if (argc)
                 usage_with_options(top_usage, options);
@@ -1133,6 +1152,9 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         if (setup_sorting() < 0)
                 usage_with_options(top_usage, options);
 
+        /* display thread wants entries to be collapsed in a different tree */
+        sort__need_collapse = 1;
+
         if (top.use_stdio)
                 use_browser = 0;
         else if (top.use_tui)
@@ -1200,15 +1222,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         if (symbol__init() < 0)
                 return -1;
 
-        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
-        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
-        sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
-
-        /*
-         * Avoid annotation data structures overhead when symbols aren't on the
-         * sort list.
-         */
-        top.sort_has_symbols = sort_sym.list.next != NULL;
+        sort__setup_elide(stdout);
 
         get_term_dimensions(&top.winsize);
         if (top.print_entries == 0) {
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index ab3ed4af1466..71aa3e35406b 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -1,34 +1,350 @@
+#include <traceevent/event-parse.h>
 #include "builtin.h"
 #include "util/color.h"
+#include "util/debug.h"
 #include "util/evlist.h"
 #include "util/machine.h"
+#include "util/session.h"
 #include "util/thread.h"
 #include "util/parse-options.h"
+#include "util/strlist.h"
+#include "util/intlist.h"
 #include "util/thread_map.h"
-#include "event-parse.h"
 
 #include <libaudit.h>
 #include <stdlib.h>
+#include <sys/mman.h>
+#include <linux/futex.h>
+
+/* For older distros: */
+#ifndef MAP_STACK
+# define MAP_STACK              0x20000
+#endif
+
+#ifndef MADV_HWPOISON
+# define MADV_HWPOISON          100
+#endif
+
+#ifndef MADV_MERGEABLE
+# define MADV_MERGEABLE         12
+#endif
+
+#ifndef MADV_UNMERGEABLE
+# define MADV_UNMERGEABLE       13
+#endif
+
+static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
+                                         unsigned long arg,
+                                         u8 arg_idx __maybe_unused,
+                                         u8 *arg_mask __maybe_unused)
+{
+        return scnprintf(bf, size, "%#lx", arg);
+}
+
+#define SCA_HEX syscall_arg__scnprintf_hex
+
+static size_t syscall_arg__scnprintf_whence(char *bf, size_t size,
+                                            unsigned long arg,
+                                            u8 arg_idx __maybe_unused,
+                                            u8 *arg_mask __maybe_unused)
+{
+        int whence = arg;
+
+        switch (whence) {
+#define P_WHENCE(n) case SEEK_##n: return scnprintf(bf, size, #n)
+        P_WHENCE(SET);
+        P_WHENCE(CUR);
+        P_WHENCE(END);
+#ifdef SEEK_DATA
+        P_WHENCE(DATA);
+#endif
+#ifdef SEEK_HOLE
+        P_WHENCE(HOLE);
+#endif
+#undef P_WHENCE
+        default: break;
+        }
+
+        return scnprintf(bf, size, "%#x", whence);
+}
+
+#define SCA_WHENCE syscall_arg__scnprintf_whence
+
+static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
+                                               unsigned long arg,
+                                               u8 arg_idx __maybe_unused,
+                                               u8 *arg_mask __maybe_unused)
+{
+        int printed = 0, prot = arg;
+
+        if (prot == PROT_NONE)
+                return scnprintf(bf, size, "NONE");
+#define P_MMAP_PROT(n) \
+        if (prot & PROT_##n) { \
+                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
+                prot &= ~PROT_##n; \
+        }
+
+        P_MMAP_PROT(EXEC);
+        P_MMAP_PROT(READ);
+        P_MMAP_PROT(WRITE);
+#ifdef PROT_SEM
+        P_MMAP_PROT(SEM);
+#endif
+        P_MMAP_PROT(GROWSDOWN);
+        P_MMAP_PROT(GROWSUP);
+#undef P_MMAP_PROT
+
+        if (prot)
+                printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
+
+        return printed;
+}
+
+#define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
+
+static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
+                                                unsigned long arg, u8 arg_idx __maybe_unused,
+                                                u8 *arg_mask __maybe_unused)
+{
+        int printed = 0, flags = arg;
+
+#define P_MMAP_FLAG(n) \
+        if (flags & MAP_##n) { \
+                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
+                flags &= ~MAP_##n; \
+        }
+
+        P_MMAP_FLAG(SHARED);
+        P_MMAP_FLAG(PRIVATE);
+#ifdef MAP_32BIT
+        P_MMAP_FLAG(32BIT);
+#endif
+        P_MMAP_FLAG(ANONYMOUS);
+        P_MMAP_FLAG(DENYWRITE);
+        P_MMAP_FLAG(EXECUTABLE);
+        P_MMAP_FLAG(FILE);
+        P_MMAP_FLAG(FIXED);
+        P_MMAP_FLAG(GROWSDOWN);
+#ifdef MAP_HUGETLB
+        P_MMAP_FLAG(HUGETLB);
+#endif
+        P_MMAP_FLAG(LOCKED);
+        P_MMAP_FLAG(NONBLOCK);
+        P_MMAP_FLAG(NORESERVE);
+        P_MMAP_FLAG(POPULATE);
+        P_MMAP_FLAG(STACK);
+#ifdef MAP_UNINITIALIZED
+        P_MMAP_FLAG(UNINITIALIZED);
+#endif
+#undef P_MMAP_FLAG
+
+        if (flags)
+                printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
+
+        return printed;
+}
+
+#define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
+
+static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
+                                                      unsigned long arg, u8 arg_idx __maybe_unused,
+                                                      u8 *arg_mask __maybe_unused)
+{
+        int behavior = arg;
+
+        switch (behavior) {
+#define P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
+        P_MADV_BHV(NORMAL);
+        P_MADV_BHV(RANDOM);
+        P_MADV_BHV(SEQUENTIAL);
+        P_MADV_BHV(WILLNEED);
+        P_MADV_BHV(DONTNEED);
+        P_MADV_BHV(REMOVE);
+        P_MADV_BHV(DONTFORK);
+        P_MADV_BHV(DOFORK);
+        P_MADV_BHV(HWPOISON);
+#ifdef MADV_SOFT_OFFLINE
+        P_MADV_BHV(SOFT_OFFLINE);
+#endif
+        P_MADV_BHV(MERGEABLE);
+        P_MADV_BHV(UNMERGEABLE);
+#ifdef MADV_HUGEPAGE
+        P_MADV_BHV(HUGEPAGE);
+#endif
+#ifdef MADV_NOHUGEPAGE
+        P_MADV_BHV(NOHUGEPAGE);
+#endif
+#ifdef MADV_DONTDUMP
+        P_MADV_BHV(DONTDUMP);
+#endif
+#ifdef MADV_DODUMP
+        P_MADV_BHV(DODUMP);
+#endif
+#undef P_MADV_PHV
+        default: break;
+        }
+
+        return scnprintf(bf, size, "%#x", behavior);
+}
+
+#define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
+
+static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, unsigned long arg,
+                                              u8 arg_idx __maybe_unused, u8 *arg_mask)
+{
+        enum syscall_futex_args {
+                SCF_UADDR   = (1 << 0),
+                SCF_OP      = (1 << 1),
+                SCF_VAL     = (1 << 2),
+                SCF_TIMEOUT = (1 << 3),
+                SCF_UADDR2  = (1 << 4),
+                SCF_VAL3    = (1 << 5),
+        };
+        int op = arg;
+        int cmd = op & FUTEX_CMD_MASK;
+        size_t printed = 0;
+
+        switch (cmd) {
+#define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
+        P_FUTEX_OP(WAIT);           *arg_mask |= SCF_VAL3|SCF_UADDR2;             break;
+        P_FUTEX_OP(WAKE);           *arg_mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
+        P_FUTEX_OP(FD);             *arg_mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
+        P_FUTEX_OP(REQUEUE);        *arg_mask |= SCF_VAL3|SCF_TIMEOUT;            break;
+        P_FUTEX_OP(CMP_REQUEUE);    *arg_mask |= SCF_TIMEOUT;                     break;
+        P_FUTEX_OP(CMP_REQUEUE_PI); *arg_mask |= SCF_TIMEOUT;                     break;
+        P_FUTEX_OP(WAKE_OP);                                                      break;
+        P_FUTEX_OP(LOCK_PI);        *arg_mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
+        P_FUTEX_OP(UNLOCK_PI);      *arg_mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
+        P_FUTEX_OP(TRYLOCK_PI);     *arg_mask |= SCF_VAL3|SCF_UADDR2;             break;
+        P_FUTEX_OP(WAIT_BITSET);    *arg_mask |= SCF_UADDR2;                      break;
+        P_FUTEX_OP(WAKE_BITSET);    *arg_mask |= SCF_UADDR2;                      break;
+        P_FUTEX_OP(WAIT_REQUEUE_PI);                                              break;
+        default: printed = scnprintf(bf, size, "%#x", cmd);                       break;
+        }
+
+        if (op & FUTEX_PRIVATE_FLAG)
+                printed += scnprintf(bf + printed, size - printed, "|PRIV");
+
+        if (op & FUTEX_CLOCK_REALTIME)
+                printed += scnprintf(bf + printed, size - printed, "|CLKRT");
+
+        return printed;
+}
+
+#define SCA_FUTEX_OP  syscall_arg__scnprintf_futex_op
+
+static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
+                                               unsigned long arg,
+                                               u8 arg_idx, u8 *arg_mask)
+{
+        int printed = 0, flags = arg;
+
+        if (!(flags & O_CREAT))
+                *arg_mask |= 1 << (arg_idx + 1); /* Mask the mode parm */
+
+        if (flags == 0)
+                return scnprintf(bf, size, "RDONLY");
+#define P_FLAG(n) \
+        if (flags & O_##n) { \
+                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
+                flags &= ~O_##n; \
+        }
+
+        P_FLAG(APPEND);
+        P_FLAG(ASYNC);
+        P_FLAG(CLOEXEC);
+        P_FLAG(CREAT);
+        P_FLAG(DIRECT);
+        P_FLAG(DIRECTORY);
+        P_FLAG(EXCL);
+        P_FLAG(LARGEFILE);
+        P_FLAG(NOATIME);
+        P_FLAG(NOCTTY);
+#ifdef O_NONBLOCK
+        P_FLAG(NONBLOCK);
+#elif O_NDELAY
+        P_FLAG(NDELAY);
+#endif
+#ifdef O_PATH
+        P_FLAG(PATH);
+#endif
+        P_FLAG(RDWR);
+#ifdef O_DSYNC
+        if ((flags & O_SYNC) == O_SYNC)
+                printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
+        else {
+                P_FLAG(DSYNC);
+        }
+#else
+        P_FLAG(SYNC);
+#endif
+        P_FLAG(TRUNC);
+        P_FLAG(WRONLY);
+#undef P_FLAG
+
+        if (flags)
+                printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
+
+        return printed;
+}
+
+#define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
 
 static struct syscall_fmt {
         const char *name;
         const char *alias;
+        size_t     (*arg_scnprintf[6])(char *bf, size_t size, unsigned long arg, u8 arg_idx, u8 *arg_mask);
         bool       errmsg;
         bool       timeout;
+        bool       hexret;
 } syscall_fmts[] = {
         { .name     = "access",     .errmsg = true, },
         { .name     = "arch_prctl", .errmsg = true, .alias = "prctl", },
+        { .name     = "brk",        .hexret = true,
+          .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
+        { .name     = "mmap",       .hexret = true, },
+        { .name     = "connect",    .errmsg = true, },
         { .name     = "fstat",      .errmsg = true, .alias = "newfstat", },
         { .name     = "fstatat",    .errmsg = true, .alias = "newfstatat", },
-        { .name     = "futex",      .errmsg = true, },
-        { .name     = "open",       .errmsg = true, },
+        { .name     = "futex",      .errmsg = true,
+          .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
+        { .name     = "ioctl",      .errmsg = true,
+          .arg_scnprintf = { [2] = SCA_HEX, /* arg */ }, },
+        { .name     = "lseek",      .errmsg = true,
+          .arg_scnprintf = { [2] = SCA_WHENCE, /* whence */ }, },
+        { .name     = "lstat",      .errmsg = true, .alias = "newlstat", },
+        { .name     = "madvise",    .errmsg = true,
+          .arg_scnprintf = { [0] = SCA_HEX,      /* start */
+                             [2] = SCA_MADV_BHV, /* behavior */ }, },
+        { .name     = "mmap",       .hexret = true,
+          .arg_scnprintf = { [0] = SCA_HEX,       /* addr */
+                             [2] = SCA_MMAP_PROT, /* prot */
+                             [3] = SCA_MMAP_FLAGS, /* flags */ }, },
+        { .name     = "mprotect",   .errmsg = true,
+          .arg_scnprintf = { [0] = SCA_HEX, /* start */
+                             [2] = SCA_MMAP_PROT, /* prot */ }, },
+        { .name     = "mremap",     .hexret = true,
+          .arg_scnprintf = { [0] = SCA_HEX, /* addr */
+                             [4] = SCA_HEX, /* new_addr */ }, },
+        { .name     = "munmap",     .errmsg = true,
+          .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
+        { .name     = "open",       .errmsg = true,
+          .arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
+        { .name     = "open_by_handle_at", .errmsg = true,
+          .arg_scnprintf = { [2] = SCA_OPEN_FLAGS, /* flags */ }, },
+        { .name     = "openat",     .errmsg = true,
+          .arg_scnprintf = { [2] = SCA_OPEN_FLAGS, /* flags */ }, },
         { .name     = "poll",       .errmsg = true, .timeout = true, },
         { .name     = "ppoll",      .errmsg = true, .timeout = true, },
+        { .name     = "pread",      .errmsg = true, .alias = "pread64", },
+        { .name     = "pwrite",     .errmsg = true, .alias = "pwrite64", },
         { .name     = "read",       .errmsg = true, },
         { .name     = "recvfrom",   .errmsg = true, },
         { .name     = "select",     .errmsg = true, .timeout = true, },
         { .name     = "socket",     .errmsg = true, },
         { .name     = "stat",       .errmsg = true, .alias = "newstat", },
+        { .name     = "uname",      .errmsg = true, .alias = "newuname", },
 };
 
 static int syscall_fmt__cmp(const void *name, const void *fmtp)
@@ -46,7 +362,10 @@ static struct syscall_fmt *syscall_fmt__find(const char *name)
 struct syscall {
         struct event_format *tp_format;
         const char          *name;
+        bool                filtered;
         struct syscall_fmt  *fmt;
+        size_t              (**arg_scnprintf)(char *bf, size_t size,
+                                              unsigned long arg, u8 arg_idx, u8 *args_mask);
 };
 
 static size_t fprintf_duration(unsigned long t, FILE *fp)
@@ -60,7 +379,7 @@ static size_t fprintf_duration(unsigned long t, FILE *fp)
                 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
         else
                 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
-        return printed + fprintf(stdout, "): ");
+        return printed + fprintf(fp, "): ");
 }
 
 struct thread_trace {
@@ -77,7 +396,7 @@ static struct thread_trace *thread_trace__new(void)
         return zalloc(sizeof(struct thread_trace));
 }
 
-static struct thread_trace *thread__trace(struct thread *thread)
+static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
 {
         struct thread_trace *ttrace;
 
@@ -95,12 +414,13 @@ static struct thread_trace *thread__trace(struct thread *thread)
 
         return ttrace;
 fail:
-        color_fprintf(stdout, PERF_COLOR_RED,
+        color_fprintf(fp, PERF_COLOR_RED,
                       "WARNING: not enough memory, dropping samples!\n");
         return NULL;
 }
 
 struct trace {
+        struct perf_tool        tool;
         int                     audit_machine;
         struct {
                 int             max;
@@ -109,7 +429,12 @@ struct trace {
         struct perf_record_opts opts;
         struct machine          host;
         u64                     base_time;
+        FILE                    *output;
         unsigned long           nr_events;
+        struct strlist          *ev_qualifier;
+        bool                    not_ev_qualifier;
+        struct intlist          *tid_list;
+        struct intlist          *pid_list;
         bool                    sched;
         bool                    multiple_threads;
         double                  duration_filter;
@@ -142,18 +467,19 @@ static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thre
         printed += fprintf_duration(duration, fp);
 
         if (trace->multiple_threads)
-                printed += fprintf(fp, "%d ", thread->pid);
+                printed += fprintf(fp, "%d ", thread->tid);
 
         return printed;
 }
 
-static int trace__process_event(struct machine *machine, union perf_event *event)
+static int trace__process_event(struct trace *trace, struct machine *machine,
+                                union perf_event *event)
 {
         int ret = 0;
 
         switch (event->header.type) {
         case PERF_RECORD_LOST:
-                color_fprintf(stdout, PERF_COLOR_RED,
+                color_fprintf(trace->output, PERF_COLOR_RED,
                               "LOST %" PRIu64 " events!\n", event->lost.lost);
                 ret = machine__process_lost_event(machine, event);
         default:
@@ -164,12 +490,13 @@ static int trace__process_event(struct machine *machine, union perf_event *event
         return ret;
 }
 
-static int trace__tool_process(struct perf_tool *tool __maybe_unused,
+static int trace__tool_process(struct perf_tool *tool,
                                union perf_event *event,
                                struct perf_sample *sample __maybe_unused,
                                struct machine *machine)
 {
-        return trace__process_event(machine, event);
+        struct trace *trace = container_of(tool, struct trace, tool);
+        return trace__process_event(trace, machine, event);
 }
 
 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
@@ -183,11 +510,11 @@ static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
         machine__create_kernel_maps(&trace->host);
 
         if (perf_target__has_task(&trace->opts.target)) {
-                err = perf_event__synthesize_thread_map(NULL, evlist->threads,
+                err = perf_event__synthesize_thread_map(&trace->tool, evlist->threads,
                                                         trace__tool_process,
                                                         &trace->host);
         } else {
-                err = perf_event__synthesize_threads(NULL, trace__tool_process,
+                err = perf_event__synthesize_threads(&trace->tool, trace__tool_process,
                                                      &trace->host);
         }
 
@@ -197,6 +524,26 @@ static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
         return err;
 }
 
+static int syscall__set_arg_fmts(struct syscall *sc)
+{
+        struct format_field *field;
+        int idx = 0;
+
+        sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
+        if (sc->arg_scnprintf == NULL)
+                return -1;
+
+        for (field = sc->tp_format->format.fields->next; field; field = field->next) {
+                if (sc->fmt && sc->fmt->arg_scnprintf[idx])
+                        sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
+                else if (field->flags & FIELD_IS_POINTER)
+                        sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
+                ++idx;
+        }
+
+        return 0;
+}
+
 static int trace__read_syscall_info(struct trace *trace, int id)
 {
         char tp_name[128];
@@ -225,6 +572,20 @@ static int trace__read_syscall_info(struct trace *trace, int id)
 
         sc = trace->syscalls.table + id;
         sc->name = name;
+
+        if (trace->ev_qualifier) {
+                bool in = strlist__find(trace->ev_qualifier, name) != NULL;
+
+                if (!(in ^ trace->not_ev_qualifier)) {
+                        sc->filtered = true;
+                        /*
+                         * No need to do read tracepoint information since this will be
+                         * filtered out.
+                         */
+                        return 0;
+                }
+        }
+
         sc->fmt  = syscall_fmt__find(sc->name);
 
         snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
@@ -235,7 +596,10 @@ static int trace__read_syscall_info(struct trace *trace, int id)
                 sc->tp_format = event_format__new("syscalls", tp_name);
         }
 
-        return sc->tp_format != NULL ? 0 : -1;
+        if (sc->tp_format == NULL)
+                return -1;
+
+        return syscall__set_arg_fmts(sc);
 }
 
 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
@@ -246,11 +610,23 @@ static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
 
         if (sc->tp_format != NULL) {
                 struct format_field *field;
+                u8 mask = 0, bit = 1;
+
+                for (field = sc->tp_format->format.fields->next; field;
+                     field = field->next, ++i, bit <<= 1) {
+                        if (mask & bit)
+                                continue;
 
-                for (field = sc->tp_format->format.fields->next; field; field = field->next) {
                         printed += scnprintf(bf + printed, size - printed,
-                                             "%s%s: %ld", printed ? ", " : "",
-                                             field->name, args[i++]);
+                                             "%s%s: ", printed ? ", " : "", field->name);
+
+                        if (sc->arg_scnprintf && sc->arg_scnprintf[i]) {
+                                printed += sc->arg_scnprintf[i](bf + printed, size - printed,
+                                                                args[i], i, &mask);
+                        } else {
+                                printed += scnprintf(bf + printed, size - printed,
+                                                     "%ld", args[i]);
+                        }
                 }
         } else {
                 while (i < 6) {
@@ -274,7 +650,22 @@ static struct syscall *trace__syscall_info(struct trace *trace,
         int id = perf_evsel__intval(evsel, sample, "id");
 
         if (id < 0) {
-                printf("Invalid syscall %d id, skipping...\n", id);
+
+                /*
+                 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
+                 * before that, leaving at a higher verbosity level till that is
+                 * explained. Reproduced with plain ftrace with:
+                 *
+                 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
+                 * grep "NR -1 " /t/trace_pipe
+                 *
+                 * After generating some load on the machine.
+                 */
+                if (verbose > 1) {
+                        static u64 n;
+                        fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
+                                id, perf_evsel__name(evsel), ++n);
+                }
                 return NULL;
         }
 
@@ -288,10 +679,12 @@ static struct syscall *trace__syscall_info(struct trace *trace,
         return &trace->syscalls.table[id];
 
 out_cant_read:
-        printf("Problems reading syscall %d", id);
-        if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
-                printf("(%s)", trace->syscalls.table[id].name);
-        puts(" information");
+        if (verbose) {
+                fprintf(trace->output, "Problems reading syscall %d", id);
+                if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
+                        fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
+                fputs(" information\n", trace->output);
+        }
         return NULL;
 }
 
@@ -301,16 +694,25 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
         char *msg;
         void *args;
         size_t printed = 0;
-        struct thread *thread = machine__findnew_thread(&trace->host, sample->tid);
+        struct thread *thread;
         struct syscall *sc = trace__syscall_info(trace, evsel, sample);
-        struct thread_trace *ttrace = thread__trace(thread);
+        struct thread_trace *ttrace;
 
-        if (ttrace == NULL || sc == NULL)
+        if (sc == NULL)
+                return -1;
+
+        if (sc->filtered)
+                return 0;
+
+        thread = machine__findnew_thread(&trace->host, sample->pid,
+                                         sample->tid);
+        ttrace = thread__trace(thread, trace->output);
+        if (ttrace == NULL)
                 return -1;
 
         args = perf_evsel__rawptr(evsel, sample, "args");
         if (args == NULL) {
-                printf("Problems reading syscall arguments\n");
+                fprintf(trace->output, "Problems reading syscall arguments\n");
                 return -1;
         }
 
@@ -330,8 +732,8 @@ static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
 
         if (!strcmp(sc->name, "exit_group") || !strcmp(sc->name, "exit")) {
                 if (!trace->duration_filter) {
-                        trace__fprintf_entry_head(trace, thread, 1, sample->time, stdout);
-                        printf("%-70s\n", ttrace->entry_str);
+                        trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
+                        fprintf(trace->output, "%-70s\n", ttrace->entry_str);
                 }
         } else
                 ttrace->entry_pending = true;
@@ -344,11 +746,20 @@ static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
 {
         int ret;
         u64 duration = 0;
-        struct thread *thread = machine__findnew_thread(&trace->host, sample->tid);
-        struct thread_trace *ttrace = thread__trace(thread);
+        struct thread *thread;
         struct syscall *sc = trace__syscall_info(trace, evsel, sample);
+        struct thread_trace *ttrace;
 
-        if (ttrace == NULL || sc == NULL)
+        if (sc == NULL)
+                return -1;
+
+        if (sc->filtered)
+                return 0;
+
+        thread = machine__findnew_thread(&trace->host, sample->pid,
+                                         sample->tid);
+        ttrace = thread__trace(thread, trace->output);
+        if (ttrace == NULL)
                 return -1;
 
         ret = perf_evsel__intval(evsel, sample, "ret");
@@ -364,28 +775,33 @@ static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
         } else if (trace->duration_filter)
                 goto out;
 
-        trace__fprintf_entry_head(trace, thread, duration, sample->time, stdout);
+        trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
 
         if (ttrace->entry_pending) {
-                printf("%-70s", ttrace->entry_str);
+                fprintf(trace->output, "%-70s", ttrace->entry_str);
         } else {
-                printf(" ... [");
-                color_fprintf(stdout, PERF_COLOR_YELLOW, "continued");
-                printf("]: %s()", sc->name);
+                fprintf(trace->output, " ... [");
+                color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
+                fprintf(trace->output, "]: %s()", sc->name);
         }
 
-        if (ret < 0 && sc->fmt && sc->fmt->errmsg) {
+        if (sc->fmt == NULL) {
+signed_print:
+                fprintf(trace->output, ") = %d", ret);
+        } else if (ret < 0 && sc->fmt->errmsg) {
                 char bf[256];
                 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
                            *e = audit_errno_to_name(-ret);
 
-                printf(") = -1 %s %s", e, emsg);
-        } else if (ret == 0 && sc->fmt && sc->fmt->timeout)
-                printf(") = 0 Timeout");
+                fprintf(trace->output, ") = -1 %s %s", e, emsg);
+        } else if (ret == 0 && sc->fmt->timeout)
+                fprintf(trace->output, ") = 0 Timeout");
+        else if (sc->fmt->hexret)
+                fprintf(trace->output, ") = %#x", ret);
         else
-                printf(") = %d", ret);
+                goto signed_print;
 
-        putchar('\n');
+        fputc('\n', trace->output);
 out:
         ttrace->entry_pending = false;
 
@@ -397,8 +813,10 @@ static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evs
 {
         u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
         double runtime_ms = (double)runtime / NSEC_PER_MSEC;
-        struct thread *thread = machine__findnew_thread(&trace->host, sample->tid);
-        struct thread_trace *ttrace = thread__trace(thread);
+        struct thread *thread = machine__findnew_thread(&trace->host,
+                                                        sample->pid,
+                                                        sample->tid);
+        struct thread_trace *ttrace = thread__trace(thread, trace->output);
 
         if (ttrace == NULL)
                 goto out_dump;
@@ -408,7 +826,7 @@ static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evs
         return 0;
 
 out_dump:
-        printf("%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
+        fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
                evsel->name,
                perf_evsel__strval(evsel, sample, "comm"),
                (pid_t)perf_evsel__intval(evsel, sample, "pid"),
@@ -417,6 +835,72 @@ out_dump:
         return 0;
 }
 
+static bool skip_sample(struct trace *trace, struct perf_sample *sample)
+{
+        if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
+            (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
+                return false;
+
+        if (trace->pid_list || trace->tid_list)
+                return true;
+
+        return false;
+}
+
+static int trace__process_sample(struct perf_tool *tool,
+                                 union perf_event *event __maybe_unused,
+                                 struct perf_sample *sample,
+                                 struct perf_evsel *evsel,
+                                 struct machine *machine __maybe_unused)
+{
+        struct trace *trace = container_of(tool, struct trace, tool);
+        int err = 0;
+
+        tracepoint_handler handler = evsel->handler.func;
+
+        if (skip_sample(trace, sample))
+                return 0;
+
+        if (trace->base_time == 0)
+                trace->base_time = sample->time;
+
+        if (handler)
+                handler(trace, evsel, sample);
+
+        return err;
+}
+
+static bool
+perf_session__has_tp(struct perf_session *session, const char *name)
+{
+        struct perf_evsel *evsel;
+
+        evsel = perf_evlist__find_tracepoint_by_name(session->evlist, name);
+
+        return evsel != NULL;
+}
+
+static int parse_target_str(struct trace *trace)
+{
+        if (trace->opts.target.pid) {
+                trace->pid_list = intlist__new(trace->opts.target.pid);
+                if (trace->pid_list == NULL) {
+                        pr_err("Error parsing process id string\n");
+                        return -EINVAL;
+                }
+        }
+
+        if (trace->opts.target.tid) {
+                trace->tid_list = intlist__new(trace->opts.target.tid);
+                if (trace->tid_list == NULL) {
+                        pr_err("Error parsing thread id string\n");
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
+
 static int trace__run(struct trace *trace, int argc, const char **argv)
 {
         struct perf_evlist *evlist = perf_evlist__new();
@@ -426,32 +910,32 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
         const bool forks = argc > 0;
 
         if (evlist == NULL) {
-                printf("Not enough memory to run!\n");
+                fprintf(trace->output, "Not enough memory to run!\n");
                 goto out;
         }
 
         if (perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_enter", trace__sys_enter) ||
             perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_exit", trace__sys_exit)) {
-                printf("Couldn't read the raw_syscalls tracepoints information!\n");
+                fprintf(trace->output, "Couldn't read the raw_syscalls tracepoints information!\n");
                 goto out_delete_evlist;
         }
 
         if (trace->sched &&
             perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
                                    trace__sched_stat_runtime)) {
-                printf("Couldn't read the sched_stat_runtime tracepoint information!\n");
+                fprintf(trace->output, "Couldn't read the sched_stat_runtime tracepoint information!\n");
                 goto out_delete_evlist;
         }
 
         err = perf_evlist__create_maps(evlist, &trace->opts.target);
         if (err < 0) {
-                printf("Problems parsing the target to trace, check your options!\n");
+                fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
                 goto out_delete_evlist;
         }
 
         err = trace__symbols_init(trace, evlist);
         if (err < 0) {
-                printf("Problems initializing symbol libraries!\n");
+                fprintf(trace->output, "Problems initializing symbol libraries!\n");
                 goto out_delete_maps;
         }
 
@@ -464,20 +948,20 @@ static int trace__run(struct trace *trace, int argc, const char **argv)
                 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
                                                     argv, false, false);
                 if (err < 0) {
-                        printf("Couldn't run the workload!\n");
+                        fprintf(trace->output, "Couldn't run the workload!\n");
                         goto out_delete_maps;
                 }
         }
 
         err = perf_evlist__open(evlist);
         if (err < 0) {
-                printf("Couldn't create the events: %s\n", strerror(errno));
+                fprintf(trace->output, "Couldn't create the events: %s\n", strerror(errno));
                 goto out_delete_maps;
         }
 
         err = perf_evlist__mmap(evlist, UINT_MAX, false);
         if (err < 0) {
-                printf("Couldn't mmap the events: %s\n", strerror(errno));
+                fprintf(trace->output, "Couldn't mmap the events: %s\n", strerror(errno));
                 goto out_close_evlist;
         }
 
@@ -502,7 +986,7 @@ again:
 
                         err = perf_evlist__parse_sample(evlist, event, &sample);
                         if (err) {
-                                printf("Can't parse sample, err = %d, skipping...\n", err);
+                                fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
                                 continue;
                         }
 
@@ -510,18 +994,18 @@ again:
                                 trace->base_time = sample.time;
 
                         if (type != PERF_RECORD_SAMPLE) {
-                                trace__process_event(&trace->host, event);
+                                trace__process_event(trace, &trace->host, event);
                                 continue;
                         }
 
                         evsel = perf_evlist__id2evsel(evlist, sample.id);
                         if (evsel == NULL) {
-                                printf("Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
+                                fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
                                 continue;
                         }
 
                         if (sample.raw_data == NULL) {
-                                printf("%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
+                                fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
                                        perf_evsel__name(evsel), sample.tid,
                                        sample.cpu, sample.raw_size);
                                 continue;
@@ -529,6 +1013,9 @@ again:
 
                         handler = evsel->handler.func;
                         handler(trace, evsel, &sample);
+
+                        if (done)
+                                goto out_unmap_evlist;
                 }
         }
 
@@ -556,6 +1043,70 @@ out:
         return err;
 }
 
+static int trace__replay(struct trace *trace)
+{
+        const struct perf_evsel_str_handler handlers[] = {
+                { "raw_syscalls:sys_enter",  trace__sys_enter, },
+                { "raw_syscalls:sys_exit",   trace__sys_exit, },
+        };
+
+        struct perf_session *session;
+        int err = -1;
+
+        trace->tool.sample        = trace__process_sample;
+        trace->tool.mmap          = perf_event__process_mmap;
+        trace->tool.mmap2         = perf_event__process_mmap2;
+        trace->tool.comm          = perf_event__process_comm;
+        trace->tool.exit          = perf_event__process_exit;
+        trace->tool.fork          = perf_event__process_fork;
+        trace->tool.attr          = perf_event__process_attr;
+        trace->tool.tracing_data = perf_event__process_tracing_data;
+        trace->tool.build_id      = perf_event__process_build_id;
+
+        trace->tool.ordered_samples = true;
+        trace->tool.ordering_requires_timestamps = true;
+
+        /* add tid to output */
+        trace->multiple_threads = true;
+
+        if (symbol__init() < 0)
+                return -1;
+
+        session = perf_session__new(input_name, O_RDONLY, 0, false,
+                                    &trace->tool);
+        if (session == NULL)
+                return -ENOMEM;
+
+        err = perf_session__set_tracepoints_handlers(session, handlers);
+        if (err)
+                goto out;
+
+        if (!perf_session__has_tp(session, "raw_syscalls:sys_enter")) {
+                pr_err("Data file does not have raw_syscalls:sys_enter events\n");
+                goto out;
+        }
+
+        if (!perf_session__has_tp(session, "raw_syscalls:sys_exit")) {
+                pr_err("Data file does not have raw_syscalls:sys_exit events\n");
+                goto out;
+        }
+
+        err = parse_target_str(trace);
+        if (err != 0)
+                goto out;
+
+        setup_pager();
+
+        err = perf_session__process_events(session, &trace->tool);
+        if (err)
+                pr_err("Failed to process events, error %d", err);
+
+out:
+        perf_session__delete(session);
+
+        return err;
+}
+
 static size_t trace__fprintf_threads_header(FILE *fp)
 {
         size_t printed;
@@ -593,7 +1144,7 @@ static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
                         color = PERF_COLOR_YELLOW;
 
                 printed += color_fprintf(fp, color, "%20s", thread->comm);
-                printed += fprintf(fp, " - %-5d :%11lu   [", thread->pid, ttrace->nr_events);
+                printed += fprintf(fp, " - %-5d :%11lu   [", thread->tid, ttrace->nr_events);
                 printed += color_fprintf(fp, color, "%5.1f%%", ratio);
                 printed += fprintf(fp, " ] %10.3f ms\n", ttrace->runtime_ms);
         }
@@ -610,6 +1161,23 @@ static int trace__set_duration(const struct option *opt, const char *str,
         return 0;
 }
 
+static int trace__open_output(struct trace *trace, const char *filename)
+{
+        struct stat st;
+
+        if (!stat(filename, &st) && st.st_size) {
+                char oldname[PATH_MAX];
+
+                scnprintf(oldname, sizeof(oldname), "%s.old", filename);
+                unlink(oldname);
+                rename(filename, oldname);
+        }
+
+        trace->output = fopen(filename, "w");
+
+        return trace->output == NULL ? -errno : 0;
+}
+
 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
 {
         const char * const trace_usage[] = {
@@ -632,26 +1200,34 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
                         .no_delay      = true,
                         .mmap_pages    = 1024,
                 },
+                .output = stdout,
         };
+        const char *output_name = NULL;
+        const char *ev_qualifier_str = NULL;
         const struct option trace_options[] = {
+        OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
+                    "list of events to trace"),
+        OPT_STRING('o', "output", &output_name, "file", "output file name"),
+        OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
         OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
                     "trace events on existing process id"),
-        OPT_STRING(0, "tid", &trace.opts.target.tid, "tid",
+        OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
                     "trace events on existing thread id"),
-        OPT_BOOLEAN(0, "all-cpus", &trace.opts.target.system_wide,
+        OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
                     "system-wide collection from all CPUs"),
-        OPT_STRING(0, "cpu", &trace.opts.target.cpu_list, "cpu",
+        OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
                     "list of cpus to monitor"),
         OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
                     "child tasks do not inherit counters"),
-        OPT_UINTEGER(0, "mmap-pages", &trace.opts.mmap_pages,
+        OPT_UINTEGER('m', "mmap-pages", &trace.opts.mmap_pages,
                      "number of mmap data pages"),
-        OPT_STRING(0, "uid", &trace.opts.target.uid_str, "user",
+        OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
                    "user to profile"),
         OPT_CALLBACK(0, "duration", &trace, "float",
                      "show only events with duration > N.M ms",
                      trace__set_duration),
         OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
+        OPT_INCR('v', "verbose", &verbose, "be more verbose"),
         OPT_END()
         };
         int err;
@@ -659,27 +1235,57 @@ int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
 
         argc = parse_options(argc, argv, trace_options, trace_usage, 0);
 
+        if (output_name != NULL) {
+                err = trace__open_output(&trace, output_name);
+                if (err < 0) {
+                        perror("failed to create output file");
+                        goto out;
+                }
+        }
+
+        if (ev_qualifier_str != NULL) {
+                const char *s = ev_qualifier_str;
+
+                trace.not_ev_qualifier = *s == '!';
+                if (trace.not_ev_qualifier)
+                        ++s;
+                trace.ev_qualifier = strlist__new(true, s);
+                if (trace.ev_qualifier == NULL) {
+                        fputs("Not enough memory to parse event qualifier",
+                              trace.output);
+                        err = -ENOMEM;
+                        goto out_close;
+                }
+        }
+
         err = perf_target__validate(&trace.opts.target);
         if (err) {
                 perf_target__strerror(&trace.opts.target, err, bf, sizeof(bf));
-                printf("%s", bf);
-                return err;
+                fprintf(trace.output, "%s", bf);
+                goto out_close;
         }
 
         err = perf_target__parse_uid(&trace.opts.target);
         if (err) {
                 perf_target__strerror(&trace.opts.target, err, bf, sizeof(bf));
-                printf("%s", bf);
-                return err;
+                fprintf(trace.output, "%s", bf);
+                goto out_close;
         }
 
         if (!argc && perf_target__none(&trace.opts.target))
                 trace.opts.target.system_wide = true;
 
-        err = trace__run(&trace, argc, argv);
+        if (input_name)
+                err = trace__replay(&trace);
+        else
+                err = trace__run(&trace, argc, argv);
 
         if (trace.sched && !err)
-                trace__fprintf_thread_summary(&trace, stdout);
+                trace__fprintf_thread_summary(&trace, trace.output);
 
+out_close:
+        if (output_name != NULL)
+                fclose(trace.output);
+out:
         return err;
 }
diff --git a/tools/perf/config/Makefile b/tools/perf/config/Makefile
new file mode 100644
index 000000000000..5f6f9b3271bb
--- /dev/null
+++ b/tools/perf/config/Makefile
@@ -0,0 +1,481 @@
+uname_M := $(shell uname -m 2>/dev/null || echo not)
+
+ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
+                                  -e s/arm.*/arm/ -e s/sa110/arm/ \
+                                  -e s/s390x/s390/ -e s/parisc64/parisc/ \
+                                  -e s/ppc.*/powerpc/ -e s/mips.*/mips/ \
+                                  -e s/sh[234].*/sh/ -e s/aarch64.*/arm64/ )
+NO_PERF_REGS := 1
+CFLAGS := $(EXTRA_CFLAGS) $(EXTRA_WARNINGS)
+
+# Additional ARCH settings for x86
+ifeq ($(ARCH),i386)
+  override ARCH := x86
+  NO_PERF_REGS := 0
+  LIBUNWIND_LIBS = -lunwind -lunwind-x86
+endif
+
+ifeq ($(ARCH),x86_64)
+  override ARCH := x86
+  IS_X86_64 := 0
+  ifeq (, $(findstring m32,$(CFLAGS)))
+    IS_X86_64 := $(shell echo __x86_64__ | ${CC} -E -x c - | tail -n 1)
+  endif
+  ifeq (${IS_X86_64}, 1)
+    RAW_ARCH := x86_64
+    CFLAGS += -DARCH_X86_64
+    ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S ../../arch/x86/lib/memset_64.S
+  endif
+  NO_PERF_REGS := 0
+  LIBUNWIND_LIBS = -lunwind -lunwind-x86_64
+endif
+
+ifeq ($(NO_PERF_REGS),0)
+  CFLAGS += -DHAVE_PERF_REGS
+endif
+
+ifeq ($(src-perf),)
+src-perf := $(srctree)/tools/perf
+endif
+
+ifeq ($(obj-perf),)
+obj-perf := $(OUTPUT)
+endif
+
+ifneq ($(obj-perf),)
+obj-perf := $(abspath $(obj-perf))/
+endif
+
+LIB_INCLUDE := $(srctree)/tools/lib/
+
+# include ARCH specific config
+-include $(src-perf)/arch/$(ARCH)/Makefile
+
+include $(src-perf)/config/feature-tests.mak
+include $(src-perf)/config/utilities.mak
+
+ifeq ($(call get-executable,$(FLEX)),)
+  dummy := $(error Error: $(FLEX) is missing on this system, please install it)
+endif
+
+ifeq ($(call get-executable,$(BISON)),)
+  dummy := $(error Error: $(BISON) is missing on this system, please install it)
+endif
+
+# Treat warnings as errors unless directed not to
+ifneq ($(WERROR),0)
+  CFLAGS += -Werror
+endif
+
+ifeq ("$(origin DEBUG)", "command line")
+  PERF_DEBUG = $(DEBUG)
+endif
+ifndef PERF_DEBUG
+  CFLAGS += -O6
+endif
+
+ifdef PARSER_DEBUG
+  PARSER_DEBUG_BISON := -t
+  PARSER_DEBUG_FLEX  := -d
+  CFLAGS             += -DPARSER_DEBUG
+endif
+
+CFLAGS += -fno-omit-frame-pointer
+CFLAGS += -ggdb3
+CFLAGS += -funwind-tables
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -std=gnu99
+
+EXTLIBS = -lelf -lpthread -lrt -lm -ldl
+
+ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -fstack-protector-all,-fstack-protector-all),y)
+  CFLAGS += -fstack-protector-all
+endif
+
+ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -Wstack-protector,-Wstack-protector),y)
+  CFLAGS += -Wstack-protector
+endif
+
+ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -Wvolatile-register-var,-Wvolatile-register-var),y)
+  CFLAGS += -Wvolatile-register-var
+endif
+
+ifndef PERF_DEBUG
+  ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -D_FORTIFY_SOURCE=2,-D_FORTIFY_SOURCE=2),y)
+    CFLAGS += -D_FORTIFY_SOURCE=2
+  endif
+endif
+
+CFLAGS += -I$(src-perf)/util/include
+CFLAGS += -I$(src-perf)/arch/$(ARCH)/include
+CFLAGS += -I$(srctree)/arch/$(ARCH)/include/uapi
+CFLAGS += -I$(srctree)/arch/$(ARCH)/include
+CFLAGS += -I$(srctree)/include/uapi
+CFLAGS += -I$(srctree)/include
+
+# $(obj-perf)      for generated common-cmds.h
+# $(obj-perf)/util for generated bison/flex headers
+ifneq ($(OUTPUT),)
+CFLAGS += -I$(obj-perf)/util
+CFLAGS += -I$(obj-perf)
+endif
+
+CFLAGS += -I$(src-perf)/util
+CFLAGS += -I$(src-perf)
+CFLAGS += -I$(LIB_INCLUDE)
+
+CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
+
+ifndef NO_BIONIC
+ifeq ($(call try-cc,$(SOURCE_BIONIC),$(CFLAGS),bionic),y)
+  BIONIC := 1
+  EXTLIBS := $(filter-out -lrt,$(EXTLIBS))
+  EXTLIBS := $(filter-out -lpthread,$(EXTLIBS))
+endif
+endif # NO_BIONIC
+
+ifdef NO_LIBELF
+  NO_DWARF := 1
+  NO_DEMANGLE := 1
+  NO_LIBUNWIND := 1
+else
+FLAGS_LIBELF=$(CFLAGS) $(LDFLAGS) $(EXTLIBS)
+ifneq ($(call try-cc,$(SOURCE_LIBELF),$(FLAGS_LIBELF),libelf),y)
+  FLAGS_GLIBC=$(CFLAGS) $(LDFLAGS)
+  ifeq ($(call try-cc,$(SOURCE_GLIBC),$(FLAGS_GLIBC),glibc),y)
+    LIBC_SUPPORT := 1
+  endif
+  ifeq ($(BIONIC),1)
+    LIBC_SUPPORT := 1
+  endif
+  ifeq ($(LIBC_SUPPORT),1)
+    msg := $(warning No libelf found, disables 'probe' tool, please install elfutils-libelf-devel/libelf-dev);
+
+    NO_LIBELF := 1
+    NO_DWARF := 1
+    NO_DEMANGLE := 1
+  else
+    msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]/glibc-static);
+  endif
+else
+  # for linking with debug library, run like:
+  # make DEBUG=1 LIBDW_DIR=/opt/libdw/
+  ifdef LIBDW_DIR
+    LIBDW_CFLAGS  := -I$(LIBDW_DIR)/include
+    LIBDW_LDFLAGS := -L$(LIBDW_DIR)/lib
+  endif
+
+  FLAGS_DWARF=$(CFLAGS) $(LIBDW_CFLAGS) -ldw -lz -lelf $(LIBDW_LDFLAGS) $(LDFLAGS) $(EXTLIBS)
+  ifneq ($(call try-cc,$(SOURCE_DWARF),$(FLAGS_DWARF),libdw),y)
+    msg := $(warning No libdw.h found or old libdw.h found or elfutils is older than 0.138, disables dwarf support. Please install new elfutils-devel/libdw-dev);
+    NO_DWARF := 1
+  endif # Dwarf support
+endif # SOURCE_LIBELF
+endif # NO_LIBELF
+
+ifndef NO_LIBELF
+CFLAGS += -DLIBELF_SUPPORT
+FLAGS_LIBELF=$(CFLAGS) $(LDFLAGS) $(EXTLIBS)
+ifeq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_LIBELF),-DLIBELF_MMAP),y)
+  CFLAGS += -DLIBELF_MMAP
+endif
+ifeq ($(call try-cc,$(SOURCE_ELF_GETPHDRNUM),$(FLAGS_LIBELF),-DHAVE_ELF_GETPHDRNUM),y)
+  CFLAGS += -DHAVE_ELF_GETPHDRNUM
+endif
+
+# include ARCH specific config
+-include $(src-perf)/arch/$(ARCH)/Makefile
+
+ifndef NO_DWARF
+ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)
+  msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);
+  NO_DWARF := 1
+else
+  CFLAGS += -DDWARF_SUPPORT $(LIBDW_CFLAGS)
+  LDFLAGS += $(LIBDW_LDFLAGS)
+  EXTLIBS += -lelf -ldw
+endif # PERF_HAVE_DWARF_REGS
+endif # NO_DWARF
+
+endif # NO_LIBELF
+
+ifndef NO_LIBELF
+CFLAGS += -DLIBELF_SUPPORT
+FLAGS_LIBELF=$(CFLAGS) $(LDFLAGS) $(EXTLIBS)
+ifeq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_LIBELF),-DLIBELF_MMAP),y)
+  CFLAGS += -DLIBELF_MMAP
+endif # try-cc
+endif # NO_LIBELF
+
+# There's only x86 (both 32 and 64) support for CFI unwind so far
+ifneq ($(ARCH),x86)
+  NO_LIBUNWIND := 1
+endif
+
+ifndef NO_LIBUNWIND
+# for linking with debug library, run like:
+# make DEBUG=1 LIBUNWIND_DIR=/opt/libunwind/
+ifdef LIBUNWIND_DIR
+  LIBUNWIND_CFLAGS  := -I$(LIBUNWIND_DIR)/include
+  LIBUNWIND_LDFLAGS := -L$(LIBUNWIND_DIR)/lib
+endif
+
+FLAGS_UNWIND=$(LIBUNWIND_CFLAGS) $(CFLAGS) $(LIBUNWIND_LDFLAGS) $(LDFLAGS) $(EXTLIBS) $(LIBUNWIND_LIBS)
+ifneq ($(call try-cc,$(SOURCE_LIBUNWIND),$(FLAGS_UNWIND),libunwind),y)
+  msg := $(warning No libunwind found, disabling post unwind support. Please install libunwind-dev[el] >= 0.99);
+  NO_LIBUNWIND := 1
+endif # Libunwind support
+endif # NO_LIBUNWIND
+
+ifndef NO_LIBUNWIND
+  CFLAGS += -DLIBUNWIND_SUPPORT
+  EXTLIBS += $(LIBUNWIND_LIBS)
+  CFLAGS += $(LIBUNWIND_CFLAGS)
+  LDFLAGS += $(LIBUNWIND_LDFLAGS)
+endif # NO_LIBUNWIND
+
+ifndef NO_LIBAUDIT
+  FLAGS_LIBAUDIT = $(CFLAGS) $(LDFLAGS) -laudit
+  ifneq ($(call try-cc,$(SOURCE_LIBAUDIT),$(FLAGS_LIBAUDIT),libaudit),y)
+    msg := $(warning No libaudit.h found, disables 'trace' tool, please install audit-libs-devel or libaudit-dev);
+    NO_LIBAUDIT := 1
+  else
+    CFLAGS += -DLIBAUDIT_SUPPORT
+    EXTLIBS += -laudit
+  endif
+endif
+
+ifdef NO_NEWT
+  NO_SLANG=1
+endif
+
+ifndef NO_SLANG
+  FLAGS_SLANG=$(CFLAGS) $(LDFLAGS) $(EXTLIBS) -I/usr/include/slang -lslang
+  ifneq ($(call try-cc,$(SOURCE_SLANG),$(FLAGS_SLANG),libslang),y)
+    msg := $(warning slang not found, disables TUI support. Please install slang-devel or libslang-dev);
+    NO_SLANG := 1
+  else
+    # Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
+    CFLAGS += -I/usr/include/slang
+    CFLAGS += -DSLANG_SUPPORT
+    EXTLIBS += -lslang
+  endif
+endif
+
+ifndef NO_GTK2
+  FLAGS_GTK2=$(CFLAGS) $(LDFLAGS) $(EXTLIBS) $(shell pkg-config --libs --cflags gtk+-2.0 2>/dev/null)
+  ifneq ($(call try-cc,$(SOURCE_GTK2),$(FLAGS_GTK2),gtk2),y)
+    msg := $(warning GTK2 not found, disables GTK2 support. Please install gtk2-devel or libgtk2.0-dev);
+    NO_GTK2 := 1
+  else
+    ifeq ($(call try-cc,$(SOURCE_GTK2_INFOBAR),$(FLAGS_GTK2),-DHAVE_GTK_INFO_BAR),y)
+      CFLAGS += -DHAVE_GTK_INFO_BAR
+    endif
+    CFLAGS += -DGTK2_SUPPORT
+    CFLAGS += $(shell pkg-config --cflags gtk+-2.0 2>/dev/null)
+    EXTLIBS += $(shell pkg-config --libs gtk+-2.0 2>/dev/null)
+  endif
+endif
+
+grep-libs  = $(filter -l%,$(1))
+strip-libs = $(filter-out -l%,$(1))
+
+ifdef NO_LIBPERL
+  CFLAGS += -DNO_LIBPERL
+else
+  PERL_EMBED_LDOPTS = $(shell perl -MExtUtils::Embed -e ldopts 2>/dev/null)
+  PERL_EMBED_LDFLAGS = $(call strip-libs,$(PERL_EMBED_LDOPTS))
+  PERL_EMBED_LIBADD = $(call grep-libs,$(PERL_EMBED_LDOPTS))
+  PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`
+  FLAGS_PERL_EMBED=$(PERL_EMBED_CCOPTS) $(PERL_EMBED_LDOPTS)
+
+  ifneq ($(call try-cc,$(SOURCE_PERL_EMBED),$(FLAGS_PERL_EMBED),perl),y)
+    CFLAGS += -DNO_LIBPERL
+    NO_LIBPERL := 1
+  else
+    LDFLAGS += $(PERL_EMBED_LDFLAGS)
+    EXTLIBS += $(PERL_EMBED_LIBADD)
+  endif
+endif
+
+disable-python = $(eval $(disable-python_code))
+define disable-python_code
+  CFLAGS += -DNO_LIBPYTHON
+  $(if $(1),$(warning No $(1) was found))
+  $(warning Python support will not be built)
+  NO_LIBPYTHON := 1
+endef
+
+override PYTHON := \
+  $(call get-executable-or-default,PYTHON,python)
+
+ifndef PYTHON
+  $(call disable-python,python interpreter)
+else
+
+  PYTHON_WORD := $(call shell-wordify,$(PYTHON))
+
+  ifdef NO_LIBPYTHON
+    $(call disable-python)
+  else
+
+    override PYTHON_CONFIG := \
+      $(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON)-config)
+
+    ifndef PYTHON_CONFIG
+      $(call disable-python,python-config tool)
+    else
+
+      PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
+
+      PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
+      PYTHON_EMBED_LDFLAGS := $(call strip-libs,$(PYTHON_EMBED_LDOPTS))
+      PYTHON_EMBED_LIBADD := $(call grep-libs,$(PYTHON_EMBED_LDOPTS))
+      PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
+      FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
+
+      ifneq ($(call try-cc,$(SOURCE_PYTHON_EMBED),$(FLAGS_PYTHON_EMBED),python),y)
+        $(call disable-python,Python.h (for Python 2.x))
+      else
+
+        ifneq ($(call try-cc,$(SOURCE_PYTHON_VERSION),$(FLAGS_PYTHON_EMBED),python version),y)
+          $(warning Python 3 is not yet supported; please set)
+          $(warning PYTHON and/or PYTHON_CONFIG appropriately.)
+          $(warning If you also have Python 2 installed, then)
+          $(warning try something like:)
+          $(warning $(and ,))
+          $(warning $(and ,)  make PYTHON=python2)
+          $(warning $(and ,))
+          $(warning Otherwise, disable Python support entirely:)
+          $(warning $(and ,))
+          $(warning $(and ,)  make NO_LIBPYTHON=1)
+          $(warning $(and ,))
+          $(error   $(and ,))
+        else
+          LDFLAGS += $(PYTHON_EMBED_LDFLAGS)
+          EXTLIBS += $(PYTHON_EMBED_LIBADD)
+          LANG_BINDINGS += $(obj-perf)python/perf.so
+        endif
+      endif
+    endif
+  endif
+endif
+
+ifdef NO_DEMANGLE
+  CFLAGS += -DNO_DEMANGLE
+else
+  ifdef HAVE_CPLUS_DEMANGLE
+    EXTLIBS += -liberty
+    CFLAGS += -DHAVE_CPLUS_DEMANGLE
+  else
+    FLAGS_BFD=$(CFLAGS) $(LDFLAGS) $(EXTLIBS) -DPACKAGE='perf' -lbfd
+    has_bfd := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD),libbfd)
+    ifeq ($(has_bfd),y)
+      EXTLIBS += -lbfd
+    else
+      FLAGS_BFD_IBERTY=$(FLAGS_BFD) -liberty
+      has_bfd_iberty := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY),liberty)
+      ifeq ($(has_bfd_iberty),y)
+        EXTLIBS += -lbfd -liberty
+      else
+        FLAGS_BFD_IBERTY_Z=$(FLAGS_BFD_IBERTY) -lz
+        has_bfd_iberty_z := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY_Z),libz)
+        ifeq ($(has_bfd_iberty_z),y)
+          EXTLIBS += -lbfd -liberty -lz
+        else
+          FLAGS_CPLUS_DEMANGLE=$(CFLAGS) $(LDFLAGS) $(EXTLIBS) -liberty
+          has_cplus_demangle := $(call try-cc,$(SOURCE_CPLUS_DEMANGLE),$(FLAGS_CPLUS_DEMANGLE),demangle)
+          ifeq ($(has_cplus_demangle),y)
+            EXTLIBS += -liberty
+            CFLAGS += -DHAVE_CPLUS_DEMANGLE
+          else
+            msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
+            CFLAGS += -DNO_DEMANGLE
+          endif
+        endif
+      endif
+    endif
+  endif
+endif
+
+ifndef NO_STRLCPY
+  ifeq ($(call try-cc,$(SOURCE_STRLCPY),,-DHAVE_STRLCPY),y)
+    CFLAGS += -DHAVE_STRLCPY
+  endif
+endif
+
+ifndef NO_ON_EXIT
+  ifeq ($(call try-cc,$(SOURCE_ON_EXIT),,-DHAVE_ON_EXIT),y)
+    CFLAGS += -DHAVE_ON_EXIT
+  endif
+endif
+
+ifndef NO_BACKTRACE
+  ifeq ($(call try-cc,$(SOURCE_BACKTRACE),,-DBACKTRACE_SUPPORT),y)
+    CFLAGS += -DBACKTRACE_SUPPORT
+  endif
+endif
+
+ifndef NO_LIBNUMA
+  FLAGS_LIBNUMA = $(CFLAGS) $(LDFLAGS) -lnuma
+  ifneq ($(call try-cc,$(SOURCE_LIBNUMA),$(FLAGS_LIBNUMA),libnuma),y)
+    msg := $(warning No numa.h found, disables 'perf bench numa mem' benchmark, please install numa-libs-devel or libnuma-dev);
+    NO_LIBNUMA := 1
+  else
+    CFLAGS += -DLIBNUMA_SUPPORT
+    EXTLIBS += -lnuma
+  endif
+endif
+
+# Among the variables below, these:
+#   perfexecdir
+#   template_dir
+#   mandir
+#   infodir
+#   htmldir
+#   ETC_PERFCONFIG (but not sysconfdir)
+# can be specified as a relative path some/where/else;
+# this is interpreted as relative to $(prefix) and "perf" at
+# runtime figures out where they are based on the path to the executable.
+# This can help installing the suite in a relocatable way.
+
+# Make the path relative to DESTDIR, not to prefix
+ifndef DESTDIR
+prefix = $(HOME)
+endif
+bindir_relative = bin
+bindir = $(prefix)/$(bindir_relative)
+mandir = share/man
+infodir = share/info
+perfexecdir = libexec/perf-core
+sharedir = $(prefix)/share
+template_dir = share/perf-core/templates
+htmldir = share/doc/perf-doc
+ifeq ($(prefix),/usr)
+sysconfdir = /etc
+ETC_PERFCONFIG = $(sysconfdir)/perfconfig
+else
+sysconfdir = $(prefix)/etc
+ETC_PERFCONFIG = etc/perfconfig
+endif
+lib = lib
+
+# Shell quote (do not use $(call) to accommodate ancient setups);
+ETC_PERFCONFIG_SQ = $(subst ','\'',$(ETC_PERFCONFIG))
+DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
+bindir_SQ = $(subst ','\'',$(bindir))
+mandir_SQ = $(subst ','\'',$(mandir))
+infodir_SQ = $(subst ','\'',$(infodir))
+perfexecdir_SQ = $(subst ','\'',$(perfexecdir))
+template_dir_SQ = $(subst ','\'',$(template_dir))
+htmldir_SQ = $(subst ','\'',$(htmldir))
+prefix_SQ = $(subst ','\'',$(prefix))
+sysconfdir_SQ = $(subst ','\'',$(sysconfdir))
+
+ifneq ($(filter /%,$(firstword $(perfexecdir))),)
+perfexec_instdir = $(perfexecdir)
+else
+perfexec_instdir = $(prefix)/$(perfexecdir)
+endif
+perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))
diff --git a/tools/perf/config/feature-tests.mak b/tools/perf/config/feature-tests.mak
index 708fb8e9822a..d5a8dd44945f 100644
--- a/tools/perf/config/feature-tests.mak
+++ b/tools/perf/config/feature-tests.mak
@@ -61,6 +61,15 @@ int main(void)
 }
 endef
 
+define SOURCE_ELF_GETPHDRNUM
+#include <libelf.h>
+int main(void)
+{
+        size_t dst;
+        return elf_getphdrnum(0, &dst);
+}
+endef
+
 ifndef NO_SLANG
 define SOURCE_SLANG
 #include <slang.h>
@@ -210,6 +219,7 @@ define SOURCE_LIBAUDIT
 
 int main(void)
 {
+        printf(\"error message: %s\n\", audit_errno_to_name(0));
         return audit_open();
 }
 endef
diff --git a/tools/perf/config/utilities.mak b/tools/perf/config/utilities.mak
index 8ef3bd30a549..94d2d4f9c35d 100644
--- a/tools/perf/config/utilities.mak
+++ b/tools/perf/config/utilities.mak
@@ -173,7 +173,7 @@ _ge-abspath = $(if $(is-executable),$(1))
 # Usage: absolute-executable-path-or-empty = $(call get-executable-or-default,variable,default)
 #
 define get-executable-or-default
-$(if $($(1)),$(call _ge_attempt,$($(1)),$(1)),$(call _ge_attempt,$(2),$(1)))
+$(if $($(1)),$(call _ge_attempt,$($(1)),$(1)),$(call _ge_attempt,$(2)))
 endef
 _ge_attempt = $(if $(get-executable),$(get-executable),$(_gea_warn)$(call _gea_err,$(2)))
 _gea_warn = $(warning The path '$(1)' is not executable.)
@@ -181,7 +181,7 @@ _gea_err  = $(if $(1),$(error Please set '$(1)' appropriately))
 
 # try-cc
 # Usage: option = $(call try-cc, source-to-build, cc-options, msg)
-ifndef V
+ifneq ($(V),1)
 TRY_CC_OUTPUT= > /dev/null 2>&1
 endif
 TRY_CC_MSG=echo "    CHK $(3)" 1>&2;
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 32bd102c32b6..cf20187eee0a 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -125,6 +125,9 @@
 #ifndef NSEC_PER_SEC
 # define NSEC_PER_SEC                   1000000000ULL
 #endif
+#ifndef NSEC_PER_USEC
+# define NSEC_PER_USEC                  1000ULL
+#endif
 
 static inline unsigned long long rdclock(void)
 {
diff --git a/tools/perf/python/twatch.py b/tools/perf/python/twatch.py
index b11cca584238..2225162ee1fc 100755
--- a/tools/perf/python/twatch.py
+++ b/tools/perf/python/twatch.py
@@ -21,7 +21,7 @@ def main():
         evsel = perf.evsel(task = 1, comm = 1, mmap = 0,
                            wakeup_events = 1, watermark = 1,
                            sample_id_all = 1,
-                           sample_type = perf.SAMPLE_PERIOD | perf.SAMPLE_TID | perf.SAMPLE_CPU | perf.SAMPLE_TID)
+                           sample_type = perf.SAMPLE_PERIOD | perf.SAMPLE_TID | perf.SAMPLE_CPU)
         evsel.open(cpus = cpus, threads = threads);
         evlist = perf.evlist(cpus, threads)
         evlist.add(evsel)
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs b/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs
index c1e2ed1ed34e..8c7ea42444d1 100644
--- a/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs
@@ -23,7 +23,7 @@
 #include "perl.h"
 #include "XSUB.h"
 #include "../../../perf.h"
-#include "../../../util/script-event.h"
+#include "../../../util/trace-event.h"
 
 MODULE = Perf::Trace::Context           PACKAGE = Perf::Trace::Context
 PROTOTYPES: ENABLE
diff --git a/tools/perf/tests/attr/base-record b/tools/perf/tests/attr/base-record
index b4fc835de607..e9bd6391f2ae 100644
--- a/tools/perf/tests/attr/base-record
+++ b/tools/perf/tests/attr/base-record
@@ -27,8 +27,8 @@ watermark=0
 precise_ip=0
 mmap_data=0
 sample_id_all=1
-exclude_host=0
-exclude_guest=1
+exclude_host=0|1
+exclude_guest=0|1
 exclude_callchain_kernel=0
 exclude_callchain_user=0
 wakeup_events=0
diff --git a/tools/perf/tests/attr/base-stat b/tools/perf/tests/attr/base-stat
index 748ee949a204..91cd48b399f3 100644
--- a/tools/perf/tests/attr/base-stat
+++ b/tools/perf/tests/attr/base-stat
@@ -27,8 +27,8 @@ watermark=0
 precise_ip=0
 mmap_data=0
 sample_id_all=0
-exclude_host=0
-exclude_guest=1
+exclude_host=0|1
+exclude_guest=0|1
 exclude_callchain_kernel=0
 exclude_callchain_user=0
 wakeup_events=0
diff --git a/tools/perf/tests/attr/test-record-data b/tools/perf/tests/attr/test-record-data
index 6627c3e7534a..716e143b5291 100644
--- a/tools/perf/tests/attr/test-record-data
+++ b/tools/perf/tests/attr/test-record-data
@@ -4,5 +4,8 @@ args    = -d kill >/dev/null 2>&1
 
 [event:base-record]
 sample_period=4000
-sample_type=271
+
+# sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID | PERF_SAMPLE_TIME |
+# PERF_SAMPLE_ADDR | PERF_SAMPLE_PERIOD | PERF_SAMPLE_DATA_SRC
+sample_type=33039
 mmap_data=1
diff --git a/tools/perf/tests/attr/test-record-group-sampling b/tools/perf/tests/attr/test-record-group-sampling
new file mode 100644
index 000000000000..658f5d60c873
--- /dev/null
+++ b/tools/perf/tests/attr/test-record-group-sampling
@@ -0,0 +1,36 @@
+[config]
+command = record
+args    = -e '{cycles,cache-misses}:S' kill >/dev/null 2>&1
+
+[event-1:base-record]
+fd=1
+group_fd=-1
+sample_type=343
+read_format=12
+inherit=0
+
+[event-2:base-record]
+fd=2
+group_fd=1
+
+# cache-misses
+type=0
+config=3
+
+# default | PERF_SAMPLE_READ
+sample_type=343
+
+# PERF_FORMAT_ID | PERF_FORMAT_GROUP
+read_format=12
+
+mmap=0
+comm=0
+enable_on_exec=0
+disabled=0
+
+# inherit is disabled for group sampling
+inherit=0
+
+# sampling disabled
+sample_freq=0
+sample_period=0
diff --git a/tools/perf/tests/bp_signal.c b/tools/perf/tests/bp_signal.c
index 68daa289e94c..aba095489193 100644
--- a/tools/perf/tests/bp_signal.c
+++ b/tools/perf/tests/bp_signal.c
@@ -4,6 +4,12 @@
  * (git://github.com/deater/perf_event_tests)
  */
 
+/*
+ * Powerpc needs __SANE_USERSPACE_TYPES__ before <linux/types.h> to select
+ * 'int-ll64.h' and avoid compile warnings when printing __u64 with %llu.
+ */
+#define __SANE_USERSPACE_TYPES__
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
diff --git a/tools/perf/tests/bp_signal_overflow.c b/tools/perf/tests/bp_signal_overflow.c
index fe7ed28815f8..44ac82179708 100644
--- a/tools/perf/tests/bp_signal_overflow.c
+++ b/tools/perf/tests/bp_signal_overflow.c
@@ -3,6 +3,12 @@
  * perf_event_tests (git://github.com/deater/perf_event_tests)
  */
 
+/*
+ * Powerpc needs __SANE_USERSPACE_TYPES__ before <linux/types.h> to select
+ * 'int-ll64.h' and avoid compile warnings when printing __u64 with %llu.
+ */
+#define __SANE_USERSPACE_TYPES__
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 0918ada4cc41..1e67437fb4ca 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -70,7 +70,7 @@ static struct test {
                 .func = test__attr,
         },
         {
-                .desc = "Test matching and linking mutliple hists",
+                .desc = "Test matching and linking multiple hists",
                 .func = test__hists_link,
         },
         {
@@ -93,6 +93,28 @@ static struct test {
                 .desc = "Test software clock events have valid period values",
                 .func = test__sw_clock_freq,
         },
+#if defined(__x86_64__) || defined(__i386__)
+        {
+                .desc = "Test converting perf time to TSC",
+                .func = test__perf_time_to_tsc,
+        },
+#endif
+        {
+                .desc = "Test object code reading",
+                .func = test__code_reading,
+        },
+        {
+                .desc = "Test sample parsing",
+                .func = test__sample_parsing,
+        },
+        {
+                .desc = "Test using a dummy software event to keep tracking",
+                .func = test__keep_tracking,
+        },
+        {
+                .desc = "Test parsing with no sample_id_all bit set",
+                .func = test__parse_no_sample_id_all,
+        },
         {
                 .func = NULL,
         },
diff --git a/tools/perf/tests/code-reading.c b/tools/perf/tests/code-reading.c
new file mode 100644
index 000000000000..6fb781d5586c
--- /dev/null
+++ b/tools/perf/tests/code-reading.c
@@ -0,0 +1,572 @@
+#include <sys/types.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "parse-events.h"
+#include "evlist.h"
+#include "evsel.h"
+#include "thread_map.h"
+#include "cpumap.h"
+#include "machine.h"
+#include "event.h"
+#include "thread.h"
+
+#include "tests.h"
+
+#define BUFSZ   1024
+#define READLEN 128
+
+struct state {
+        u64 done[1024];
+        size_t done_cnt;
+};
+
+static unsigned int hex(char c)
+{
+        if (c >= '0' && c <= '9')
+                return c - '0';
+        if (c >= 'a' && c <= 'f')
+                return c - 'a' + 10;
+        return c - 'A' + 10;
+}
+
+static void read_objdump_line(const char *line, size_t line_len, void **buf,
+                              size_t *len)
+{
+        const char *p;
+        size_t i;
+
+        /* Skip to a colon */
+        p = strchr(line, ':');
+        if (!p)
+                return;
+        i = p + 1 - line;
+
+        /* Read bytes */
+        while (*len) {
+                char c1, c2;
+
+                /* Skip spaces */
+                for (; i < line_len; i++) {
+                        if (!isspace(line[i]))
+                                break;
+                }
+                /* Get 2 hex digits */
+                if (i >= line_len || !isxdigit(line[i]))
+                        break;
+                c1 = line[i++];
+                if (i >= line_len || !isxdigit(line[i]))
+                        break;
+                c2 = line[i++];
+                /* Followed by a space */
+                if (i < line_len && line[i] && !isspace(line[i]))
+                        break;
+                /* Store byte */
+                *(unsigned char *)*buf = (hex(c1) << 4) | hex(c2);
+                *buf += 1;
+                *len -= 1;
+        }
+}
+
+static int read_objdump_output(FILE *f, void **buf, size_t *len)
+{
+        char *line = NULL;
+        size_t line_len;
+        ssize_t ret;
+        int err = 0;
+
+        while (1) {
+                ret = getline(&line, &line_len, f);
+                if (feof(f))
+                        break;
+                if (ret < 0) {
+                        pr_debug("getline failed\n");
+                        err = -1;
+                        break;
+                }
+                read_objdump_line(line, ret, buf, len);
+        }
+
+        free(line);
+
+        return err;
+}
+
+static int read_via_objdump(const char *filename, u64 addr, void *buf,
+                            size_t len)
+{
+        char cmd[PATH_MAX * 2];
+        const char *fmt;
+        FILE *f;
+        int ret;
+
+        fmt = "%s -d --start-address=0x%"PRIx64" --stop-address=0x%"PRIx64" %s";
+        ret = snprintf(cmd, sizeof(cmd), fmt, "objdump", addr, addr + len,
+                       filename);
+        if (ret <= 0 || (size_t)ret >= sizeof(cmd))
+                return -1;
+
+        pr_debug("Objdump command is: %s\n", cmd);
+
+        /* Ignore objdump errors */
+        strcat(cmd, " 2>/dev/null");
+
+        f = popen(cmd, "r");
+        if (!f) {
+                pr_debug("popen failed\n");
+                return -1;
+        }
+
+        ret = read_objdump_output(f, &buf, &len);
+        if (len) {
+                pr_debug("objdump read too few bytes\n");
+                if (!ret)
+                        ret = len;
+        }
+
+        pclose(f);
+
+        return ret;
+}
+
+static int read_object_code(u64 addr, size_t len, u8 cpumode,
+                            struct thread *thread, struct machine *machine,
+                            struct state *state)
+{
+        struct addr_location al;
+        unsigned char buf1[BUFSZ];
+        unsigned char buf2[BUFSZ];
+        size_t ret_len;
+        u64 objdump_addr;
+        int ret;
+
+        pr_debug("Reading object code for memory address: %#"PRIx64"\n", addr);
+
+        thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION, addr,
+                              &al);
+        if (!al.map || !al.map->dso) {
+                pr_debug("thread__find_addr_map failed\n");
+                return -1;
+        }
+
+        pr_debug("File is: %s\n", al.map->dso->long_name);
+
+        if (al.map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
+            !dso__is_kcore(al.map->dso)) {
+                pr_debug("Unexpected kernel address - skipping\n");
+                return 0;
+        }
+
+        pr_debug("On file address is: %#"PRIx64"\n", al.addr);
+
+        if (len > BUFSZ)
+                len = BUFSZ;
+
+        /* Do not go off the map */
+        if (addr + len > al.map->end)
+                len = al.map->end - addr;
+
+        /* Read the object code using perf */
+        ret_len = dso__data_read_offset(al.map->dso, machine, al.addr, buf1,
+                                        len);
+        if (ret_len != len) {
+                pr_debug("dso__data_read_offset failed\n");
+                return -1;
+        }
+
+        /*
+         * Converting addresses for use by objdump requires more information.
+         * map__load() does that.  See map__rip_2objdump() for details.
+         */
+        if (map__load(al.map, NULL))
+                return -1;
+
+        /* objdump struggles with kcore - try each map only once */
+        if (dso__is_kcore(al.map->dso)) {
+                size_t d;
+
+                for (d = 0; d < state->done_cnt; d++) {
+                        if (state->done[d] == al.map->start) {
+                                pr_debug("kcore map tested already");
+                                pr_debug(" - skipping\n");
+                                return 0;
+                        }
+                }
+                if (state->done_cnt >= ARRAY_SIZE(state->done)) {
+                        pr_debug("Too many kcore maps - skipping\n");
+                        return 0;
+                }
+                state->done[state->done_cnt++] = al.map->start;
+        }
+
+        /* Read the object code using objdump */
+        objdump_addr = map__rip_2objdump(al.map, al.addr);
+        ret = read_via_objdump(al.map->dso->long_name, objdump_addr, buf2, len);
+        if (ret > 0) {
+                /*
+                 * The kernel maps are inaccurate - assume objdump is right in
+                 * that case.
+                 */
+                if (cpumode == PERF_RECORD_MISC_KERNEL ||
+                    cpumode == PERF_RECORD_MISC_GUEST_KERNEL) {
+                        len -= ret;
+                        if (len) {
+                                pr_debug("Reducing len to %zu\n", len);
+                        } else if (dso__is_kcore(al.map->dso)) {
+                                /*
+                                 * objdump cannot handle very large segments
+                                 * that may be found in kcore.
+                                 */
+                                pr_debug("objdump failed for kcore");
+                                pr_debug(" - skipping\n");
+                                return 0;
+                        } else {
+                                return -1;
+                        }
+                }
+        }
+        if (ret < 0) {
+                pr_debug("read_via_objdump failed\n");
+                return -1;
+        }
+
+        /* The results should be identical */
+        if (memcmp(buf1, buf2, len)) {
+                pr_debug("Bytes read differ from those read by objdump\n");
+                return -1;
+        }
+        pr_debug("Bytes read match those read by objdump\n");
+
+        return 0;
+}
+
+static int process_sample_event(struct machine *machine,
+                                struct perf_evlist *evlist,
+                                union perf_event *event, struct state *state)
+{
+        struct perf_sample sample;
+        struct thread *thread;
+        u8 cpumode;
+
+        if (perf_evlist__parse_sample(evlist, event, &sample)) {
+                pr_debug("perf_evlist__parse_sample failed\n");
+                return -1;
+        }
+
+        thread = machine__findnew_thread(machine, sample.pid, sample.pid);
+        if (!thread) {
+                pr_debug("machine__findnew_thread failed\n");
+                return -1;
+        }
+
+        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+
+        return read_object_code(sample.ip, READLEN, cpumode, thread, machine,
+                                state);
+}
+
+static int process_event(struct machine *machine, struct perf_evlist *evlist,
+                         union perf_event *event, struct state *state)
+{
+        if (event->header.type == PERF_RECORD_SAMPLE)
+                return process_sample_event(machine, evlist, event, state);
+
+        if (event->header.type < PERF_RECORD_MAX)
+                return machine__process_event(machine, event);
+
+        return 0;
+}
+
+static int process_events(struct machine *machine, struct perf_evlist *evlist,
+                          struct state *state)
+{
+        union perf_event *event;
+        int i, ret;
+
+        for (i = 0; i < evlist->nr_mmaps; i++) {
+                while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
+                        ret = process_event(machine, evlist, event, state);
+                        if (ret < 0)
+                                return ret;
+                }
+        }
+        return 0;
+}
+
+static int comp(const void *a, const void *b)
+{
+        return *(int *)a - *(int *)b;
+}
+
+static void do_sort_something(void)
+{
+        int buf[40960], i;
+
+        for (i = 0; i < (int)ARRAY_SIZE(buf); i++)
+                buf[i] = ARRAY_SIZE(buf) - i - 1;
+
+        qsort(buf, ARRAY_SIZE(buf), sizeof(int), comp);
+
+        for (i = 0; i < (int)ARRAY_SIZE(buf); i++) {
+                if (buf[i] != i) {
+                        pr_debug("qsort failed\n");
+                        break;
+                }
+        }
+}
+
+static void sort_something(void)
+{
+        int i;
+
+        for (i = 0; i < 10; i++)
+                do_sort_something();
+}
+
+static void syscall_something(void)
+{
+        int pipefd[2];
+        int i;
+
+        for (i = 0; i < 1000; i++) {
+                if (pipe(pipefd) < 0) {
+                        pr_debug("pipe failed\n");
+                        break;
+                }
+                close(pipefd[1]);
+                close(pipefd[0]);
+        }
+}
+
+static void fs_something(void)
+{
+        const char *test_file_name = "temp-perf-code-reading-test-file--";
+        FILE *f;
+        int i;
+
+        for (i = 0; i < 1000; i++) {
+                f = fopen(test_file_name, "w+");
+                if (f) {
+                        fclose(f);
+                        unlink(test_file_name);
+                }
+        }
+}
+
+static void do_something(void)
+{
+        fs_something();
+
+        sort_something();
+
+        syscall_something();
+}
+
+enum {
+        TEST_CODE_READING_OK,
+        TEST_CODE_READING_NO_VMLINUX,
+        TEST_CODE_READING_NO_KCORE,
+        TEST_CODE_READING_NO_ACCESS,
+        TEST_CODE_READING_NO_KERNEL_OBJ,
+};
+
+static int do_test_code_reading(bool try_kcore)
+{
+        struct machines machines;
+        struct machine *machine;
+        struct thread *thread;
+        struct perf_record_opts opts = {
+                .mmap_pages          = UINT_MAX,
+                .user_freq           = UINT_MAX,
+                .user_interval       = ULLONG_MAX,
+                .freq                = 4000,
+                .target              = {
+                        .uses_mmap   = true,
+                },
+        };
+        struct state state = {
+                .done_cnt = 0,
+        };
+        struct thread_map *threads = NULL;
+        struct cpu_map *cpus = NULL;
+        struct perf_evlist *evlist = NULL;
+        struct perf_evsel *evsel = NULL;
+        int err = -1, ret;
+        pid_t pid;
+        struct map *map;
+        bool have_vmlinux, have_kcore, excl_kernel = false;
+
+        pid = getpid();
+
+        machines__init(&machines);
+        machine = &machines.host;
+
+        ret = machine__create_kernel_maps(machine);
+        if (ret < 0) {
+                pr_debug("machine__create_kernel_maps failed\n");
+                goto out_err;
+        }
+
+        /* Force the use of kallsyms instead of vmlinux to try kcore */
+        if (try_kcore)
+                symbol_conf.kallsyms_name = "/proc/kallsyms";
+
+        /* Load kernel map */
+        map = machine->vmlinux_maps[MAP__FUNCTION];
+        ret = map__load(map, NULL);
+        if (ret < 0) {
+                pr_debug("map__load failed\n");
+                goto out_err;
+        }
+        have_vmlinux = dso__is_vmlinux(map->dso);
+        have_kcore = dso__is_kcore(map->dso);
+
+        /* 2nd time through we just try kcore */
+        if (try_kcore && !have_kcore)
+                return TEST_CODE_READING_NO_KCORE;
+
+        /* No point getting kernel events if there is no kernel object */
+        if (!have_vmlinux && !have_kcore)
+                excl_kernel = true;
+
+        threads = thread_map__new_by_tid(pid);
+        if (!threads) {
+                pr_debug("thread_map__new_by_tid failed\n");
+                goto out_err;
+        }
+
+        ret = perf_event__synthesize_thread_map(NULL, threads,
+                                                perf_event__process, machine);
+        if (ret < 0) {
+                pr_debug("perf_event__synthesize_thread_map failed\n");
+                goto out_err;
+        }
+
+        thread = machine__findnew_thread(machine, pid, pid);
+        if (!thread) {
+                pr_debug("machine__findnew_thread failed\n");
+                goto out_err;
+        }
+
+        cpus = cpu_map__new(NULL);
+        if (!cpus) {
+                pr_debug("cpu_map__new failed\n");
+                goto out_err;
+        }
+
+        while (1) {
+                const char *str;
+
+                evlist = perf_evlist__new();
+                if (!evlist) {
+                        pr_debug("perf_evlist__new failed\n");
+                        goto out_err;
+                }
+
+                perf_evlist__set_maps(evlist, cpus, threads);
+
+                if (excl_kernel)
+                        str = "cycles:u";
+                else
+                        str = "cycles";
+                pr_debug("Parsing event '%s'\n", str);
+                ret = parse_events(evlist, str);
+                if (ret < 0) {
+                        pr_debug("parse_events failed\n");
+                        goto out_err;
+                }
+
+                perf_evlist__config(evlist, &opts);
+
+                evsel = perf_evlist__first(evlist);
+
+                evsel->attr.comm = 1;
+                evsel->attr.disabled = 1;
+                evsel->attr.enable_on_exec = 0;
+
+                ret = perf_evlist__open(evlist);
+                if (ret < 0) {
+                        if (!excl_kernel) {
+                                excl_kernel = true;
+                                perf_evlist__delete(evlist);
+                                evlist = NULL;
+                                continue;
+                        }
+                        pr_debug("perf_evlist__open failed\n");
+                        goto out_err;
+                }
+                break;
+        }
+
+        ret = perf_evlist__mmap(evlist, UINT_MAX, false);
+        if (ret < 0) {
+                pr_debug("perf_evlist__mmap failed\n");
+                goto out_err;
+        }
+
+        perf_evlist__enable(evlist);
+
+        do_something();
+
+        perf_evlist__disable(evlist);
+
+        ret = process_events(machine, evlist, &state);
+        if (ret < 0)
+                goto out_err;
+
+        if (!have_vmlinux && !have_kcore && !try_kcore)
+                err = TEST_CODE_READING_NO_KERNEL_OBJ;
+        else if (!have_vmlinux && !try_kcore)
+                err = TEST_CODE_READING_NO_VMLINUX;
+        else if (excl_kernel)
+                err = TEST_CODE_READING_NO_ACCESS;
+        else
+                err = TEST_CODE_READING_OK;
+out_err:
+        if (evlist) {
+                perf_evlist__munmap(evlist);
+                perf_evlist__close(evlist);
+                perf_evlist__delete(evlist);
+        }
+        if (cpus)
+                cpu_map__delete(cpus);
+        if (threads)
+                thread_map__delete(threads);
+        machines__destroy_kernel_maps(&machines);
+        machine__delete_threads(machine);
+        machines__exit(&machines);
+
+        return err;
+}
+
+int test__code_reading(void)
+{
+        int ret;
+
+        ret = do_test_code_reading(false);
+        if (!ret)
+                ret = do_test_code_reading(true);
+
+        switch (ret) {
+        case TEST_CODE_READING_OK:
+                return 0;
+        case TEST_CODE_READING_NO_VMLINUX:
+                fprintf(stderr, " (no vmlinux)");
+                return 0;
+        case TEST_CODE_READING_NO_KCORE:
+                fprintf(stderr, " (no kcore)");
+                return 0;
+        case TEST_CODE_READING_NO_ACCESS:
+                fprintf(stderr, " (no access)");
+                return 0;
+        case TEST_CODE_READING_NO_KERNEL_OBJ:
+                fprintf(stderr, " (no kernel obj)");
+                return 0;
+        default:
+                return -1;
+        };
+}
diff --git a/tools/perf/tests/dso-data.c b/tools/perf/tests/dso-data.c
index 5eaffa2de9c5..dffe0551acaa 100644
--- a/tools/perf/tests/dso-data.c
+++ b/tools/perf/tests/dso-data.c
@@ -10,14 +10,6 @@
 #include "symbol.h"
 #include "tests.h"
 
-#define TEST_ASSERT_VAL(text, cond) \
-do { \
-        if (!(cond)) { \
-                pr_debug("FAILED %s:%d %s\n", __FILE__, __LINE__, text); \
-                return -1; \
-        } \
-} while (0)
-
 static char *test_file(int size)
 {
         static char buf_templ[] = "/tmp/test-XXXXXX";
diff --git a/tools/perf/tests/evsel-tp-sched.c b/tools/perf/tests/evsel-tp-sched.c
index a5d2fcc5ae35..9b98c1554833 100644
--- a/tools/perf/tests/evsel-tp-sched.c
+++ b/tools/perf/tests/evsel-tp-sched.c
@@ -1,6 +1,6 @@
+#include <traceevent/event-parse.h>
 #include "evsel.h"
 #include "tests.h"
-#include "event-parse.h"
 
 static int perf_evsel__test_field(struct perf_evsel *evsel, const char *name,
                                   int size, bool should_be_signed)
@@ -49,7 +49,7 @@ int test__perf_evsel__tp_sched_test(void)
         if (perf_evsel__test_field(evsel, "prev_prio", 4, true))
                 ret = -1;
 
-        if (perf_evsel__test_field(evsel, "prev_state", 8, true))
+        if (perf_evsel__test_field(evsel, "prev_state", sizeof(long), true))
                 ret = -1;
 
         if (perf_evsel__test_field(evsel, "next_comm", 16, true))
diff --git a/tools/perf/tests/hists_link.c b/tools/perf/tests/hists_link.c
index 89085a9615e2..4228ffc0d968 100644
--- a/tools/perf/tests/hists_link.c
+++ b/tools/perf/tests/hists_link.c
@@ -88,7 +88,8 @@ static struct machine *setup_fake_machine(struct machines *machines)
         for (i = 0; i < ARRAY_SIZE(fake_threads); i++) {
                 struct thread *thread;
 
-                thread = machine__findnew_thread(machine, fake_threads[i].pid);
+                thread = machine__findnew_thread(machine, fake_threads[i].pid,
+                                                 fake_threads[i].pid);
                 if (thread == NULL)
                         goto out;
 
@@ -210,17 +211,15 @@ static int add_hist_entries(struct perf_evlist *evlist, struct machine *machine)
         list_for_each_entry(evsel, &evlist->entries, node) {
                 for (k = 0; k < ARRAY_SIZE(fake_common_samples); k++) {
                         const union perf_event event = {
-                                .ip = {
-                                        .header = {
-                                                .misc = PERF_RECORD_MISC_USER,
-                                        },
-                                        .pid = fake_common_samples[k].pid,
-                                        .ip  = fake_common_samples[k].ip,
+                                .header = {
+                                        .misc = PERF_RECORD_MISC_USER,
                                 },
                         };
 
+                        sample.pid = fake_common_samples[k].pid;
+                        sample.ip = fake_common_samples[k].ip;
                         if (perf_event__preprocess_sample(&event, machine, &al,
-                                                          &sample, 0) < 0)
+                                                          &sample) < 0)
                                 goto out;
 
                         he = __hists__add_entry(&evsel->hists, &al, NULL, 1, 1);
@@ -234,17 +233,15 @@ static int add_hist_entries(struct perf_evlist *evlist, struct machine *machine)
 
                 for (k = 0; k < ARRAY_SIZE(fake_samples[i]); k++) {
                         const union perf_event event = {
-                                .ip = {
-                                        .header = {
-                                                .misc = PERF_RECORD_MISC_USER,
-                                        },
-                                        .pid = fake_samples[i][k].pid,
-                                        .ip  = fake_samples[i][k].ip,
+                                .header = {
+                                        .misc = PERF_RECORD_MISC_USER,
                                 },
                         };
 
+                        sample.pid = fake_samples[i][k].pid;
+                        sample.ip = fake_samples[i][k].ip;
                         if (perf_event__preprocess_sample(&event, machine, &al,
-                                                          &sample, 0) < 0)
+                                                          &sample) < 0)
                                 goto out;
 
                         he = __hists__add_entry(&evsel->hists, &al, NULL, 1, 1);
diff --git a/tools/perf/tests/keep-tracking.c b/tools/perf/tests/keep-tracking.c
new file mode 100644
index 000000000000..d444ea2c47d9
--- /dev/null
+++ b/tools/perf/tests/keep-tracking.c
@@ -0,0 +1,154 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/prctl.h>
+
+#include "parse-events.h"
+#include "evlist.h"
+#include "evsel.h"
+#include "thread_map.h"
+#include "cpumap.h"
+#include "tests.h"
+
+#define CHECK__(x) {                            \
+        while ((x) < 0) {                       \
+                pr_debug(#x " failed!\n");      \
+                goto out_err;                   \
+        }                                       \
+}
+
+#define CHECK_NOT_NULL__(x) {                   \
+        while ((x) == NULL) {                   \
+                pr_debug(#x " failed!\n");      \
+                goto out_err;                   \
+        }                                       \
+}
+
+static int find_comm(struct perf_evlist *evlist, const char *comm)
+{
+        union perf_event *event;
+        int i, found;
+
+        found = 0;
+        for (i = 0; i < evlist->nr_mmaps; i++) {
+                while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
+                        if (event->header.type == PERF_RECORD_COMM &&
+                            (pid_t)event->comm.pid == getpid() &&
+                            (pid_t)event->comm.tid == getpid() &&
+                            strcmp(event->comm.comm, comm) == 0)
+                                found += 1;
+                }
+        }
+        return found;
+}
+
+/**
+ * test__keep_tracking - test using a dummy software event to keep tracking.
+ *
+ * This function implements a test that checks that tracking events continue
+ * when an event is disabled but a dummy software event is not disabled.  If the
+ * test passes %0 is returned, otherwise %-1 is returned.
+ */
+int test__keep_tracking(void)
+{
+        struct perf_record_opts opts = {
+                .mmap_pages          = UINT_MAX,
+                .user_freq           = UINT_MAX,
+                .user_interval       = ULLONG_MAX,
+                .freq                = 4000,
+                .target              = {
+                        .uses_mmap   = true,
+                },
+        };
+        struct thread_map *threads = NULL;
+        struct cpu_map *cpus = NULL;
+        struct perf_evlist *evlist = NULL;
+        struct perf_evsel *evsel = NULL;
+        int found, err = -1;
+        const char *comm;
+
+        threads = thread_map__new(-1, getpid(), UINT_MAX);
+        CHECK_NOT_NULL__(threads);
+
+        cpus = cpu_map__new(NULL);
+        CHECK_NOT_NULL__(cpus);
+
+        evlist = perf_evlist__new();
+        CHECK_NOT_NULL__(evlist);
+
+        perf_evlist__set_maps(evlist, cpus, threads);
+
+        CHECK__(parse_events(evlist, "dummy:u"));
+        CHECK__(parse_events(evlist, "cycles:u"));
+
+        perf_evlist__config(evlist, &opts);
+
+        evsel = perf_evlist__first(evlist);
+
+        evsel->attr.comm = 1;
+        evsel->attr.disabled = 1;
+        evsel->attr.enable_on_exec = 0;
+
+        if (perf_evlist__open(evlist) < 0) {
+                fprintf(stderr, " (not supported)");
+                err = 0;
+                goto out_err;
+        }
+
+        CHECK__(perf_evlist__mmap(evlist, UINT_MAX, false));
+
+        /*
+         * First, test that a 'comm' event can be found when the event is
+         * enabled.
+         */
+
+        perf_evlist__enable(evlist);
+
+        comm = "Test COMM 1";
+        CHECK__(prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0));
+
+        perf_evlist__disable(evlist);
+
+        found = find_comm(evlist, comm);
+        if (found != 1) {
+                pr_debug("First time, failed to find tracking event.\n");
+                goto out_err;
+        }
+
+        /*
+         * Secondly, test that a 'comm' event can be found when the event is
+         * disabled with the dummy event still enabled.
+         */
+
+        perf_evlist__enable(evlist);
+
+        evsel = perf_evlist__last(evlist);
+
+        CHECK__(perf_evlist__disable_event(evlist, evsel));
+
+        comm = "Test COMM 2";
+        CHECK__(prctl(PR_SET_NAME, (unsigned long)comm, 0, 0, 0));
+
+        perf_evlist__disable(evlist);
+
+        found = find_comm(evlist, comm);
+        if (found != 1) {
+                pr_debug("Seconf time, failed to find tracking event.\n");
+                goto out_err;
+        }
+
+        err = 0;
+
+out_err:
+        if (evlist) {
+                perf_evlist__disable(evlist);
+                perf_evlist__munmap(evlist);
+                perf_evlist__close(evlist);
+                perf_evlist__delete(evlist);
+        }
+        if (cpus)
+                cpu_map__delete(cpus);
+        if (threads)
+                thread_map__delete(threads);
+
+        return err;
+}
diff --git a/tools/perf/tests/make b/tools/perf/tests/make
new file mode 100644
index 000000000000..2ca0abf1b2b6
--- /dev/null
+++ b/tools/perf/tests/make
@@ -0,0 +1,189 @@
+PERF := .
+MK   := Makefile
+
+has = $(shell which $1 2>/dev/null)
+
+# standard single make variable specified
+make_clean_all      := clean all
+make_python_perf_so := python/perf.so
+make_debug          := DEBUG=1
+make_no_libperl     := NO_LIBPERL=1
+make_no_libpython   := NO_LIBPYTHON=1
+make_no_scripts     := NO_LIBPYTHON=1 NO_LIBPERL=1
+make_no_newt        := NO_NEWT=1
+make_no_slang       := NO_SLANG=1
+make_no_gtk2        := NO_GTK2=1
+make_no_ui          := NO_NEWT=1 NO_SLANG=1 NO_GTK2=1
+make_no_demangle    := NO_DEMANGLE=1
+make_no_libelf      := NO_LIBELF=1
+make_no_libunwind   := NO_LIBUNWIND=1
+make_no_backtrace   := NO_BACKTRACE=1
+make_no_libnuma     := NO_LIBNUMA=1
+make_no_libaudit    := NO_LIBAUDIT=1
+make_no_libbionic   := NO_LIBBIONIC=1
+make_tags           := tags
+make_cscope         := cscope
+make_help           := help
+make_doc            := doc
+make_perf_o         := perf.o
+make_util_map_o     := util/map.o
+make_install        := install
+make_install_bin    := install-bin
+make_install_doc    := install-doc
+make_install_man    := install-man
+make_install_html   := install-html
+make_install_info   := install-info
+make_install_pdf    := install-pdf
+
+# all the NO_* variable combined
+make_minimal        := NO_LIBPERL=1 NO_LIBPYTHON=1 NO_NEWT=1 NO_GTK2=1
+make_minimal        += NO_DEMANGLE=1 NO_LIBELF=1 NO_LIBUNWIND=1 NO_BACKTRACE=1
+make_minimal        += NO_LIBNUMA=1 NO_LIBAUDIT=1 NO_LIBBIONIC=1
+
+# $(run) contains all available tests
+run := make_pure
+run += make_clean_all
+run += make_python_perf_so
+run += make_debug
+run += make_no_libperl
+run += make_no_libpython
+run += make_no_scripts
+run += make_no_newt
+run += make_no_slang
+run += make_no_gtk2
+run += make_no_ui
+run += make_no_demangle
+run += make_no_libelf
+run += make_no_libunwind
+run += make_no_backtrace
+run += make_no_libnuma
+run += make_no_libaudit
+run += make_no_libbionic
+run += make_help
+run += make_doc
+run += make_perf_o
+run += make_util_map_o
+run += make_install
+run += make_install_bin
+# FIXME 'install-*' commented out till they're fixed
+# run += make_install_doc
+# run += make_install_man
+# run += make_install_html
+# run += make_install_info
+# run += make_install_pdf
+run += make_minimal
+
+ifneq ($(call has,ctags),)
+run += make_tags
+endif
+ifneq ($(call has,cscope),)
+run += make_cscope
+endif
+
+# $(run_O) contains same portion of $(run) tests with '_O' attached
+# to distinguish O=... tests
+run_O := $(addsuffix _O,$(run))
+
+# disable some tests for O=...
+run_O := $(filter-out make_python_perf_so_O,$(run_O))
+
+# define test for each compile as 'test_NAME' variable
+# with the test itself as a value
+test_make_tags   = test -f tags
+test_make_cscope = test -f cscope.out
+
+test_make_tags_O   := $(test_make_tags)
+test_make_cscope_O := $(test_make_cscope)
+
+test_ok          := true
+test_make_help   := $(test_ok)
+test_make_doc    := $(test_ok)
+test_make_help_O := $(test_ok)
+test_make_doc_O  := $(test_ok)
+
+test_make_python_perf_so := test -f $(PERF)/python/perf.so
+
+test_make_perf_o     := test -f $(PERF)/perf.o
+test_make_util_map_o := test -f $(PERF)/util/map.o
+
+test_make_install       := test -x $$TMP_DEST/bin/perf
+test_make_install_O     := $(test_make_install)
+test_make_install_bin   := $(test_make_install)
+test_make_install_bin_O := $(test_make_install)
+
+# FIXME nothing gets installed
+test_make_install_man    := test -f $$TMP_DEST/share/man/man1/perf.1
+test_make_install_man_O  := $(test_make_install_man)
+
+# FIXME nothing gets installed
+test_make_install_doc    := $(test_ok)
+test_make_install_doc_O  := $(test_ok)
+
+# FIXME nothing gets installed
+test_make_install_html   := $(test_ok)
+test_make_install_html_O := $(test_ok)
+
+# FIXME nothing gets installed
+test_make_install_info   := $(test_ok)
+test_make_install_info_O := $(test_ok)
+
+# FIXME nothing gets installed
+test_make_install_pdf    := $(test_ok)
+test_make_install_pdf_O  := $(test_ok)
+
+# Kbuild tests only
+#test_make_python_perf_so_O := test -f $$TMP/tools/perf/python/perf.so
+#test_make_perf_o_O         := test -f $$TMP/tools/perf/perf.o
+#test_make_util_map_o_O     := test -f $$TMP/tools/perf/util/map.o
+
+test_make_perf_o_O     := true
+test_make_util_map_o_O := true
+
+test_default = test -x $(PERF)/perf
+test = $(if $(test_$1),$(test_$1),$(test_default))
+
+test_default_O = test -x $$TMP_O/perf
+test_O = $(if $(test_$1),$(test_$1),$(test_default_O))
+
+all:
+
+ifdef DEBUG
+d := $(info run   $(run))
+d := $(info run_O $(run_O))
+endif
+
+MAKEFLAGS := --no-print-directory
+
+clean := @(cd $(PERF); make -s -f $(MK) clean >/dev/null)
+
+$(run):
+        $(call clean)
+        @TMP_DEST=$$(mktemp -d); \
+        cmd="cd $(PERF) && make -f $(MK) DESTDIR=$$TMP_DEST $($@)"; \
+        echo "- $@: $$cmd" && echo $$cmd > $@ && \
+        ( eval $$cmd ) >> $@ 2>&1; \
+        echo "  test: $(call test,$@)"; \
+        $(call test,$@) && \
+        rm -f $@ \
+        rm -rf $$TMP_DEST
+
+$(run_O):
+        $(call clean)
+        @TMP_O=$$(mktemp -d); \
+        TMP_DEST=$$(mktemp -d); \
+        cmd="cd $(PERF) && make -f $(MK) O=$$TMP_O DESTDIR=$$TMP_DEST $($(patsubst %_O,%,$@))"; \
+        echo "- $@: $$cmd" && echo $$cmd > $@ && \
+        ( eval $$cmd ) >> $@ 2>&1 && \
+        echo "  test: $(call test_O,$@)"; \
+        $(call test_O,$@) && \
+        rm -f $@ && \
+        rm -rf $$TMP_O \
+        rm -rf $$TMP_DEST
+
+all: $(run) $(run_O)
+        @echo OK
+
+out: $(run_O)
+        @echo OK
+
+.PHONY: all $(run) $(run_O) clean
diff --git a/tools/perf/tests/mmap-basic.c b/tools/perf/tests/mmap-basic.c
index 5b1b5aba722b..c4185b9aeb80 100644
--- a/tools/perf/tests/mmap-basic.c
+++ b/tools/perf/tests/mmap-basic.c
@@ -72,7 +72,7 @@ int test__basic_mmap(void)
                 }
 
                 evsels[i]->attr.wakeup_events = 1;
-                perf_evsel__set_sample_id(evsels[i]);
+                perf_evsel__set_sample_id(evsels[i], false);
 
                 perf_evlist__add(evlist, evsels[i]);
 
diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index 0275bab4ea9e..48114d164e9f 100644
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -7,14 +7,6 @@
 #include "tests.h"
 #include <linux/hw_breakpoint.h>
 
-#define TEST_ASSERT_VAL(text, cond) \
-do { \
-        if (!(cond)) { \
-                pr_debug("FAILED %s:%d %s\n", __FILE__, __LINE__, text); \
-                return -1; \
-        } \
-} while (0)
-
 #define PERF_TP_SAMPLE_TYPE (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | \
                              PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD)
 
@@ -460,6 +452,7 @@ static int test__checkevent_pmu_events(struct perf_evlist *evlist)
                         evsel->attr.exclude_kernel);
         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong pinned", !evsel->attr.pinned);
 
         return 0;
 }
@@ -528,6 +521,7 @@ static int test__group1(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
         TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* cycles:upp */
         evsel = perf_evsel__next(evsel);
@@ -543,6 +537,7 @@ static int test__group1(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip == 2);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         return 0;
 }
@@ -568,6 +563,7 @@ static int test__group2(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
         TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* cache-references + :u modifier */
         evsel = perf_evsel__next(evsel);
@@ -582,6 +578,7 @@ static int test__group2(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* cycles:k */
         evsel = perf_evsel__next(evsel);
@@ -595,6 +592,7 @@ static int test__group2(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         return 0;
 }
@@ -623,6 +621,7 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
                 !strcmp(leader->group_name, "group1"));
         TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* group1 cycles:kppp */
         evsel = perf_evsel__next(evsel);
@@ -639,6 +638,7 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
         TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* group2 cycles + G modifier */
         evsel = leader = perf_evsel__next(evsel);
@@ -656,6 +656,7 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
                 !strcmp(leader->group_name, "group2"));
         TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* group2 1:3 + G modifier */
         evsel = perf_evsel__next(evsel);
@@ -669,6 +670,7 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* instructions:u */
         evsel = perf_evsel__next(evsel);
@@ -682,6 +684,7 @@ static int test__group3(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         return 0;
 }
@@ -709,6 +712,7 @@ static int test__group4(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
         TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* instructions:kp + p */
         evsel = perf_evsel__next(evsel);
@@ -724,6 +728,7 @@ static int test__group4(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip == 2);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         return 0;
 }
@@ -750,6 +755,7 @@ static int test__group5(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
         TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* instructions + G */
         evsel = perf_evsel__next(evsel);
@@ -764,6 +770,7 @@ static int test__group5(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 1);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* cycles:G */
         evsel = leader = perf_evsel__next(evsel);
@@ -780,6 +787,7 @@ static int test__group5(struct perf_evlist *evlist __maybe_unused)
         TEST_ASSERT_VAL("wrong leader", perf_evsel__is_group_leader(evsel));
         TEST_ASSERT_VAL("wrong nr_members", evsel->nr_members == 2);
         TEST_ASSERT_VAL("wrong group_idx", perf_evsel__group_idx(evsel) == 0);
+        TEST_ASSERT_VAL("wrong sample_read", !evsel->sample_read);
 
         /* instructions:G */
         evsel = perf_evsel__next(evsel);
@@ -971,6 +979,142 @@ static int test__group_gh4(struct perf_evlist *evlist)
         return 0;
 }
 
+static int test__leader_sample1(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->nr_entries);
+
+        /* cycles - sampling group leader */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        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 exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
+
+        /* cache-misses - not sampling */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CACHE_MISSES == evsel->attr.config);
+        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 exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
+
+        /* branch-misses - not sampling */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_BRANCH_MISSES == evsel->attr.config);
+        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 exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
+
+        return 0;
+}
+
+static int test__leader_sample2(struct perf_evlist *evlist __maybe_unused)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
+
+        /* instructions - sampling group leader */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_INSTRUCTIONS == evsel->attr.config);
+        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 exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
+
+        /* branch-misses - not sampling */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_BRANCH_MISSES == evsel->attr.config);
+        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 exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong sample_read", evsel->sample_read);
+
+        return 0;
+}
+
+static int test__checkevent_pinned_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);
+        TEST_ASSERT_VAL("wrong pinned", evsel->attr.pinned);
+
+        return test__checkevent_symbolic_name(evlist);
+}
+
+static int test__pinned_group(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->nr_entries);
+
+        /* cycles - group leader */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong pinned", evsel->attr.pinned);
+
+        /* cache-misses - can not be pinned, but will go on with the leader */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CACHE_MISSES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong pinned", !evsel->attr.pinned);
+
+        /* branch-misses - ditto */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_BRANCH_MISSES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong pinned", !evsel->attr.pinned);
+
+        return 0;
+}
+
 static int count_tracepoints(void)
 {
         char events_path[PATH_MAX];
@@ -1187,6 +1331,22 @@ static struct evlist_test test__events[] = {
                 .name  = "{cycles:G,cache-misses:H}:uG",
                 .check = test__group_gh4,
         },
+        [38] = {
+                .name  = "{cycles,cache-misses,branch-misses}:S",
+                .check = test__leader_sample1,
+        },
+        [39] = {
+                .name  = "{instructions,branch-misses}:Su",
+                .check = test__leader_sample2,
+        },
+        [40] = {
+                .name  = "instructions:uDp",
+                .check = test__checkevent_pinned_modifier,
+        },
+        [41] = {
+                .name  = "{cycles,cache-misses,branch-misses}:D",
+                .check = test__pinned_group,
+        },
 };
 
 static struct evlist_test test__events_pmu[] = {
@@ -1254,24 +1414,20 @@ static int test_events(struct evlist_test *events, unsigned cnt)
 
 static int test_term(struct terms_test *t)
 {
-        struct list_head *terms;
+        struct list_head terms;
         int ret;
 
-        terms = malloc(sizeof(*terms));
-        if (!terms)
-                return -ENOMEM;
-
-        INIT_LIST_HEAD(terms);
+        INIT_LIST_HEAD(&terms);
 
-        ret = parse_events_terms(terms, t->str);
+        ret = parse_events_terms(&terms, t->str);
         if (ret) {
                 pr_debug("failed to parse terms '%s', err %d\n",
                          t->str , ret);
                 return ret;
         }
 
-        ret = t->check(terms);
-        parse_events__free_terms(terms);
+        ret = t->check(&terms);
+        parse_events__free_terms(&terms);
 
         return ret;
 }
diff --git a/tools/perf/tests/parse-no-sample-id-all.c b/tools/perf/tests/parse-no-sample-id-all.c
new file mode 100644
index 000000000000..e117b6c6a248
--- /dev/null
+++ b/tools/perf/tests/parse-no-sample-id-all.c
@@ -0,0 +1,108 @@
+#include <sys/types.h>
+#include <stddef.h>
+
+#include "tests.h"
+
+#include "event.h"
+#include "evlist.h"
+#include "header.h"
+#include "util.h"
+
+static int process_event(struct perf_evlist **pevlist, union perf_event *event)
+{
+        struct perf_sample sample;
+
+        if (event->header.type == PERF_RECORD_HEADER_ATTR) {
+                if (perf_event__process_attr(NULL, event, pevlist)) {
+                        pr_debug("perf_event__process_attr failed\n");
+                        return -1;
+                }
+                return 0;
+        }
+
+        if (event->header.type >= PERF_RECORD_USER_TYPE_START)
+                return -1;
+
+        if (!*pevlist)
+                return -1;
+
+        if (perf_evlist__parse_sample(*pevlist, event, &sample)) {
+                pr_debug("perf_evlist__parse_sample failed\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+static int process_events(union perf_event **events, size_t count)
+{
+        struct perf_evlist *evlist = NULL;
+        int err = 0;
+        size_t i;
+
+        for (i = 0; i < count && !err; i++)
+                err = process_event(&evlist, events[i]);
+
+        if (evlist)
+                perf_evlist__delete(evlist);
+
+        return err;
+}
+
+struct test_attr_event {
+        struct attr_event attr;
+        u64 id;
+};
+
+/**
+ * test__parse_no_sample_id_all - test parsing with no sample_id_all bit set.
+ *
+ * This function tests parsing data produced on kernel's that do not support the
+ * sample_id_all bit.  Without the sample_id_all bit, non-sample events (such as
+ * mmap events) do not have an id sample appended, and consequently logic
+ * designed to determine the id will not work.  That case happens when there is
+ * more than one selected event, so this test processes three events: 2
+ * attributes representing the selected events and one mmap event.
+ *
+ * Return: %0 on success, %-1 if the test fails.
+ */
+int test__parse_no_sample_id_all(void)
+{
+        int err;
+
+        struct test_attr_event event1 = {
+                .attr = {
+                        .header = {
+                                .type = PERF_RECORD_HEADER_ATTR,
+                                .size = sizeof(struct test_attr_event),
+                        },
+                },
+                .id = 1,
+        };
+        struct test_attr_event event2 = {
+                .attr = {
+                        .header = {
+                                .type = PERF_RECORD_HEADER_ATTR,
+                                .size = sizeof(struct test_attr_event),
+                        },
+                },
+                .id = 2,
+        };
+        struct mmap_event event3 = {
+                .header = {
+                        .type = PERF_RECORD_MMAP,
+                        .size = sizeof(struct mmap_event),
+                },
+        };
+        union perf_event *events[] = {
+                (union perf_event *)&event1,
+                (union perf_event *)&event2,
+                (union perf_event *)&event3,
+        };
+
+        err = process_events(events, ARRAY_SIZE(events));
+        if (err)
+                return -1;
+
+        return 0;
+}
diff --git a/tools/perf/tests/perf-record.c b/tools/perf/tests/perf-record.c
index 72d8881873b0..b8a7056519ac 100644
--- a/tools/perf/tests/perf-record.c
+++ b/tools/perf/tests/perf-record.c
@@ -50,7 +50,7 @@ int test__PERF_RECORD(void)
         struct perf_sample sample;
         const char *cmd = "sleep";
         const char *argv[] = { cmd, "1", NULL, };
-        char *bname;
+        char *bname, *mmap_filename;
         u64 prev_time = 0;
         bool found_cmd_mmap = false,
              found_libc_mmap = false,
@@ -212,6 +212,7 @@ int test__PERF_RECORD(void)
 
                                 if ((type == PERF_RECORD_COMM ||
                                      type == PERF_RECORD_MMAP ||
+                                     type == PERF_RECORD_MMAP2 ||
                                      type == PERF_RECORD_FORK ||
                                      type == PERF_RECORD_EXIT) &&
                                      (pid_t)event->comm.pid != evlist->workload.pid) {
@@ -220,7 +221,8 @@ int test__PERF_RECORD(void)
                                 }
 
                                 if ((type == PERF_RECORD_COMM ||
-                                     type == PERF_RECORD_MMAP) &&
+                                     type == PERF_RECORD_MMAP ||
+                                     type == PERF_RECORD_MMAP2) &&
                                      event->comm.pid != event->comm.tid) {
                                         pr_debug("%s with different pid/tid!\n", name);
                                         ++errs;
@@ -236,7 +238,12 @@ int test__PERF_RECORD(void)
                                 case PERF_RECORD_EXIT:
                                         goto found_exit;
                                 case PERF_RECORD_MMAP:
-                                        bname = strrchr(event->mmap.filename, '/');
+                                        mmap_filename = event->mmap.filename;
+                                        goto check_bname;
+                                case PERF_RECORD_MMAP2:
+                                        mmap_filename = event->mmap2.filename;
+                                check_bname:
+                                        bname = strrchr(mmap_filename, '/');
                                         if (bname != NULL) {
                                                 if (!found_cmd_mmap)
                                                         found_cmd_mmap = !strcmp(bname + 1, cmd);
@@ -245,7 +252,7 @@ int test__PERF_RECORD(void)
                                                 if (!found_ld_mmap)
                                                         found_ld_mmap = !strncmp(bname + 1, "ld", 2);
                                         } else if (!found_vdso_mmap)
-                                                found_vdso_mmap = !strcmp(event->mmap.filename, "[vdso]");
+                                                found_vdso_mmap = !strcmp(mmap_filename, "[vdso]");
                                         break;
 
                                 case PERF_RECORD_SAMPLE:
diff --git a/tools/perf/tests/perf-time-to-tsc.c b/tools/perf/tests/perf-time-to-tsc.c
new file mode 100644
index 000000000000..0ab61b1f408e
--- /dev/null
+++ b/tools/perf/tests/perf-time-to-tsc.c
@@ -0,0 +1,177 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <sys/prctl.h>
+
+#include "parse-events.h"
+#include "evlist.h"
+#include "evsel.h"
+#include "thread_map.h"
+#include "cpumap.h"
+#include "tests.h"
+
+#include "../arch/x86/util/tsc.h"
+
+#define CHECK__(x) {                            \
+        while ((x) < 0) {                       \
+                pr_debug(#x " failed!\n");      \
+                goto out_err;                   \
+        }                                       \
+}
+
+#define CHECK_NOT_NULL__(x) {                   \
+        while ((x) == NULL) {                   \
+                pr_debug(#x " failed!\n");      \
+                goto out_err;                   \
+        }                                       \
+}
+
+static u64 rdtsc(void)
+{
+        unsigned int low, high;
+
+        asm volatile("rdtsc" : "=a" (low), "=d" (high));
+
+        return low | ((u64)high) << 32;
+}
+
+/**
+ * test__perf_time_to_tsc - test converting perf time to TSC.
+ *
+ * This function implements a test that checks that the conversion of perf time
+ * to and from TSC is consistent with the order of events.  If the test passes
+ * %0 is returned, otherwise %-1 is returned.  If TSC conversion is not
+ * supported then then the test passes but " (not supported)" is printed.
+ */
+int test__perf_time_to_tsc(void)
+{
+        struct perf_record_opts opts = {
+                .mmap_pages          = UINT_MAX,
+                .user_freq           = UINT_MAX,
+                .user_interval       = ULLONG_MAX,
+                .freq                = 4000,
+                .target              = {
+                        .uses_mmap   = true,
+                },
+                .sample_time         = true,
+        };
+        struct thread_map *threads = NULL;
+        struct cpu_map *cpus = NULL;
+        struct perf_evlist *evlist = NULL;
+        struct perf_evsel *evsel = NULL;
+        int err = -1, ret, i;
+        const char *comm1, *comm2;
+        struct perf_tsc_conversion tc;
+        struct perf_event_mmap_page *pc;
+        union perf_event *event;
+        u64 test_tsc, comm1_tsc, comm2_tsc;
+        u64 test_time, comm1_time = 0, comm2_time = 0;
+
+        threads = thread_map__new(-1, getpid(), UINT_MAX);
+        CHECK_NOT_NULL__(threads);
+
+        cpus = cpu_map__new(NULL);
+        CHECK_NOT_NULL__(cpus);
+
+        evlist = perf_evlist__new();
+        CHECK_NOT_NULL__(evlist);
+
+        perf_evlist__set_maps(evlist, cpus, threads);
+
+        CHECK__(parse_events(evlist, "cycles:u"));
+
+        perf_evlist__config(evlist, &opts);
+
+        evsel = perf_evlist__first(evlist);
+
+        evsel->attr.comm = 1;
+        evsel->attr.disabled = 1;
+        evsel->attr.enable_on_exec = 0;
+
+        CHECK__(perf_evlist__open(evlist));
+
+        CHECK__(perf_evlist__mmap(evlist, UINT_MAX, false));
+
+        pc = evlist->mmap[0].base;
+        ret = perf_read_tsc_conversion(pc, &tc);
+        if (ret) {
+                if (ret == -EOPNOTSUPP) {
+                        fprintf(stderr, " (not supported)");
+                        return 0;
+                }
+                goto out_err;
+        }
+
+        perf_evlist__enable(evlist);
+
+        comm1 = "Test COMM 1";
+        CHECK__(prctl(PR_SET_NAME, (unsigned long)comm1, 0, 0, 0));
+
+        test_tsc = rdtsc();
+
+        comm2 = "Test COMM 2";
+        CHECK__(prctl(PR_SET_NAME, (unsigned long)comm2, 0, 0, 0));
+
+        perf_evlist__disable(evlist);
+
+        for (i = 0; i < evlist->nr_mmaps; i++) {
+                while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
+                        struct perf_sample sample;
+
+                        if (event->header.type != PERF_RECORD_COMM ||
+                            (pid_t)event->comm.pid != getpid() ||
+                            (pid_t)event->comm.tid != getpid())
+                                continue;
+
+                        if (strcmp(event->comm.comm, comm1) == 0) {
+                                CHECK__(perf_evsel__parse_sample(evsel, event,
+                                                                 &sample));
+                                comm1_time = sample.time;
+                        }
+                        if (strcmp(event->comm.comm, comm2) == 0) {
+                                CHECK__(perf_evsel__parse_sample(evsel, event,
+                                                                 &sample));
+                                comm2_time = sample.time;
+                        }
+                }
+        }
+
+        if (!comm1_time || !comm2_time)
+                goto out_err;
+
+        test_time = tsc_to_perf_time(test_tsc, &tc);
+        comm1_tsc = perf_time_to_tsc(comm1_time, &tc);
+        comm2_tsc = perf_time_to_tsc(comm2_time, &tc);
+
+        pr_debug("1st event perf time %"PRIu64" tsc %"PRIu64"\n",
+                 comm1_time, comm1_tsc);
+        pr_debug("rdtsc          time %"PRIu64" tsc %"PRIu64"\n",
+                 test_time, test_tsc);
+        pr_debug("2nd event perf time %"PRIu64" tsc %"PRIu64"\n",
+                 comm2_time, comm2_tsc);
+
+        if (test_time <= comm1_time ||
+            test_time >= comm2_time)
+                goto out_err;
+
+        if (test_tsc <= comm1_tsc ||
+            test_tsc >= comm2_tsc)
+                goto out_err;
+
+        err = 0;
+
+out_err:
+        if (evlist) {
+                perf_evlist__disable(evlist);
+                perf_evlist__munmap(evlist);
+                perf_evlist__close(evlist);
+                perf_evlist__delete(evlist);
+        }
+        if (cpus)
+                cpu_map__delete(cpus);
+        if (threads)
+                thread_map__delete(threads);
+
+        return err;
+}
diff --git a/tools/perf/tests/sample-parsing.c b/tools/perf/tests/sample-parsing.c
new file mode 100644
index 000000000000..77f598dbd97a
--- /dev/null
+++ b/tools/perf/tests/sample-parsing.c
@@ -0,0 +1,316 @@
+#include <stdbool.h>
+#include <inttypes.h>
+
+#include "util.h"
+#include "event.h"
+#include "evsel.h"
+
+#include "tests.h"
+
+#define COMP(m) do {                                    \
+        if (s1->m != s2->m) {                           \
+                pr_debug("Samples differ at '"#m"'\n"); \
+                return false;                           \
+        }                                               \
+} while (0)
+
+#define MCOMP(m) do {                                   \
+        if (memcmp(&s1->m, &s2->m, sizeof(s1->m))) {    \
+                pr_debug("Samples differ at '"#m"'\n"); \
+                return false;                           \
+        }                                               \
+} while (0)
+
+static bool samples_same(const struct perf_sample *s1,
+                         const struct perf_sample *s2, u64 type, u64 regs_user,
+                         u64 read_format)
+{
+        size_t i;
+
+        if (type & PERF_SAMPLE_IDENTIFIER)
+                COMP(id);
+
+        if (type & PERF_SAMPLE_IP)
+                COMP(ip);
+
+        if (type & PERF_SAMPLE_TID) {
+                COMP(pid);
+                COMP(tid);
+        }
+
+        if (type & PERF_SAMPLE_TIME)
+                COMP(time);
+
+        if (type & PERF_SAMPLE_ADDR)
+                COMP(addr);
+
+        if (type & PERF_SAMPLE_ID)
+                COMP(id);
+
+        if (type & PERF_SAMPLE_STREAM_ID)
+                COMP(stream_id);
+
+        if (type & PERF_SAMPLE_CPU)
+                COMP(cpu);
+
+        if (type & PERF_SAMPLE_PERIOD)
+                COMP(period);
+
+        if (type & PERF_SAMPLE_READ) {
+                if (read_format & PERF_FORMAT_GROUP)
+                        COMP(read.group.nr);
+                else
+                        COMP(read.one.value);
+                if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
+                        COMP(read.time_enabled);
+                if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
+                        COMP(read.time_running);
+                /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */
+                if (read_format & PERF_FORMAT_GROUP) {
+                        for (i = 0; i < s1->read.group.nr; i++)
+                                MCOMP(read.group.values[i]);
+                } else {
+                        COMP(read.one.id);
+                }
+        }
+
+        if (type & PERF_SAMPLE_CALLCHAIN) {
+                COMP(callchain->nr);
+                for (i = 0; i < s1->callchain->nr; i++)
+                        COMP(callchain->ips[i]);
+        }
+
+        if (type & PERF_SAMPLE_RAW) {
+                COMP(raw_size);
+                if (memcmp(s1->raw_data, s2->raw_data, s1->raw_size)) {
+                        pr_debug("Samples differ at 'raw_data'\n");
+                        return false;
+                }
+        }
+
+        if (type & PERF_SAMPLE_BRANCH_STACK) {
+                COMP(branch_stack->nr);
+                for (i = 0; i < s1->branch_stack->nr; i++)
+                        MCOMP(branch_stack->entries[i]);
+        }
+
+        if (type & PERF_SAMPLE_REGS_USER) {
+                size_t sz = hweight_long(regs_user) * sizeof(u64);
+
+                COMP(user_regs.abi);
+                if (s1->user_regs.abi &&
+                    (!s1->user_regs.regs || !s2->user_regs.regs ||
+                     memcmp(s1->user_regs.regs, s2->user_regs.regs, sz))) {
+                        pr_debug("Samples differ at 'user_regs'\n");
+                        return false;
+                }
+        }
+
+        if (type & PERF_SAMPLE_STACK_USER) {
+                COMP(user_stack.size);
+                if (memcmp(s1->user_stack.data, s1->user_stack.data,
+                           s1->user_stack.size)) {
+                        pr_debug("Samples differ at 'user_stack'\n");
+                        return false;
+                }
+        }
+
+        if (type & PERF_SAMPLE_WEIGHT)
+                COMP(weight);
+
+        if (type & PERF_SAMPLE_DATA_SRC)
+                COMP(data_src);
+
+        return true;
+}
+
+static int do_test(u64 sample_type, u64 sample_regs_user, u64 read_format)
+{
+        struct perf_evsel evsel = {
+                .needs_swap = false,
+                .attr = {
+                        .sample_type = sample_type,
+                        .sample_regs_user = sample_regs_user,
+                        .read_format = read_format,
+                },
+        };
+        union perf_event *event;
+        union {
+                struct ip_callchain callchain;
+                u64 data[64];
+        } callchain = {
+                /* 3 ips */
+                .data = {3, 201, 202, 203},
+        };
+        union {
+                struct branch_stack branch_stack;
+                u64 data[64];
+        } branch_stack = {
+                /* 1 branch_entry */
+                .data = {1, 211, 212, 213},
+        };
+        u64 user_regs[64];
+        const u64 raw_data[] = {0x123456780a0b0c0dULL, 0x1102030405060708ULL};
+        const u64 data[] = {0x2211443366558877ULL, 0, 0xaabbccddeeff4321ULL};
+        struct perf_sample sample = {
+                .ip             = 101,
+                .pid            = 102,
+                .tid            = 103,
+                .time           = 104,
+                .addr           = 105,
+                .id             = 106,
+                .stream_id      = 107,
+                .period         = 108,
+                .weight         = 109,
+                .cpu            = 110,
+                .raw_size       = sizeof(raw_data),
+                .data_src       = 111,
+                .raw_data       = (void *)raw_data,
+                .callchain      = &callchain.callchain,
+                .branch_stack   = &branch_stack.branch_stack,
+                .user_regs      = {
+                        .abi    = PERF_SAMPLE_REGS_ABI_64,
+                        .regs   = user_regs,
+                },
+                .user_stack     = {
+                        .size   = sizeof(data),
+                        .data   = (void *)data,
+                },
+                .read           = {
+                        .time_enabled = 0x030a59d664fca7deULL,
+                        .time_running = 0x011b6ae553eb98edULL,
+                },
+        };
+        struct sample_read_value values[] = {{1, 5}, {9, 3}, {2, 7}, {6, 4},};
+        struct perf_sample sample_out;
+        size_t i, sz, bufsz;
+        int err, ret = -1;
+
+        for (i = 0; i < sizeof(user_regs); i++)
+                *(i + (u8 *)user_regs) = i & 0xfe;
+
+        if (read_format & PERF_FORMAT_GROUP) {
+                sample.read.group.nr     = 4;
+                sample.read.group.values = values;
+        } else {
+                sample.read.one.value = 0x08789faeb786aa87ULL;
+                sample.read.one.id    = 99;
+        }
+
+        sz = perf_event__sample_event_size(&sample, sample_type,
+                                           sample_regs_user, read_format);
+        bufsz = sz + 4096; /* Add a bit for overrun checking */
+        event = malloc(bufsz);
+        if (!event) {
+                pr_debug("malloc failed\n");
+                return -1;
+        }
+
+        memset(event, 0xff, bufsz);
+        event->header.type = PERF_RECORD_SAMPLE;
+        event->header.misc = 0;
+        event->header.size = sz;
+
+        err = perf_event__synthesize_sample(event, sample_type,
+                                            sample_regs_user, read_format,
+                                            &sample, false);
+        if (err) {
+                pr_debug("%s failed for sample_type %#"PRIx64", error %d\n",
+                         "perf_event__synthesize_sample", sample_type, err);
+                goto out_free;
+        }
+
+        /* The data does not contain 0xff so we use that to check the size */
+        for (i = bufsz; i > 0; i--) {
+                if (*(i - 1 + (u8 *)event) != 0xff)
+                        break;
+        }
+        if (i != sz) {
+                pr_debug("Event size mismatch: actual %zu vs expected %zu\n",
+                         i, sz);
+                goto out_free;
+        }
+
+        evsel.sample_size = __perf_evsel__sample_size(sample_type);
+
+        err = perf_evsel__parse_sample(&evsel, event, &sample_out);
+        if (err) {
+                pr_debug("%s failed for sample_type %#"PRIx64", error %d\n",
+                         "perf_evsel__parse_sample", sample_type, err);
+                goto out_free;
+        }
+
+        if (!samples_same(&sample, &sample_out, sample_type,
+                          sample_regs_user, read_format)) {
+                pr_debug("parsing failed for sample_type %#"PRIx64"\n",
+                         sample_type);
+                goto out_free;
+        }
+
+        ret = 0;
+out_free:
+        free(event);
+        if (ret && read_format)
+                pr_debug("read_format %#"PRIx64"\n", read_format);
+        return ret;
+}
+
+/**
+ * test__sample_parsing - test sample parsing.
+ *
+ * This function implements a test that synthesizes a sample event, parses it
+ * and then checks that the parsed sample matches the original sample.  The test
+ * checks sample format bits separately and together.  If the test passes %0 is
+ * returned, otherwise %-1 is returned.
+ */
+int test__sample_parsing(void)
+{
+        const u64 rf[] = {4, 5, 6, 7, 12, 13, 14, 15};
+        u64 sample_type;
+        u64 sample_regs_user;
+        size_t i;
+        int err;
+
+        /*
+         * Fail the test if it has not been updated when new sample format bits
+         * were added.
+         */
+        if (PERF_SAMPLE_MAX > PERF_SAMPLE_IDENTIFIER << 1) {
+                pr_debug("sample format has changed - test needs updating\n");
+                return -1;
+        }
+
+        /* Test each sample format bit separately */
+        for (sample_type = 1; sample_type != PERF_SAMPLE_MAX;
+             sample_type <<= 1) {
+                /* Test read_format variations */
+                if (sample_type == PERF_SAMPLE_READ) {
+                        for (i = 0; i < ARRAY_SIZE(rf); i++) {
+                                err = do_test(sample_type, 0, rf[i]);
+                                if (err)
+                                        return err;
+                        }
+                        continue;
+                }
+
+                if (sample_type == PERF_SAMPLE_REGS_USER)
+                        sample_regs_user = 0x3fff;
+                else
+                        sample_regs_user = 0;
+
+                err = do_test(sample_type, sample_regs_user, 0);
+                if (err)
+                        return err;
+        }
+
+        /* Test all sample format bits together */
+        sample_type = PERF_SAMPLE_MAX - 1;
+        sample_regs_user = 0x3fff;
+        for (i = 0; i < ARRAY_SIZE(rf); i++) {
+                err = do_test(sample_type, sample_regs_user, rf[i]);
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index dd7feae2d37b..e0ac713857ba 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -1,6 +1,14 @@
 #ifndef TESTS_H
 #define TESTS_H
 
+#define TEST_ASSERT_VAL(text, cond)                                      \
+do {                                                                     \
+        if (!(cond)) {                                                   \
+                pr_debug("FAILED %s:%d %s\n", __FILE__, __LINE__, text); \
+                return -1;                                               \
+        }                                                                \
+} while (0)
+
 enum {
         TEST_OK   =  0,
         TEST_FAIL = -1,
@@ -27,5 +35,10 @@ int test__bp_signal(void);
 int test__bp_signal_overflow(void);
 int test__task_exit(void);
 int test__sw_clock_freq(void);
+int test__perf_time_to_tsc(void);
+int test__code_reading(void);
+int test__sample_parsing(void);
+int test__keep_tracking(void);
+int test__parse_no_sample_id_all(void);
 
 #endif /* TESTS_H */
diff --git a/tools/perf/tests/vmlinux-kallsyms.c b/tools/perf/tests/vmlinux-kallsyms.c
index 7b4c4d26d1ba..2bd13edcbc17 100644
--- a/tools/perf/tests/vmlinux-kallsyms.c
+++ b/tools/perf/tests/vmlinux-kallsyms.c
@@ -16,6 +16,8 @@ static int vmlinux_matches_kallsyms_filter(struct map *map __maybe_unused,
         return 0;
 }
 
+#define UM(x) kallsyms_map->unmap_ip(kallsyms_map, (x))
+
 int test__vmlinux_matches_kallsyms(void)
 {
         int err = -1;
@@ -25,6 +27,7 @@ int test__vmlinux_matches_kallsyms(void)
         struct machine kallsyms, vmlinux;
         enum map_type type = MAP__FUNCTION;
         struct ref_reloc_sym ref_reloc_sym = { .name = "_stext", };
+        u64 mem_start, mem_end;
 
         /*
          * Step 1:
@@ -73,7 +76,7 @@ int test__vmlinux_matches_kallsyms(void)
                 goto out;
         }
 
-        ref_reloc_sym.addr = sym->start;
+        ref_reloc_sym.addr = UM(sym->start);
 
         /*
          * Step 5:
@@ -123,10 +126,14 @@ int test__vmlinux_matches_kallsyms(void)
                 if (sym->start == sym->end)
                         continue;
 
-                first_pair = machine__find_kernel_symbol(&kallsyms, type, sym->start, NULL, NULL);
+                mem_start = vmlinux_map->unmap_ip(vmlinux_map, sym->start);
+                mem_end = vmlinux_map->unmap_ip(vmlinux_map, sym->end);
+
+                first_pair = machine__find_kernel_symbol(&kallsyms, type,
+                                                         mem_start, NULL, NULL);
                 pair = first_pair;
 
-                if (pair && pair->start == sym->start) {
+                if (pair && UM(pair->start) == mem_start) {
 next_pair:
                         if (strcmp(sym->name, pair->name) == 0) {
                                 /*
@@ -138,12 +145,20 @@ next_pair:
                                  * off the real size. More than that and we
                                  * _really_ have a problem.
                                  */
-                                s64 skew = sym->end - pair->end;
-                                if (llabs(skew) < page_size)
-                                        continue;
+                                s64 skew = mem_end - UM(pair->end);
+                                if (llabs(skew) >= page_size)
+                                        pr_debug("%#" PRIx64 ": diff end addr for %s v: %#" PRIx64 " k: %#" PRIx64 "\n",
+                                                 mem_start, sym->name, mem_end,
+                                                 UM(pair->end));
+
+                                /*
+                                 * Do not count this as a failure, because we
+                                 * could really find a case where it's not
+                                 * possible to get proper function end from
+                                 * kallsyms.
+                                 */
+                                continue;
 
-                                pr_debug("%#" PRIx64 ": diff end addr for %s v: %#" PRIx64 " k: %#" PRIx64 "\n",
-                                         sym->start, sym->name, sym->end, pair->end);
                         } else {
                                 struct rb_node *nnd;
 detour:
@@ -152,7 +167,7 @@ detour:
                                 if (nnd) {
                                         struct symbol *next = rb_entry(nnd, struct symbol, rb_node);
 
-                                        if (next->start == sym->start) {
+                                        if (UM(next->start) == mem_start) {
                                                 pair = next;
                                                 goto next_pair;
                                         }
@@ -165,10 +180,11 @@ detour:
                                 }
 
                                 pr_debug("%#" PRIx64 ": diff name v: %s k: %s\n",
-                                         sym->start, sym->name, pair->name);
+                                         mem_start, sym->name, pair->name);
                         }
                 } else
-                        pr_debug("%#" PRIx64 ": %s not on kallsyms\n", sym->start, sym->name);
+                        pr_debug("%#" PRIx64 ": %s not on kallsyms\n",
+                                 mem_start, sym->name);
 
                 err = -1;
         }
@@ -201,16 +217,19 @@ detour:
         for (nd = rb_first(&vmlinux.kmaps.maps[type]); nd; nd = rb_next(nd)) {
                 struct map *pos = rb_entry(nd, struct map, rb_node), *pair;
 
-                pair = map_groups__find(&kallsyms.kmaps, type, pos->start);
+                mem_start = vmlinux_map->unmap_ip(vmlinux_map, pos->start);
+                mem_end = vmlinux_map->unmap_ip(vmlinux_map, pos->end);
+
+                pair = map_groups__find(&kallsyms.kmaps, type, mem_start);
                 if (pair == NULL || pair->priv)
                         continue;
 
-                if (pair->start == pos->start) {
+                if (pair->start == mem_start) {
                         pair->priv = 1;
                         pr_info(" %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s in kallsyms as",
                                 pos->start, pos->end, pos->pgoff, pos->dso->name);
-                        if (pos->pgoff != pair->pgoff || pos->end != pair->end)
-                                pr_info(": \n*%" PRIx64 "-%" PRIx64 " %" PRIx64 "",
+                        if (mem_end != pair->end)
+                                pr_info(":\n*%" PRIx64 "-%" PRIx64 " %" PRIx64,
                                         pair->start, pair->end, pair->pgoff);
                         pr_info(" %s\n", pair->dso->name);
                         pair->priv = 1;
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
index cc64d3f7fc36..08545ae46992 100644
--- a/tools/perf/ui/browsers/annotate.c
+++ b/tools/perf/ui/browsers/annotate.c
@@ -428,6 +428,14 @@ static void annotate_browser__init_asm_mode(struct annotate_browser *browser)
         browser->b.nr_entries = browser->nr_asm_entries;
 }
 
+#define SYM_TITLE_MAX_SIZE (PATH_MAX + 64)
+
+static int sym_title(struct symbol *sym, struct map *map, char *title,
+                     size_t sz)
+{
+        return snprintf(title, sz, "%s  %s", sym->name, map->dso->long_name);
+}
+
 static bool annotate_browser__callq(struct annotate_browser *browser,
                                     struct perf_evsel *evsel,
                                     struct hist_browser_timer *hbt)
@@ -438,6 +446,7 @@ static bool annotate_browser__callq(struct annotate_browser *browser,
         struct annotation *notes;
         struct symbol *target;
         u64 ip;
+        char title[SYM_TITLE_MAX_SIZE];
 
         if (!ins__is_call(dl->ins))
                 return false;
@@ -461,7 +470,8 @@ static bool annotate_browser__callq(struct annotate_browser *browser,
 
         pthread_mutex_unlock(&notes->lock);
         symbol__tui_annotate(target, ms->map, evsel, hbt);
-        ui_browser__show_title(&browser->b, sym->name);
+        sym_title(sym, ms->map, title, sizeof(title));
+        ui_browser__show_title(&browser->b, title);
         return true;
 }
 
@@ -495,7 +505,7 @@ static bool annotate_browser__jump(struct annotate_browser *browser)
 
         dl = annotate_browser__find_offset(browser, dl->ops.target.offset, &idx);
         if (dl == NULL) {
-                ui_helpline__puts("Invallid jump offset");
+                ui_helpline__puts("Invalid jump offset");
                 return true;
         }
 
@@ -653,8 +663,10 @@ static int annotate_browser__run(struct annotate_browser *browser,
         const char *help = "Press 'h' for help on key bindings";
         int delay_secs = hbt ? hbt->refresh : 0;
         int key;
+        char title[SYM_TITLE_MAX_SIZE];
 
-        if (ui_browser__show(&browser->b, sym->name, help) < 0)
+        sym_title(sym, ms->map, title, sizeof(title));
+        if (ui_browser__show(&browser->b, title, help) < 0)
                 return -1;
 
         annotate_browser__calc_percent(browser, evsel);
@@ -720,7 +732,7 @@ static int annotate_browser__run(struct annotate_browser *browser,
                 "s             Toggle source code view\n"
                 "/             Search string\n"
                 "r             Run available scripts\n"
-                "?             Search previous string\n");
+                "?             Search string backwards\n");
                         continue;
                 case 'r':
                         {
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index d88a2d0acb6d..7ef36c360471 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -25,7 +25,8 @@ struct hist_browser {
         struct map_symbol   *selection;
         int                  print_seq;
         bool                 show_dso;
-        bool                 has_symbols;
+        float                min_pcnt;
+        u64                  nr_pcnt_entries;
 };
 
 extern void hist_browser__init_hpp(void);
@@ -309,6 +310,8 @@ static void ui_browser__warn_lost_events(struct ui_browser *browser)
                 "Or reduce the sampling frequency.");
 }
 
+static void hist_browser__update_pcnt_entries(struct hist_browser *hb);
+
 static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
                              struct hist_browser_timer *hbt)
 {
@@ -318,6 +321,8 @@ static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
 
         browser->b.entries = &browser->hists->entries;
         browser->b.nr_entries = browser->hists->nr_entries;
+        if (browser->min_pcnt)
+                browser->b.nr_entries = browser->nr_pcnt_entries;
 
         hist_browser__refresh_dimensions(browser);
         hists__browser_title(browser->hists, title, sizeof(title), ev_name);
@@ -330,9 +335,18 @@ static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
                 key = ui_browser__run(&browser->b, delay_secs);
 
                 switch (key) {
-                case K_TIMER:
+                case K_TIMER: {
+                        u64 nr_entries;
                         hbt->timer(hbt->arg);
-                        ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
+
+                        if (browser->min_pcnt) {
+                                hist_browser__update_pcnt_entries(browser);
+                                nr_entries = browser->nr_pcnt_entries;
+                        } else {
+                                nr_entries = browser->hists->nr_entries;
+                        }
+
+                        ui_browser__update_nr_entries(&browser->b, nr_entries);
 
                         if (browser->hists->stats.nr_lost_warned !=
                             browser->hists->stats.nr_events[PERF_RECORD_LOST]) {
@@ -344,6 +358,7 @@ static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
                         hists__browser_title(browser->hists, title, sizeof(title), ev_name);
                         ui_browser__show_title(&browser->b, title);
                         continue;
+                }
                 case 'D': { /* Debug */
                         static int seq;
                         struct hist_entry *h = rb_entry(browser->b.top,
@@ -670,8 +685,10 @@ static u64 __hpp_get_##_field(struct hist_entry *he)			\
         return he->stat._field;                                         \
 }                                                                       \
                                                                         \
-static int hist_browser__hpp_color_##_type(struct perf_hpp *hpp,        \
-                                           struct hist_entry *he)       \
+static int                                                              \
+hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt __maybe_unused,\
+                                struct perf_hpp *hpp,                   \
+                                struct hist_entry *he)                  \
 {                                                                       \
         return __hpp__color_fmt(hpp, he, __hpp_get_##_field, _cb);      \
 }
@@ -686,8 +703,6 @@ __HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us, NULL)
 
 void hist_browser__init_hpp(void)
 {
-        perf_hpp__column_enable(PERF_HPP__OVERHEAD);
-
         perf_hpp__init();
 
         perf_hpp__format[PERF_HPP__OVERHEAD].color =
@@ -747,9 +762,9 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                         first = false;
 
                         if (fmt->color) {
-                                width -= fmt->color(&hpp, entry);
+                                width -= fmt->color(fmt, &hpp, entry);
                         } else {
-                                width -= fmt->entry(&hpp, entry);
+                                width -= fmt->entry(fmt, &hpp, entry);
                                 slsmg_printf("%s", s);
                         }
                 }
@@ -796,10 +811,15 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser)
 
         for (nd = browser->top; nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                float percent = h->stat.period * 100.0 /
+                                        hb->hists->stats.total_period;
 
                 if (h->filtered)
                         continue;
 
+                if (percent < hb->min_pcnt)
+                        continue;
+
                 row += hist_browser__show_entry(hb, h, row);
                 if (row == browser->height)
                         break;
@@ -808,10 +828,18 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser)
         return row;
 }
 
-static struct rb_node *hists__filter_entries(struct rb_node *nd)
+static struct rb_node *hists__filter_entries(struct rb_node *nd,
+                                             struct hists *hists,
+                                             float min_pcnt)
 {
         while (nd != NULL) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                float percent = h->stat.period * 100.0 /
+                                        hists->stats.total_period;
+
+                if (percent < min_pcnt)
+                        return NULL;
+
                 if (!h->filtered)
                         return nd;
 
@@ -821,11 +849,16 @@ static struct rb_node *hists__filter_entries(struct rb_node *nd)
         return NULL;
 }
 
-static struct rb_node *hists__filter_prev_entries(struct rb_node *nd)
+static struct rb_node *hists__filter_prev_entries(struct rb_node *nd,
+                                                  struct hists *hists,
+                                                  float min_pcnt)
 {
         while (nd != NULL) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
-                if (!h->filtered)
+                float percent = h->stat.period * 100.0 /
+                                        hists->stats.total_period;
+
+                if (!h->filtered && percent >= min_pcnt)
                         return nd;
 
                 nd = rb_prev(nd);
@@ -840,6 +873,9 @@ static void ui_browser__hists_seek(struct ui_browser *browser,
         struct hist_entry *h;
         struct rb_node *nd;
         bool first = true;
+        struct hist_browser *hb;
+
+        hb = container_of(browser, struct hist_browser, b);
 
         if (browser->nr_entries == 0)
                 return;
@@ -848,13 +884,15 @@ static void ui_browser__hists_seek(struct ui_browser *browser,
 
         switch (whence) {
         case SEEK_SET:
-                nd = hists__filter_entries(rb_first(browser->entries));
+                nd = hists__filter_entries(rb_first(browser->entries),
+                                           hb->hists, hb->min_pcnt);
                 break;
         case SEEK_CUR:
                 nd = browser->top;
                 goto do_offset;
         case SEEK_END:
-                nd = hists__filter_prev_entries(rb_last(browser->entries));
+                nd = hists__filter_prev_entries(rb_last(browser->entries),
+                                                hb->hists, hb->min_pcnt);
                 first = false;
                 break;
         default:
@@ -897,7 +935,8 @@ do_offset:
                                         break;
                                 }
                         }
-                        nd = hists__filter_entries(rb_next(nd));
+                        nd = hists__filter_entries(rb_next(nd), hb->hists,
+                                                   hb->min_pcnt);
                         if (nd == NULL)
                                 break;
                         --offset;
@@ -930,7 +969,8 @@ do_offset:
                                 }
                         }
 
-                        nd = hists__filter_prev_entries(rb_prev(nd));
+                        nd = hists__filter_prev_entries(rb_prev(nd), hb->hists,
+                                                        hb->min_pcnt);
                         if (nd == NULL)
                                 break;
                         ++offset;
@@ -1099,14 +1139,17 @@ static int hist_browser__fprintf_entry(struct hist_browser *browser,
 
 static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)
 {
-        struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries));
+        struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries),
+                                                   browser->hists,
+                                                   browser->min_pcnt);
         int printed = 0;
 
         while (nd) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
                 printed += hist_browser__fprintf_entry(browser, h, fp);
-                nd = hists__filter_entries(rb_next(nd));
+                nd = hists__filter_entries(rb_next(nd), browser->hists,
+                                           browser->min_pcnt);
         }
 
         return printed;
@@ -1155,10 +1198,6 @@ static struct hist_browser *hist_browser__new(struct hists *hists)
                 browser->b.refresh = hist_browser__refresh;
                 browser->b.seek = ui_browser__hists_seek;
                 browser->b.use_navkeypressed = true;
-                if (sort__branch_mode == 1)
-                        browser->has_symbols = sort_sym_from.list.next != NULL;
-                else
-                        browser->has_symbols = sort_sym.list.next != NULL;
         }
 
         return browser;
@@ -1217,7 +1256,7 @@ static int hists__browser_title(struct hists *hists, char *bf, size_t size,
                 printed += scnprintf(bf + printed, size - printed,
                                     ", Thread: %s(%d)",
                                     (thread->comm_set ? thread->comm : ""),
-                                    thread->pid);
+                                    thread->tid);
         if (dso)
                 printed += scnprintf(bf + printed, size - printed,
                                     ", DSO: %s", dso->short_name);
@@ -1329,11 +1368,25 @@ close_file_and_continue:
         return ret;
 }
 
+static void hist_browser__update_pcnt_entries(struct hist_browser *hb)
+{
+        u64 nr_entries = 0;
+        struct rb_node *nd = rb_first(&hb->hists->entries);
+
+        while (nd) {
+                nr_entries++;
+                nd = hists__filter_entries(rb_next(nd), hb->hists,
+                                           hb->min_pcnt);
+        }
+
+        hb->nr_pcnt_entries = nr_entries;
+}
 
 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                                     const char *helpline, const char *ev_name,
                                     bool left_exits,
                                     struct hist_browser_timer *hbt,
+                                    float min_pcnt,
                                     struct perf_session_env *env)
 {
         struct hists *hists = &evsel->hists;
@@ -1350,6 +1403,11 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
         if (browser == NULL)
                 return -1;
 
+        if (min_pcnt) {
+                browser->min_pcnt = min_pcnt;
+                hist_browser__update_pcnt_entries(browser);
+        }
+
         fstack = pstack__new(2);
         if (fstack == NULL)
                 goto out;
@@ -1386,7 +1444,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                          */
                         goto out_free_stack;
                 case 'a':
-                        if (!browser->has_symbols) {
+                        if (!sort__has_sym) {
                                 ui_browser__warning(&browser->b, delay_secs * 2,
                         "Annotation is only available for symbolic views, "
                         "include \"sym*\" in --sort to use it.");
@@ -1485,10 +1543,10 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                         continue;
                 }
 
-                if (!browser->has_symbols)
+                if (!sort__has_sym)
                         goto add_exit_option;
 
-                if (sort__branch_mode == 1) {
+                if (sort__mode == SORT_MODE__BRANCH) {
                         bi = browser->he_selection->branch_info;
                         if (browser->selection != NULL &&
                             bi &&
@@ -1521,7 +1579,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                     asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
                              (browser->hists->thread_filter ? "out of" : "into"),
                              (thread->comm_set ? thread->comm : ""),
-                             thread->pid) > 0)
+                             thread->tid) > 0)
                         zoom_thread = nr_options++;
 
                 if (dso != NULL &&
@@ -1644,7 +1702,7 @@ zoom_out_thread:
                         } else {
                                 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
                                                    thread->comm_set ? thread->comm : "",
-                                                   thread->pid);
+                                                   thread->tid);
                                 browser->hists->thread_filter = thread;
                                 sort_thread.elide = true;
                                 pstack__push(fstack, &browser->hists->thread_filter);
@@ -1689,6 +1747,7 @@ struct perf_evsel_menu {
         struct ui_browser b;
         struct perf_evsel *selection;
         bool lost_events, lost_events_warned;
+        float min_pcnt;
         struct perf_session_env *env;
 };
 
@@ -1782,6 +1841,7 @@ browse_hists:
                         ev_name = perf_evsel__name(pos);
                         key = perf_evsel__hists_browse(pos, nr_events, help,
                                                        ev_name, true, hbt,
+                                                       menu->min_pcnt,
                                                        menu->env);
                         ui_browser__show_title(&menu->b, title);
                         switch (key) {
@@ -1843,6 +1903,7 @@ static bool filter_group_entries(struct ui_browser *self __maybe_unused,
 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
                                            int nr_entries, const char *help,
                                            struct hist_browser_timer *hbt,
+                                           float min_pcnt,
                                            struct perf_session_env *env)
 {
         struct perf_evsel *pos;
@@ -1856,6 +1917,7 @@ static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
                         .nr_entries = nr_entries,
                         .priv       = evlist,
                 },
+                .min_pcnt = min_pcnt,
                 .env = env,
         };
 
@@ -1874,6 +1936,7 @@ static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
 
 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
                                   struct hist_browser_timer *hbt,
+                                  float min_pcnt,
                                   struct perf_session_env *env)
 {
         int nr_entries = evlist->nr_entries;
@@ -1885,7 +1948,8 @@ single_entry:
                 const char *ev_name = perf_evsel__name(first);
 
                 return perf_evsel__hists_browse(first, nr_entries, help,
-                                                ev_name, false, hbt, env);
+                                                ev_name, false, hbt, min_pcnt,
+                                                env);
         }
 
         if (symbol_conf.event_group) {
@@ -1901,5 +1965,5 @@ single_entry:
         }
 
         return __perf_evlist__tui_browse_hists(evlist, nr_entries, help,
-                                               hbt, env);
+                                               hbt, min_pcnt, env);
 }
diff --git a/tools/perf/ui/gtk/hists.c b/tools/perf/ui/gtk/hists.c
index 6f259b3d14e2..2ca66cc1160f 100644
--- a/tools/perf/ui/gtk/hists.c
+++ b/tools/perf/ui/gtk/hists.c
@@ -91,7 +91,8 @@ static u64 he_get_##_field(struct hist_entry *he)				\
         return he->stat._field;                                                 \
 }                                                                               \
                                                                                 \
-static int perf_gtk__hpp_color_##_type(struct perf_hpp *hpp,                    \
+static int perf_gtk__hpp_color_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \
+                                       struct perf_hpp *hpp,                    \
                                        struct hist_entry *he)                   \
 {                                                                               \
         return __hpp__color_fmt(hpp, he, he_get_##_field);                      \
@@ -108,8 +109,6 @@ __HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us)
 
 void perf_gtk__init_hpp(void)
 {
-        perf_hpp__column_enable(PERF_HPP__OVERHEAD);
-
         perf_hpp__init();
 
         perf_hpp__format[PERF_HPP__OVERHEAD].color =
@@ -124,16 +123,93 @@ void perf_gtk__init_hpp(void)
                                 perf_gtk__hpp_color_overhead_guest_us;
 }
 
-static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
+static void callchain_list__sym_name(struct callchain_list *cl,
+                                     char *bf, size_t bfsize)
+{
+        if (cl->ms.sym)
+                scnprintf(bf, bfsize, "%s", cl->ms.sym->name);
+        else
+                scnprintf(bf, bfsize, "%#" PRIx64, cl->ip);
+}
+
+static void perf_gtk__add_callchain(struct rb_root *root, GtkTreeStore *store,
+                                    GtkTreeIter *parent, int col, u64 total)
+{
+        struct rb_node *nd;
+        bool has_single_node = (rb_first(root) == rb_last(root));
+
+        for (nd = rb_first(root); nd; nd = rb_next(nd)) {
+                struct callchain_node *node;
+                struct callchain_list *chain;
+                GtkTreeIter iter, new_parent;
+                bool need_new_parent;
+                double percent;
+                u64 hits, child_total;
+
+                node = rb_entry(nd, struct callchain_node, rb_node);
+
+                hits = callchain_cumul_hits(node);
+                percent = 100.0 * hits / total;
+
+                new_parent = *parent;
+                need_new_parent = !has_single_node && (node->val_nr > 1);
+
+                list_for_each_entry(chain, &node->val, list) {
+                        char buf[128];
+
+                        gtk_tree_store_append(store, &iter, &new_parent);
+
+                        scnprintf(buf, sizeof(buf), "%5.2f%%", percent);
+                        gtk_tree_store_set(store, &iter, 0, buf, -1);
+
+                        callchain_list__sym_name(chain, buf, sizeof(buf));
+                        gtk_tree_store_set(store, &iter, col, buf, -1);
+
+                        if (need_new_parent) {
+                                /*
+                                 * Only show the top-most symbol in a callchain
+                                 * if it's not the only callchain.
+                                 */
+                                new_parent = iter;
+                                need_new_parent = false;
+                        }
+                }
+
+                if (callchain_param.mode == CHAIN_GRAPH_REL)
+                        child_total = node->children_hit;
+                else
+                        child_total = total;
+
+                /* Now 'iter' contains info of the last callchain_list */
+                perf_gtk__add_callchain(&node->rb_root, store, &iter, col,
+                                        child_total);
+        }
+}
+
+static void on_row_activated(GtkTreeView *view, GtkTreePath *path,
+                             GtkTreeViewColumn *col __maybe_unused,
+                             gpointer user_data __maybe_unused)
+{
+        bool expanded = gtk_tree_view_row_expanded(view, path);
+
+        if (expanded)
+                gtk_tree_view_collapse_row(view, path);
+        else
+                gtk_tree_view_expand_row(view, path, FALSE);
+}
+
+static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists,
+                                 float min_pcnt)
 {
         struct perf_hpp_fmt *fmt;
         GType col_types[MAX_COLUMNS];
         GtkCellRenderer *renderer;
         struct sort_entry *se;
-        GtkListStore *store;
+        GtkTreeStore *store;
         struct rb_node *nd;
         GtkWidget *view;
         int col_idx;
+        int sym_col = -1;
         int nr_cols;
         char s[512];
 
@@ -152,10 +228,13 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
                 if (se->elide)
                         continue;
 
+                if (se == &sort_sym)
+                        sym_col = nr_cols;
+
                 col_types[nr_cols++] = G_TYPE_STRING;
         }
 
-        store = gtk_list_store_newv(nr_cols, col_types);
+        store = gtk_tree_store_newv(nr_cols, col_types);
 
         view = gtk_tree_view_new();
 
@@ -164,7 +243,7 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
         col_idx = 0;
 
         perf_hpp__for_each_format(fmt) {
-                fmt->header(&hpp);
+                fmt->header(fmt, &hpp);
 
                 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
                                                             -1, ltrim(s),
@@ -182,6 +261,18 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
                                                             col_idx++, NULL);
         }
 
+        for (col_idx = 0; col_idx < nr_cols; col_idx++) {
+                GtkTreeViewColumn *column;
+
+                column = gtk_tree_view_get_column(GTK_TREE_VIEW(view), col_idx);
+                gtk_tree_view_column_set_resizable(column, TRUE);
+
+                if (col_idx == sym_col) {
+                        gtk_tree_view_set_expander_column(GTK_TREE_VIEW(view),
+                                                          column);
+                }
+        }
+
         gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
 
         g_object_unref(GTK_TREE_MODEL(store));
@@ -189,21 +280,26 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
         for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
                 GtkTreeIter iter;
+                float percent = h->stat.period * 100.0 /
+                                        hists->stats.total_period;
 
                 if (h->filtered)
                         continue;
 
-                gtk_list_store_append(store, &iter);
+                if (percent < min_pcnt)
+                        continue;
+
+                gtk_tree_store_append(store, &iter, NULL);
 
                 col_idx = 0;
 
                 perf_hpp__for_each_format(fmt) {
                         if (fmt->color)
-                                fmt->color(&hpp, h);
+                                fmt->color(fmt, &hpp, h);
                         else
-                                fmt->entry(&hpp, h);
+                                fmt->entry(fmt, &hpp, h);
 
-                        gtk_list_store_set(store, &iter, col_idx++, s, -1);
+                        gtk_tree_store_set(store, &iter, col_idx++, s, -1);
                 }
 
                 list_for_each_entry(se, &hist_entry__sort_list, list) {
@@ -213,16 +309,33 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
                         se->se_snprintf(h, s, ARRAY_SIZE(s),
                                         hists__col_len(hists, se->se_width_idx));
 
-                        gtk_list_store_set(store, &iter, col_idx++, s, -1);
+                        gtk_tree_store_set(store, &iter, col_idx++, s, -1);
+                }
+
+                if (symbol_conf.use_callchain && sort__has_sym) {
+                        u64 total;
+
+                        if (callchain_param.mode == CHAIN_GRAPH_REL)
+                                total = h->stat.period;
+                        else
+                                total = hists->stats.total_period;
+
+                        perf_gtk__add_callchain(&h->sorted_chain, store, &iter,
+                                                sym_col, total);
                 }
         }
 
+        gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
+
+        g_signal_connect(view, "row-activated",
+                         G_CALLBACK(on_row_activated), NULL);
         gtk_container_add(GTK_CONTAINER(window), view);
 }
 
 int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
                                   const char *help,
-                                  struct hist_browser_timer *hbt __maybe_unused)
+                                  struct hist_browser_timer *hbt __maybe_unused,
+                                  float min_pcnt)
 {
         struct perf_evsel *pos;
         GtkWidget *vbox;
@@ -286,7 +399,7 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
                                                         GTK_POLICY_AUTOMATIC,
                                                         GTK_POLICY_AUTOMATIC);
 
-                perf_gtk__show_hists(scrolled_window, hists);
+                perf_gtk__show_hists(scrolled_window, hists, min_pcnt);
 
                 tab_label = gtk_label_new(evname);
 
diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c
index 4bf91b09d62d..0a193281eba8 100644
--- a/tools/perf/ui/hist.c
+++ b/tools/perf/ui/hist.c
@@ -1,4 +1,5 @@
 #include <math.h>
+#include <linux/compiler.h>
 
 #include "../util/hist.h"
 #include "../util/util.h"
@@ -79,7 +80,8 @@ static int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
 }
 
 #define __HPP_HEADER_FN(_type, _str, _min_width, _unit_width)           \
-static int hpp__header_##_type(struct perf_hpp *hpp)                    \
+static int hpp__header_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \
+                               struct perf_hpp *hpp)                    \
 {                                                                       \
         int len = _min_width;                                           \
                                                                         \
@@ -92,7 +94,8 @@ static int hpp__header_##_type(struct perf_hpp *hpp)			\
 }
 
 #define __HPP_WIDTH_FN(_type, _min_width, _unit_width)                  \
-static int hpp__width_##_type(struct perf_hpp *hpp __maybe_unused)      \
+static int hpp__width_##_type(struct perf_hpp_fmt *fmt __maybe_unused,  \
+                              struct perf_hpp *hpp __maybe_unused)      \
 {                                                                       \
         int len = _min_width;                                           \
                                                                         \
@@ -110,14 +113,16 @@ static u64 he_get_##_field(struct hist_entry *he)				\
         return he->stat._field;                                                 \
 }                                                                               \
                                                                                 \
-static int hpp__color_##_type(struct perf_hpp *hpp, struct hist_entry *he)      \
+static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused,          \
+                              struct perf_hpp *hpp, struct hist_entry *he)      \
 {                                                                               \
         return __hpp__fmt(hpp, he, he_get_##_field, " %6.2f%%",                 \
                           (hpp_snprint_fn)percent_color_snprintf, true);        \
 }
 
 #define __HPP_ENTRY_PERCENT_FN(_type, _field)                                   \
-static int hpp__entry_##_type(struct perf_hpp *hpp, struct hist_entry *he)      \
+static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused,         \
+                              struct perf_hpp *hpp, struct hist_entry *he)      \
 {                                                                               \
         const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%";         \
         return __hpp__fmt(hpp, he, he_get_##_field, fmt,                        \
@@ -130,7 +135,8 @@ static u64 he_get_raw_##_field(struct hist_entry *he)				\
         return he->stat._field;                                                 \
 }                                                                               \
                                                                                 \
-static int hpp__entry_##_type(struct perf_hpp *hpp, struct hist_entry *he)      \
+static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused,         \
+                              struct perf_hpp *hpp, struct hist_entry *he)      \
 {                                                                               \
         const char *fmt = symbol_conf.field_sep ? " %"PRIu64 : " %11"PRIu64;    \
         return __hpp__fmt(hpp, he, he_get_raw_##_field, fmt, scnprintf, false); \
@@ -157,196 +163,6 @@ HPP_PERCENT_FNS(overhead_guest_us, "guest usr", period_guest_us, 9, 8)
 HPP_RAW_FNS(samples, "Samples", nr_events, 12, 12)
 HPP_RAW_FNS(period, "Period", period, 12, 12)
 
-
-static int hpp__header_baseline(struct perf_hpp *hpp)
-{
-        return scnprintf(hpp->buf, hpp->size, "Baseline");
-}
-
-static int hpp__width_baseline(struct perf_hpp *hpp __maybe_unused)
-{
-        return 8;
-}
-
-static double baseline_percent(struct hist_entry *he)
-{
-        struct hist_entry *pair = hist_entry__next_pair(he);
-        struct hists *pair_hists = pair ? pair->hists : NULL;
-        double percent = 0.0;
-
-        if (pair) {
-                u64 total_period = pair_hists->stats.total_period;
-                u64 base_period  = pair->stat.period;
-
-                percent = 100.0 * base_period / total_period;
-        }
-
-        return percent;
-}
-
-static int hpp__color_baseline(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        double percent = baseline_percent(he);
-
-        if (hist_entry__has_pairs(he) || symbol_conf.field_sep)
-                return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%%", percent);
-        else
-                return scnprintf(hpp->buf, hpp->size, "        ");
-}
-
-static int hpp__entry_baseline(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        double percent = baseline_percent(he);
-        const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%%";
-
-        if (hist_entry__has_pairs(he) || symbol_conf.field_sep)
-                return scnprintf(hpp->buf, hpp->size, fmt, percent);
-        else
-                return scnprintf(hpp->buf, hpp->size, "            ");
-}
-
-static int hpp__header_period_baseline(struct perf_hpp *hpp)
-{
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%12s";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, "Period Base");
-}
-
-static int hpp__width_period_baseline(struct perf_hpp *hpp __maybe_unused)
-{
-        return 12;
-}
-
-static int hpp__entry_period_baseline(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        struct hist_entry *pair = hist_entry__next_pair(he);
-        u64 period = pair ? pair->stat.period : 0;
-        const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%12" PRIu64;
-
-        return scnprintf(hpp->buf, hpp->size, fmt, period);
-}
-
-static int hpp__header_delta(struct perf_hpp *hpp)
-{
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%7s";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, "Delta");
-}
-
-static int hpp__width_delta(struct perf_hpp *hpp __maybe_unused)
-{
-        return 7;
-}
-
-static int hpp__entry_delta(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        struct hist_entry *pair = hist_entry__next_pair(he);
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%7.7s";
-        char buf[32] = " ";
-        double diff = 0.0;
-
-        if (pair) {
-                if (he->diff.computed)
-                        diff = he->diff.period_ratio_delta;
-                else
-                        diff = perf_diff__compute_delta(he, pair);
-        } else
-                diff = perf_diff__period_percent(he, he->stat.period);
-
-        if (fabs(diff) >= 0.01)
-                scnprintf(buf, sizeof(buf), "%+4.2F%%", diff);
-
-        return scnprintf(hpp->buf, hpp->size, fmt, buf);
-}
-
-static int hpp__header_ratio(struct perf_hpp *hpp)
-{
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%14s";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, "Ratio");
-}
-
-static int hpp__width_ratio(struct perf_hpp *hpp __maybe_unused)
-{
-        return 14;
-}
-
-static int hpp__entry_ratio(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        struct hist_entry *pair = hist_entry__next_pair(he);
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%14s";
-        char buf[32] = " ";
-        double ratio = 0.0;
-
-        if (pair) {
-                if (he->diff.computed)
-                        ratio = he->diff.period_ratio;
-                else
-                        ratio = perf_diff__compute_ratio(he, pair);
-        }
-
-        if (ratio > 0.0)
-                scnprintf(buf, sizeof(buf), "%+14.6F", ratio);
-
-        return scnprintf(hpp->buf, hpp->size, fmt, buf);
-}
-
-static int hpp__header_wdiff(struct perf_hpp *hpp)
-{
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%14s";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, "Weighted diff");
-}
-
-static int hpp__width_wdiff(struct perf_hpp *hpp __maybe_unused)
-{
-        return 14;
-}
-
-static int hpp__entry_wdiff(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        struct hist_entry *pair = hist_entry__next_pair(he);
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%14s";
-        char buf[32] = " ";
-        s64 wdiff = 0;
-
-        if (pair) {
-                if (he->diff.computed)
-                        wdiff = he->diff.wdiff;
-                else
-                        wdiff = perf_diff__compute_wdiff(he, pair);
-        }
-
-        if (wdiff != 0)
-                scnprintf(buf, sizeof(buf), "%14ld", wdiff);
-
-        return scnprintf(hpp->buf, hpp->size, fmt, buf);
-}
-
-static int hpp__header_formula(struct perf_hpp *hpp)
-{
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%70s";
-
-        return scnprintf(hpp->buf, hpp->size, fmt, "Formula");
-}
-
-static int hpp__width_formula(struct perf_hpp *hpp __maybe_unused)
-{
-        return 70;
-}
-
-static int hpp__entry_formula(struct perf_hpp *hpp, struct hist_entry *he)
-{
-        struct hist_entry *pair = hist_entry__next_pair(he);
-        const char *fmt = symbol_conf.field_sep ? "%s" : "%-70s";
-        char buf[96] = " ";
-
-        if (pair)
-                perf_diff__formula(he, pair, buf, sizeof(buf));
-
-        return scnprintf(hpp->buf, hpp->size, fmt, buf);
-}
-
 #define HPP__COLOR_PRINT_FNS(_name)                     \
         {                                               \
                 .header = hpp__header_ ## _name,        \
@@ -363,19 +179,13 @@ static int hpp__entry_formula(struct perf_hpp *hpp, struct hist_entry *he)
         }
 
 struct perf_hpp_fmt perf_hpp__format[] = {
-        HPP__COLOR_PRINT_FNS(baseline),
         HPP__COLOR_PRINT_FNS(overhead),
         HPP__COLOR_PRINT_FNS(overhead_sys),
         HPP__COLOR_PRINT_FNS(overhead_us),
         HPP__COLOR_PRINT_FNS(overhead_guest_sys),
         HPP__COLOR_PRINT_FNS(overhead_guest_us),
         HPP__PRINT_FNS(samples),
-        HPP__PRINT_FNS(period),
-        HPP__PRINT_FNS(period_baseline),
-        HPP__PRINT_FNS(delta),
-        HPP__PRINT_FNS(ratio),
-        HPP__PRINT_FNS(wdiff),
-        HPP__PRINT_FNS(formula)
+        HPP__PRINT_FNS(period)
 };
 
 LIST_HEAD(perf_hpp__list);
@@ -396,6 +206,8 @@ LIST_HEAD(perf_hpp__list);
 
 void perf_hpp__init(void)
 {
+        perf_hpp__column_enable(PERF_HPP__OVERHEAD);
+
         if (symbol_conf.show_cpu_utilization) {
                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS);
                 perf_hpp__column_enable(PERF_HPP__OVERHEAD_US);
@@ -424,46 +236,6 @@ void perf_hpp__column_enable(unsigned col)
         perf_hpp__column_register(&perf_hpp__format[col]);
 }
 
-static inline void advance_hpp(struct perf_hpp *hpp, int inc)
-{
-        hpp->buf  += inc;
-        hpp->size -= inc;
-}
-
-int hist_entry__period_snprintf(struct perf_hpp *hpp, struct hist_entry *he,
-                                bool color)
-{
-        const char *sep = symbol_conf.field_sep;
-        struct perf_hpp_fmt *fmt;
-        char *start = hpp->buf;
-        int ret;
-        bool first = true;
-
-        if (symbol_conf.exclude_other && !he->parent)
-                return 0;
-
-        perf_hpp__for_each_format(fmt) {
-                /*
-                 * If there's no field_sep, we still need
-                 * to display initial '  '.
-                 */
-                if (!sep || !first) {
-                        ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
-                        advance_hpp(hpp, ret);
-                } else
-                        first = false;
-
-                if (color && fmt->color)
-                        ret = fmt->color(hpp, he);
-                else
-                        ret = fmt->entry(hpp, he);
-
-                advance_hpp(hpp, ret);
-        }
-
-        return hpp->buf - start;
-}
-
 int hist_entry__sort_snprintf(struct hist_entry *he, char *s, size_t size,
                               struct hists *hists)
 {
@@ -499,7 +271,7 @@ unsigned int hists__sort_list_width(struct hists *hists)
                 if (i)
                         ret += 2;
 
-                ret += fmt->width(&dummy_hpp);
+                ret += fmt->width(fmt, &dummy_hpp);
         }
 
         list_for_each_entry(se, &hist_entry__sort_list, list)
diff --git a/tools/perf/ui/setup.c b/tools/perf/ui/setup.c
index ae6a789cb0f6..47d9a571f261 100644
--- a/tools/perf/ui/setup.c
+++ b/tools/perf/ui/setup.c
@@ -30,7 +30,6 @@ void setup_browser(bool fallback_to_pager)
                 if (fallback_to_pager)
                         setup_pager();
 
-                perf_hpp__column_enable(PERF_HPP__OVERHEAD);
                 perf_hpp__init();
                 break;
         }
diff --git a/tools/perf/ui/stdio/hist.c b/tools/perf/ui/stdio/hist.c
index ff1f60cf442e..194e2f42ff5d 100644
--- a/tools/perf/ui/stdio/hist.c
+++ b/tools/perf/ui/stdio/hist.c
@@ -308,10 +308,51 @@ static size_t hist_entry__callchain_fprintf(struct hist_entry *he,
         return hist_entry_callchain__fprintf(he, total_period, left_margin, fp);
 }
 
+static inline void advance_hpp(struct perf_hpp *hpp, int inc)
+{
+        hpp->buf  += inc;
+        hpp->size -= inc;
+}
+
+static int hist_entry__period_snprintf(struct perf_hpp *hpp,
+                                       struct hist_entry *he,
+                                       bool color)
+{
+        const char *sep = symbol_conf.field_sep;
+        struct perf_hpp_fmt *fmt;
+        char *start = hpp->buf;
+        int ret;
+        bool first = true;
+
+        if (symbol_conf.exclude_other && !he->parent)
+                return 0;
+
+        perf_hpp__for_each_format(fmt) {
+                /*
+                 * If there's no field_sep, we still need
+                 * to display initial '  '.
+                 */
+                if (!sep || !first) {
+                        ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
+                        advance_hpp(hpp, ret);
+                } else
+                        first = false;
+
+                if (color && fmt->color)
+                        ret = fmt->color(fmt, hpp, he);
+                else
+                        ret = fmt->entry(fmt, hpp, he);
+
+                advance_hpp(hpp, ret);
+        }
+
+        return hpp->buf - start;
+}
+
 static int hist_entry__fprintf(struct hist_entry *he, size_t size,
-                               struct hists *hists, FILE *fp)
+                               struct hists *hists,
+                               char *bf, size_t bfsz, FILE *fp)
 {
-        char bf[512];
         int ret;
         struct perf_hpp hpp = {
                 .buf            = bf,
@@ -319,8 +360,8 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,
         };
         bool color = !symbol_conf.field_sep;
 
-        if (size == 0 || size > sizeof(bf))
-                size = hpp.size = sizeof(bf);
+        if (size == 0 || size > bfsz)
+                size = hpp.size = bfsz;
 
         ret = hist_entry__period_snprintf(&hpp, he, color);
         hist_entry__sort_snprintf(he, bf + ret, size - ret, hists);
@@ -334,7 +375,7 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,
 }
 
 size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
-                      int max_cols, FILE *fp)
+                      int max_cols, float min_pcnt, FILE *fp)
 {
         struct perf_hpp_fmt *fmt;
         struct sort_entry *se;
@@ -351,6 +392,8 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
                 .ptr    = hists_to_evsel(hists),
         };
         bool first = true;
+        size_t linesz;
+        char *line = NULL;
 
         init_rem_hits();
 
@@ -365,7 +408,7 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
                 else
                         first = false;
 
-                fmt->header(&dummy_hpp);
+                fmt->header(fmt, &dummy_hpp);
                 fprintf(fp, "%s", bf);
         }
 
@@ -410,7 +453,7 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
                 else
                         first = false;
 
-                width = fmt->width(&dummy_hpp);
+                width = fmt->width(fmt, &dummy_hpp);
                 for (i = 0; i < width; i++)
                         fprintf(fp, ".");
         }
@@ -438,16 +481,28 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
                 goto out;
 
 print_entries:
+        linesz = hists__sort_list_width(hists) + 3 + 1;
+        line = malloc(linesz);
+        if (line == NULL) {
+                ret = -1;
+                goto out;
+        }
+
         for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                float percent = h->stat.period * 100.0 /
+                                        hists->stats.total_period;
 
                 if (h->filtered)
                         continue;
 
-                ret += hist_entry__fprintf(h, max_cols, hists, fp);
+                if (percent < min_pcnt)
+                        continue;
+
+                ret += hist_entry__fprintf(h, max_cols, hists, line, linesz, fp);
 
                 if (max_rows && ++nr_rows >= max_rows)
-                        goto out;
+                        break;
 
                 if (h->ms.map == NULL && verbose > 1) {
                         __map_groups__fprintf_maps(&h->thread->mg,
@@ -455,6 +510,8 @@ print_entries:
                         fprintf(fp, "%.10s end\n", graph_dotted_line);
                 }
         }
+
+        free(line);
 out:
         free(rem_sq_bracket);
 
diff --git a/tools/perf/util/PERF-VERSION-GEN b/tools/perf/util/PERF-VERSION-GEN
index 055fef34b6f6..15a77b7c0e36 100755
--- a/tools/perf/util/PERF-VERSION-GEN
+++ b/tools/perf/util/PERF-VERSION-GEN
@@ -13,13 +13,22 @@ LF='
 # First check if there is a .git to get the version from git describe
 # otherwise try to get the version from the kernel Makefile
 #
-if test -d ../../.git -o -f ../../.git &&
-        VN=$(git tag 2>/dev/null | tail -1 | grep -E "v[0-9].[0-9]*")
+CID=
+TAG=
+if test -d ../../.git -o -f ../../.git
 then
-        VN=$(echo $VN"-g"$(git log -1 --abbrev=4 --pretty=format:"%h" HEAD))
-        VN=$(echo "$VN" | sed -e 's/-/./g');
-else
-        VN=$(MAKEFLAGS= make -sC ../.. kernelversion)
+        TAG=$(git describe --abbrev=0 --match "v[0-9].[0-9]*" 2>/dev/null )
+        CID=$(git log -1 --abbrev=4 --pretty=format:"%h" 2>/dev/null) && CID="-g$CID"
+fi
+if test -z "$TAG"
+then
+        TAG=$(MAKEFLAGS= make -sC ../.. kernelversion)
+fi
+VN="$TAG$CID"
+if test -n "$CID"
+then
+        # format version string, strip trailing zero of sublevel:
+        VN=$(echo "$VN" | sed -e 's/-/./g;s/\([0-9]*[.][0-9]*\)[.]0/\1/')
 fi
 
 VN=$(expr "$VN" : v*'\(.*\)')
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index d102716c43a1..7eae5488ecea 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -110,10 +110,10 @@ static int jump__parse(struct ins_operands *ops)
 {
         const char *s = strchr(ops->raw, '+');
 
-        ops->target.addr = strtoll(ops->raw, NULL, 16);
+        ops->target.addr = strtoull(ops->raw, NULL, 16);
 
         if (s++ != NULL)
-                ops->target.offset = strtoll(s, NULL, 16);
+                ops->target.offset = strtoull(s, NULL, 16);
         else
                 ops->target.offset = UINT64_MAX;
 
@@ -809,7 +809,7 @@ static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
                     end = map__rip_2objdump(map, sym->end);
 
                 offset = line_ip - start;
-                if (offset < 0 || (u64)line_ip > end)
+                if ((u64)line_ip < start || (u64)line_ip > end)
                         offset = -1;
                 else
                         parsed_line = tmp2 + 1;
@@ -821,11 +821,55 @@ static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
         if (dl == NULL)
                 return -1;
 
+        if (dl->ops.target.offset == UINT64_MAX)
+                dl->ops.target.offset = dl->ops.target.addr -
+                                        map__rip_2objdump(map, sym->start);
+
+        /*
+         * kcore has no symbols, so add the call target name if it is on the
+         * same map.
+         */
+        if (dl->ins && ins__is_call(dl->ins) && !dl->ops.target.name) {
+                struct symbol *s;
+                u64 ip = dl->ops.target.addr;
+
+                if (ip >= map->start && ip <= map->end) {
+                        ip = map->map_ip(map, ip);
+                        s = map__find_symbol(map, ip, NULL);
+                        if (s && s->start == ip)
+                                dl->ops.target.name = strdup(s->name);
+                }
+        }
+
         disasm__add(&notes->src->source, dl);
 
         return 0;
 }
 
+static void delete_last_nop(struct symbol *sym)
+{
+        struct annotation *notes = symbol__annotation(sym);
+        struct list_head *list = &notes->src->source;
+        struct disasm_line *dl;
+
+        while (!list_empty(list)) {
+                dl = list_entry(list->prev, struct disasm_line, node);
+
+                if (dl->ins && dl->ins->ops) {
+                        if (dl->ins->ops != &nop_ops)
+                                return;
+                } else {
+                        if (!strstr(dl->line, " nop ") &&
+                            !strstr(dl->line, " nopl ") &&
+                            !strstr(dl->line, " nopw "))
+                                return;
+                }
+
+                list_del(&dl->node);
+                disasm_line__free(dl);
+        }
+}
+
 int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize)
 {
         struct dso *dso = map->dso;
@@ -864,7 +908,8 @@ fallback:
                 free_filename = false;
         }
 
-        if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS) {
+        if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
+            !dso__is_kcore(dso)) {
                 char bf[BUILD_ID_SIZE * 2 + 16] = " with build id ";
                 char *build_id_msg = NULL;
 
@@ -898,7 +943,7 @@ fallback:
         snprintf(command, sizeof(command),
                  "%s %s%s --start-address=0x%016" PRIx64
                  " --stop-address=0x%016" PRIx64
-                 " -d %s %s -C %s|grep -v %s|expand",
+                 " -d %s %s -C %s 2>/dev/null|grep -v %s|expand",
                  objdump_path ? objdump_path : "objdump",
                  disassembler_style ? "-M " : "",
                  disassembler_style ? disassembler_style : "",
@@ -918,6 +963,13 @@ fallback:
                 if (symbol__parse_objdump_line(sym, map, file, privsize) < 0)
                         break;
 
+        /*
+         * kallsyms does not have symbol sizes so there may a nop at the end.
+         * Remove it.
+         */
+        if (dso__is_kcore(dso))
+                delete_last_nop(sym);
+
         pclose(file);
 out_free_filename:
         if (free_filename)
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 5295625c0c00..7ded71d19d75 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -18,13 +18,14 @@
 
 int build_id__mark_dso_hit(struct perf_tool *tool __maybe_unused,
                            union perf_event *event,
-                           struct perf_sample *sample __maybe_unused,
+                           struct perf_sample *sample,
                            struct perf_evsel *evsel __maybe_unused,
                            struct machine *machine)
 {
         struct addr_location al;
         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-        struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
+        struct thread *thread = machine__findnew_thread(machine, sample->pid,
+                                                        sample->pid);
 
         if (thread == NULL) {
                 pr_err("problem processing %d event, skipping it.\n",
@@ -33,7 +34,7 @@ int build_id__mark_dso_hit(struct perf_tool *tool __maybe_unused,
         }
 
         thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
-                              event->ip.ip, &al);
+                              sample->ip, &al);
 
         if (al.map != NULL)
                 al.map->dso->hit = 1;
@@ -47,7 +48,9 @@ static int perf_event__exit_del_thread(struct perf_tool *tool __maybe_unused,
                                        __maybe_unused,
                                        struct machine *machine)
 {
-        struct thread *thread = machine__findnew_thread(machine, event->fork.tid);
+        struct thread *thread = machine__findnew_thread(machine,
+                                                        event->fork.pid,
+                                                        event->fork.tid);
 
         dump_printf("(%d:%d):(%d:%d)\n", event->fork.pid, event->fork.tid,
                     event->fork.ppid, event->fork.ptid);
@@ -64,6 +67,7 @@ static int perf_event__exit_del_thread(struct perf_tool *tool __maybe_unused,
 struct perf_tool build_id__mark_dso_hit_ops = {
         .sample = build_id__mark_dso_hit,
         .mmap   = perf_event__process_mmap,
+        .mmap2  = perf_event__process_mmap2,
         .fork   = perf_event__process_fork,
         .exit   = perf_event__exit_del_thread,
         .attr            = perf_event__process_attr,
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 42b6a632fe7b..482f68081cd8 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -15,19 +15,12 @@
 #include <errno.h>
 #include <math.h>
 
+#include "hist.h"
 #include "util.h"
 #include "callchain.h"
 
 __thread struct callchain_cursor callchain_cursor;
 
-bool ip_callchain__valid(struct ip_callchain *chain,
-                         const union perf_event *event)
-{
-        unsigned int chain_size = event->header.size;
-        chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
-        return chain->nr * sizeof(u64) <= chain_size;
-}
-
 #define chain_for_each_child(child, parent)     \
         list_for_each_entry(child, &parent->children, siblings)
 
@@ -327,7 +320,8 @@ append_chain(struct callchain_node *root,
         /*
          * Lookup in the current node
          * If we have a symbol, then compare the start to match
-         * anywhere inside a function.
+         * anywhere inside a function, unless function
+         * mode is disabled.
          */
         list_for_each_entry(cnode, &root->val, list) {
                 struct callchain_cursor_node *node;
@@ -339,7 +333,8 @@ append_chain(struct callchain_node *root,
 
                 sym = node->sym;
 
-                if (cnode->ms.sym && sym) {
+                if (cnode->ms.sym && sym &&
+                    callchain_param.key == CCKEY_FUNCTION) {
                         if (cnode->ms.sym->start != sym->start)
                                 break;
                 } else if (cnode->ip != node->ip)
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index 3ee9f67d5af0..2b585bc308cf 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -41,12 +41,18 @@ struct callchain_param;
 typedef void (*sort_chain_func_t)(struct rb_root *, struct callchain_root *,
                                  u64, struct callchain_param *);
 
+enum chain_key {
+        CCKEY_FUNCTION,
+        CCKEY_ADDRESS
+};
+
 struct callchain_param {
         enum chain_mode         mode;
         u32                     print_limit;
         double                  min_percent;
         sort_chain_func_t       sort;
         enum chain_order        order;
+        enum chain_key          key;
 };
 
 struct callchain_list {
@@ -103,11 +109,6 @@ int callchain_append(struct callchain_root *root,
 int callchain_merge(struct callchain_cursor *cursor,
                     struct callchain_root *dst, struct callchain_root *src);
 
-struct ip_callchain;
-union perf_event;
-
-bool ip_callchain__valid(struct ip_callchain *chain,
-                         const union perf_event *event);
 /*
  * Initialize a cursor before adding entries inside, but keep
  * the previously allocated entries as a cache.
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
index 9bed02e5fb3d..b123bb9d6f55 100644
--- a/tools/perf/util/cpumap.h
+++ b/tools/perf/util/cpumap.h
@@ -41,7 +41,7 @@ static inline int cpu_map__nr(const struct cpu_map *map)
         return map ? map->nr : 1;
 }
 
-static inline bool cpu_map__all(const struct cpu_map *map)
+static inline bool cpu_map__empty(const struct cpu_map *map)
 {
         return map ? map->map[0] == -1 : true;
 }
diff --git a/tools/perf/util/dso.c b/tools/perf/util/dso.c
index 6f7d5a9d6b05..e3c1ff8512c8 100644
--- a/tools/perf/util/dso.c
+++ b/tools/perf/util/dso.c
@@ -78,6 +78,8 @@ int dso__binary_type_file(struct dso *dso, enum dso_binary_type type,
                          symbol_conf.symfs, build_id_hex, build_id_hex + 2);
                 break;
 
+        case DSO_BINARY_TYPE__VMLINUX:
+        case DSO_BINARY_TYPE__GUEST_VMLINUX:
         case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
                 snprintf(file, size, "%s%s",
                          symbol_conf.symfs, dso->long_name);
@@ -93,11 +95,14 @@ int dso__binary_type_file(struct dso *dso, enum dso_binary_type type,
                          dso->long_name);
                 break;
 
+        case DSO_BINARY_TYPE__KCORE:
+        case DSO_BINARY_TYPE__GUEST_KCORE:
+                snprintf(file, size, "%s", dso->long_name);
+                break;
+
         default:
         case DSO_BINARY_TYPE__KALLSYMS:
-        case DSO_BINARY_TYPE__VMLINUX:
         case DSO_BINARY_TYPE__GUEST_KALLSYMS:
-        case DSO_BINARY_TYPE__GUEST_VMLINUX:
         case DSO_BINARY_TYPE__JAVA_JIT:
         case DSO_BINARY_TYPE__NOT_FOUND:
                 ret = -1;
@@ -419,6 +424,7 @@ struct dso *dso__new(const char *name)
                 dso->symtab_type = DSO_BINARY_TYPE__NOT_FOUND;
                 dso->data_type   = DSO_BINARY_TYPE__NOT_FOUND;
                 dso->loaded = 0;
+                dso->rel = 0;
                 dso->sorted_by_name = 0;
                 dso->has_build_id = 0;
                 dso->kernel = DSO_TYPE_USER;
@@ -513,10 +519,16 @@ void dsos__add(struct list_head *head, struct dso *dso)
         list_add_tail(&dso->node, head);
 }
 
-struct dso *dsos__find(struct list_head *head, const char *name)
+struct dso *dsos__find(struct list_head *head, const char *name, bool cmp_short)
 {
         struct dso *pos;
 
+        if (cmp_short) {
+                list_for_each_entry(pos, head, node)
+                        if (strcmp(pos->short_name, name) == 0)
+                                return pos;
+                return NULL;
+        }
         list_for_each_entry(pos, head, node)
                 if (strcmp(pos->long_name, name) == 0)
                         return pos;
@@ -525,7 +537,7 @@ struct dso *dsos__find(struct list_head *head, const char *name)
 
 struct dso *__dsos__findnew(struct list_head *head, const char *name)
 {
-        struct dso *dso = dsos__find(head, name);
+        struct dso *dso = dsos__find(head, name, false);
 
         if (!dso) {
                 dso = dso__new(name);
diff --git a/tools/perf/util/dso.h b/tools/perf/util/dso.h
index 450199ab51b5..b793053335d6 100644
--- a/tools/perf/util/dso.h
+++ b/tools/perf/util/dso.h
@@ -3,6 +3,7 @@
 
 #include <linux/types.h>
 #include <linux/rbtree.h>
+#include <stdbool.h>
 #include "types.h"
 #include "map.h"
 
@@ -20,6 +21,8 @@ enum dso_binary_type {
         DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
         DSO_BINARY_TYPE__GUEST_KMODULE,
         DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
+        DSO_BINARY_TYPE__KCORE,
+        DSO_BINARY_TYPE__GUEST_KCORE,
         DSO_BINARY_TYPE__NOT_FOUND,
 };
 
@@ -84,6 +87,7 @@ struct dso {
         u8               lname_alloc:1;
         u8               sorted_by_name;
         u8               loaded;
+        u8               rel;
         u8               build_id[BUILD_ID_SIZE];
         const char       *short_name;
         char             *long_name;
@@ -133,7 +137,8 @@ struct dso *dso__kernel_findnew(struct machine *machine, const char *name,
                                 const char *short_name, int dso_type);
 
 void dsos__add(struct list_head *head, struct dso *dso);
-struct dso *dsos__find(struct list_head *head, const char *name);
+struct dso *dsos__find(struct list_head *head, const char *name,
+                       bool cmp_short);
 struct dso *__dsos__findnew(struct list_head *head, const char *name);
 bool __dsos__read_build_ids(struct list_head *head, bool with_hits);
 
@@ -145,4 +150,17 @@ size_t dso__fprintf_buildid(struct dso *dso, FILE *fp);
 size_t dso__fprintf_symbols_by_name(struct dso *dso,
                                     enum map_type type, FILE *fp);
 size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp);
+
+static inline bool dso__is_vmlinux(struct dso *dso)
+{
+        return dso->data_type == DSO_BINARY_TYPE__VMLINUX ||
+               dso->data_type == DSO_BINARY_TYPE__GUEST_VMLINUX;
+}
+
+static inline bool dso__is_kcore(struct dso *dso)
+{
+        return dso->data_type == DSO_BINARY_TYPE__KCORE ||
+               dso->data_type == DSO_BINARY_TYPE__GUEST_KCORE;
+}
+
 #endif /* __PERF_DSO */
diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c
index 3e5f5430a28a..e23bde19d590 100644
--- a/tools/perf/util/dwarf-aux.c
+++ b/tools/perf/util/dwarf-aux.c
@@ -263,6 +263,21 @@ bool die_is_signed_type(Dwarf_Die *tp_die)
 }
 
 /**
+ * die_is_func_def - Ensure that this DIE is a subprogram and definition
+ * @dw_die: a DIE
+ *
+ * Ensure that this DIE is a subprogram and NOT a declaration. This
+ * returns true if @dw_die is a function definition.
+ **/
+bool die_is_func_def(Dwarf_Die *dw_die)
+{
+        Dwarf_Attribute attr;
+
+        return (dwarf_tag(dw_die) == DW_TAG_subprogram &&
+                dwarf_attr(dw_die, DW_AT_declaration, &attr) == NULL);
+}
+
+/**
  * die_get_data_member_location - Get the data-member offset
  * @mb_die: a DIE of a member of a data structure
  * @offs: The offset of the member in the data structure
@@ -392,6 +407,10 @@ static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
 {
         struct __addr_die_search_param *ad = data;
 
+        /*
+         * Since a declaration entry doesn't has given pc, this always returns
+         * function definition entry.
+         */
         if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
             dwarf_haspc(fn_die, ad->addr)) {
                 memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
diff --git a/tools/perf/util/dwarf-aux.h b/tools/perf/util/dwarf-aux.h
index 6ce1717784b7..8658d41697d2 100644
--- a/tools/perf/util/dwarf-aux.h
+++ b/tools/perf/util/dwarf-aux.h
@@ -38,6 +38,9 @@ extern int cu_find_lineinfo(Dwarf_Die *cudie, unsigned long addr,
 extern int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
                         int (*callback)(Dwarf_Die *, void *), void *data);
 
+/* Ensure that this DIE is a subprogram and definition (not declaration) */
+extern bool die_is_func_def(Dwarf_Die *dw_die);
+
 /* Compare diename and tname */
 extern bool die_compare_name(Dwarf_Die *dw_die, const char *tname);
 
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 5cd13d768cec..9b393e7dca6f 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -11,6 +11,7 @@
 static const char *perf_event__names[] = {
         [0]                                     = "TOTAL",
         [PERF_RECORD_MMAP]                      = "MMAP",
+        [PERF_RECORD_MMAP2]                     = "MMAP2",
         [PERF_RECORD_LOST]                      = "LOST",
         [PERF_RECORD_COMM]                      = "COMM",
         [PERF_RECORD_EXIT]                      = "EXIT",
@@ -186,7 +187,7 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                 return -1;
         }
 
-        event->header.type = PERF_RECORD_MMAP;
+        event->header.type = PERF_RECORD_MMAP2;
         /*
          * Just like the kernel, see __perf_event_mmap in kernel/perf_event.c
          */
@@ -197,7 +198,9 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                 char prot[5];
                 char execname[PATH_MAX];
                 char anonstr[] = "//anon";
+                unsigned int ino;
                 size_t size;
+                ssize_t n;
 
                 if (fgets(bf, sizeof(bf), fp) == NULL)
                         break;
@@ -206,9 +209,16 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                 strcpy(execname, "");
 
                 /* 00400000-0040c000 r-xp 00000000 fd:01 41038  /bin/cat */
-                sscanf(bf, "%"PRIx64"-%"PRIx64" %s %"PRIx64" %*x:%*x %*u %s\n",
-                       &event->mmap.start, &event->mmap.len, prot,
-                       &event->mmap.pgoff, execname);
+                n = sscanf(bf, "%"PRIx64"-%"PRIx64" %s %"PRIx64" %x:%x %u %s\n",
+                       &event->mmap2.start, &event->mmap2.len, prot,
+                       &event->mmap2.pgoff, &event->mmap2.maj,
+                       &event->mmap2.min,
+                       &ino, execname);
+
+                event->mmap2.ino = (u64)ino;
+
+                if (n != 8)
+                        continue;
 
                 if (prot[2] != 'x')
                         continue;
@@ -217,15 +227,15 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                         strcpy(execname, anonstr);
 
                 size = strlen(execname) + 1;
-                memcpy(event->mmap.filename, execname, size);
+                memcpy(event->mmap2.filename, execname, size);
                 size = PERF_ALIGN(size, sizeof(u64));
-                event->mmap.len -= event->mmap.start;
-                event->mmap.header.size = (sizeof(event->mmap) -
-                                           (sizeof(event->mmap.filename) - size));
-                memset(event->mmap.filename + size, 0, machine->id_hdr_size);
-                event->mmap.header.size += machine->id_hdr_size;
-                event->mmap.pid = tgid;
-                event->mmap.tid = pid;
+                event->mmap2.len -= event->mmap.start;
+                event->mmap2.header.size = (sizeof(event->mmap2) -
+                                        (sizeof(event->mmap2.filename) - size));
+                memset(event->mmap2.filename + size, 0, machine->id_hdr_size);
+                event->mmap2.header.size += machine->id_hdr_size;
+                event->mmap2.pid = tgid;
+                event->mmap2.tid = pid;
 
                 if (process(tool, event, &synth_sample, machine) != 0) {
                         rc = -1;
@@ -527,6 +537,17 @@ size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp)
                        event->mmap.len, event->mmap.pgoff, event->mmap.filename);
 }
 
+size_t perf_event__fprintf_mmap2(union perf_event *event, FILE *fp)
+{
+        return fprintf(fp, " %d/%d: [%#" PRIx64 "(%#" PRIx64 ") @ %#" PRIx64
+                           " %02x:%02x %"PRIu64" %"PRIu64"]: %s\n",
+                       event->mmap2.pid, event->mmap2.tid, event->mmap2.start,
+                       event->mmap2.len, event->mmap2.pgoff, event->mmap2.maj,
+                       event->mmap2.min, event->mmap2.ino,
+                       event->mmap2.ino_generation,
+                       event->mmap2.filename);
+}
+
 int perf_event__process_mmap(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
                              struct perf_sample *sample __maybe_unused,
@@ -535,6 +556,14 @@ int perf_event__process_mmap(struct perf_tool *tool __maybe_unused,
         return machine__process_mmap_event(machine, event);
 }
 
+int perf_event__process_mmap2(struct perf_tool *tool __maybe_unused,
+                             union perf_event *event,
+                             struct perf_sample *sample __maybe_unused,
+                             struct machine *machine)
+{
+        return machine__process_mmap2_event(machine, event);
+}
+
 size_t perf_event__fprintf_task(union perf_event *event, FILE *fp)
 {
         return fprintf(fp, "(%d:%d):(%d:%d)\n",
@@ -574,6 +603,9 @@ size_t perf_event__fprintf(union perf_event *event, FILE *fp)
         case PERF_RECORD_MMAP:
                 ret += perf_event__fprintf_mmap(event, fp);
                 break;
+        case PERF_RECORD_MMAP2:
+                ret += perf_event__fprintf_mmap2(event, fp);
+                break;
         default:
                 ret += fprintf(fp, "\n");
         }
@@ -595,6 +627,7 @@ void thread__find_addr_map(struct thread *self,
                            struct addr_location *al)
 {
         struct map_groups *mg = &self->mg;
+        bool load_map = false;
 
         al->thread = self;
         al->addr = addr;
@@ -609,11 +642,13 @@ void thread__find_addr_map(struct thread *self,
         if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
                 al->level = 'k';
                 mg = &machine->kmaps;
+                load_map = true;
         } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {
                 al->level = '.';
         } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
                 al->level = 'g';
                 mg = &machine->kmaps;
+                load_map = true;
         } else {
                 /*
                  * 'u' means guest os user space.
@@ -654,18 +689,25 @@ try_again:
                         mg = &machine->kmaps;
                         goto try_again;
                 }
-        } else
+        } else {
+                /*
+                 * Kernel maps might be changed when loading symbols so loading
+                 * must be done prior to using kernel maps.
+                 */
+                if (load_map)
+                        map__load(al->map, machine->symbol_filter);
                 al->addr = al->map->map_ip(al->map, al->addr);
+        }
 }
 
 void thread__find_addr_location(struct thread *thread, struct machine *machine,
                                 u8 cpumode, enum map_type type, u64 addr,
-                                struct addr_location *al,
-                                symbol_filter_t filter)
+                                struct addr_location *al)
 {
         thread__find_addr_map(thread, machine, cpumode, type, addr, al);
         if (al->map != NULL)
-                al->sym = map__find_symbol(al->map, al->addr, filter);
+                al->sym = map__find_symbol(al->map, al->addr,
+                                           machine->symbol_filter);
         else
                 al->sym = NULL;
 }
@@ -673,11 +715,11 @@ void thread__find_addr_location(struct thread *thread, struct machine *machine,
 int perf_event__preprocess_sample(const union perf_event *event,
                                   struct machine *machine,
                                   struct addr_location *al,
-                                  struct perf_sample *sample,
-                                  symbol_filter_t filter)
+                                  struct perf_sample *sample)
 {
         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-        struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
+        struct thread *thread = machine__findnew_thread(machine, sample->pid,
+                                                        sample->pid);
 
         if (thread == NULL)
                 return -1;
@@ -686,7 +728,7 @@ int perf_event__preprocess_sample(const union perf_event *event,
             !strlist__has_entry(symbol_conf.comm_list, thread->comm))
                 goto out_filtered;
 
-        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+        dump_printf(" ... thread: %s:%d\n", thread->comm, thread->tid);
         /*
          * Have we already created the kernel maps for this machine?
          *
@@ -699,7 +741,7 @@ int perf_event__preprocess_sample(const union perf_event *event,
                 machine__create_kernel_maps(machine);
 
         thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
-                              event->ip.ip, al);
+                              sample->ip, al);
         dump_printf(" ...... dso: %s\n",
                     al->map ? al->map->dso->long_name :
                         al->level == 'H' ? "[hypervisor]" : "<not found>");
@@ -717,7 +759,8 @@ int perf_event__preprocess_sample(const union perf_event *event,
                                                    dso->long_name)))))
                         goto out_filtered;
 
-                al->sym = map__find_symbol(al->map, al->addr, filter);
+                al->sym = map__find_symbol(al->map, al->addr,
+                                           machine->symbol_filter);
         }
 
         if (symbol_conf.sym_list &&
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 181389535c0c..c67ecc457d29 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -8,22 +8,25 @@
 #include "map.h"
 #include "build-id.h"
 
-/*
- * PERF_SAMPLE_IP | PERF_SAMPLE_TID | *
- */
-struct ip_event {
+struct mmap_event {
         struct perf_event_header header;
-        u64 ip;
         u32 pid, tid;
-        unsigned char __more_data[];
+        u64 start;
+        u64 len;
+        u64 pgoff;
+        char filename[PATH_MAX];
 };
 
-struct mmap_event {
+struct mmap2_event {
         struct perf_event_header header;
         u32 pid, tid;
         u64 start;
         u64 len;
         u64 pgoff;
+        u32 maj;
+        u32 min;
+        u64 ino;
+        u64 ino_generation;
         char filename[PATH_MAX];
 };
 
@@ -63,7 +66,8 @@ struct read_event {
         (PERF_SAMPLE_IP | PERF_SAMPLE_TID |             \
          PERF_SAMPLE_TIME | PERF_SAMPLE_ADDR |          \
         PERF_SAMPLE_ID | PERF_SAMPLE_STREAM_ID |        \
-         PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD)
+         PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD |         \
+         PERF_SAMPLE_IDENTIFIER)
 
 struct sample_event {
         struct perf_event_header        header;
@@ -71,6 +75,7 @@ struct sample_event {
 };
 
 struct regs_dump {
+        u64 abi;
         u64 *regs;
 };
 
@@ -80,6 +85,23 @@ struct stack_dump {
         char *data;
 };
 
+struct sample_read_value {
+        u64 value;
+        u64 id;
+};
+
+struct sample_read {
+        u64 time_enabled;
+        u64 time_running;
+        union {
+                struct {
+                        u64 nr;
+                        struct sample_read_value *values;
+                } group;
+                struct sample_read_value one;
+        };
+};
+
 struct perf_sample {
         u64 ip;
         u32 pid, tid;
@@ -97,6 +119,7 @@ struct perf_sample {
         struct branch_stack *branch_stack;
         struct regs_dump  user_regs;
         struct stack_dump user_stack;
+        struct sample_read read;
 };
 
 #define PERF_MEM_DATA_SRC_NONE \
@@ -116,7 +139,7 @@ struct build_id_event {
 enum perf_user_event_type { /* above any possible kernel type */
         PERF_RECORD_USER_TYPE_START             = 64,
         PERF_RECORD_HEADER_ATTR                 = 64,
-        PERF_RECORD_HEADER_EVENT_TYPE           = 65,
+        PERF_RECORD_HEADER_EVENT_TYPE           = 65, /* depreceated */
         PERF_RECORD_HEADER_TRACING_DATA         = 66,
         PERF_RECORD_HEADER_BUILD_ID             = 67,
         PERF_RECORD_FINISHED_ROUND              = 68,
@@ -148,8 +171,8 @@ struct tracing_data_event {
 
 union perf_event {
         struct perf_event_header        header;
-        struct ip_event                 ip;
         struct mmap_event               mmap;
+        struct mmap2_event              mmap2;
         struct comm_event               comm;
         struct fork_event               fork;
         struct lost_event               lost;
@@ -199,6 +222,10 @@ int perf_event__process_mmap(struct perf_tool *tool,
                              union perf_event *event,
                              struct perf_sample *sample,
                              struct machine *machine);
+int perf_event__process_mmap2(struct perf_tool *tool,
+                             union perf_event *event,
+                             struct perf_sample *sample,
+                             struct machine *machine);
 int perf_event__process_fork(struct perf_tool *tool,
                              union perf_event *event,
                              struct perf_sample *sample,
@@ -216,17 +243,20 @@ struct addr_location;
 int perf_event__preprocess_sample(const union perf_event *self,
                                   struct machine *machine,
                                   struct addr_location *al,
-                                  struct perf_sample *sample,
-                                  symbol_filter_t filter);
+                                  struct perf_sample *sample);
 
 const char *perf_event__name(unsigned int id);
 
+size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type,
+                                     u64 sample_regs_user, u64 read_format);
 int perf_event__synthesize_sample(union perf_event *event, u64 type,
+                                  u64 sample_regs_user, u64 read_format,
                                   const struct perf_sample *sample,
                                   bool swapped);
 
 size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp);
+size_t perf_event__fprintf_mmap2(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf_task(union perf_event *event, FILE *fp);
 size_t perf_event__fprintf(union perf_event *event, FILE *fp);
 
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index f7c727801aab..f9f77bee0b1b 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -14,6 +14,7 @@
 #include "target.h"
 #include "evlist.h"
 #include "evsel.h"
+#include "debug.h"
 #include <unistd.h>
 
 #include "parse-events.h"
@@ -48,26 +49,29 @@ struct perf_evlist *perf_evlist__new(void)
         return evlist;
 }
 
-void perf_evlist__config(struct perf_evlist *evlist,
-                        struct perf_record_opts *opts)
+/**
+ * perf_evlist__set_id_pos - set the positions of event ids.
+ * @evlist: selected event list
+ *
+ * Events with compatible sample types all have the same id_pos
+ * and is_pos.  For convenience, put a copy on evlist.
+ */
+void perf_evlist__set_id_pos(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel;
-        /*
-         * Set the evsel leader links before we configure attributes,
-         * since some might depend on this info.
-         */
-        if (opts->group)
-                perf_evlist__set_leader(evlist);
+        struct perf_evsel *first = perf_evlist__first(evlist);
 
-        if (evlist->cpus->map[0] < 0)
-                opts->no_inherit = true;
+        evlist->id_pos = first->id_pos;
+        evlist->is_pos = first->is_pos;
+}
 
-        list_for_each_entry(evsel, &evlist->entries, node) {
-                perf_evsel__config(evsel, opts);
+static void perf_evlist__update_id_pos(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
 
-                if (evlist->nr_entries > 1)
-                        perf_evsel__set_sample_id(evsel);
-        }
+        list_for_each_entry(evsel, &evlist->entries, node)
+                perf_evsel__calc_id_pos(evsel);
+
+        perf_evlist__set_id_pos(evlist);
 }
 
 static void perf_evlist__purge(struct perf_evlist *evlist)
@@ -100,15 +104,20 @@ void perf_evlist__delete(struct perf_evlist *evlist)
 void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
 {
         list_add_tail(&entry->node, &evlist->entries);
-        ++evlist->nr_entries;
+        if (!evlist->nr_entries++)
+                perf_evlist__set_id_pos(evlist);
 }
 
 void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
                                    struct list_head *list,
                                    int nr_entries)
 {
+        bool set_id_pos = !evlist->nr_entries;
+
         list_splice_tail(list, &evlist->entries);
         evlist->nr_entries += nr_entries;
+        if (set_id_pos)
+                perf_evlist__set_id_pos(evlist);
 }
 
 void __perf_evlist__set_leader(struct list_head *list)
@@ -209,6 +218,21 @@ perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
         return NULL;
 }
 
+struct perf_evsel *
+perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,
+                                     const char *name)
+{
+        struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                if ((evsel->attr.type == PERF_TYPE_TRACEPOINT) &&
+                    (strcmp(evsel->name, name) == 0))
+                        return evsel;
+        }
+
+        return NULL;
+}
+
 int perf_evlist__add_newtp(struct perf_evlist *evlist,
                            const char *sys, const char *name, void *handler)
 {
@@ -232,7 +256,7 @@ void perf_evlist__disable(struct perf_evlist *evlist)
 
         for (cpu = 0; cpu < nr_cpus; cpu++) {
                 list_for_each_entry(pos, &evlist->entries, node) {
-                        if (!perf_evsel__is_group_leader(pos))
+                        if (!perf_evsel__is_group_leader(pos) || !pos->fd)
                                 continue;
                         for (thread = 0; thread < nr_threads; thread++)
                                 ioctl(FD(pos, cpu, thread),
@@ -250,7 +274,7 @@ void perf_evlist__enable(struct perf_evlist *evlist)
 
         for (cpu = 0; cpu < nr_cpus; cpu++) {
                 list_for_each_entry(pos, &evlist->entries, node) {
-                        if (!perf_evsel__is_group_leader(pos))
+                        if (!perf_evsel__is_group_leader(pos) || !pos->fd)
                                 continue;
                         for (thread = 0; thread < nr_threads; thread++)
                                 ioctl(FD(pos, cpu, thread),
@@ -259,6 +283,44 @@ void perf_evlist__enable(struct perf_evlist *evlist)
         }
 }
 
+int perf_evlist__disable_event(struct perf_evlist *evlist,
+                               struct perf_evsel *evsel)
+{
+        int cpu, thread, err;
+
+        if (!evsel->fd)
+                return 0;
+
+        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+                for (thread = 0; thread < evlist->threads->nr; thread++) {
+                        err = ioctl(FD(evsel, cpu, thread),
+                                    PERF_EVENT_IOC_DISABLE, 0);
+                        if (err)
+                                return err;
+                }
+        }
+        return 0;
+}
+
+int perf_evlist__enable_event(struct perf_evlist *evlist,
+                              struct perf_evsel *evsel)
+{
+        int cpu, thread, err;
+
+        if (!evsel->fd)
+                return -EINVAL;
+
+        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+                for (thread = 0; thread < evlist->threads->nr; thread++) {
+                        err = ioctl(FD(evsel, cpu, thread),
+                                    PERF_EVENT_IOC_ENABLE, 0);
+                        if (err)
+                                return err;
+                }
+        }
+        return 0;
+}
+
 static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
 {
         int nr_cpus = cpu_map__nr(evlist->cpus);
@@ -302,6 +364,24 @@ static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
 {
         u64 read_data[4] = { 0, };
         int id_idx = 1; /* The first entry is the counter value */
+        u64 id;
+        int ret;
+
+        ret = ioctl(fd, PERF_EVENT_IOC_ID, &id);
+        if (!ret)
+                goto add;
+
+        if (errno != ENOTTY)
+                return -1;
+
+        /* Legacy way to get event id.. All hail to old kernels! */
+
+        /*
+         * This way does not work with group format read, so bail
+         * out in that case.
+         */
+        if (perf_evlist__read_format(evlist) & PERF_FORMAT_GROUP)
+                return -1;
 
         if (!(evsel->attr.read_format & PERF_FORMAT_ID) ||
             read(fd, &read_data, sizeof(read_data)) == -1)
@@ -312,25 +392,39 @@ static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
         if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
                 ++id_idx;
 
-        perf_evlist__id_add(evlist, evsel, cpu, thread, read_data[id_idx]);
+        id = read_data[id_idx];
+
+ add:
+        perf_evlist__id_add(evlist, evsel, cpu, thread, id);
         return 0;
 }
 
-struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
+struct perf_sample_id *perf_evlist__id2sid(struct perf_evlist *evlist, u64 id)
 {
         struct hlist_head *head;
         struct perf_sample_id *sid;
         int hash;
 
-        if (evlist->nr_entries == 1)
-                return perf_evlist__first(evlist);
-
         hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
         head = &evlist->heads[hash];
 
         hlist_for_each_entry(sid, head, node)
                 if (sid->id == id)
-                        return sid->evsel;
+                        return sid;
+
+        return NULL;
+}
+
+struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
+{
+        struct perf_sample_id *sid;
+
+        if (evlist->nr_entries == 1)
+                return perf_evlist__first(evlist);
+
+        sid = perf_evlist__id2sid(evlist, id);
+        if (sid)
+                return sid->evsel;
 
         if (!perf_evlist__sample_id_all(evlist))
                 return perf_evlist__first(evlist);
@@ -338,6 +432,60 @@ struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
         return NULL;
 }
 
+static int perf_evlist__event2id(struct perf_evlist *evlist,
+                                 union perf_event *event, u64 *id)
+{
+        const u64 *array = event->sample.array;
+        ssize_t n;
+
+        n = (event->header.size - sizeof(event->header)) >> 3;
+
+        if (event->header.type == PERF_RECORD_SAMPLE) {
+                if (evlist->id_pos >= n)
+                        return -1;
+                *id = array[evlist->id_pos];
+        } else {
+                if (evlist->is_pos > n)
+                        return -1;
+                n -= evlist->is_pos;
+                *id = array[n];
+        }
+        return 0;
+}
+
+static struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
+                                                   union perf_event *event)
+{
+        struct perf_evsel *first = perf_evlist__first(evlist);
+        struct hlist_head *head;
+        struct perf_sample_id *sid;
+        int hash;
+        u64 id;
+
+        if (evlist->nr_entries == 1)
+                return first;
+
+        if (!first->attr.sample_id_all &&
+            event->header.type != PERF_RECORD_SAMPLE)
+                return first;
+
+        if (perf_evlist__event2id(evlist, event, &id))
+                return NULL;
+
+        /* Synthesized events have an id of zero */
+        if (!id)
+                return first;
+
+        hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
+        head = &evlist->heads[hash];
+
+        hlist_for_each_entry(sid, head, node) {
+                if (sid->id == id)
+                        return sid->evsel;
+        }
+        return NULL;
+}
+
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
 {
         struct perf_mmap *md = &evlist->mmap[idx];
@@ -403,16 +551,20 @@ union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
         return event;
 }
 
+static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx)
+{
+        if (evlist->mmap[idx].base != NULL) {
+                munmap(evlist->mmap[idx].base, evlist->mmap_len);
+                evlist->mmap[idx].base = NULL;
+        }
+}
+
 void perf_evlist__munmap(struct perf_evlist *evlist)
 {
         int i;
 
-        for (i = 0; i < evlist->nr_mmaps; i++) {
-                if (evlist->mmap[i].base != NULL) {
-                        munmap(evlist->mmap[i].base, evlist->mmap_len);
-                        evlist->mmap[i].base = NULL;
-                }
-        }
+        for (i = 0; i < evlist->nr_mmaps; i++)
+                __perf_evlist__munmap(evlist, i);
 
         free(evlist->mmap);
         evlist->mmap = NULL;
@@ -421,7 +573,7 @@ void perf_evlist__munmap(struct perf_evlist *evlist)
 static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
 {
         evlist->nr_mmaps = cpu_map__nr(evlist->cpus);
-        if (cpu_map__all(evlist->cpus))
+        if (cpu_map__empty(evlist->cpus))
                 evlist->nr_mmaps = thread_map__nr(evlist->threads);
         evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
         return evlist->mmap != NULL ? 0 : -ENOMEM;
@@ -450,6 +602,7 @@ static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int m
         int nr_cpus = cpu_map__nr(evlist->cpus);
         int nr_threads = thread_map__nr(evlist->threads);
 
+        pr_debug2("perf event ring buffer mmapped per cpu\n");
         for (cpu = 0; cpu < nr_cpus; cpu++) {
                 int output = -1;
 
@@ -477,12 +630,8 @@ static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int m
         return 0;
 
 out_unmap:
-        for (cpu = 0; cpu < nr_cpus; cpu++) {
-                if (evlist->mmap[cpu].base != NULL) {
-                        munmap(evlist->mmap[cpu].base, evlist->mmap_len);
-                        evlist->mmap[cpu].base = NULL;
-                }
-        }
+        for (cpu = 0; cpu < nr_cpus; cpu++)
+                __perf_evlist__munmap(evlist, cpu);
         return -1;
 }
 
@@ -492,6 +641,7 @@ static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, in
         int thread;
         int nr_threads = thread_map__nr(evlist->threads);
 
+        pr_debug2("perf event ring buffer mmapped per thread\n");
         for (thread = 0; thread < nr_threads; thread++) {
                 int output = -1;
 
@@ -517,12 +667,8 @@ static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, in
         return 0;
 
 out_unmap:
-        for (thread = 0; thread < nr_threads; thread++) {
-                if (evlist->mmap[thread].base != NULL) {
-                        munmap(evlist->mmap[thread].base, evlist->mmap_len);
-                        evlist->mmap[thread].base = NULL;
-                }
-        }
+        for (thread = 0; thread < nr_threads; thread++)
+                __perf_evlist__munmap(evlist, thread);
         return -1;
 }
 
@@ -573,7 +719,7 @@ int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
                         return -ENOMEM;
         }
 
-        if (cpu_map__all(cpus))
+        if (cpu_map__empty(cpus))
                 return perf_evlist__mmap_per_thread(evlist, prot, mask);
 
         return perf_evlist__mmap_per_cpu(evlist, prot, mask);
@@ -650,20 +796,66 @@ int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
 
 bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
 {
+        struct perf_evsel *pos;
+
+        if (evlist->nr_entries == 1)
+                return true;
+
+        if (evlist->id_pos < 0 || evlist->is_pos < 0)
+                return false;
+
+        list_for_each_entry(pos, &evlist->entries, node) {
+                if (pos->id_pos != evlist->id_pos ||
+                    pos->is_pos != evlist->is_pos)
+                        return false;
+        }
+
+        return true;
+}
+
+u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+
+        if (evlist->combined_sample_type)
+                return evlist->combined_sample_type;
+
+        list_for_each_entry(evsel, &evlist->entries, node)
+                evlist->combined_sample_type |= evsel->attr.sample_type;
+
+        return evlist->combined_sample_type;
+}
+
+u64 perf_evlist__combined_sample_type(struct perf_evlist *evlist)
+{
+        evlist->combined_sample_type = 0;
+        return __perf_evlist__combined_sample_type(evlist);
+}
+
+bool perf_evlist__valid_read_format(struct perf_evlist *evlist)
+{
         struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
+        u64 read_format = first->attr.read_format;
+        u64 sample_type = first->attr.sample_type;
 
         list_for_each_entry_continue(pos, &evlist->entries, node) {
-                if (first->attr.sample_type != pos->attr.sample_type)
+                if (read_format != pos->attr.read_format)
                         return false;
         }
 
+        /* PERF_SAMPLE_READ imples PERF_FORMAT_ID. */
+        if ((sample_type & PERF_SAMPLE_READ) &&
+            !(read_format & PERF_FORMAT_ID)) {
+                return false;
+        }
+
         return true;
 }
 
-u64 perf_evlist__sample_type(struct perf_evlist *evlist)
+u64 perf_evlist__read_format(struct perf_evlist *evlist)
 {
         struct perf_evsel *first = perf_evlist__first(evlist);
-        return first->attr.sample_type;
+        return first->attr.read_format;
 }
 
 u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)
@@ -692,6 +884,9 @@ u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)
 
         if (sample_type & PERF_SAMPLE_CPU)
                 size += sizeof(data->cpu) * 2;
+
+        if (sample_type & PERF_SAMPLE_IDENTIFIER)
+                size += sizeof(data->id);
 out:
         return size;
 }
@@ -735,6 +930,8 @@ int perf_evlist__open(struct perf_evlist *evlist)
         struct perf_evsel *evsel;
         int err;
 
+        perf_evlist__update_id_pos(evlist);
+
         list_for_each_entry(evsel, &evlist->entries, node) {
                 err = perf_evsel__open(evsel, evlist->cpus, evlist->threads);
                 if (err < 0)
@@ -776,18 +973,13 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist,
                 if (pipe_output)
                         dup2(2, 1);
 
+                signal(SIGTERM, SIG_DFL);
+
                 close(child_ready_pipe[0]);
                 close(go_pipe[1]);
                 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
 
                 /*
-                 * Do a dummy execvp to get the PLT entry resolved,
-                 * so we avoid the resolver overhead on the real
-                 * execvp call.
-                 */
-                execvp("", (char **)argv);
-
-                /*
                  * Tell the parent we're ready to go
                  */
                 close(child_ready_pipe[1]);
@@ -819,6 +1011,7 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist,
                 goto out_close_pipes;
         }
 
+        fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC);
         evlist->workload.cork_fd = go_pipe[1];
         close(child_ready_pipe[0]);
         return 0;
@@ -835,10 +1028,17 @@ out_close_ready_pipe:
 int perf_evlist__start_workload(struct perf_evlist *evlist)
 {
         if (evlist->workload.cork_fd > 0) {
+                char bf = 0;
+                int ret;
                 /*
                  * Remove the cork, let it rip!
                  */
-                return close(evlist->workload.cork_fd);
+                ret = write(evlist->workload.cork_fd, &bf, 1);
+                if (ret < 0)
+                        perror("enable to write to pipe");
+
+                close(evlist->workload.cork_fd);
+                return ret;
         }
 
         return 0;
@@ -847,7 +1047,10 @@ int perf_evlist__start_workload(struct perf_evlist *evlist)
 int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event,
                               struct perf_sample *sample)
 {
-        struct perf_evsel *evsel = perf_evlist__first(evlist);
+        struct perf_evsel *evsel = perf_evlist__event2evsel(evlist, event);
+
+        if (!evsel)
+                return -EFAULT;
         return perf_evsel__parse_sample(evsel, event, sample);
 }
 
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 0583d36252be..880d7139d2fb 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -32,6 +32,9 @@ struct perf_evlist {
         int              nr_fds;
         int              nr_mmaps;
         int              mmap_len;
+        int              id_pos;
+        int              is_pos;
+        u64              combined_sample_type;
         struct {
                 int     cork_fd;
                 pid_t   pid;
@@ -71,6 +74,10 @@ int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter);
 struct perf_evsel *
 perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id);
 
+struct perf_evsel *
+perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,
+                                     const char *name);
+
 void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
                          int cpu, int thread, u64 id);
 
@@ -78,11 +85,15 @@ void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd);
 
 struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id);
 
+struct perf_sample_id *perf_evlist__id2sid(struct perf_evlist *evlist, u64 id);
+
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *self, int idx);
 
 int perf_evlist__open(struct perf_evlist *evlist);
 void perf_evlist__close(struct perf_evlist *evlist);
 
+void perf_evlist__set_id_pos(struct perf_evlist *evlist);
+bool perf_can_sample_identifier(void);
 void perf_evlist__config(struct perf_evlist *evlist,
                          struct perf_record_opts *opts);
 
@@ -99,6 +110,11 @@ void perf_evlist__munmap(struct perf_evlist *evlist);
 void perf_evlist__disable(struct perf_evlist *evlist);
 void perf_evlist__enable(struct perf_evlist *evlist);
 
+int perf_evlist__disable_event(struct perf_evlist *evlist,
+                               struct perf_evsel *evsel);
+int perf_evlist__enable_event(struct perf_evlist *evlist,
+                              struct perf_evsel *evsel);
+
 void perf_evlist__set_selected(struct perf_evlist *evlist,
                                struct perf_evsel *evsel);
 
@@ -118,7 +134,9 @@ int perf_evlist__apply_filters(struct perf_evlist *evlist);
 void __perf_evlist__set_leader(struct list_head *list);
 void perf_evlist__set_leader(struct perf_evlist *evlist);
 
-u64 perf_evlist__sample_type(struct perf_evlist *evlist);
+u64 perf_evlist__read_format(struct perf_evlist *evlist);
+u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist);
+u64 perf_evlist__combined_sample_type(struct perf_evlist *evlist);
 bool perf_evlist__sample_id_all(struct perf_evlist *evlist);
 u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist);
 
@@ -127,6 +145,7 @@ int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *even
 
 bool perf_evlist__valid_sample_type(struct perf_evlist *evlist);
 bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist);
+bool perf_evlist__valid_read_format(struct perf_evlist *evlist);
 
 void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
                                    struct list_head *list,
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 07b1a3ad3e24..0ce9febf1ba0 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -9,27 +9,30 @@
 
 #include <byteswap.h>
 #include <linux/bitops.h>
-#include "asm/bug.h"
 #include <lk/debugfs.h>
-#include "event-parse.h"
+#include <traceevent/event-parse.h>
+#include <linux/hw_breakpoint.h>
+#include <linux/perf_event.h>
+#include <sys/resource.h>
+#include "asm/bug.h"
 #include "evsel.h"
 #include "evlist.h"
 #include "util.h"
 #include "cpumap.h"
 #include "thread_map.h"
 #include "target.h"
-#include <linux/hw_breakpoint.h>
-#include <linux/perf_event.h>
 #include "perf_regs.h"
+#include "debug.h"
 
 static struct {
         bool sample_id_all;
         bool exclude_guest;
+        bool mmap2;
 } perf_missing_features;
 
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
 
-static int __perf_evsel__sample_size(u64 sample_type)
+int __perf_evsel__sample_size(u64 sample_type)
 {
         u64 mask = sample_type & PERF_SAMPLE_MASK;
         int size = 0;
@@ -45,6 +48,72 @@ static int __perf_evsel__sample_size(u64 sample_type)
         return size;
 }
 
+/**
+ * __perf_evsel__calc_id_pos - calculate id_pos.
+ * @sample_type: sample type
+ *
+ * This function returns the position of the event id (PERF_SAMPLE_ID or
+ * PERF_SAMPLE_IDENTIFIER) in a sample event i.e. in the array of struct
+ * sample_event.
+ */
+static int __perf_evsel__calc_id_pos(u64 sample_type)
+{
+        int idx = 0;
+
+        if (sample_type & PERF_SAMPLE_IDENTIFIER)
+                return 0;
+
+        if (!(sample_type & PERF_SAMPLE_ID))
+                return -1;
+
+        if (sample_type & PERF_SAMPLE_IP)
+                idx += 1;
+
+        if (sample_type & PERF_SAMPLE_TID)
+                idx += 1;
+
+        if (sample_type & PERF_SAMPLE_TIME)
+                idx += 1;
+
+        if (sample_type & PERF_SAMPLE_ADDR)
+                idx += 1;
+
+        return idx;
+}
+
+/**
+ * __perf_evsel__calc_is_pos - calculate is_pos.
+ * @sample_type: sample type
+ *
+ * This function returns the position (counting backwards) of the event id
+ * (PERF_SAMPLE_ID or PERF_SAMPLE_IDENTIFIER) in a non-sample event i.e. if
+ * sample_id_all is used there is an id sample appended to non-sample events.
+ */
+static int __perf_evsel__calc_is_pos(u64 sample_type)
+{
+        int idx = 1;
+
+        if (sample_type & PERF_SAMPLE_IDENTIFIER)
+                return 1;
+
+        if (!(sample_type & PERF_SAMPLE_ID))
+                return -1;
+
+        if (sample_type & PERF_SAMPLE_CPU)
+                idx += 1;
+
+        if (sample_type & PERF_SAMPLE_STREAM_ID)
+                idx += 1;
+
+        return idx;
+}
+
+void perf_evsel__calc_id_pos(struct perf_evsel *evsel)
+{
+        evsel->id_pos = __perf_evsel__calc_id_pos(evsel->attr.sample_type);
+        evsel->is_pos = __perf_evsel__calc_is_pos(evsel->attr.sample_type);
+}
+
 void hists__init(struct hists *hists)
 {
         memset(hists, 0, sizeof(*hists));
@@ -61,6 +130,7 @@ void __perf_evsel__set_sample_bit(struct perf_evsel *evsel,
         if (!(evsel->attr.sample_type & bit)) {
                 evsel->attr.sample_type |= bit;
                 evsel->sample_size += sizeof(u64);
+                perf_evsel__calc_id_pos(evsel);
         }
 }
 
@@ -70,12 +140,19 @@ void __perf_evsel__reset_sample_bit(struct perf_evsel *evsel,
         if (evsel->attr.sample_type & bit) {
                 evsel->attr.sample_type &= ~bit;
                 evsel->sample_size -= sizeof(u64);
+                perf_evsel__calc_id_pos(evsel);
         }
 }
 
-void perf_evsel__set_sample_id(struct perf_evsel *evsel)
+void perf_evsel__set_sample_id(struct perf_evsel *evsel,
+                               bool can_sample_identifier)
 {
-        perf_evsel__set_sample_bit(evsel, ID);
+        if (can_sample_identifier) {
+                perf_evsel__reset_sample_bit(evsel, ID);
+                perf_evsel__set_sample_bit(evsel, IDENTIFIER);
+        } else {
+                perf_evsel__set_sample_bit(evsel, ID);
+        }
         evsel->attr.read_format |= PERF_FORMAT_ID;
 }
 
@@ -88,6 +165,7 @@ void perf_evsel__init(struct perf_evsel *evsel,
         INIT_LIST_HEAD(&evsel->node);
         hists__init(&evsel->hists);
         evsel->sample_size = __perf_evsel__sample_size(attr->sample_type);
+        perf_evsel__calc_id_pos(evsel);
 }
 
 struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
@@ -124,7 +202,7 @@ struct event_format *event_format__new(const char *sys, const char *name)
                         bf = nbf;
                 }
 
-                n = read(fd, bf + size, BUFSIZ);
+                n = read(fd, bf + size, alloc_size - size);
                 if (n < 0)
                         goto out_free_bf;
                 size += n;
@@ -246,6 +324,7 @@ const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX] = {
         "major-faults",
         "alignment-faults",
         "emulation-faults",
+        "dummy",
 };
 
 static const char *__perf_evsel__sw_name(u64 config)
@@ -490,6 +569,7 @@ int perf_evsel__group_desc(struct perf_evsel *evsel, char *buf, size_t size)
 void perf_evsel__config(struct perf_evsel *evsel,
                         struct perf_record_opts *opts)
 {
+        struct perf_evsel *leader = evsel->leader;
         struct perf_event_attr *attr = &evsel->attr;
         int track = !evsel->idx; /* only the first counter needs these */
 
@@ -499,6 +579,25 @@ void perf_evsel__config(struct perf_evsel *evsel,
         perf_evsel__set_sample_bit(evsel, IP);
         perf_evsel__set_sample_bit(evsel, TID);
 
+        if (evsel->sample_read) {
+                perf_evsel__set_sample_bit(evsel, READ);
+
+                /*
+                 * We need ID even in case of single event, because
+                 * PERF_SAMPLE_READ process ID specific data.
+                 */
+                perf_evsel__set_sample_id(evsel, false);
+
+                /*
+                 * Apply group format only if we belong to group
+                 * with more than one members.
+                 */
+                if (leader->nr_members > 1) {
+                        attr->read_format |= PERF_FORMAT_GROUP;
+                        attr->inherit = 0;
+                }
+        }
+
         /*
          * We default some events to a 1 default interval. But keep
          * it a weak assumption overridable by the user.
@@ -514,6 +613,15 @@ void perf_evsel__config(struct perf_evsel *evsel,
                 }
         }
 
+        /*
+         * Disable sampling for all group members other
+         * than leader in case leader 'leads' the sampling.
+         */
+        if ((leader != evsel) && leader->sample_read) {
+                attr->sample_freq   = 0;
+                attr->sample_period = 0;
+        }
+
         if (opts->no_samples)
                 attr->sample_freq = 0;
 
@@ -569,8 +677,9 @@ void perf_evsel__config(struct perf_evsel *evsel,
         if (opts->sample_weight)
                 attr->sample_type       |= PERF_SAMPLE_WEIGHT;
 
-        attr->mmap = track;
-        attr->comm = track;
+        attr->mmap  = track;
+        attr->mmap2 = track && !perf_missing_features.mmap2;
+        attr->comm  = track;
 
         /*
          * XXX see the function comment above
@@ -605,15 +714,15 @@ int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
         return evsel->fd != NULL ? 0 : -ENOMEM;
 }
 
-int perf_evsel__set_filter(struct perf_evsel *evsel, int ncpus, int nthreads,
-                           const char *filter)
+static int perf_evsel__run_ioctl(struct perf_evsel *evsel, int ncpus, int nthreads,
+                          int ioc,  void *arg)
 {
         int cpu, thread;
 
         for (cpu = 0; cpu < ncpus; cpu++) {
                 for (thread = 0; thread < nthreads; thread++) {
                         int fd = FD(evsel, cpu, thread),
-                            err = ioctl(fd, PERF_EVENT_IOC_SET_FILTER, filter);
+                            err = ioctl(fd, ioc, arg);
 
                         if (err)
                                 return err;
@@ -623,6 +732,21 @@ int perf_evsel__set_filter(struct perf_evsel *evsel, int ncpus, int nthreads,
         return 0;
 }
 
+int perf_evsel__set_filter(struct perf_evsel *evsel, int ncpus, int nthreads,
+                           const char *filter)
+{
+        return perf_evsel__run_ioctl(evsel, ncpus, nthreads,
+                                     PERF_EVENT_IOC_SET_FILTER,
+                                     (void *)filter);
+}
+
+int perf_evsel__enable(struct perf_evsel *evsel, int ncpus, int nthreads)
+{
+        return perf_evsel__run_ioctl(evsel, ncpus, nthreads,
+                                     PERF_EVENT_IOC_ENABLE,
+                                     0);
+}
+
 int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
 {
         evsel->sample_id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id));
@@ -817,12 +941,72 @@ static int get_group_fd(struct perf_evsel *evsel, int cpu, int thread)
         return fd;
 }
 
+#define __PRINT_ATTR(fmt, cast, field)  \
+        fprintf(fp, "  %-19s "fmt"\n", #field, cast attr->field)
+
+#define PRINT_ATTR_U32(field)  __PRINT_ATTR("%u" , , field)
+#define PRINT_ATTR_X32(field)  __PRINT_ATTR("%#x", , field)
+#define PRINT_ATTR_U64(field)  __PRINT_ATTR("%" PRIu64, (uint64_t), field)
+#define PRINT_ATTR_X64(field)  __PRINT_ATTR("%#"PRIx64, (uint64_t), field)
+
+#define PRINT_ATTR2N(name1, field1, name2, field2)      \
+        fprintf(fp, "  %-19s %u    %-19s %u\n",         \
+        name1, attr->field1, name2, attr->field2)
+
+#define PRINT_ATTR2(field1, field2) \
+        PRINT_ATTR2N(#field1, field1, #field2, field2)
+
+static size_t perf_event_attr__fprintf(struct perf_event_attr *attr, FILE *fp)
+{
+        size_t ret = 0;
+
+        ret += fprintf(fp, "%.60s\n", graph_dotted_line);
+        ret += fprintf(fp, "perf_event_attr:\n");
+
+        ret += PRINT_ATTR_U32(type);
+        ret += PRINT_ATTR_U32(size);
+        ret += PRINT_ATTR_X64(config);
+        ret += PRINT_ATTR_U64(sample_period);
+        ret += PRINT_ATTR_U64(sample_freq);
+        ret += PRINT_ATTR_X64(sample_type);
+        ret += PRINT_ATTR_X64(read_format);
+
+        ret += PRINT_ATTR2(disabled, inherit);
+        ret += PRINT_ATTR2(pinned, exclusive);
+        ret += PRINT_ATTR2(exclude_user, exclude_kernel);
+        ret += PRINT_ATTR2(exclude_hv, exclude_idle);
+        ret += PRINT_ATTR2(mmap, comm);
+        ret += PRINT_ATTR2(freq, inherit_stat);
+        ret += PRINT_ATTR2(enable_on_exec, task);
+        ret += PRINT_ATTR2(watermark, precise_ip);
+        ret += PRINT_ATTR2(mmap_data, sample_id_all);
+        ret += PRINT_ATTR2(exclude_host, exclude_guest);
+        ret += PRINT_ATTR2N("excl.callchain_kern", exclude_callchain_kernel,
+                            "excl.callchain_user", exclude_callchain_user);
+
+        ret += PRINT_ATTR_U32(wakeup_events);
+        ret += PRINT_ATTR_U32(wakeup_watermark);
+        ret += PRINT_ATTR_X32(bp_type);
+        ret += PRINT_ATTR_X64(bp_addr);
+        ret += PRINT_ATTR_X64(config1);
+        ret += PRINT_ATTR_U64(bp_len);
+        ret += PRINT_ATTR_X64(config2);
+        ret += PRINT_ATTR_X64(branch_sample_type);
+        ret += PRINT_ATTR_X64(sample_regs_user);
+        ret += PRINT_ATTR_U32(sample_stack_user);
+
+        ret += fprintf(fp, "%.60s\n", graph_dotted_line);
+
+        return ret;
+}
+
 static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
                               struct thread_map *threads)
 {
         int cpu, thread;
         unsigned long flags = 0;
         int pid = -1, err;
+        enum { NO_CHANGE, SET_TO_MAX, INCREASED_MAX } set_rlimit = NO_CHANGE;
 
         if (evsel->fd == NULL &&
             perf_evsel__alloc_fd(evsel, cpus->nr, threads->nr) < 0)
@@ -834,12 +1018,17 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
         }
 
 fallback_missing_features:
+        if (perf_missing_features.mmap2)
+                evsel->attr.mmap2 = 0;
         if (perf_missing_features.exclude_guest)
                 evsel->attr.exclude_guest = evsel->attr.exclude_host = 0;
 retry_sample_id:
         if (perf_missing_features.sample_id_all)
                 evsel->attr.sample_id_all = 0;
 
+        if (verbose >= 2)
+                perf_event_attr__fprintf(&evsel->attr, stderr);
+
         for (cpu = 0; cpu < cpus->nr; cpu++) {
 
                 for (thread = 0; thread < threads->nr; thread++) {
@@ -849,6 +1038,9 @@ retry_sample_id:
                                 pid = threads->map[thread];
 
                         group_fd = get_group_fd(evsel, cpu, thread);
+retry_open:
+                        pr_debug2("perf_event_open: pid %d  cpu %d  group_fd %d  flags %#lx\n",
+                                  pid, cpus->map[cpu], group_fd, flags);
 
                         FD(evsel, cpu, thread) = sys_perf_event_open(&evsel->attr,
                                                                      pid,
@@ -858,17 +1050,45 @@ retry_sample_id:
                                 err = -errno;
                                 goto try_fallback;
                         }
+                        set_rlimit = NO_CHANGE;
                 }
         }
 
         return 0;
 
 try_fallback:
+        /*
+         * perf stat needs between 5 and 22 fds per CPU. When we run out
+         * of them try to increase the limits.
+         */
+        if (err == -EMFILE && set_rlimit < INCREASED_MAX) {
+                struct rlimit l;
+                int old_errno = errno;
+
+                if (getrlimit(RLIMIT_NOFILE, &l) == 0) {
+                        if (set_rlimit == NO_CHANGE)
+                                l.rlim_cur = l.rlim_max;
+                        else {
+                                l.rlim_cur = l.rlim_max + 1000;
+                                l.rlim_max = l.rlim_cur;
+                        }
+                        if (setrlimit(RLIMIT_NOFILE, &l) == 0) {
+                                set_rlimit++;
+                                errno = old_errno;
+                                goto retry_open;
+                        }
+                }
+                errno = old_errno;
+        }
+
         if (err != -EINVAL || cpu > 0 || thread > 0)
                 goto out_close;
 
-        if (!perf_missing_features.exclude_guest &&
-            (evsel->attr.exclude_guest || evsel->attr.exclude_host)) {
+        if (!perf_missing_features.mmap2 && evsel->attr.mmap2) {
+                perf_missing_features.mmap2 = true;
+                goto fallback_missing_features;
+        } else if (!perf_missing_features.exclude_guest &&
+                   (evsel->attr.exclude_guest || evsel->attr.exclude_host)) {
                 perf_missing_features.exclude_guest = true;
                 goto fallback_missing_features;
         } else if (!perf_missing_features.sample_id_all) {
@@ -951,6 +1171,11 @@ static int perf_evsel__parse_id_sample(const struct perf_evsel *evsel,
         array += ((event->header.size -
                    sizeof(event->header)) / sizeof(u64)) - 1;
 
+        if (type & PERF_SAMPLE_IDENTIFIER) {
+                sample->id = *array;
+                array--;
+        }
+
         if (type & PERF_SAMPLE_CPU) {
                 u.val64 = *array;
                 if (swapped) {
@@ -994,24 +1219,30 @@ static int perf_evsel__parse_id_sample(const struct perf_evsel *evsel,
         return 0;
 }
 
-static bool sample_overlap(const union perf_event *event,
-                           const void *offset, u64 size)
+static inline bool overflow(const void *endp, u16 max_size, const void *offset,
+                            u64 size)
 {
-        const void *base = event;
+        return size > max_size || offset + size > endp;
+}
 
-        if (offset + size > base + event->header.size)
-                return true;
+#define OVERFLOW_CHECK(offset, size, max_size)                          \
+        do {                                                            \
+                if (overflow(endp, (max_size), (offset), (size)))       \
+                        return -EFAULT;                                 \
+        } while (0)
 
-        return false;
-}
+#define OVERFLOW_CHECK_u64(offset) \
+        OVERFLOW_CHECK(offset, sizeof(u64), sizeof(u64))
 
 int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
                              struct perf_sample *data)
 {
         u64 type = evsel->attr.sample_type;
-        u64 regs_user = evsel->attr.sample_regs_user;
         bool swapped = evsel->needs_swap;
         const u64 *array;
+        u16 max_size = event->header.size;
+        const void *endp = (void *)event + max_size;
+        u64 sz;
 
         /*
          * used for cross-endian analysis. See git commit 65014ab3
@@ -1033,11 +1264,22 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
 
         array = event->sample.array;
 
+        /*
+         * The evsel's sample_size is based on PERF_SAMPLE_MASK which includes
+         * up to PERF_SAMPLE_PERIOD.  After that overflow() must be used to
+         * check the format does not go past the end of the event.
+         */
         if (evsel->sample_size + sizeof(event->header) > event->header.size)
                 return -EFAULT;
 
+        data->id = -1ULL;
+        if (type & PERF_SAMPLE_IDENTIFIER) {
+                data->id = *array;
+                array++;
+        }
+
         if (type & PERF_SAMPLE_IP) {
-                data->ip = event->ip.ip;
+                data->ip = *array;
                 array++;
         }
 
@@ -1066,7 +1308,6 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
                 array++;
         }
 
-        data->id = -1ULL;
         if (type & PERF_SAMPLE_ID) {
                 data->id = *array;
                 array++;
@@ -1096,25 +1337,62 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
         }
 
         if (type & PERF_SAMPLE_READ) {
-                fprintf(stderr, "PERF_SAMPLE_READ is unsupported for now\n");
-                return -1;
+                u64 read_format = evsel->attr.read_format;
+
+                OVERFLOW_CHECK_u64(array);
+                if (read_format & PERF_FORMAT_GROUP)
+                        data->read.group.nr = *array;
+                else
+                        data->read.one.value = *array;
+
+                array++;
+
+                if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
+                        OVERFLOW_CHECK_u64(array);
+                        data->read.time_enabled = *array;
+                        array++;
+                }
+
+                if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
+                        OVERFLOW_CHECK_u64(array);
+                        data->read.time_running = *array;
+                        array++;
+                }
+
+                /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */
+                if (read_format & PERF_FORMAT_GROUP) {
+                        const u64 max_group_nr = UINT64_MAX /
+                                        sizeof(struct sample_read_value);
+
+                        if (data->read.group.nr > max_group_nr)
+                                return -EFAULT;
+                        sz = data->read.group.nr *
+                             sizeof(struct sample_read_value);
+                        OVERFLOW_CHECK(array, sz, max_size);
+                        data->read.group.values =
+                                        (struct sample_read_value *)array;
+                        array = (void *)array + sz;
+                } else {
+                        OVERFLOW_CHECK_u64(array);
+                        data->read.one.id = *array;
+                        array++;
+                }
         }
 
         if (type & PERF_SAMPLE_CALLCHAIN) {
-                if (sample_overlap(event, array, sizeof(data->callchain->nr)))
-                        return -EFAULT;
-
-                data->callchain = (struct ip_callchain *)array;
+                const u64 max_callchain_nr = UINT64_MAX / sizeof(u64);
 
-                if (sample_overlap(event, array, data->callchain->nr))
+                OVERFLOW_CHECK_u64(array);
+                data->callchain = (struct ip_callchain *)array++;
+                if (data->callchain->nr > max_callchain_nr)
                         return -EFAULT;
-
-                array += 1 + data->callchain->nr;
+                sz = data->callchain->nr * sizeof(u64);
+                OVERFLOW_CHECK(array, sz, max_size);
+                array = (void *)array + sz;
         }
 
         if (type & PERF_SAMPLE_RAW) {
-                const u64 *pdata;
-
+                OVERFLOW_CHECK_u64(array);
                 u.val64 = *array;
                 if (WARN_ONCE(swapped,
                               "Endianness of raw data not corrected!\n")) {
@@ -1123,65 +1401,71 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
                         u.val32[0] = bswap_32(u.val32[0]);
                         u.val32[1] = bswap_32(u.val32[1]);
                 }
-
-                if (sample_overlap(event, array, sizeof(u32)))
-                        return -EFAULT;
-
                 data->raw_size = u.val32[0];
-                pdata = (void *) array + sizeof(u32);
+                array = (void *)array + sizeof(u32);
 
-                if (sample_overlap(event, pdata, data->raw_size))
-                        return -EFAULT;
-
-                data->raw_data = (void *) pdata;
-
-                array = (void *)array + data->raw_size + sizeof(u32);
+                OVERFLOW_CHECK(array, data->raw_size, max_size);
+                data->raw_data = (void *)array;
+                array = (void *)array + data->raw_size;
         }
 
         if (type & PERF_SAMPLE_BRANCH_STACK) {
-                u64 sz;
+                const u64 max_branch_nr = UINT64_MAX /
+                                          sizeof(struct branch_entry);
 
-                data->branch_stack = (struct branch_stack *)array;
-                array++; /* nr */
+                OVERFLOW_CHECK_u64(array);
+                data->branch_stack = (struct branch_stack *)array++;
 
+                if (data->branch_stack->nr > max_branch_nr)
+                        return -EFAULT;
                 sz = data->branch_stack->nr * sizeof(struct branch_entry);
-                sz /= sizeof(u64);
-                array += sz;
+                OVERFLOW_CHECK(array, sz, max_size);
+                array = (void *)array + sz;
         }
 
         if (type & PERF_SAMPLE_REGS_USER) {
-                /* First u64 tells us if we have any regs in sample. */
-                u64 avail = *array++;
+                OVERFLOW_CHECK_u64(array);
+                data->user_regs.abi = *array;
+                array++;
+
+                if (data->user_regs.abi) {
+                        u64 regs_user = evsel->attr.sample_regs_user;
 
-                if (avail) {
+                        sz = hweight_long(regs_user) * sizeof(u64);
+                        OVERFLOW_CHECK(array, sz, max_size);
                         data->user_regs.regs = (u64 *)array;
-                        array += hweight_long(regs_user);
+                        array = (void *)array + sz;
                 }
         }
 
         if (type & PERF_SAMPLE_STACK_USER) {
-                u64 size = *array++;
+                OVERFLOW_CHECK_u64(array);
+                sz = *array++;
 
                 data->user_stack.offset = ((char *)(array - 1)
                                           - (char *) event);
 
-                if (!size) {
+                if (!sz) {
                         data->user_stack.size = 0;
                 } else {
+                        OVERFLOW_CHECK(array, sz, max_size);
                         data->user_stack.data = (char *)array;
-                        array += size / sizeof(*array);
-                        data->user_stack.size = *array;
+                        array = (void *)array + sz;
+                        OVERFLOW_CHECK_u64(array);
+                        data->user_stack.size = *array++;
                 }
         }
 
         data->weight = 0;
         if (type & PERF_SAMPLE_WEIGHT) {
+                OVERFLOW_CHECK_u64(array);
                 data->weight = *array;
                 array++;
         }
 
         data->data_src = PERF_MEM_DATA_SRC_NONE;
         if (type & PERF_SAMPLE_DATA_SRC) {
+                OVERFLOW_CHECK_u64(array);
                 data->data_src = *array;
                 array++;
         }
@@ -1189,12 +1473,105 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
         return 0;
 }
 
+size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type,
+                                     u64 sample_regs_user, u64 read_format)
+{
+        size_t sz, result = sizeof(struct sample_event);
+
+        if (type & PERF_SAMPLE_IDENTIFIER)
+                result += sizeof(u64);
+
+        if (type & PERF_SAMPLE_IP)
+                result += sizeof(u64);
+
+        if (type & PERF_SAMPLE_TID)
+                result += sizeof(u64);
+
+        if (type & PERF_SAMPLE_TIME)
+                result += sizeof(u64);
+
+        if (type & PERF_SAMPLE_ADDR)
+                result += sizeof(u64);
+
+        if (type & PERF_SAMPLE_ID)
+                result += sizeof(u64);
+
+        if (type & PERF_SAMPLE_STREAM_ID)
+                result += sizeof(u64);
+
+        if (type & PERF_SAMPLE_CPU)
+                result += sizeof(u64);
+
+        if (type & PERF_SAMPLE_PERIOD)
+                result += sizeof(u64);
+
+        if (type & PERF_SAMPLE_READ) {
+                result += sizeof(u64);
+                if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
+                        result += sizeof(u64);
+                if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
+                        result += sizeof(u64);
+                /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */
+                if (read_format & PERF_FORMAT_GROUP) {
+                        sz = sample->read.group.nr *
+                             sizeof(struct sample_read_value);
+                        result += sz;
+                } else {
+                        result += sizeof(u64);
+                }
+        }
+
+        if (type & PERF_SAMPLE_CALLCHAIN) {
+                sz = (sample->callchain->nr + 1) * sizeof(u64);
+                result += sz;
+        }
+
+        if (type & PERF_SAMPLE_RAW) {
+                result += sizeof(u32);
+                result += sample->raw_size;
+        }
+
+        if (type & PERF_SAMPLE_BRANCH_STACK) {
+                sz = sample->branch_stack->nr * sizeof(struct branch_entry);
+                sz += sizeof(u64);
+                result += sz;
+        }
+
+        if (type & PERF_SAMPLE_REGS_USER) {
+                if (sample->user_regs.abi) {
+                        result += sizeof(u64);
+                        sz = hweight_long(sample_regs_user) * sizeof(u64);
+                        result += sz;
+                } else {
+                        result += sizeof(u64);
+                }
+        }
+
+        if (type & PERF_SAMPLE_STACK_USER) {
+                sz = sample->user_stack.size;
+                result += sizeof(u64);
+                if (sz) {
+                        result += sz;
+                        result += sizeof(u64);
+                }
+        }
+
+        if (type & PERF_SAMPLE_WEIGHT)
+                result += sizeof(u64);
+
+        if (type & PERF_SAMPLE_DATA_SRC)
+                result += sizeof(u64);
+
+        return result;
+}
+
 int perf_event__synthesize_sample(union perf_event *event, u64 type,
+                                  u64 sample_regs_user, u64 read_format,
                                   const struct perf_sample *sample,
                                   bool swapped)
 {
         u64 *array;
-
+        size_t sz;
         /*
          * used for cross-endian analysis. See git commit 65014ab3
          * for why this goofiness is needed.
@@ -1203,8 +1580,13 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type,
 
         array = event->sample.array;
 
+        if (type & PERF_SAMPLE_IDENTIFIER) {
+                *array = sample->id;
+                array++;
+        }
+
         if (type & PERF_SAMPLE_IP) {
-                event->ip.ip = sample->ip;
+                *array = sample->ip;
                 array++;
         }
 
@@ -1262,6 +1644,97 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type,
                 array++;
         }
 
+        if (type & PERF_SAMPLE_READ) {
+                if (read_format & PERF_FORMAT_GROUP)
+                        *array = sample->read.group.nr;
+                else
+                        *array = sample->read.one.value;
+                array++;
+
+                if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
+                        *array = sample->read.time_enabled;
+                        array++;
+                }
+
+                if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
+                        *array = sample->read.time_running;
+                        array++;
+                }
+
+                /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */
+                if (read_format & PERF_FORMAT_GROUP) {
+                        sz = sample->read.group.nr *
+                             sizeof(struct sample_read_value);
+                        memcpy(array, sample->read.group.values, sz);
+                        array = (void *)array + sz;
+                } else {
+                        *array = sample->read.one.id;
+                        array++;
+                }
+        }
+
+        if (type & PERF_SAMPLE_CALLCHAIN) {
+                sz = (sample->callchain->nr + 1) * sizeof(u64);
+                memcpy(array, sample->callchain, sz);
+                array = (void *)array + sz;
+        }
+
+        if (type & PERF_SAMPLE_RAW) {
+                u.val32[0] = sample->raw_size;
+                if (WARN_ONCE(swapped,
+                              "Endianness of raw data not corrected!\n")) {
+                        /*
+                         * Inverse of what is done in perf_evsel__parse_sample
+                         */
+                        u.val32[0] = bswap_32(u.val32[0]);
+                        u.val32[1] = bswap_32(u.val32[1]);
+                        u.val64 = bswap_64(u.val64);
+                }
+                *array = u.val64;
+                array = (void *)array + sizeof(u32);
+
+                memcpy(array, sample->raw_data, sample->raw_size);
+                array = (void *)array + sample->raw_size;
+        }
+
+        if (type & PERF_SAMPLE_BRANCH_STACK) {
+                sz = sample->branch_stack->nr * sizeof(struct branch_entry);
+                sz += sizeof(u64);
+                memcpy(array, sample->branch_stack, sz);
+                array = (void *)array + sz;
+        }
+
+        if (type & PERF_SAMPLE_REGS_USER) {
+                if (sample->user_regs.abi) {
+                        *array++ = sample->user_regs.abi;
+                        sz = hweight_long(sample_regs_user) * sizeof(u64);
+                        memcpy(array, sample->user_regs.regs, sz);
+                        array = (void *)array + sz;
+                } else {
+                        *array++ = 0;
+                }
+        }
+
+        if (type & PERF_SAMPLE_STACK_USER) {
+                sz = sample->user_stack.size;
+                *array++ = sz;
+                if (sz) {
+                        memcpy(array, sample->user_stack.data, sz);
+                        array = (void *)array + sz;
+                        *array++ = sz;
+                }
+        }
+
+        if (type & PERF_SAMPLE_WEIGHT) {
+                *array = sample->weight;
+                array++;
+        }
+
+        if (type & PERF_SAMPLE_DATA_SRC) {
+                *array = sample->data_src;
+                array++;
+        }
+
         return 0;
 }
 
@@ -1391,6 +1864,7 @@ static int sample_type__fprintf(FILE *fp, bool *first, u64 value)
                 bit_name(READ), bit_name(CALLCHAIN), bit_name(ID), bit_name(CPU),
                 bit_name(PERIOD), bit_name(STREAM_ID), bit_name(RAW),
                 bit_name(BRANCH_STACK), bit_name(REGS_USER), bit_name(STACK_USER),
+                bit_name(IDENTIFIER),
                 { .name = NULL, }
         };
 #undef bit_name
@@ -1458,6 +1932,7 @@ int perf_evsel__fprintf(struct perf_evsel *evsel,
                 if_print(exclude_hv);
                 if_print(exclude_idle);
                 if_print(mmap);
+                if_print(mmap2);
                 if_print(comm);
                 if_print(freq);
                 if_print(inherit_stat);
@@ -1482,7 +1957,7 @@ out:
 bool perf_evsel__fallback(struct perf_evsel *evsel, int err,
                           char *msg, size_t msgsize)
 {
-        if ((err == ENOENT || err == ENXIO) &&
+        if ((err == ENOENT || err == ENXIO || err == ENODEV) &&
             evsel->attr.type   == PERF_TYPE_HARDWARE &&
             evsel->attr.config == PERF_COUNT_HW_CPU_CYCLES) {
                 /*
@@ -1514,7 +1989,7 @@ int perf_evsel__open_strerror(struct perf_evsel *evsel,
         switch (err) {
         case EPERM:
         case EACCES:
-                return scnprintf(msg, size, "%s",
+                return scnprintf(msg, size,
                  "You may not have permission to collect %sstats.\n"
                  "Consider tweaking /proc/sys/kernel/perf_event_paranoid:\n"
                  " -1 - Not paranoid at all\n"
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 3f156ccc1acb..4a7bdc713bab 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -38,6 +38,9 @@ struct perf_sample_id {
         struct hlist_node       node;
         u64                     id;
         struct perf_evsel       *evsel;
+
+        /* Holds total ID period value for PERF_SAMPLE_READ processing. */
+        u64                     period;
 };
 
 /** struct perf_evsel - event selector
@@ -45,6 +48,12 @@ struct perf_sample_id {
  * @name - Can be set to retain the original event name passed by the user,
  *         so that when showing results in tools such as 'perf stat', we
  *         show the name used, not some alias.
+ * @id_pos: the position of the event id (PERF_SAMPLE_ID or
+ *          PERF_SAMPLE_IDENTIFIER) in a sample event i.e. in the array of
+ *          struct sample_event
+ * @is_pos: the position (counting backwards) of the event id (PERF_SAMPLE_ID or
+ *          PERF_SAMPLE_IDENTIFIER) in a non-sample event i.e. if sample_id_all
+ *          is used there is an id sample appended to non-sample events
  */
 struct perf_evsel {
         struct list_head        node;
@@ -71,11 +80,14 @@ struct perf_evsel {
         } handler;
         struct cpu_map          *cpus;
         unsigned int            sample_size;
+        int                     id_pos;
+        int                     is_pos;
         bool                    supported;
         bool                    needs_swap;
         /* parse modifier helper */
         int                     exclude_GH;
         int                     nr_members;
+        int                     sample_read;
         struct perf_evsel       *leader;
         char                    *group_name;
 };
@@ -100,6 +112,9 @@ void perf_evsel__delete(struct perf_evsel *evsel);
 void perf_evsel__config(struct perf_evsel *evsel,
                         struct perf_record_opts *opts);
 
+int __perf_evsel__sample_size(u64 sample_type);
+void perf_evsel__calc_id_pos(struct perf_evsel *evsel);
+
 bool perf_evsel__is_cache_op_valid(u8 type, u8 op);
 
 #define PERF_EVSEL__MAX_ALIASES 8
@@ -138,10 +153,12 @@ void __perf_evsel__reset_sample_bit(struct perf_evsel *evsel,
 #define perf_evsel__reset_sample_bit(evsel, bit) \
         __perf_evsel__reset_sample_bit(evsel, PERF_SAMPLE_##bit)
 
-void perf_evsel__set_sample_id(struct perf_evsel *evsel);
+void perf_evsel__set_sample_id(struct perf_evsel *evsel,
+                               bool use_sample_identifier);
 
 int perf_evsel__set_filter(struct perf_evsel *evsel, int ncpus, int nthreads,
                            const char *filter);
+int perf_evsel__enable(struct perf_evsel *evsel, int ncpus, int nthreads);
 
 int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
                              struct cpu_map *cpus);
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 326068a593a5..ce69901176d8 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -25,41 +25,9 @@
 
 static bool no_buildid_cache = false;
 
-static int trace_event_count;
-static struct perf_trace_event_type *trace_events;
-
 static u32 header_argc;
 static const char **header_argv;
 
-int perf_header__push_event(u64 id, const char *name)
-{
-        struct perf_trace_event_type *nevents;
-
-        if (strlen(name) > MAX_EVENT_NAME)
-                pr_warning("Event %s will be truncated\n", name);
-
-        nevents = realloc(trace_events, (trace_event_count + 1) * sizeof(*trace_events));
-        if (nevents == NULL)
-                return -ENOMEM;
-        trace_events = nevents;
-
-        memset(&trace_events[trace_event_count], 0, sizeof(struct perf_trace_event_type));
-        trace_events[trace_event_count].event_id = id;
-        strncpy(trace_events[trace_event_count].name, name, MAX_EVENT_NAME - 1);
-        trace_event_count++;
-        return 0;
-}
-
-char *perf_header__find_event(u64 id)
-{
-        int i;
-        for (i = 0 ; i < trace_event_count; i++) {
-                if (trace_events[i].event_id == id)
-                        return trace_events[i].name;
-        }
-        return NULL;
-}
-
 /*
  * magic2 = "PERFILE2"
  * must be a numerical value to let the endianness
@@ -231,9 +199,11 @@ static int write_buildid(char *name, size_t name_len, u8 *build_id,
         return write_padded(fd, name, name_len + 1, len);
 }
 
-static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
-                                u16 misc, int fd)
+static int __dsos__write_buildid_table(struct list_head *head,
+                                       struct machine *machine,
+                                       pid_t pid, u16 misc, int fd)
 {
+        char nm[PATH_MAX];
         struct dso *pos;
 
         dsos__for_each_with_build_id(pos, head) {
@@ -247,6 +217,10 @@ static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
                 if (is_vdso_map(pos->short_name)) {
                         name = (char *) VDSO__MAP_NAME;
                         name_len = sizeof(VDSO__MAP_NAME) + 1;
+                } else if (dso__is_kcore(pos)) {
+                        machine__mmap_name(machine, nm, sizeof(nm));
+                        name = nm;
+                        name_len = strlen(nm) + 1;
                 } else {
                         name = pos->long_name;
                         name_len = pos->long_name_len + 1;
@@ -272,10 +246,10 @@ static int machine__write_buildid_table(struct machine *machine, int fd)
                 umisc = PERF_RECORD_MISC_GUEST_USER;
         }
 
-        err = __dsos__write_buildid_table(&machine->kernel_dsos, machine->pid,
-                                          kmisc, fd);
+        err = __dsos__write_buildid_table(&machine->kernel_dsos, machine,
+                                          machine->pid, kmisc, fd);
         if (err == 0)
-                err = __dsos__write_buildid_table(&machine->user_dsos,
+                err = __dsos__write_buildid_table(&machine->user_dsos, machine,
                                                   machine->pid, umisc, fd);
         return err;
 }
@@ -407,23 +381,31 @@ out_free:
         return err;
 }
 
-static int dso__cache_build_id(struct dso *dso, const char *debugdir)
+static int dso__cache_build_id(struct dso *dso, struct machine *machine,
+                               const char *debugdir)
 {
         bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
         bool is_vdso = is_vdso_map(dso->short_name);
+        char *name = dso->long_name;
+        char nm[PATH_MAX];
 
-        return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id),
-                                     dso->long_name, debugdir,
-                                     is_kallsyms, is_vdso);
+        if (dso__is_kcore(dso)) {
+                is_kallsyms = true;
+                machine__mmap_name(machine, nm, sizeof(nm));
+                name = nm;
+        }
+        return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id), name,
+                                     debugdir, is_kallsyms, is_vdso);
 }
 
-static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
+static int __dsos__cache_build_ids(struct list_head *head,
+                                   struct machine *machine, const char *debugdir)
 {
         struct dso *pos;
         int err = 0;
 
         dsos__for_each_with_build_id(pos, head)
-                if (dso__cache_build_id(pos, debugdir))
+                if (dso__cache_build_id(pos, machine, debugdir))
                         err = -1;
 
         return err;
@@ -431,8 +413,9 @@ static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
 
 static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
 {
-        int ret = __dsos__cache_build_ids(&machine->kernel_dsos, debugdir);
-        ret |= __dsos__cache_build_ids(&machine->user_dsos, debugdir);
+        int ret = __dsos__cache_build_ids(&machine->kernel_dsos, machine,
+                                          debugdir);
+        ret |= __dsos__cache_build_ids(&machine->user_dsos, machine, debugdir);
         return ret;
 }
 
@@ -748,18 +731,19 @@ static int build_cpu_topo(struct cpu_topo *tp, int cpu)
         char filename[MAXPATHLEN];
         char *buf = NULL, *p;
         size_t len = 0;
+        ssize_t sret;
         u32 i = 0;
         int ret = -1;
 
         sprintf(filename, CORE_SIB_FMT, cpu);
         fp = fopen(filename, "r");
         if (!fp)
-                return -1;
-
-        if (getline(&buf, &len, fp) <= 0)
-                goto done;
+                goto try_threads;
 
+        sret = getline(&buf, &len, fp);
         fclose(fp);
+        if (sret <= 0)
+                goto try_threads;
 
         p = strchr(buf, '\n');
         if (p)
@@ -775,7 +759,9 @@ static int build_cpu_topo(struct cpu_topo *tp, int cpu)
                 buf = NULL;
                 len = 0;
         }
+        ret = 0;
 
+try_threads:
         sprintf(filename, THRD_SIB_FMT, cpu);
         fp = fopen(filename, "r");
         if (!fp)
@@ -1380,6 +1366,9 @@ static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
 
                 fprintf(fp, ", precise_ip = %d", evsel->attr.precise_ip);
 
+                fprintf(fp, ", attr_mmap2 = %d", evsel->attr.mmap2);
+                fprintf(fp, ", attr_mmap  = %d", evsel->attr.mmap);
+                fprintf(fp, ", attr_mmap_data = %d", evsel->attr.mmap_data);
                 if (evsel->ids) {
                         fprintf(fp, ", id = {");
                         for (j = 0, id = evsel->id; j < evsel->ids; j++, id++) {
@@ -2257,7 +2246,7 @@ static int perf_header__adds_write(struct perf_header *header,
 
         sec_size = sizeof(*feat_sec) * nr_sections;
 
-        sec_start = header->data_offset + header->data_size;
+        sec_start = header->feat_offset;
         lseek(fd, sec_start + sec_size, SEEK_SET);
 
         for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
@@ -2303,32 +2292,22 @@ int perf_session__write_header(struct perf_session *session,
         struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
         struct perf_header *header = &session->header;
-        struct perf_evsel *evsel, *pair = NULL;
+        struct perf_evsel *evsel;
+        u64 attr_offset;
         int err;
 
         lseek(fd, sizeof(f_header), SEEK_SET);
 
-        if (session->evlist != evlist)
-                pair = perf_evlist__first(session->evlist);
-
         list_for_each_entry(evsel, &evlist->entries, node) {
                 evsel->id_offset = lseek(fd, 0, SEEK_CUR);
                 err = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
                 if (err < 0) {
-out_err_write:
                         pr_debug("failed to write perf header\n");
                         return err;
                 }
-                if (session->evlist != evlist) {
-                        err = do_write(fd, pair->id, pair->ids * sizeof(u64));
-                        if (err < 0)
-                                goto out_err_write;
-                        evsel->ids += pair->ids;
-                        pair = perf_evsel__next(pair);
-                }
         }
 
-        header->attr_offset = lseek(fd, 0, SEEK_CUR);
+        attr_offset = lseek(fd, 0, SEEK_CUR);
 
         list_for_each_entry(evsel, &evlist->entries, node) {
                 f_attr = (struct perf_file_attr){
@@ -2345,17 +2324,8 @@ out_err_write:
                 }
         }
 
-        header->event_offset = lseek(fd, 0, SEEK_CUR);
-        header->event_size = trace_event_count * sizeof(struct perf_trace_event_type);
-        if (trace_events) {
-                err = do_write(fd, trace_events, header->event_size);
-                if (err < 0) {
-                        pr_debug("failed to write perf header events\n");
-                        return err;
-                }
-        }
-
         header->data_offset = lseek(fd, 0, SEEK_CUR);
+        header->feat_offset = header->data_offset + header->data_size;
 
         if (at_exit) {
                 err = perf_header__adds_write(header, evlist, fd);
@@ -2368,17 +2338,14 @@ out_err_write:
                 .size      = sizeof(f_header),
                 .attr_size = sizeof(f_attr),
                 .attrs = {
-                        .offset = header->attr_offset,
+                        .offset = attr_offset,
                         .size   = evlist->nr_entries * sizeof(f_attr),
                 },
                 .data = {
                         .offset = header->data_offset,
                         .size   = header->data_size,
                 },
-                .event_types = {
-                        .offset = header->event_offset,
-                        .size   = header->event_size,
-                },
+                /* event_types is ignored, store zeros */
         };
 
         memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
@@ -2391,7 +2358,6 @@ out_err_write:
         }
         lseek(fd, header->data_offset + header->data_size, SEEK_SET);
 
-        header->frozen = 1;
         return 0;
 }
 
@@ -2429,7 +2395,7 @@ int perf_header__process_sections(struct perf_header *header, int fd,
 
         sec_size = sizeof(*feat_sec) * nr_sections;
 
-        lseek(fd, header->data_offset + header->data_size, SEEK_SET);
+        lseek(fd, header->feat_offset, SEEK_SET);
 
         err = perf_header__getbuffer64(header, fd, feat_sec, sec_size);
         if (err < 0)
@@ -2535,6 +2501,7 @@ static int check_magic_endian(u64 magic, uint64_t hdr_sz,
         /* check for legacy format */
         ret = memcmp(&magic, __perf_magic1, sizeof(magic));
         if (ret == 0) {
+                ph->version = PERF_HEADER_VERSION_1;
                 pr_debug("legacy perf.data format\n");
                 if (is_pipe)
                         return try_all_pipe_abis(hdr_sz, ph);
@@ -2556,6 +2523,7 @@ 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;
 }
@@ -2626,10 +2594,9 @@ int perf_file_header__read(struct perf_file_header *header,
         memcpy(&ph->adds_features, &header->adds_features,
                sizeof(ph->adds_features));
 
-        ph->event_offset = header->event_types.offset;
-        ph->event_size   = header->event_types.size;
         ph->data_offset  = header->data.offset;
         ph->data_size    = header->data.size;
+        ph->feat_offset  = header->data.offset + header->data.size;
         return 0;
 }
 
@@ -2678,19 +2645,17 @@ static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
         return 0;
 }
 
-static int perf_header__read_pipe(struct perf_session *session, int fd)
+static int perf_header__read_pipe(struct perf_session *session)
 {
         struct perf_header *header = &session->header;
         struct perf_pipe_file_header f_header;
 
-        if (perf_file_header__read_pipe(&f_header, header, fd,
+        if (perf_file_header__read_pipe(&f_header, header, session->fd,
                                         session->repipe) < 0) {
                 pr_debug("incompatible file format\n");
                 return -EINVAL;
         }
 
-        session->fd = fd;
-
         return 0;
 }
 
@@ -2784,20 +2749,21 @@ static int perf_evlist__prepare_tracepoint_events(struct perf_evlist *evlist,
         return 0;
 }
 
-int perf_session__read_header(struct perf_session *session, int fd)
+int perf_session__read_header(struct perf_session *session)
 {
         struct perf_header *header = &session->header;
         struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
         u64                     f_id;
         int nr_attrs, nr_ids, i, j;
+        int fd = session->fd;
 
         session->evlist = perf_evlist__new();
         if (session->evlist == NULL)
                 return -ENOMEM;
 
         if (session->fd_pipe)
-                return perf_header__read_pipe(session, fd);
+                return perf_header__read_pipe(session);
 
         if (perf_file_header__read(&f_header, header, fd) < 0)
                 return -EINVAL;
@@ -2851,27 +2817,13 @@ int perf_session__read_header(struct perf_session *session, int fd)
 
         symbol_conf.nr_events = nr_attrs;
 
-        if (f_header.event_types.size) {
-                lseek(fd, f_header.event_types.offset, SEEK_SET);
-                trace_events = malloc(f_header.event_types.size);
-                if (trace_events == NULL)
-                        return -ENOMEM;
-                if (perf_header__getbuffer64(header, fd, trace_events,
-                                             f_header.event_types.size))
-                        goto out_errno;
-                trace_event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
-        }
-
         perf_header__process_sections(header, fd, &session->pevent,
                                       perf_file_section__process);
 
-        lseek(fd, header->data_offset, SEEK_SET);
-
         if (perf_evlist__prepare_tracepoint_events(session->evlist,
                                                    session->pevent))
                 goto out_delete_evlist;
 
-        header->frozen = 1;
         return 0;
 out_errno:
         return -errno;
@@ -2935,7 +2887,8 @@ int perf_event__synthesize_attrs(struct perf_tool *tool,
         return err;
 }
 
-int perf_event__process_attr(union perf_event *event,
+int perf_event__process_attr(struct perf_tool *tool __maybe_unused,
+                             union perf_event *event,
                              struct perf_evlist **pevlist)
 {
         u32 i, ids, n_ids;
@@ -2969,63 +2922,7 @@ int perf_event__process_attr(union perf_event *event,
                 perf_evlist__id_add(evlist, evsel, 0, i, event->attr.id[i]);
         }
 
-        return 0;
-}
-
-int perf_event__synthesize_event_type(struct perf_tool *tool,
-                                      u64 event_id, char *name,
-                                      perf_event__handler_t process,
-                                      struct machine *machine)
-{
-        union perf_event ev;
-        size_t size = 0;
-        int err = 0;
-
-        memset(&ev, 0, sizeof(ev));
-
-        ev.event_type.event_type.event_id = event_id;
-        memset(ev.event_type.event_type.name, 0, MAX_EVENT_NAME);
-        strncpy(ev.event_type.event_type.name, name, MAX_EVENT_NAME - 1);
-
-        ev.event_type.header.type = PERF_RECORD_HEADER_EVENT_TYPE;
-        size = strlen(ev.event_type.event_type.name);
-        size = PERF_ALIGN(size, sizeof(u64));
-        ev.event_type.header.size = sizeof(ev.event_type) -
-                (sizeof(ev.event_type.event_type.name) - size);
-
-        err = process(tool, &ev, NULL, machine);
-
-        return err;
-}
-
-int perf_event__synthesize_event_types(struct perf_tool *tool,
-                                       perf_event__handler_t process,
-                                       struct machine *machine)
-{
-        struct perf_trace_event_type *type;
-        int i, err = 0;
-
-        for (i = 0; i < trace_event_count; i++) {
-                type = &trace_events[i];
-
-                err = perf_event__synthesize_event_type(tool, type->event_id,
-                                                        type->name, process,
-                                                        machine);
-                if (err) {
-                        pr_debug("failed to create perf header event type\n");
-                        return err;
-                }
-        }
-
-        return err;
-}
-
-int perf_event__process_event_type(struct perf_tool *tool __maybe_unused,
-                                   union perf_event *event)
-{
-        if (perf_header__push_event(event->event_type.event_type.event_id,
-                                    event->event_type.event_type.name) < 0)
-                return -ENOMEM;
+        symbol_conf.nr_events = evlist->nr_entries;
 
         return 0;
 }
@@ -3076,7 +2973,8 @@ int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
         return aligned_size;
 }
 
-int perf_event__process_tracing_data(union perf_event *event,
+int perf_event__process_tracing_data(struct perf_tool *tool __maybe_unused,
+                                     union perf_event *event,
                                      struct perf_session *session)
 {
         ssize_t size_read, padding, size = event->tracing_data.size;
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index c9fc55cada6d..307c9aed972e 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -34,6 +34,11 @@ enum {
         HEADER_FEAT_BITS        = 256,
 };
 
+enum perf_header_version {
+        PERF_HEADER_VERSION_1,
+        PERF_HEADER_VERSION_2,
+};
+
 struct perf_file_section {
         u64 offset;
         u64 size;
@@ -45,6 +50,7 @@ struct perf_file_header {
         u64                             attr_size;
         struct perf_file_section        attrs;
         struct perf_file_section        data;
+        /* event_types is ignored */
         struct perf_file_section        event_types;
         DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
 };
@@ -84,29 +90,24 @@ struct perf_session_env {
 };
 
 struct perf_header {
-        int                     frozen;
-        bool                    needs_swap;
-        s64                     attr_offset;
-        u64                     data_offset;
-        u64                     data_size;
-        u64                     event_offset;
-        u64                     event_size;
+        enum perf_header_version        version;
+        bool                            needs_swap;
+        u64                             data_offset;
+        u64                             data_size;
+        u64                             feat_offset;
         DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
-        struct perf_session_env env;
+        struct perf_session_env         env;
 };
 
 struct perf_evlist;
 struct perf_session;
 
-int perf_session__read_header(struct perf_session *session, int fd);
+int perf_session__read_header(struct perf_session *session);
 int perf_session__write_header(struct perf_session *session,
                                struct perf_evlist *evlist,
                                int fd, bool at_exit);
 int perf_header__write_pipe(int fd);
 
-int perf_header__push_event(u64 id, const char *name);
-char *perf_header__find_event(u64 id);
-
 void perf_header__set_feat(struct perf_header *header, int feat);
 void perf_header__clear_feat(struct perf_header *header, int feat);
 bool perf_header__has_feat(const struct perf_header *header, int feat);
@@ -131,22 +132,14 @@ int perf_event__synthesize_attr(struct perf_tool *tool,
 int perf_event__synthesize_attrs(struct perf_tool *tool,
                                  struct perf_session *session,
                                  perf_event__handler_t process);
-int perf_event__process_attr(union perf_event *event, struct perf_evlist **pevlist);
-
-int perf_event__synthesize_event_type(struct perf_tool *tool,
-                                      u64 event_id, char *name,
-                                      perf_event__handler_t process,
-                                      struct machine *machine);
-int perf_event__synthesize_event_types(struct perf_tool *tool,
-                                       perf_event__handler_t process,
-                                       struct machine *machine);
-int perf_event__process_event_type(struct perf_tool *tool,
-                                   union perf_event *event);
+int perf_event__process_attr(struct perf_tool *tool, union perf_event *event,
+                             struct perf_evlist **pevlist);
 
 int perf_event__synthesize_tracing_data(struct perf_tool *tool,
                                         int fd, struct perf_evlist *evlist,
                                         perf_event__handler_t process);
-int perf_event__process_tracing_data(union perf_event *event,
+int perf_event__process_tracing_data(struct perf_tool *tool,
+                                     union perf_event *event,
                                      struct perf_session *session);
 
 int perf_event__synthesize_build_id(struct perf_tool *tool,
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 6b32721f829a..9ff6cf3e9a99 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -24,7 +24,8 @@ enum hist_filter {
 struct callchain_param  callchain_param = {
         .mode   = CHAIN_GRAPH_REL,
         .min_percent = 0.5,
-        .order  = ORDER_CALLEE
+        .order  = ORDER_CALLEE,
+        .key    = CCKEY_FUNCTION
 };
 
 u16 hists__col_len(struct hists *hists, enum hist_column col)
@@ -70,9 +71,17 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
         int symlen;
         u16 len;
 
-        if (h->ms.sym)
-                hists__new_col_len(hists, HISTC_SYMBOL, h->ms.sym->namelen + 4);
-        else {
+        /*
+         * +4 accounts for '[x] ' priv level info
+         * +2 accounts for 0x prefix on raw addresses
+         * +3 accounts for ' y ' symtab origin info
+         */
+        if (h->ms.sym) {
+                symlen = h->ms.sym->namelen + 4;
+                if (verbose)
+                        symlen += BITS_PER_LONG / 4 + 2 + 3;
+                hists__new_col_len(hists, HISTC_SYMBOL, symlen);
+        } else {
                 symlen = unresolved_col_width + 4 + 2;
                 hists__new_col_len(hists, HISTC_SYMBOL, symlen);
                 hists__set_unres_dso_col_len(hists, HISTC_DSO);
@@ -91,12 +100,10 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
                 hists__new_col_len(hists, HISTC_PARENT, h->parent->namelen);
 
         if (h->branch_info) {
-                /*
-                 * +4 accounts for '[x] ' priv level info
-                 * +2 account of 0x prefix on raw addresses
-                 */
                 if (h->branch_info->from.sym) {
                         symlen = (int)h->branch_info->from.sym->namelen + 4;
+                        if (verbose)
+                                symlen += BITS_PER_LONG / 4 + 2 + 3;
                         hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
 
                         symlen = dso__name_len(h->branch_info->from.map->dso);
@@ -109,6 +116,8 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
 
                 if (h->branch_info->to.sym) {
                         symlen = (int)h->branch_info->to.sym->namelen + 4;
+                        if (verbose)
+                                symlen += BITS_PER_LONG / 4 + 2 + 3;
                         hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
 
                         symlen = dso__name_len(h->branch_info->to.map->dso);
@@ -121,10 +130,6 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
         }
 
         if (h->mem_info) {
-                /*
-                 * +4 accounts for '[x] ' priv level info
-                 * +2 account of 0x prefix on raw addresses
-                 */
                 if (h->mem_info->daddr.sym) {
                         symlen = (int)h->mem_info->daddr.sym->namelen + 4
                                + unresolved_col_width + 2;
@@ -236,8 +241,7 @@ static bool hists__decay_entry(struct hists *hists, struct hist_entry *he)
         return he->stat.period == 0;
 }
 
-static void __hists__decay_entries(struct hists *hists, bool zap_user,
-                                   bool zap_kernel, bool threaded)
+void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
 {
         struct rb_node *next = rb_first(&hists->entries);
         struct hist_entry *n;
@@ -256,7 +260,7 @@ static void __hists__decay_entries(struct hists *hists, bool zap_user,
                     !n->used) {
                         rb_erase(&n->rb_node, &hists->entries);
 
-                        if (sort__need_collapse || threaded)
+                        if (sort__need_collapse)
                                 rb_erase(&n->rb_node_in, &hists->entries_collapsed);
 
                         hist_entry__free(n);
@@ -265,17 +269,6 @@ static void __hists__decay_entries(struct hists *hists, bool zap_user,
         }
 }
 
-void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
-{
-        return __hists__decay_entries(hists, zap_user, zap_kernel, false);
-}
-
-void hists__decay_entries_threaded(struct hists *hists,
-                                   bool zap_user, bool zap_kernel)
-{
-        return __hists__decay_entries(hists, zap_user, zap_kernel, true);
-}
-
 /*
  * histogram, sorted on item, collects periods
  */
@@ -292,6 +285,20 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template)
                         he->ms.map->referenced = true;
 
                 if (he->branch_info) {
+                        /*
+                         * This branch info is (a part of) allocated from
+                         * machine__resolve_bstack() and will be freed after
+                         * adding new entries.  So we need to save a copy.
+                         */
+                        he->branch_info = malloc(sizeof(*he->branch_info));
+                        if (he->branch_info == NULL) {
+                                free(he);
+                                return NULL;
+                        }
+
+                        memcpy(he->branch_info, template->branch_info,
+                               sizeof(*he->branch_info));
+
                         if (he->branch_info->from.map)
                                 he->branch_info->from.map->referenced = true;
                         if (he->branch_info->to.map)
@@ -341,8 +348,6 @@ static struct hist_entry *add_hist_entry(struct hists *hists,
         struct hist_entry *he;
         int cmp;
 
-        pthread_mutex_lock(&hists->lock);
-
         p = &hists->entries_in->rb_node;
 
         while (*p != NULL) {
@@ -360,6 +365,12 @@ static struct hist_entry *add_hist_entry(struct hists *hists,
                 if (!cmp) {
                         he_stat__add_period(&he->stat, period, weight);
 
+                        /*
+                         * This mem info was allocated from machine__resolve_mem
+                         * and will not be used anymore.
+                         */
+                        free(entry->mem_info);
+
                         /* If the map of an existing hist_entry has
                          * become out-of-date due to an exec() or
                          * similar, update it.  Otherwise we will
@@ -382,14 +393,12 @@ static struct hist_entry *add_hist_entry(struct hists *hists,
 
         he = hist_entry__new(entry);
         if (!he)
-                goto out_unlock;
+                return NULL;
 
         rb_link_node(&he->rb_node_in, parent, p);
         rb_insert_color(&he->rb_node_in, hists->entries_in);
 out:
         hist_entry__add_cpumode_period(he, al->cpumode, period);
-out_unlock:
-        pthread_mutex_unlock(&hists->lock);
         return he;
 }
 
@@ -589,19 +598,21 @@ static void hists__apply_filters(struct hists *hists, struct hist_entry *he)
         hists__filter_entry_by_symbol(hists, he);
 }
 
-static void __hists__collapse_resort(struct hists *hists, bool threaded)
+void hists__collapse_resort(struct hists *hists)
 {
         struct rb_root *root;
         struct rb_node *next;
         struct hist_entry *n;
 
-        if (!sort__need_collapse && !threaded)
+        if (!sort__need_collapse)
                 return;
 
         root = hists__get_rotate_entries_in(hists);
         next = rb_first(root);
 
         while (next) {
+                if (session_done())
+                        break;
                 n = rb_entry(next, struct hist_entry, rb_node_in);
                 next = rb_next(&n->rb_node_in);
 
@@ -617,16 +628,6 @@ static void __hists__collapse_resort(struct hists *hists, bool threaded)
         }
 }
 
-void hists__collapse_resort(struct hists *hists)
-{
-        return __hists__collapse_resort(hists, false);
-}
-
-void hists__collapse_resort_threaded(struct hists *hists)
-{
-        return __hists__collapse_resort(hists, true);
-}
-
 /*
  * reverse the map, sort on period.
  */
@@ -713,7 +714,7 @@ static void __hists__insert_output_entry(struct rb_root *entries,
         rb_insert_color(&he->rb_node, entries);
 }
 
-static void __hists__output_resort(struct hists *hists, bool threaded)
+void hists__output_resort(struct hists *hists)
 {
         struct rb_root *root;
         struct rb_node *next;
@@ -722,7 +723,7 @@ static void __hists__output_resort(struct hists *hists, bool threaded)
 
         min_callchain_hits = hists->stats.total_period * (callchain_param.min_percent / 100);
 
-        if (sort__need_collapse || threaded)
+        if (sort__need_collapse)
                 root = &hists->entries_collapsed;
         else
                 root = hists->entries_in;
@@ -743,16 +744,6 @@ static void __hists__output_resort(struct hists *hists, bool threaded)
         }
 }
 
-void hists__output_resort(struct hists *hists)
-{
-        return __hists__output_resort(hists, false);
-}
-
-void hists__output_resort_threaded(struct hists *hists)
-{
-        return __hists__output_resort(hists, true);
-}
-
 static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h,
                                        enum hist_filter filter)
 {
@@ -924,6 +915,7 @@ static struct hist_entry *hists__add_dummy_entry(struct hists *hists,
                 rb_link_node(&he->rb_node_in, parent, p);
                 rb_insert_color(&he->rb_node_in, root);
                 hists__inc_nr_entries(hists, he);
+                he->dummy = true;
         }
 out:
         return he;
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 14c2fe20aa62..1329b6b6ffe6 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -43,12 +43,12 @@ enum hist_column {
         HISTC_COMM,
         HISTC_PARENT,
         HISTC_CPU,
+        HISTC_SRCLINE,
         HISTC_MISPREDICT,
         HISTC_SYMBOL_FROM,
         HISTC_SYMBOL_TO,
         HISTC_DSO_FROM,
         HISTC_DSO_TO,
-        HISTC_SRCLINE,
         HISTC_LOCAL_WEIGHT,
         HISTC_GLOBAL_WEIGHT,
         HISTC_MEM_DADDR_SYMBOL,
@@ -104,13 +104,9 @@ struct hist_entry *__hists__add_mem_entry(struct hists *self,
                                           u64 weight);
 
 void hists__output_resort(struct hists *self);
-void hists__output_resort_threaded(struct hists *hists);
 void hists__collapse_resort(struct hists *self);
-void hists__collapse_resort_threaded(struct hists *hists);
 
 void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel);
-void hists__decay_entries_threaded(struct hists *hists, bool zap_user,
-                                   bool zap_kernel);
 void hists__output_recalc_col_len(struct hists *hists, int max_rows);
 
 void hists__inc_nr_entries(struct hists *hists, struct hist_entry *h);
@@ -119,7 +115,7 @@ void events_stats__inc(struct events_stats *stats, u32 type);
 size_t events_stats__fprintf(struct events_stats *stats, FILE *fp);
 
 size_t hists__fprintf(struct hists *self, bool show_header, int max_rows,
-                      int max_cols, FILE *fp);
+                      int max_cols, float min_pcnt, FILE *fp);
 
 int hist_entry__inc_addr_samples(struct hist_entry *self, int evidx, u64 addr);
 int hist_entry__annotate(struct hist_entry *self, size_t privsize);
@@ -145,10 +141,12 @@ struct perf_hpp {
 };
 
 struct perf_hpp_fmt {
-        int (*header)(struct perf_hpp *hpp);
-        int (*width)(struct perf_hpp *hpp);
-        int (*color)(struct perf_hpp *hpp, struct hist_entry *he);
-        int (*entry)(struct perf_hpp *hpp, struct hist_entry *he);
+        int (*header)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp);
+        int (*width)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp);
+        int (*color)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
+                     struct hist_entry *he);
+        int (*entry)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
+                     struct hist_entry *he);
 
         struct list_head list;
 };
@@ -161,7 +159,7 @@ extern struct list_head perf_hpp__list;
 extern struct perf_hpp_fmt perf_hpp__format[];
 
 enum {
-        PERF_HPP__BASELINE,
+        /* Matches perf_hpp__format array. */
         PERF_HPP__OVERHEAD,
         PERF_HPP__OVERHEAD_SYS,
         PERF_HPP__OVERHEAD_US,
@@ -169,11 +167,6 @@ enum {
         PERF_HPP__OVERHEAD_GUEST_US,
         PERF_HPP__SAMPLES,
         PERF_HPP__PERIOD,
-        PERF_HPP__PERIOD_BASELINE,
-        PERF_HPP__DELTA,
-        PERF_HPP__RATIO,
-        PERF_HPP__WEIGHTED_DIFF,
-        PERF_HPP__FORMULA,
 
         PERF_HPP__MAX_INDEX
 };
@@ -181,8 +174,6 @@ enum {
 void perf_hpp__init(void);
 void perf_hpp__column_register(struct perf_hpp_fmt *format);
 void perf_hpp__column_enable(unsigned col);
-int hist_entry__period_snprintf(struct perf_hpp *hpp, struct hist_entry *he,
-                                bool color);
 
 struct perf_evlist;
 
@@ -199,6 +190,7 @@ int hist_entry__tui_annotate(struct hist_entry *he, struct perf_evsel *evsel,
 
 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
                                   struct hist_browser_timer *hbt,
+                                  float min_pcnt,
                                   struct perf_session_env *env);
 int script_browse(const char *script_opt);
 #else
@@ -206,6 +198,7 @@ static inline
 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist __maybe_unused,
                                   const char *help __maybe_unused,
                                   struct hist_browser_timer *hbt __maybe_unused,
+                                  float min_pcnt __maybe_unused,
                                   struct perf_session_env *env __maybe_unused)
 {
         return 0;
@@ -233,23 +226,18 @@ static inline int script_browse(const char *script_opt __maybe_unused)
 
 #ifdef GTK2_SUPPORT
 int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist, const char *help,
-                                  struct hist_browser_timer *hbt __maybe_unused);
+                                  struct hist_browser_timer *hbt __maybe_unused,
+                                  float min_pcnt);
 #else
 static inline
 int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist __maybe_unused,
                                   const char *help __maybe_unused,
-                                  struct hist_browser_timer *hbt __maybe_unused)
+                                  struct hist_browser_timer *hbt __maybe_unused,
+                                  float min_pcnt __maybe_unused)
 {
         return 0;
 }
 #endif
 
 unsigned int hists__sort_list_width(struct hists *self);
-
-double perf_diff__compute_delta(struct hist_entry *he, struct hist_entry *pair);
-double perf_diff__compute_ratio(struct hist_entry *he, struct hist_entry *pair);
-s64 perf_diff__compute_wdiff(struct hist_entry *he, struct hist_entry *pair);
-int perf_diff__formula(struct hist_entry *he, struct hist_entry *pair,
-                       char *buf, size_t size);
-double perf_diff__period_percent(struct hist_entry *he, u64 period);
 #endif  /* __PERF_HIST_H */
diff --git a/tools/perf/util/include/linux/string.h b/tools/perf/util/include/linux/string.h
index 6f19c548ecc0..97a800738226 100644
--- a/tools/perf/util/include/linux/string.h
+++ b/tools/perf/util/include/linux/string.h
@@ -1,3 +1,4 @@
 #include <string.h>
 
 void *memdup(const void *src, size_t len);
+int str_append(char **s, int *len, const char *a);
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index b2ecad6ec46b..6188d2876a71 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -25,12 +25,15 @@ int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
         machine->kmaps.machine = machine;
         machine->pid = pid;
 
+        machine->symbol_filter = NULL;
+
         machine->root_dir = strdup(root_dir);
         if (machine->root_dir == NULL)
                 return -ENOMEM;
 
         if (pid != HOST_KERNEL_ID) {
-                struct thread *thread = machine__findnew_thread(machine, pid);
+                struct thread *thread = machine__findnew_thread(machine, 0,
+                                                                pid);
                 char comm[64];
 
                 if (thread == NULL)
@@ -95,6 +98,7 @@ void machines__init(struct machines *machines)
 {
         machine__init(&machines->host, "", HOST_KERNEL_ID);
         machines->guests = RB_ROOT;
+        machines->symbol_filter = NULL;
 }
 
 void machines__exit(struct machines *machines)
@@ -118,6 +122,8 @@ struct machine *machines__add(struct machines *machines, pid_t pid,
                 return NULL;
         }
 
+        machine->symbol_filter = machines->symbol_filter;
+
         while (*p != NULL) {
                 parent = *p;
                 pos = rb_entry(parent, struct machine, rb_node);
@@ -133,6 +139,21 @@ struct machine *machines__add(struct machines *machines, pid_t pid,
         return machine;
 }
 
+void machines__set_symbol_filter(struct machines *machines,
+                                 symbol_filter_t symbol_filter)
+{
+        struct rb_node *nd;
+
+        machines->symbol_filter = symbol_filter;
+        machines->host.symbol_filter = symbol_filter;
+
+        for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
+                struct machine *machine = rb_entry(nd, struct machine, rb_node);
+
+                machine->symbol_filter = symbol_filter;
+        }
+}
+
 struct machine *machines__find(struct machines *machines, pid_t pid)
 {
         struct rb_node **p = &machines->guests.rb_node;
@@ -233,7 +254,8 @@ void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size)
         return;
 }
 
-static struct thread *__machine__findnew_thread(struct machine *machine, pid_t pid,
+static struct thread *__machine__findnew_thread(struct machine *machine,
+                                                pid_t pid, pid_t tid,
                                                 bool create)
 {
         struct rb_node **p = &machine->threads.rb_node;
@@ -241,23 +263,28 @@ static struct thread *__machine__findnew_thread(struct machine *machine, pid_t p
         struct thread *th;
 
         /*
-         * Font-end cache - PID lookups come in blocks,
+         * Front-end cache - TID lookups come in blocks,
          * so most of the time we dont have to look up
          * the full rbtree:
          */
-        if (machine->last_match && machine->last_match->pid == pid)
+        if (machine->last_match && machine->last_match->tid == tid) {
+                if (pid && pid != machine->last_match->pid_)
+                        machine->last_match->pid_ = pid;
                 return machine->last_match;
+        }
 
         while (*p != NULL) {
                 parent = *p;
                 th = rb_entry(parent, struct thread, rb_node);
 
-                if (th->pid == pid) {
+                if (th->tid == tid) {
                         machine->last_match = th;
+                        if (pid && pid != th->pid_)
+                                th->pid_ = pid;
                         return th;
                 }
 
-                if (pid < th->pid)
+                if (tid < th->tid)
                         p = &(*p)->rb_left;
                 else
                         p = &(*p)->rb_right;
@@ -266,7 +293,7 @@ static struct thread *__machine__findnew_thread(struct machine *machine, pid_t p
         if (!create)
                 return NULL;
 
-        th = thread__new(pid);
+        th = thread__new(pid, tid);
         if (th != NULL) {
                 rb_link_node(&th->rb_node, parent, p);
                 rb_insert_color(&th->rb_node, &machine->threads);
@@ -276,19 +303,22 @@ static struct thread *__machine__findnew_thread(struct machine *machine, pid_t p
         return th;
 }
 
-struct thread *machine__findnew_thread(struct machine *machine, pid_t pid)
+struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
+                                       pid_t tid)
 {
-        return __machine__findnew_thread(machine, pid, true);
+        return __machine__findnew_thread(machine, pid, tid, true);
 }
 
-struct thread *machine__find_thread(struct machine *machine, pid_t pid)
+struct thread *machine__find_thread(struct machine *machine, pid_t tid)
 {
-        return __machine__findnew_thread(machine, pid, false);
+        return __machine__findnew_thread(machine, 0, tid, false);
 }
 
 int machine__process_comm_event(struct machine *machine, union perf_event *event)
 {
-        struct thread *thread = machine__findnew_thread(machine, event->comm.tid);
+        struct thread *thread = machine__findnew_thread(machine,
+                                                        event->comm.pid,
+                                                        event->comm.tid);
 
         if (dump_trace)
                 perf_event__fprintf_comm(event, stdout);
@@ -628,10 +658,8 @@ int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
         struct map *map = machine->vmlinux_maps[type];
         int ret = dso__load_vmlinux_path(map->dso, map, filter);
 
-        if (ret > 0) {
+        if (ret > 0)
                 dso__set_loaded(map->dso, type);
-                map__reloc_vmlinux(map);
-        }
 
         return ret;
 }
@@ -764,7 +792,7 @@ static int machine__create_modules(struct machine *machine)
                 modules = path;
         }
 
-        if (symbol__restricted_filename(path, "/proc/modules"))
+        if (symbol__restricted_filename(modules, "/proc/modules"))
                 return -1;
 
         file = fopen(modules, "r");
@@ -808,7 +836,10 @@ static int machine__create_modules(struct machine *machine)
         free(line);
         fclose(file);
 
-        return machine__set_modules_path(machine);
+        if (machine__set_modules_path(machine) < 0) {
+                pr_debug("Problems setting modules path maps, continuing anyway...\n");
+        }
+        return 0;
 
 out_delete_line:
         free(line);
@@ -858,6 +889,18 @@ static void machine__set_kernel_mmap_len(struct machine *machine,
         }
 }
 
+static bool machine__uses_kcore(struct machine *machine)
+{
+        struct dso *dso;
+
+        list_for_each_entry(dso, &machine->kernel_dsos, node) {
+                if (dso__is_kcore(dso))
+                        return true;
+        }
+
+        return false;
+}
+
 static int machine__process_kernel_mmap_event(struct machine *machine,
                                               union perf_event *event)
 {
@@ -866,6 +909,10 @@ static int machine__process_kernel_mmap_event(struct machine *machine,
         enum dso_kernel_type kernel_type;
         bool is_kernel_mmap;
 
+        /* If we have maps from kcore then we do not need or want any others */
+        if (machine__uses_kcore(machine))
+                return 0;
+
         machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
         if (machine__is_host(machine))
                 kernel_type = DSO_TYPE_KERNEL;
@@ -950,6 +997,54 @@ out_problem:
         return -1;
 }
 
+int machine__process_mmap2_event(struct machine *machine,
+                                 union perf_event *event)
+{
+        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        struct thread *thread;
+        struct map *map;
+        enum map_type type;
+        int ret = 0;
+
+        if (dump_trace)
+                perf_event__fprintf_mmap2(event, stdout);
+
+        if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
+            cpumode == PERF_RECORD_MISC_KERNEL) {
+                ret = machine__process_kernel_mmap_event(machine, event);
+                if (ret < 0)
+                        goto out_problem;
+                return 0;
+        }
+
+        thread = machine__findnew_thread(machine, event->mmap2.pid,
+                                        event->mmap2.pid);
+        if (thread == NULL)
+                goto out_problem;
+
+        if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
+                type = MAP__VARIABLE;
+        else
+                type = MAP__FUNCTION;
+
+        map = map__new(&machine->user_dsos, event->mmap2.start,
+                        event->mmap2.len, event->mmap2.pgoff,
+                        event->mmap2.pid, event->mmap2.maj,
+                        event->mmap2.min, event->mmap2.ino,
+                        event->mmap2.ino_generation,
+                        event->mmap2.filename, type);
+
+        if (map == NULL)
+                goto out_problem;
+
+        thread__insert_map(thread, map);
+        return 0;
+
+out_problem:
+        dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n");
+        return 0;
+}
+
 int machine__process_mmap_event(struct machine *machine, union perf_event *event)
 {
         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
@@ -969,7 +1064,8 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event
                 return 0;
         }
 
-        thread = machine__findnew_thread(machine, event->mmap.pid);
+        thread = machine__findnew_thread(machine, event->mmap.pid,
+                                         event->mmap.pid);
         if (thread == NULL)
                 goto out_problem;
 
@@ -980,7 +1076,8 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event
 
         map = map__new(&machine->user_dsos, event->mmap.start,
                         event->mmap.len, event->mmap.pgoff,
-                        event->mmap.pid, event->mmap.filename,
+                        event->mmap.pid, 0, 0, 0, 0,
+                        event->mmap.filename,
                         type);
 
         if (map == NULL)
@@ -994,11 +1091,30 @@ out_problem:
         return 0;
 }
 
+static void machine__remove_thread(struct machine *machine, struct thread *th)
+{
+        machine->last_match = NULL;
+        rb_erase(&th->rb_node, &machine->threads);
+        /*
+         * We may have references to this thread, for instance in some hist_entry
+         * instances, so just move them to a separate list.
+         */
+        list_add_tail(&th->node, &machine->dead_threads);
+}
+
 int machine__process_fork_event(struct machine *machine, union perf_event *event)
 {
-        struct thread *thread = machine__findnew_thread(machine, event->fork.tid);
-        struct thread *parent = machine__findnew_thread(machine, event->fork.ptid);
+        struct thread *thread = machine__find_thread(machine, event->fork.tid);
+        struct thread *parent = machine__findnew_thread(machine,
+                                                        event->fork.ppid,
+                                                        event->fork.ptid);
 
+        /* if a thread currently exists for the thread id remove it */
+        if (thread != NULL)
+                machine__remove_thread(machine, thread);
+
+        thread = machine__findnew_thread(machine, event->fork.pid,
+                                         event->fork.tid);
         if (dump_trace)
                 perf_event__fprintf_task(event, stdout);
 
@@ -1011,18 +1127,8 @@ int machine__process_fork_event(struct machine *machine, union perf_event *event
         return 0;
 }
 
-static void machine__remove_thread(struct machine *machine, struct thread *th)
-{
-        machine->last_match = NULL;
-        rb_erase(&th->rb_node, &machine->threads);
-        /*
-         * We may have references to this thread, for instance in some hist_entry
-         * instances, so just move them to a separate list.
-         */
-        list_add_tail(&th->node, &machine->dead_threads);
-}
-
-int machine__process_exit_event(struct machine *machine, union perf_event *event)
+int machine__process_exit_event(struct machine *machine __maybe_unused,
+                                union perf_event *event)
 {
         struct thread *thread = machine__find_thread(machine, event->fork.tid);
 
@@ -1030,7 +1136,7 @@ int machine__process_exit_event(struct machine *machine, union perf_event *event
                 perf_event__fprintf_task(event, stdout);
 
         if (thread != NULL)
-                machine__remove_thread(machine, thread);
+                thread__exited(thread);
 
         return 0;
 }
@@ -1044,6 +1150,8 @@ int machine__process_event(struct machine *machine, union perf_event *event)
                 ret = machine__process_comm_event(machine, event); break;
         case PERF_RECORD_MMAP:
                 ret = machine__process_mmap_event(machine, event); break;
+        case PERF_RECORD_MMAP2:
+                ret = machine__process_mmap2_event(machine, event); break;
         case PERF_RECORD_FORK:
                 ret = machine__process_fork_event(machine, event); break;
         case PERF_RECORD_EXIT:
@@ -1058,11 +1166,10 @@ int machine__process_event(struct machine *machine, union perf_event *event)
         return ret;
 }
 
-static bool symbol__match_parent_regex(struct symbol *sym)
+static bool symbol__match_regex(struct symbol *sym, regex_t *regex)
 {
-        if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
+        if (sym->name && !regexec(regex, sym->name, 0, NULL, 0))
                 return 1;
-
         return 0;
 }
 
@@ -1094,7 +1201,7 @@ static void ip__resolve_ams(struct machine *machine, struct thread *thread,
                  * or else, the symbol is unknown
                  */
                 thread__find_addr_location(thread, machine, m, MAP__FUNCTION,
-                                ip, &al, NULL);
+                                ip, &al);
                 if (al.sym)
                         goto found;
         }
@@ -1112,8 +1219,8 @@ static void ip__resolve_data(struct machine *machine, struct thread *thread,
 
         memset(&al, 0, sizeof(al));
 
-        thread__find_addr_location(thread, machine, m, MAP__VARIABLE, addr, &al,
-                                   NULL);
+        thread__find_addr_location(thread, machine, m, MAP__VARIABLE, addr,
+                                   &al);
         ams->addr = addr;
         ams->al_addr = al.addr;
         ams->sym = al.sym;
@@ -1159,8 +1266,8 @@ struct branch_info *machine__resolve_bstack(struct machine *machine,
 static int machine__resolve_callchain_sample(struct machine *machine,
                                              struct thread *thread,
                                              struct ip_callchain *chain,
-                                             struct symbol **parent)
-
+                                             struct symbol **parent,
+                                             struct addr_location *root_al)
 {
         u8 cpumode = PERF_RECORD_MISC_USER;
         unsigned int i;
@@ -1208,11 +1315,18 @@ static int machine__resolve_callchain_sample(struct machine *machine,
 
                 al.filtered = false;
                 thread__find_addr_location(thread, machine, cpumode,
-                                           MAP__FUNCTION, ip, &al, NULL);
+                                           MAP__FUNCTION, ip, &al);
                 if (al.sym != NULL) {
                         if (sort__has_parent && !*parent &&
-                            symbol__match_parent_regex(al.sym))
+                            symbol__match_regex(al.sym, &parent_regex))
                                 *parent = al.sym;
+                        else if (have_ignore_callees && root_al &&
+                          symbol__match_regex(al.sym, &ignore_callees_regex)) {
+                                /* Treat this symbol as the root,
+                                   forgetting its callees. */
+                                *root_al = al;
+                                callchain_cursor_reset(&callchain_cursor);
+                        }
                         if (!symbol_conf.use_callchain)
                                 break;
                 }
@@ -1237,15 +1351,13 @@ int machine__resolve_callchain(struct machine *machine,
                                struct perf_evsel *evsel,
                                struct thread *thread,
                                struct perf_sample *sample,
-                               struct symbol **parent)
-
+                               struct symbol **parent,
+                               struct addr_location *root_al)
 {
         int ret;
 
-        callchain_cursor_reset(&callchain_cursor);
-
         ret = machine__resolve_callchain_sample(machine, thread,
-                                                sample->callchain, parent);
+                                                sample->callchain, parent, root_al);
         if (ret)
                 return ret;
 
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index 77940680f1fc..58a6be1fc739 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -5,6 +5,7 @@
 #include <linux/rbtree.h>
 #include "map.h"
 
+struct addr_location;
 struct branch_stack;
 struct perf_evsel;
 struct perf_sample;
@@ -28,6 +29,7 @@ struct machine {
         struct list_head  kernel_dsos;
         struct map_groups kmaps;
         struct map        *vmlinux_maps[MAP__NR_TYPES];
+        symbol_filter_t   symbol_filter;
 };
 
 static inline
@@ -36,13 +38,14 @@ struct map *machine__kernel_map(struct machine *machine, enum map_type type)
         return machine->vmlinux_maps[type];
 }
 
-struct thread *machine__find_thread(struct machine *machine, pid_t pid);
+struct thread *machine__find_thread(struct machine *machine, pid_t tid);
 
 int machine__process_comm_event(struct machine *machine, union perf_event *event);
 int machine__process_exit_event(struct machine *machine, union perf_event *event);
 int machine__process_fork_event(struct machine *machine, union perf_event *event);
 int machine__process_lost_event(struct machine *machine, union perf_event *event);
 int machine__process_mmap_event(struct machine *machine, union perf_event *event);
+int machine__process_mmap2_event(struct machine *machine, union perf_event *event);
 int machine__process_event(struct machine *machine, union perf_event *event);
 
 typedef void (*machine__process_t)(struct machine *machine, void *data);
@@ -50,6 +53,7 @@ typedef void (*machine__process_t)(struct machine *machine, void *data);
 struct machines {
         struct machine host;
         struct rb_root guests;
+        symbol_filter_t symbol_filter;
 };
 
 void machines__init(struct machines *machines);
@@ -67,6 +71,9 @@ struct machine *machines__findnew(struct machines *machines, pid_t pid);
 void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size);
 char *machine__mmap_name(struct machine *machine, char *bf, size_t size);
 
+void machines__set_symbol_filter(struct machines *machines,
+                                 symbol_filter_t symbol_filter);
+
 int machine__init(struct machine *machine, const char *root_dir, pid_t pid);
 void machine__exit(struct machine *machine);
 void machine__delete_dead_threads(struct machine *machine);
@@ -83,7 +90,8 @@ int machine__resolve_callchain(struct machine *machine,
                                struct perf_evsel *evsel,
                                struct thread *thread,
                                struct perf_sample *sample,
-                               struct symbol **parent);
+                               struct symbol **parent,
+                               struct addr_location *root_al);
 
 /*
  * Default guest kernel is defined by parameter --guestkallsyms
@@ -99,7 +107,8 @@ static inline bool machine__is_host(struct machine *machine)
         return machine ? machine->pid == HOST_KERNEL_ID : false;
 }
 
-struct thread *machine__findnew_thread(struct machine *machine, pid_t pid);
+struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
+                                       pid_t tid);
 
 size_t machine__fprintf(struct machine *machine, FILE *fp);
 
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 6fcb9de62340..4f6680d2043b 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -21,6 +21,7 @@ const char *map_type__name[MAP__NR_TYPES] = {
 static inline int is_anon_memory(const char *filename)
 {
         return !strcmp(filename, "//anon") ||
+               !strcmp(filename, "/dev/zero (deleted)") ||
                !strcmp(filename, "/anon_hugepage (deleted)");
 }
 
@@ -47,7 +48,8 @@ void map__init(struct map *map, enum map_type type,
 }
 
 struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
-                     u64 pgoff, u32 pid, char *filename,
+                     u64 pgoff, u32 pid, u32 d_maj, u32 d_min, u64 ino,
+                     u64 ino_gen, char *filename,
                      enum map_type type)
 {
         struct map *map = malloc(sizeof(*map));
@@ -61,6 +63,11 @@ struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
                 vdso = is_vdso_map(filename);
                 no_dso = is_no_dso_memory(filename);
 
+                map->maj = d_maj;
+                map->min = d_min;
+                map->ino = ino;
+                map->ino_generation = ino_gen;
+
                 if (anon) {
                         snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", pid);
                         filename = newfilename;
@@ -181,12 +188,6 @@ int map__load(struct map *map, symbol_filter_t filter)
 #endif
                 return -1;
         }
-        /*
-         * Only applies to the kernel, as its symtabs aren't relative like the
-         * module ones.
-         */
-        if (map->dso->kernel)
-                map__reloc_vmlinux(map);
 
         return 0;
 }
@@ -253,14 +254,18 @@ size_t map__fprintf_dsoname(struct map *map, FILE *fp)
 
 /*
  * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
- * map->dso->adjust_symbols==1 for ET_EXEC-like cases.
+ * map->dso->adjust_symbols==1 for ET_EXEC-like cases except ET_REL which is
+ * relative to section start.
  */
 u64 map__rip_2objdump(struct map *map, u64 rip)
 {
-        u64 addr = map->dso->adjust_symbols ?
-                        map->unmap_ip(map, rip) :       /* RIP -> IP */
-                        rip;
-        return addr;
+        if (!map->dso->adjust_symbols)
+                return rip;
+
+        if (map->dso->rel)
+                return rip - map->pgoff;
+
+        return map->unmap_ip(map, rip);
 }
 
 void map_groups__init(struct map_groups *mg)
@@ -512,35 +517,6 @@ int map_groups__clone(struct map_groups *mg,
         return 0;
 }
 
-static u64 map__reloc_map_ip(struct map *map, u64 ip)
-{
-        return ip + (s64)map->pgoff;
-}
-
-static u64 map__reloc_unmap_ip(struct map *map, u64 ip)
-{
-        return ip - (s64)map->pgoff;
-}
-
-void map__reloc_vmlinux(struct map *map)
-{
-        struct kmap *kmap = map__kmap(map);
-        s64 reloc;
-
-        if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->unrelocated_addr)
-                return;
-
-        reloc = (kmap->ref_reloc_sym->unrelocated_addr -
-                 kmap->ref_reloc_sym->addr);
-
-        if (!reloc)
-                return;
-
-        map->map_ip   = map__reloc_map_ip;
-        map->unmap_ip = map__reloc_unmap_ip;
-        map->pgoff    = reloc;
-}
-
 void maps__insert(struct rb_root *maps, struct map *map)
 {
         struct rb_node **p = &maps->rb_node;
@@ -585,3 +561,21 @@ struct map *maps__find(struct rb_root *maps, u64 ip)
 
         return NULL;
 }
+
+struct map *maps__first(struct rb_root *maps)
+{
+        struct rb_node *first = rb_first(maps);
+
+        if (first)
+                return rb_entry(first, struct map, rb_node);
+        return NULL;
+}
+
+struct map *maps__next(struct map *map)
+{
+        struct rb_node *next = rb_next(&map->rb_node);
+
+        if (next)
+                return rb_entry(next, struct map, rb_node);
+        return NULL;
+}
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index a887f2c9dfbb..4886ca280536 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -36,6 +36,9 @@ struct map {
         bool                    erange_warned;
         u32                     priv;
         u64                     pgoff;
+        u32                     maj, min; /* only valid for MMAP2 record */
+        u64                     ino;      /* only valid for MMAP2 record */
+        u64                     ino_generation;/* only valid for MMAP2 record */
 
         /* ip -> dso rip */
         u64                     (*map_ip)(struct map *, u64);
@@ -88,8 +91,9 @@ typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
 void map__init(struct map *map, enum map_type type,
                u64 start, u64 end, u64 pgoff, struct dso *dso);
 struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
-                     u64 pgoff, u32 pid, char *filename,
-                     enum map_type type);
+                     u64 pgoff, u32 pid, u32 d_maj, u32 d_min, u64 ino,
+                     u64 ino_gen,
+                     char *filename, enum map_type type);
 struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
 void map__delete(struct map *map);
 struct map *map__clone(struct map *map);
@@ -112,6 +116,8 @@ size_t __map_groups__fprintf_maps(struct map_groups *mg,
 void maps__insert(struct rb_root *maps, struct map *map);
 void maps__remove(struct rb_root *maps, struct map *map);
 struct map *maps__find(struct rb_root *maps, u64 addr);
+struct map *maps__first(struct rb_root *maps);
+struct map *maps__next(struct map *map);
 void map_groups__init(struct map_groups *mg);
 void map_groups__exit(struct map_groups *mg);
 int map_groups__clone(struct map_groups *mg,
@@ -139,6 +145,17 @@ static inline struct map *map_groups__find(struct map_groups *mg,
         return maps__find(&mg->maps[type], addr);
 }
 
+static inline struct map *map_groups__first(struct map_groups *mg,
+                                            enum map_type type)
+{
+        return maps__first(&mg->maps[type]);
+}
+
+static inline struct map *map_groups__next(struct map *map)
+{
+        return maps__next(map);
+}
+
 struct symbol *map_groups__find_symbol(struct map_groups *mg,
                                        enum map_type type, u64 addr,
                                        struct map **mapp,
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 6c8bb0fb189b..98125319b158 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -6,7 +6,7 @@
 #include "parse-options.h"
 #include "parse-events.h"
 #include "exec_cmd.h"
-#include "string.h"
+#include "linux/string.h"
 #include "symbol.h"
 #include "cache.h"
 #include "header.h"
@@ -15,6 +15,7 @@
 #define YY_EXTRA_TYPE int
 #include "parse-events-flex.h"
 #include "pmu.h"
+#include "thread_map.h"
 
 #define MAX_NAME_LEN 100
 
@@ -108,6 +109,10 @@ static struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
                 .symbol = "emulation-faults",
                 .alias  = "",
         },
+        [PERF_COUNT_SW_DUMMY] = {
+                .symbol = "dummy",
+                .alias  = "",
+        },
 };
 
 #define __PERF_EVENT_FIELD(config, name) \
@@ -217,6 +222,29 @@ struct tracepoint_path *tracepoint_id_to_path(u64 config)
         return NULL;
 }
 
+struct tracepoint_path *tracepoint_name_to_path(const char *name)
+{
+        struct tracepoint_path *path = zalloc(sizeof(*path));
+        char *str = strchr(name, ':');
+
+        if (path == NULL || str == NULL) {
+                free(path);
+                return NULL;
+        }
+
+        path->system = strndup(name, str - name);
+        path->name = strdup(str+1);
+
+        if (path->system == NULL || path->name == NULL) {
+                free(path->system);
+                free(path->name);
+                free(path);
+                path = NULL;
+        }
+
+        return path;
+}
+
 const char *event_type(int type)
 {
         switch (type) {
@@ -241,40 +269,29 @@ const char *event_type(int type)
 
 
 
-static int __add_event(struct list_head **_list, int *idx,
+static int __add_event(struct list_head *list, int *idx,
                        struct perf_event_attr *attr,
                        char *name, struct cpu_map *cpus)
 {
         struct perf_evsel *evsel;
-        struct list_head *list = *_list;
-
-        if (!list) {
-                list = malloc(sizeof(*list));
-                if (!list)
-                        return -ENOMEM;
-                INIT_LIST_HEAD(list);
-        }
 
         event_attr_init(attr);
 
         evsel = perf_evsel__new(attr, (*idx)++);
-        if (!evsel) {
-                free(list);
+        if (!evsel)
                 return -ENOMEM;
-        }
 
         evsel->cpus = cpus;
         if (name)
                 evsel->name = strdup(name);
         list_add_tail(&evsel->node, list);
-        *_list = list;
         return 0;
 }
 
-static int add_event(struct list_head **_list, int *idx,
+static int add_event(struct list_head *list, int *idx,
                      struct perf_event_attr *attr, char *name)
 {
-        return __add_event(_list, idx, attr, name, NULL);
+        return __add_event(list, idx, attr, name, NULL);
 }
 
 static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
@@ -295,7 +312,7 @@ static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES]
         return -1;
 }
 
-int parse_events_add_cache(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)
 {
         struct perf_event_attr attr;
@@ -356,31 +373,21 @@ int parse_events_add_cache(struct list_head **list, int *idx,
         return add_event(list, idx, &attr, name);
 }
 
-static int add_tracepoint(struct list_head **listp, int *idx,
+static int add_tracepoint(struct list_head *list, int *idx,
                           char *sys_name, char *evt_name)
 {
         struct perf_evsel *evsel;
-        struct list_head *list = *listp;
-
-        if (!list) {
-                list = malloc(sizeof(*list));
-                if (!list)
-                        return -ENOMEM;
-                INIT_LIST_HEAD(list);
-        }
 
         evsel = perf_evsel__newtp(sys_name, evt_name, (*idx)++);
-        if (!evsel) {
-                free(list);
+        if (!evsel)
                 return -ENOMEM;
-        }
 
         list_add_tail(&evsel->node, list);
-        *listp = list;
+
         return 0;
 }
 
-static int add_tracepoint_multi_event(struct list_head **list, int *idx,
+static int add_tracepoint_multi_event(struct list_head *list, int *idx,
                                       char *sys_name, char *evt_name)
 {
         char evt_path[MAXPATHLEN];
@@ -412,7 +419,7 @@ static int add_tracepoint_multi_event(struct list_head **list, int *idx,
         return ret;
 }
 
-static int add_tracepoint_event(struct list_head **list, int *idx,
+static int add_tracepoint_event(struct list_head *list, int *idx,
                                 char *sys_name, char *evt_name)
 {
         return strpbrk(evt_name, "*?") ?
@@ -420,7 +427,7 @@ static int add_tracepoint_event(struct list_head **list, int *idx,
                add_tracepoint(list, idx, sys_name, evt_name);
 }
 
-static int add_tracepoint_multi_sys(struct list_head **list, int *idx,
+static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
                                     char *sys_name, char *evt_name)
 {
         struct dirent *events_ent;
@@ -452,7 +459,7 @@ static int add_tracepoint_multi_sys(struct list_head **list, int *idx,
         return ret;
 }
 
-int parse_events_add_tracepoint(struct list_head **list, int *idx,
+int parse_events_add_tracepoint(struct list_head *list, int *idx,
                                 char *sys, char *event)
 {
         int ret;
@@ -507,7 +514,7 @@ do {					\
         return 0;
 }
 
-int parse_events_add_breakpoint(struct list_head **list, int *idx,
+int parse_events_add_breakpoint(struct list_head *list, int *idx,
                                 void *ptr, char *type)
 {
         struct perf_event_attr attr;
@@ -588,7 +595,7 @@ static int config_attr(struct perf_event_attr *attr,
         return 0;
 }
 
-int parse_events_add_numeric(struct list_head **list, int *idx,
+int parse_events_add_numeric(struct list_head *list, int *idx,
                              u32 type, u64 config,
                              struct list_head *head_config)
 {
@@ -621,7 +628,7 @@ static char *pmu_event_name(struct list_head *head_terms)
         return NULL;
 }
 
-int parse_events_add_pmu(struct list_head **list, int *idx,
+int parse_events_add_pmu(struct list_head *list, int *idx,
                          char *name, struct list_head *head_config)
 {
         struct perf_event_attr attr;
@@ -664,6 +671,7 @@ void parse_events__set_leader(char *name, struct list_head *list)
         leader->group_name = name ? strdup(name) : NULL;
 }
 
+/* list_event is assumed to point to malloc'ed memory */
 void parse_events_update_lists(struct list_head *list_event,
                                struct list_head *list_all)
 {
@@ -684,6 +692,8 @@ struct event_modifier {
         int eG;
         int precise;
         int exclude_GH;
+        int sample_read;
+        int pinned;
 };
 
 static int get_event_modifier(struct event_modifier *mod, char *str,
@@ -695,6 +705,8 @@ static int get_event_modifier(struct event_modifier *mod, char *str,
         int eH = evsel ? evsel->attr.exclude_host : 0;
         int eG = evsel ? evsel->attr.exclude_guest : 0;
         int precise = evsel ? evsel->attr.precise_ip : 0;
+        int sample_read = 0;
+        int pinned = evsel ? evsel->attr.pinned : 0;
 
         int exclude = eu | ek | eh;
         int exclude_GH = evsel ? evsel->exclude_GH : 0;
@@ -727,6 +739,10 @@ static int get_event_modifier(struct event_modifier *mod, char *str,
                         /* use of precise requires exclude_guest */
                         if (!exclude_GH)
                                 eG = 1;
+                } else if (*str == 'S') {
+                        sample_read = 1;
+                } else if (*str == 'D') {
+                        pinned = 1;
                 } else
                         break;
 
@@ -753,6 +769,9 @@ static int get_event_modifier(struct event_modifier *mod, char *str,
         mod->eG = eG;
         mod->precise = precise;
         mod->exclude_GH = exclude_GH;
+        mod->sample_read = sample_read;
+        mod->pinned = pinned;
+
         return 0;
 }
 
@@ -765,7 +784,7 @@ static int check_modifier(char *str)
         char *p = str;
 
         /* The sizeof includes 0 byte as well. */
-        if (strlen(str) > (sizeof("ukhGHppp") - 1))
+        if (strlen(str) > (sizeof("ukhGHpppSD") - 1))
                 return -1;
 
         while (*p) {
@@ -803,6 +822,10 @@ int parse_events__modifier_event(struct list_head *list, char *str, bool add)
                 evsel->attr.exclude_host   = mod.eH;
                 evsel->attr.exclude_guest  = mod.eG;
                 evsel->exclude_GH          = mod.exclude_GH;
+                evsel->sample_read         = mod.sample_read;
+
+                if (perf_evsel__is_group_leader(evsel))
+                        evsel->attr.pinned = mod.pinned;
         }
 
         return 0;
@@ -820,6 +843,32 @@ int parse_events_name(struct list_head *list, char *name)
         return 0;
 }
 
+static int parse_events__scanner(const char *str, void *data, int start_token);
+
+static int parse_events_fixup(int ret, const char *str, void *data,
+                              int start_token)
+{
+        char *o = strdup(str);
+        char *s = NULL;
+        char *t = o;
+        char *p;
+        int len = 0;
+
+        if (!o)
+                return ret;
+        while ((p = strsep(&t, ",")) != NULL) {
+                if (s)
+                        str_append(&s, &len, ",");
+                str_append(&s, &len, "cpu/");
+                str_append(&s, &len, p);
+                str_append(&s, &len, "/");
+        }
+        free(o);
+        if (!s)
+                return -ENOMEM;
+        return parse_events__scanner(s, data, start_token);
+}
+
 static int parse_events__scanner(const char *str, void *data, int start_token)
 {
         YY_BUFFER_STATE buffer;
@@ -840,6 +889,8 @@ static int parse_events__scanner(const char *str, void *data, int start_token)
         parse_events__flush_buffer(buffer, scanner);
         parse_events__delete_buffer(buffer, scanner);
         parse_events_lex_destroy(scanner);
+        if (ret && !strchr(str, '/'))
+                ret = parse_events_fixup(ret, str, data, start_token);
         return ret;
 }
 
@@ -860,7 +911,8 @@ int parse_events_terms(struct list_head *terms, const char *str)
                 return 0;
         }
 
-        parse_events__free_terms(data.terms);
+        if (data.terms)
+                parse_events__free_terms(data.terms);
         return ret;
 }
 
@@ -1025,6 +1077,33 @@ int is_valid_tracepoint(const char *event_string)
         return 0;
 }
 
+static bool is_event_supported(u8 type, unsigned config)
+{
+        bool ret = true;
+        struct perf_evsel *evsel;
+        struct perf_event_attr attr = {
+                .type = type,
+                .config = config,
+                .disabled = 1,
+                .exclude_kernel = 1,
+        };
+        struct {
+                struct thread_map map;
+                int threads[1];
+        } tmap = {
+                .map.nr  = 1,
+                .threads = { 0 },
+        };
+
+        evsel = perf_evsel__new(&attr, 0);
+        if (evsel) {
+                ret = perf_evsel__open(evsel, NULL, &tmap.map) >= 0;
+                perf_evsel__delete(evsel);
+        }
+
+        return ret;
+}
+
 static void __print_events_type(u8 type, struct event_symbol *syms,
                                 unsigned max)
 {
@@ -1032,14 +1111,16 @@ static void __print_events_type(u8 type, struct event_symbol *syms,
         unsigned i;
 
         for (i = 0; i < max ; i++, syms++) {
+                if (!is_event_supported(type, i))
+                        continue;
+
                 if (strlen(syms->alias))
                         snprintf(name, sizeof(name),  "%s OR %s",
                                  syms->symbol, syms->alias);
                 else
                         snprintf(name, sizeof(name), "%s", syms->symbol);
 
-                printf("  %-50s [%s]\n", name,
-                        event_type_descriptors[type]);
+                printf("  %-50s [%s]\n", name, event_type_descriptors[type]);
         }
 }
 
@@ -1068,6 +1149,10 @@ int print_hwcache_events(const char *event_glob, bool name_only)
                                 if (event_glob != NULL && !strglobmatch(name, event_glob))
                                         continue;
 
+                                if (!is_event_supported(PERF_TYPE_HW_CACHE,
+                                                        type | (op << 8) | (i << 16)))
+                                        continue;
+
                                 if (name_only)
                                         printf("%s ", name);
                                 else
@@ -1078,6 +1163,8 @@ int print_hwcache_events(const char *event_glob, bool name_only)
                 }
         }
 
+        if (printed)
+                printf("\n");
         return printed;
 }
 
@@ -1095,6 +1182,9 @@ static void print_symbol_events(const char *event_glob, unsigned type,
                       (syms->alias && strglobmatch(syms->alias, event_glob))))
                         continue;
 
+                if (!is_event_supported(type, i))
+                        continue;
+
                 if (name_only) {
                         printf("%s ", syms->symbol);
                         continue;
@@ -1132,11 +1222,12 @@ void print_events(const char *event_glob, bool name_only)
 
         print_hwcache_events(event_glob, name_only);
 
+        print_pmu_events(event_glob, name_only);
+
         if (event_glob != NULL)
                 return;
 
         if (!name_only) {
-                printf("\n");
                 printf("  %-50s [%s]\n",
                        "rNNN",
                        event_type_descriptors[PERF_TYPE_RAW]);
@@ -1183,6 +1274,7 @@ static int new_term(struct parse_events_term **_term, int type_val,
                 term->val.str = str;
                 break;
         default:
+                free(term);
                 return -EINVAL;
         }
 
@@ -1235,6 +1327,4 @@ void parse_events__free_terms(struct list_head *terms)
 
         list_for_each_entry_safe(term, h, terms, list)
                 free(term);
-
-        free(terms);
 }
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 8a4859315fd9..f1cb4c4b3c70 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -23,6 +23,7 @@ struct tracepoint_path {
 };
 
 extern struct tracepoint_path *tracepoint_id_to_path(u64 config);
+extern struct tracepoint_path *tracepoint_name_to_path(const char *name);
 extern bool have_tracepoints(struct list_head *evlist);
 
 const char *event_type(int type);
@@ -84,16 +85,16 @@ void parse_events__free_terms(struct list_head *terms);
 int parse_events__modifier_event(struct list_head *list, char *str, bool add);
 int parse_events__modifier_group(struct list_head *list, char *event_mod);
 int parse_events_name(struct list_head *list, char *name);
-int parse_events_add_tracepoint(struct list_head **list, int *idx,
+int parse_events_add_tracepoint(struct list_head *list, int *idx,
                                 char *sys, char *event);
-int parse_events_add_numeric(struct list_head **list, int *idx,
+int parse_events_add_numeric(struct list_head *list, int *idx,
                              u32 type, u64 config,
                              struct list_head *head_config);
-int parse_events_add_cache(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,
+int parse_events_add_breakpoint(struct list_head *list, int *idx,
                                 void *ptr, char *type);
-int parse_events_add_pmu(struct list_head **list, int *idx,
+int parse_events_add_pmu(struct list_head *list, int *idx,
                          char *pmu , struct list_head *head_config);
 void parse_events__set_leader(char *name, struct list_head *list);
 void parse_events_update_lists(struct list_head *list_event,
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index e9d1134c2c68..91346b753960 100644
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -82,7 +82,8 @@ num_hex		0x[a-fA-F0-9]+
 num_raw_hex     [a-fA-F0-9]+
 name            [a-zA-Z_*?][a-zA-Z0-9_*?]*
 name_minus      [a-zA-Z_*?][a-zA-Z0-9\-_*?]*
-modifier_event  [ukhpGH]+
+/* If you add a modifier you need to update check_modifier() */
+modifier_event  [ukhpGHSD]+
 modifier_bp     [rwx]{1,3}
 
 %%
@@ -144,6 +145,7 @@ context-switches|cs				{ return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW
 cpu-migrations|migrations                       { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); }
 alignment-faults                                { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); }
 emulation-faults                                { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); }
+dummy                                           { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_DUMMY); }
 
 L1-dcache|l1-d|l1d|L1-data              |
 L1-icache|l1-i|l1i|L1-instruction       |
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index afc44c18dfe1..4eb67ec333f1 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -22,6 +22,13 @@ do { \
                 YYABORT; \
 } while (0)
 
+#define ALLOC_LIST(list) \
+do { \
+        list = malloc(sizeof(*list)); \
+        ABORT_ON(!list);              \
+        INIT_LIST_HEAD(list);         \
+} while (0)
+
 static inc_group_count(struct list_head *list,
                        struct parse_events_evlist *data)
 {
@@ -196,9 +203,10 @@ event_pmu:
 PE_NAME '/' event_config '/'
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
 
-        ABORT_ON(parse_events_add_pmu(&list, &data->idx, $1, $3));
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_pmu(list, &data->idx, $1, $3));
         parse_events__free_terms($3);
         $$ = list;
 }
@@ -212,11 +220,12 @@ event_legacy_symbol:
 value_sym '/' event_config '/'
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
         int type = $1 >> 16;
         int config = $1 & 255;
 
-        ABORT_ON(parse_events_add_numeric(&list, &data->idx,
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_numeric(list, &data->idx,
                                           type, config, $3));
         parse_events__free_terms($3);
         $$ = list;
@@ -225,11 +234,12 @@ value_sym '/' event_config '/'
 value_sym sep_slash_dc
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
         int type = $1 >> 16;
         int config = $1 & 255;
 
-        ABORT_ON(parse_events_add_numeric(&list, &data->idx,
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_numeric(list, &data->idx,
                                           type, config, NULL));
         $$ = list;
 }
@@ -238,27 +248,30 @@ event_legacy_cache:
 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
 
-        ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, $3, $5));
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, $5));
         $$ = list;
 }
 |
 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
 
-        ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, $3, NULL));
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_cache(list, &data->idx, $1, $3, NULL));
         $$ = list;
 }
 |
 PE_NAME_CACHE_TYPE
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
 
-        ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, NULL, NULL));
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_cache(list, &data->idx, $1, NULL, NULL));
         $$ = list;
 }
 
@@ -266,9 +279,10 @@ event_legacy_mem:
 PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
 
-        ABORT_ON(parse_events_add_breakpoint(&list, &data->idx,
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
                                              (void *) $2, $4));
         $$ = list;
 }
@@ -276,9 +290,10 @@ PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
 PE_PREFIX_MEM PE_VALUE sep_dc
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
 
-        ABORT_ON(parse_events_add_breakpoint(&list, &data->idx,
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_breakpoint(list, &data->idx,
                                              (void *) $2, NULL));
         $$ = list;
 }
@@ -287,9 +302,10 @@ event_legacy_tracepoint:
 PE_NAME ':' PE_NAME
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
 
-        ABORT_ON(parse_events_add_tracepoint(&list, &data->idx, $1, $3));
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_tracepoint(list, &data->idx, $1, $3));
         $$ = list;
 }
 
@@ -297,9 +313,10 @@ event_legacy_numeric:
 PE_VALUE ':' PE_VALUE
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
 
-        ABORT_ON(parse_events_add_numeric(&list, &data->idx, (u32)$1, $3, NULL));
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_numeric(list, &data->idx, (u32)$1, $3, NULL));
         $$ = list;
 }
 
@@ -307,9 +324,10 @@ event_legacy_raw:
 PE_RAW
 {
         struct parse_events_evlist *data = _data;
-        struct list_head *list = NULL;
+        struct list_head *list;
 
-        ABORT_ON(parse_events_add_numeric(&list, &data->idx,
+        ALLOC_LIST(list);
+        ABORT_ON(parse_events_add_numeric(list, &data->idx,
                                           PERF_TYPE_RAW, $1, NULL));
         $$ = list;
 }
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index 4c6f9c490a8d..bc9d8069d376 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -73,7 +73,7 @@ int perf_pmu__format_parse(char *dir, struct list_head *head)
  * located at:
  * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes.
  */
-static int pmu_format(char *name, struct list_head *format)
+static int pmu_format(const char *name, struct list_head *format)
 {
         struct stat st;
         char path[PATH_MAX];
@@ -162,7 +162,7 @@ static int pmu_aliases_parse(char *dir, struct list_head *head)
  * Reading the pmu event aliases definition, which should be located at:
  * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes.
  */
-static int pmu_aliases(char *name, struct list_head *head)
+static int pmu_aliases(const char *name, struct list_head *head)
 {
         struct stat st;
         char path[PATH_MAX];
@@ -208,7 +208,7 @@ static int pmu_alias_terms(struct perf_pmu_alias *alias,
  * located at:
  * /sys/bus/event_source/devices/<dev>/type as sysfs attribute.
  */
-static int pmu_type(char *name, __u32 *type)
+static int pmu_type(const char *name, __u32 *type)
 {
         struct stat st;
         char path[PATH_MAX];
@@ -266,7 +266,7 @@ static void pmu_read_sysfs(void)
         closedir(dir);
 }
 
-static struct cpu_map *pmu_cpumask(char *name)
+static struct cpu_map *pmu_cpumask(const char *name)
 {
         struct stat st;
         char path[PATH_MAX];
@@ -293,7 +293,7 @@ static struct cpu_map *pmu_cpumask(char *name)
         return cpus;
 }
 
-static struct perf_pmu *pmu_lookup(char *name)
+static struct perf_pmu *pmu_lookup(const char *name)
 {
         struct perf_pmu *pmu;
         LIST_HEAD(format);
@@ -330,7 +330,7 @@ static struct perf_pmu *pmu_lookup(char *name)
         return pmu;
 }
 
-static struct perf_pmu *pmu_find(char *name)
+static struct perf_pmu *pmu_find(const char *name)
 {
         struct perf_pmu *pmu;
 
@@ -356,7 +356,7 @@ struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu)
         return NULL;
 }
 
-struct perf_pmu *perf_pmu__find(char *name)
+struct perf_pmu *perf_pmu__find(const char *name)
 {
         struct perf_pmu *pmu;
 
@@ -564,3 +564,76 @@ void perf_pmu__set_format(unsigned long *bits, long from, long to)
         for (b = from; b <= to; b++)
                 set_bit(b, bits);
 }
+
+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);
+        return buf;
+}
+
+static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu,
+                             struct perf_pmu_alias *alias)
+{
+        snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name);
+        return buf;
+}
+
+static int cmp_string(const void *a, const void *b)
+{
+        const char * const *as = a;
+        const char * const *bs = b;
+        return strcmp(*as, *bs);
+}
+
+void print_pmu_events(const char *event_glob, bool name_only)
+{
+        struct perf_pmu *pmu;
+        struct perf_pmu_alias *alias;
+        char buf[1024];
+        int printed = 0;
+        int len, j;
+        char **aliases;
+
+        pmu = NULL;
+        len = 0;
+        while ((pmu = perf_pmu__scan(pmu)) != NULL)
+                list_for_each_entry(alias, &pmu->aliases, list)
+                        len++;
+        aliases = malloc(sizeof(char *) * len);
+        if (!aliases)
+                return;
+        pmu = NULL;
+        j = 0;
+        while ((pmu = perf_pmu__scan(pmu)) != NULL)
+                list_for_each_entry(alias, &pmu->aliases, list) {
+                        char *name = format_alias(buf, sizeof(buf), pmu, alias);
+                        bool is_cpu = !strcmp(pmu->name, "cpu");
+
+                        if (event_glob != NULL &&
+                            !(strglobmatch(name, event_glob) ||
+                              (!is_cpu && strglobmatch(alias->name,
+                                                       event_glob))))
+                                continue;
+                        aliases[j] = name;
+                        if (is_cpu && !name_only)
+                                aliases[j] = format_alias_or(buf, sizeof(buf),
+                                                              pmu, alias);
+                        aliases[j] = strdup(aliases[j]);
+                        j++;
+                }
+        len = j;
+        qsort(aliases, len, sizeof(char *), cmp_string);
+        for (j = 0; j < len; j++) {
+                if (name_only) {
+                        printf("%s ", aliases[j]);
+                        continue;
+                }
+                printf("  %-50s [Kernel PMU event]\n", aliases[j]);
+                free(aliases[j]);
+                printed++;
+        }
+        if (printed)
+                printf("\n");
+        free(aliases);
+}
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index 32fe55b659fa..6b2cbe2d4cc3 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -3,6 +3,7 @@
 
 #include <linux/bitops.h>
 #include <linux/perf_event.h>
+#include <stdbool.h>
 
 enum {
         PERF_PMU_FORMAT_VALUE_CONFIG,
@@ -21,7 +22,7 @@ struct perf_pmu {
         struct list_head list;
 };
 
-struct perf_pmu *perf_pmu__find(char *name);
+struct perf_pmu *perf_pmu__find(const char *name);
 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
                      struct list_head *head_terms);
 int perf_pmu__config_terms(struct list_head *formats,
@@ -40,5 +41,7 @@ int perf_pmu__format_parse(char *dir, struct list_head *head);
 
 struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu);
 
+void print_pmu_events(const char *event_glob, bool name_only);
+
 int perf_pmu__test(void);
 #endif /* __PMU_H */
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index be0329394d56..371476cb8ddc 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -118,7 +118,6 @@ static const Dwfl_Callbacks offline_callbacks = {
 static int debuginfo__init_offline_dwarf(struct debuginfo *self,
                                          const char *path)
 {
-        Dwfl_Module *mod;
         int fd;
 
         fd = open(path, O_RDONLY);
@@ -129,11 +128,11 @@ static int debuginfo__init_offline_dwarf(struct debuginfo *self,
         if (!self->dwfl)
                 goto error;
 
-        mod = dwfl_report_offline(self->dwfl, "", "", fd);
-        if (!mod)
+        self->mod = dwfl_report_offline(self->dwfl, "", "", fd);
+        if (!self->mod)
                 goto error;
 
-        self->dbg = dwfl_module_getdwarf(mod, &self->bias);
+        self->dbg = dwfl_module_getdwarf(self->mod, &self->bias);
         if (!self->dbg)
                 goto error;
 
@@ -676,37 +675,42 @@ static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
 }
 
 /* Convert subprogram DIE to trace point */
-static int convert_to_trace_point(Dwarf_Die *sp_die, Dwarf_Addr paddr,
-                                  bool retprobe, struct probe_trace_point *tp)
+static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
+                                  Dwarf_Addr paddr, bool retprobe,
+                                  struct probe_trace_point *tp)
 {
         Dwarf_Addr eaddr, highaddr;
-        const char *name;
-
-        /* Copy the name of probe point */
-        name = dwarf_diename(sp_die);
-        if (name) {
-                if (dwarf_entrypc(sp_die, &eaddr) != 0) {
-                        pr_warning("Failed to get entry address of %s\n",
-                                   dwarf_diename(sp_die));
-                        return -ENOENT;
-                }
-                if (dwarf_highpc(sp_die, &highaddr) != 0) {
-                        pr_warning("Failed to get end address of %s\n",
-                                   dwarf_diename(sp_die));
-                        return -ENOENT;
-                }
-                if (paddr > highaddr) {
-                        pr_warning("Offset specified is greater than size of %s\n",
-                                   dwarf_diename(sp_die));
-                        return -EINVAL;
-                }
-                tp->symbol = strdup(name);
-                if (tp->symbol == NULL)
-                        return -ENOMEM;
-                tp->offset = (unsigned long)(paddr - eaddr);
-        } else
-                /* This function has no name. */
-                tp->offset = (unsigned long)paddr;
+        GElf_Sym sym;
+        const char *symbol;
+
+        /* Verify the address is correct */
+        if (dwarf_entrypc(sp_die, &eaddr) != 0) {
+                pr_warning("Failed to get entry address of %s\n",
+                           dwarf_diename(sp_die));
+                return -ENOENT;
+        }
+        if (dwarf_highpc(sp_die, &highaddr) != 0) {
+                pr_warning("Failed to get end address of %s\n",
+                           dwarf_diename(sp_die));
+                return -ENOENT;
+        }
+        if (paddr > highaddr) {
+                pr_warning("Offset specified is greater than size of %s\n",
+                           dwarf_diename(sp_die));
+                return -EINVAL;
+        }
+
+        /* Get an appropriate symbol from symtab */
+        symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
+        if (!symbol) {
+                pr_warning("Failed to find symbol at 0x%lx\n",
+                           (unsigned long)paddr);
+                return -ENOENT;
+        }
+        tp->offset = (unsigned long)(paddr - sym.st_value);
+        tp->symbol = strdup(symbol);
+        if (!tp->symbol)
+                return -ENOMEM;
 
         /* Return probe must be on the head of a subprogram */
         if (retprobe) {
@@ -734,7 +738,7 @@ static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf)
         }
 
         /* If not a real subprogram, find a real one */
-        if (dwarf_tag(sc_die) != DW_TAG_subprogram) {
+        if (!die_is_func_def(sc_die)) {
                 if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
                         pr_warning("Failed to find probe point in any "
                                    "functions.\n");
@@ -980,12 +984,10 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
         struct dwarf_callback_param *param = data;
         struct probe_finder *pf = param->data;
         struct perf_probe_point *pp = &pf->pev->point;
-        Dwarf_Attribute attr;
 
         /* Check tag and diename */
-        if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
-            !die_compare_name(sp_die, pp->function) ||
-            dwarf_attr(sp_die, DW_AT_declaration, &attr))
+        if (!die_is_func_def(sp_die) ||
+            !die_compare_name(sp_die, pp->function))
                 return DWARF_CB_OK;
 
         /* Check declared file */
@@ -1151,7 +1153,7 @@ static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
         tev = &tf->tevs[tf->ntevs++];
 
         /* Trace point should be converted from subprogram DIE */
-        ret = convert_to_trace_point(&pf->sp_die, pf->addr,
+        ret = convert_to_trace_point(&pf->sp_die, tf->mod, pf->addr,
                                      pf->pev->point.retprobe, &tev->point);
         if (ret < 0)
                 return ret;
@@ -1183,7 +1185,7 @@ int debuginfo__find_trace_events(struct debuginfo *self,
 {
         struct trace_event_finder tf = {
                         .pf = {.pev = pev, .callback = add_probe_trace_event},
-                        .max_tevs = max_tevs};
+                        .mod = self->mod, .max_tevs = max_tevs};
         int ret;
 
         /* Allocate result tevs array */
@@ -1252,7 +1254,7 @@ static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf)
         vl = &af->vls[af->nvls++];
 
         /* Trace point should be converted from subprogram DIE */
-        ret = convert_to_trace_point(&pf->sp_die, pf->addr,
+        ret = convert_to_trace_point(&pf->sp_die, af->mod, pf->addr,
                                      pf->pev->point.retprobe, &vl->point);
         if (ret < 0)
                 return ret;
@@ -1291,6 +1293,7 @@ int debuginfo__find_available_vars_at(struct debuginfo *self,
 {
         struct available_var_finder af = {
                         .pf = {.pev = pev, .callback = add_available_vars},
+                        .mod = self->mod,
                         .max_vls = max_vls, .externs = externs};
         int ret;
 
@@ -1474,7 +1477,7 @@ static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
         return 0;
 }
 
-/* Search function from function name */
+/* Search function definition from function name */
 static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
 {
         struct dwarf_callback_param *param = data;
@@ -1485,7 +1488,7 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
         if (lr->file && strtailcmp(lr->file, dwarf_decl_file(sp_die)))
                 return DWARF_CB_OK;
 
-        if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
+        if (die_is_func_def(sp_die) &&
             die_compare_name(sp_die, lr->function)) {
                 lf->fname = dwarf_decl_file(sp_die);
                 dwarf_decl_line(sp_die, &lr->offset);
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index 17e94d0c36f9..3b7d63018960 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -23,6 +23,7 @@ static inline int is_c_varname(const char *name)
 /* debug information structure */
 struct debuginfo {
         Dwarf           *dbg;
+        Dwfl_Module     *mod;
         Dwfl            *dwfl;
         Dwarf_Addr      bias;
 };
@@ -77,6 +78,7 @@ struct probe_finder {
 
 struct trace_event_finder {
         struct probe_finder     pf;
+        Dwfl_Module             *mod;           /* For solving symbols */
         struct probe_trace_event *tevs;         /* Found trace events */
         int                     ntevs;          /* Number of trace events */
         int                     max_tevs;       /* Max number of trace events */
@@ -84,6 +86,7 @@ struct trace_event_finder {
 
 struct available_var_finder {
         struct probe_finder     pf;
+        Dwfl_Module             *mod;           /* For solving symbols */
         struct variable_list    *vls;           /* Found variable lists */
         int                     nvls;           /* Number of variable lists */
         int                     max_vls;        /* Max no. of variable lists */
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index 925e0c3e6d91..71b5412bbbb9 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -8,6 +8,26 @@
 #include "cpumap.h"
 #include "thread_map.h"
 
+/*
+ * Support debug printing even though util/debug.c is not linked.  That means
+ * implementing 'verbose' and 'eprintf'.
+ */
+int verbose;
+
+int eprintf(int level, const char *fmt, ...)
+{
+        va_list args;
+        int ret = 0;
+
+        if (verbose >= level) {
+                va_start(args, fmt);
+                ret = vfprintf(stderr, fmt, args);
+                va_end(args);
+        }
+
+        return ret;
+}
+
 /* Define PyVarObject_HEAD_INIT for python 2.5 */
 #ifndef PyVarObject_HEAD_INIT
 # define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size,
@@ -967,6 +987,7 @@ static struct {
         { "COUNT_SW_PAGE_FAULTS_MAJ",  PERF_COUNT_SW_PAGE_FAULTS_MAJ },
         { "COUNT_SW_ALIGNMENT_FAULTS", PERF_COUNT_SW_ALIGNMENT_FAULTS },
         { "COUNT_SW_EMULATION_FAULTS", PERF_COUNT_SW_EMULATION_FAULTS },
+        { "COUNT_SW_DUMMY",            PERF_COUNT_SW_DUMMY },
 
         { "SAMPLE_IP",        PERF_SAMPLE_IP },
         { "SAMPLE_TID",       PERF_SAMPLE_TID },
diff --git a/tools/perf/util/record.c b/tools/perf/util/record.c
new file mode 100644
index 000000000000..18d73aa2f0f8
--- /dev/null
+++ b/tools/perf/util/record.c
@@ -0,0 +1,108 @@
+#include "evlist.h"
+#include "evsel.h"
+#include "cpumap.h"
+#include "parse-events.h"
+
+typedef void (*setup_probe_fn_t)(struct perf_evsel *evsel);
+
+static int perf_do_probe_api(setup_probe_fn_t fn, int cpu, const char *str)
+{
+        struct perf_evlist *evlist;
+        struct perf_evsel *evsel;
+        int err = -EAGAIN, fd;
+
+        evlist = perf_evlist__new();
+        if (!evlist)
+                return -ENOMEM;
+
+        if (parse_events(evlist, str))
+                goto out_delete;
+
+        evsel = perf_evlist__first(evlist);
+
+        fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1, 0);
+        if (fd < 0)
+                goto out_delete;
+        close(fd);
+
+        fn(evsel);
+
+        fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1, 0);
+        if (fd < 0) {
+                if (errno == EINVAL)
+                        err = -EINVAL;
+                goto out_delete;
+        }
+        close(fd);
+        err = 0;
+
+out_delete:
+        perf_evlist__delete(evlist);
+        return err;
+}
+
+static bool perf_probe_api(setup_probe_fn_t fn)
+{
+        const char *try[] = {"cycles:u", "instructions:u", "cpu-clock", NULL};
+        struct cpu_map *cpus;
+        int cpu, ret, i = 0;
+
+        cpus = cpu_map__new(NULL);
+        if (!cpus)
+                return false;
+        cpu = cpus->map[0];
+        cpu_map__delete(cpus);
+
+        do {
+                ret = perf_do_probe_api(fn, cpu, try[i++]);
+                if (!ret)
+                        return true;
+        } while (ret == -EAGAIN && try[i]);
+
+        return false;
+}
+
+static void perf_probe_sample_identifier(struct perf_evsel *evsel)
+{
+        evsel->attr.sample_type |= PERF_SAMPLE_IDENTIFIER;
+}
+
+bool perf_can_sample_identifier(void)
+{
+        return perf_probe_api(perf_probe_sample_identifier);
+}
+
+void perf_evlist__config(struct perf_evlist *evlist,
+                        struct perf_record_opts *opts)
+{
+        struct perf_evsel *evsel;
+        bool use_sample_identifier = false;
+
+        /*
+         * Set the evsel leader links before we configure attributes,
+         * since some might depend on this info.
+         */
+        if (opts->group)
+                perf_evlist__set_leader(evlist);
+
+        if (evlist->cpus->map[0] < 0)
+                opts->no_inherit = true;
+
+        list_for_each_entry(evsel, &evlist->entries, node)
+                perf_evsel__config(evsel, opts);
+
+        if (evlist->nr_entries > 1) {
+                struct perf_evsel *first = perf_evlist__first(evlist);
+
+                list_for_each_entry(evsel, &evlist->entries, node) {
+                        if (evsel->attr.sample_type == first->attr.sample_type)
+                                continue;
+                        use_sample_identifier = perf_can_sample_identifier();
+                        break;
+                }
+                list_for_each_entry(evsel, &evlist->entries, node)
+                        perf_evsel__set_sample_id(evsel, use_sample_identifier);
+        }
+
+        perf_evlist__set_id_pos(evlist);
+}
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index eacec859f299..a85e4ae5f3ac 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -261,7 +261,8 @@ static void perl_process_tracepoint(union perf_event *perf_event __maybe_unused,
                                     struct perf_sample *sample,
                                     struct perf_evsel *evsel,
                                     struct machine *machine __maybe_unused,
-                                    struct addr_location *al)
+                                    struct thread *thread,
+                                        struct addr_location *al)
 {
         struct format_field *field;
         static char handler[256];
@@ -272,7 +273,6 @@ static void perl_process_tracepoint(union perf_event *perf_event __maybe_unused,
         int cpu = sample->cpu;
         void *data = sample->raw_data;
         unsigned long long nsecs = sample->time;
-        struct thread *thread = al->thread;
         char *comm = thread->comm;
 
         dSP;
@@ -351,7 +351,8 @@ static void perl_process_event_generic(union perf_event *event,
                                        struct perf_sample *sample,
                                        struct perf_evsel *evsel,
                                        struct machine *machine __maybe_unused,
-                                       struct addr_location *al __maybe_unused)
+                                       struct thread *thread __maybe_unused,
+                                           struct addr_location *al __maybe_unused)
 {
         dSP;
 
@@ -377,10 +378,11 @@ static void perl_process_event(union perf_event *event,
                                struct perf_sample *sample,
                                struct perf_evsel *evsel,
                                struct machine *machine,
-                               struct addr_location *al)
+                               struct thread *thread,
+                                   struct addr_location *al)
 {
-        perl_process_tracepoint(event, sample, evsel, machine, al);
-        perl_process_event_generic(event, sample, evsel, machine, al);
+        perl_process_tracepoint(event, sample, evsel, machine, thread, al);
+        perl_process_event_generic(event, sample, evsel, machine, thread, al);
 }
 
 static void run_start_sub(void)
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index e87aa5d9696b..cc75a3cef388 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -225,6 +225,7 @@ static void python_process_tracepoint(union perf_event *perf_event
                                  struct perf_sample *sample,
                                  struct perf_evsel *evsel,
                                  struct machine *machine __maybe_unused,
+                                 struct thread *thread,
                                  struct addr_location *al)
 {
         PyObject *handler, *retval, *context, *t, *obj, *dict = NULL;
@@ -238,7 +239,6 @@ static void python_process_tracepoint(union perf_event *perf_event
         int cpu = sample->cpu;
         void *data = sample->raw_data;
         unsigned long long nsecs = sample->time;
-        struct thread *thread = al->thread;
         char *comm = thread->comm;
 
         t = PyTuple_New(MAX_FIELDS);
@@ -345,12 +345,12 @@ static void python_process_general_event(union perf_event *perf_event
                                          struct perf_sample *sample,
                                          struct perf_evsel *evsel,
                                          struct machine *machine __maybe_unused,
+                                         struct thread *thread,
                                          struct addr_location *al)
 {
         PyObject *handler, *retval, *t, *dict;
         static char handler_name[64];
         unsigned n = 0;
-        struct thread *thread = al->thread;
 
         /*
          * Use the MAX_FIELDS to make the function expandable, though
@@ -404,17 +404,18 @@ static void python_process_event(union perf_event *perf_event,
                                  struct perf_sample *sample,
                                  struct perf_evsel *evsel,
                                  struct machine *machine,
+                                 struct thread *thread,
                                  struct addr_location *al)
 {
         switch (evsel->attr.type) {
         case PERF_TYPE_TRACEPOINT:
                 python_process_tracepoint(perf_event, sample, evsel,
-                                          machine, al);
+                                          machine, thread, al);
                 break;
         /* Reserve for future process_hw/sw/raw APIs */
         default:
                 python_process_general_event(perf_event, sample, evsel,
-                                             machine, al);
+                                             machine, thread, al);
         }
 }
 
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index cf1fe01b7e89..70ffa41518f3 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -1,4 +1,5 @@
 #include <linux/kernel.h>
+#include <traceevent/event-parse.h>
 
 #include <byteswap.h>
 #include <unistd.h>
@@ -12,7 +13,6 @@
 #include "sort.h"
 #include "util.h"
 #include "cpumap.h"
-#include "event-parse.h"
 #include "perf_regs.h"
 #include "vdso.h"
 
@@ -24,7 +24,7 @@ static int perf_session__open(struct perf_session *self, bool force)
                 self->fd_pipe = true;
                 self->fd = STDIN_FILENO;
 
-                if (perf_session__read_header(self, self->fd) < 0)
+                if (perf_session__read_header(self) < 0)
                         pr_err("incompatible file format (rerun with -v to learn more)");
 
                 return 0;
@@ -56,7 +56,7 @@ static int perf_session__open(struct perf_session *self, bool force)
                 goto out_close;
         }
 
-        if (perf_session__read_header(self, self->fd) < 0) {
+        if (perf_session__read_header(self) < 0) {
                 pr_err("incompatible file format (rerun with -v to learn more)");
                 goto out_close;
         }
@@ -71,6 +71,11 @@ static int perf_session__open(struct perf_session *self, bool force)
                 goto out_close;
         }
 
+        if (!perf_evlist__valid_read_format(self->evlist)) {
+                pr_err("non matching read_format");
+                goto out_close;
+        }
+
         self->size = input_stat.st_size;
         return 0;
 
@@ -193,7 +198,9 @@ void perf_session__delete(struct perf_session *self)
         vdso__exit();
 }
 
-static int process_event_synth_tracing_data_stub(union perf_event *event
+static int process_event_synth_tracing_data_stub(struct perf_tool *tool
+                                                 __maybe_unused,
+                                                 union perf_event *event
                                                  __maybe_unused,
                                                  struct perf_session *session
                                                 __maybe_unused)
@@ -202,7 +209,8 @@ static int process_event_synth_tracing_data_stub(union perf_event *event
         return 0;
 }
 
-static int process_event_synth_attr_stub(union perf_event *event __maybe_unused,
+static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused,
+                                         union perf_event *event __maybe_unused,
                                          struct perf_evlist **pevlist
                                          __maybe_unused)
 {
@@ -238,18 +246,11 @@ static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
         return 0;
 }
 
-static int process_event_type_stub(struct perf_tool *tool __maybe_unused,
-                                   union perf_event *event __maybe_unused)
-{
-        dump_printf(": unhandled!\n");
-        return 0;
-}
-
 static int process_finished_round(struct perf_tool *tool,
                                   union perf_event *event,
                                   struct perf_session *session);
 
-static void perf_tool__fill_defaults(struct perf_tool *tool)
+void perf_tool__fill_defaults(struct perf_tool *tool)
 {
         if (tool->sample == NULL)
                 tool->sample = process_event_sample_stub;
@@ -271,8 +272,6 @@ static void perf_tool__fill_defaults(struct perf_tool *tool)
                 tool->unthrottle = process_event_stub;
         if (tool->attr == NULL)
                 tool->attr = process_event_synth_attr_stub;
-        if (tool->event_type == NULL)
-                tool->event_type = process_event_type_stub;
         if (tool->tracing_data == NULL)
                 tool->tracing_data = process_event_synth_tracing_data_stub;
         if (tool->build_id == NULL)
@@ -352,6 +351,25 @@ static void perf_event__mmap_swap(union perf_event *event,
         }
 }
 
+static void perf_event__mmap2_swap(union perf_event *event,
+                                  bool sample_id_all)
+{
+        event->mmap2.pid   = bswap_32(event->mmap2.pid);
+        event->mmap2.tid   = bswap_32(event->mmap2.tid);
+        event->mmap2.start = bswap_64(event->mmap2.start);
+        event->mmap2.len   = bswap_64(event->mmap2.len);
+        event->mmap2.pgoff = bswap_64(event->mmap2.pgoff);
+        event->mmap2.maj   = bswap_32(event->mmap2.maj);
+        event->mmap2.min   = bswap_32(event->mmap2.min);
+        event->mmap2.ino   = bswap_64(event->mmap2.ino);
+
+        if (sample_id_all) {
+                void *data = &event->mmap2.filename;
+
+                data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
+                swap_sample_id_all(event, data);
+        }
+}
 static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
 {
         event->fork.pid  = bswap_32(event->fork.pid);
@@ -456,6 +474,7 @@ typedef void (*perf_event__swap_op)(union perf_event *event,
 
 static perf_event__swap_op perf_event__swap_ops[] = {
         [PERF_RECORD_MMAP]                = perf_event__mmap_swap,
+        [PERF_RECORD_MMAP2]               = perf_event__mmap2_swap,
         [PERF_RECORD_COMM]                = perf_event__comm_swap,
         [PERF_RECORD_FORK]                = perf_event__task_swap,
         [PERF_RECORD_EXIT]                = perf_event__task_swap,
@@ -496,7 +515,7 @@ static int perf_session_deliver_event(struct perf_session *session,
                                       u64 file_offset);
 
 static int flush_sample_queue(struct perf_session *s,
-                               struct perf_tool *tool)
+                       struct perf_tool *tool)
 {
         struct ordered_samples *os = &s->ordered_samples;
         struct list_head *head = &os->samples;
@@ -505,12 +524,16 @@ static int flush_sample_queue(struct perf_session *s,
         u64 limit = os->next_flush;
         u64 last_ts = os->last_sample ? os->last_sample->timestamp : 0ULL;
         unsigned idx = 0, progress_next = os->nr_samples / 16;
+        bool show_progress = limit == ULLONG_MAX;
         int ret;
 
         if (!tool->ordered_samples || !limit)
                 return 0;
 
         list_for_each_entry_safe(iter, tmp, head, list) {
+                if (session_done())
+                        return 0;
+
                 if (iter->timestamp > limit)
                         break;
 
@@ -527,7 +550,7 @@ static int flush_sample_queue(struct perf_session *s,
                 os->last_flush = iter->timestamp;
                 list_del(&iter->list);
                 list_add(&iter->list, &os->sample_cache);
-                if (++idx >= progress_next) {
+                if (show_progress && (++idx >= progress_next)) {
                         progress_next += os->nr_samples / 16;
                         ui_progress__update(idx, os->nr_samples,
                                             "Processing time ordered events...");
@@ -644,7 +667,7 @@ static void __queue_event(struct sample_queue *new, struct perf_session *s)
 
 #define MAX_SAMPLE_BUFFER       (64 * 1024 / sizeof(struct sample_queue))
 
-static int perf_session_queue_event(struct perf_session *s, union perf_event *event,
+int perf_session_queue_event(struct perf_session *s, union perf_event *event,
                                     struct perf_sample *sample, u64 file_offset)
 {
         struct ordered_samples *os = &s->ordered_samples;
@@ -740,7 +763,7 @@ static void perf_session__print_tstamp(struct perf_session *session,
                                        union perf_event *event,
                                        struct perf_sample *sample)
 {
-        u64 sample_type = perf_evlist__sample_type(session->evlist);
+        u64 sample_type = __perf_evlist__combined_sample_type(session->evlist);
 
         if (event->header.type != PERF_RECORD_SAMPLE &&
             !perf_evlist__sample_id_all(session->evlist)) {
@@ -755,6 +778,36 @@ static void perf_session__print_tstamp(struct perf_session *session,
                 printf("%" PRIu64 " ", sample->time);
 }
 
+static void sample_read__printf(struct perf_sample *sample, u64 read_format)
+{
+        printf("... sample_read:\n");
+
+        if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
+                printf("...... time enabled %016" PRIx64 "\n",
+                       sample->read.time_enabled);
+
+        if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
+                printf("...... time running %016" PRIx64 "\n",
+                       sample->read.time_running);
+
+        if (read_format & PERF_FORMAT_GROUP) {
+                u64 i;
+
+                printf(".... group nr %" PRIu64 "\n", sample->read.group.nr);
+
+                for (i = 0; i < sample->read.group.nr; i++) {
+                        struct sample_read_value *value;
+
+                        value = &sample->read.group.values[i];
+                        printf("..... id %016" PRIx64
+                               ", value %016" PRIx64 "\n",
+                               value->id, value->value);
+                }
+        } else
+                printf("..... id %016" PRIx64 ", value %016" PRIx64 "\n",
+                        sample->read.one.id, sample->read.one.value);
+}
+
 static void dump_event(struct perf_session *session, union perf_event *event,
                        u64 file_offset, struct perf_sample *sample)
 {
@@ -804,11 +857,15 @@ static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
 
         if (sample_type & PERF_SAMPLE_DATA_SRC)
                 printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
+
+        if (sample_type & PERF_SAMPLE_READ)
+                sample_read__printf(sample, evsel->attr.read_format);
 }
 
 static struct machine *
         perf_session__find_machine_for_cpumode(struct perf_session *session,
-                                               union perf_event *event)
+                                               union perf_event *event,
+                                               struct perf_sample *sample)
 {
         const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
@@ -817,10 +874,11 @@ static struct machine *
              (cpumode == PERF_RECORD_MISC_GUEST_USER))) {
                 u32 pid;
 
-                if (event->header.type == PERF_RECORD_MMAP)
+                if (event->header.type == PERF_RECORD_MMAP
+                    || event->header.type == PERF_RECORD_MMAP2)
                         pid = event->mmap.pid;
                 else
-                        pid = event->ip.pid;
+                        pid = sample->pid;
 
                 return perf_session__findnew_machine(session, pid);
         }
@@ -828,6 +886,75 @@ static struct machine *
         return &session->machines.host;
 }
 
+static int deliver_sample_value(struct perf_session *session,
+                                struct perf_tool *tool,
+                                union perf_event *event,
+                                struct perf_sample *sample,
+                                struct sample_read_value *v,
+                                struct machine *machine)
+{
+        struct perf_sample_id *sid;
+
+        sid = perf_evlist__id2sid(session->evlist, v->id);
+        if (sid) {
+                sample->id     = v->id;
+                sample->period = v->value - sid->period;
+                sid->period    = v->value;
+        }
+
+        if (!sid || sid->evsel == NULL) {
+                ++session->stats.nr_unknown_id;
+                return 0;
+        }
+
+        return tool->sample(tool, event, sample, sid->evsel, machine);
+}
+
+static int deliver_sample_group(struct perf_session *session,
+                                struct perf_tool *tool,
+                                union  perf_event *event,
+                                struct perf_sample *sample,
+                                struct machine *machine)
+{
+        int ret = -EINVAL;
+        u64 i;
+
+        for (i = 0; i < sample->read.group.nr; i++) {
+                ret = deliver_sample_value(session, tool, event, sample,
+                                           &sample->read.group.values[i],
+                                           machine);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+}
+
+static int
+perf_session__deliver_sample(struct perf_session *session,
+                             struct perf_tool *tool,
+                             union  perf_event *event,
+                             struct perf_sample *sample,
+                             struct perf_evsel *evsel,
+                             struct machine *machine)
+{
+        /* We know evsel != NULL. */
+        u64 sample_type = evsel->attr.sample_type;
+        u64 read_format = evsel->attr.read_format;
+
+        /* Standard sample delievery. */
+        if (!(sample_type & PERF_SAMPLE_READ))
+                return tool->sample(tool, event, sample, evsel, machine);
+
+        /* For PERF_SAMPLE_READ we have either single or group mode. */
+        if (read_format & PERF_FORMAT_GROUP)
+                return deliver_sample_group(session, tool, event, sample,
+                                            machine);
+        else
+                return deliver_sample_value(session, tool, event, sample,
+                                            &sample->read.one, machine);
+}
+
 static int perf_session_deliver_event(struct perf_session *session,
                                       union perf_event *event,
                                       struct perf_sample *sample,
@@ -857,7 +984,8 @@ static int perf_session_deliver_event(struct perf_session *session,
                 hists__inc_nr_events(&evsel->hists, event->header.type);
         }
 
-        machine = perf_session__find_machine_for_cpumode(session, event);
+        machine = perf_session__find_machine_for_cpumode(session, event,
+                                                         sample);
 
         switch (event->header.type) {
         case PERF_RECORD_SAMPLE:
@@ -870,9 +998,12 @@ static int perf_session_deliver_event(struct perf_session *session,
                         ++session->stats.nr_unprocessable_samples;
                         return 0;
                 }
-                return tool->sample(tool, event, sample, evsel, machine);
+                return perf_session__deliver_sample(session, tool, event,
+                                                    sample, evsel, machine);
         case PERF_RECORD_MMAP:
                 return tool->mmap(tool, event, sample, machine);
+        case PERF_RECORD_MMAP2:
+                return tool->mmap2(tool, event, sample, machine);
         case PERF_RECORD_COMM:
                 return tool->comm(tool, event, sample, machine);
         case PERF_RECORD_FORK:
@@ -895,22 +1026,6 @@ static int perf_session_deliver_event(struct perf_session *session,
         }
 }
 
-static int perf_session__preprocess_sample(struct perf_session *session,
-                                           union perf_event *event, struct perf_sample *sample)
-{
-        if (event->header.type != PERF_RECORD_SAMPLE ||
-            !(perf_evlist__sample_type(session->evlist) & PERF_SAMPLE_CALLCHAIN))
-                return 0;
-
-        if (!ip_callchain__valid(sample->callchain, event)) {
-                pr_debug("call-chain problem with event, skipping it.\n");
-                ++session->stats.nr_invalid_chains;
-                session->stats.total_invalid_chains += sample->period;
-                return -EINVAL;
-        }
-        return 0;
-}
-
 static int perf_session__process_user_event(struct perf_session *session, union perf_event *event,
                                             struct perf_tool *tool, u64 file_offset)
 {
@@ -921,16 +1036,14 @@ static int perf_session__process_user_event(struct perf_session *session, union
         /* These events are processed right away */
         switch (event->header.type) {
         case PERF_RECORD_HEADER_ATTR:
-                err = tool->attr(event, &session->evlist);
+                err = tool->attr(tool, event, &session->evlist);
                 if (err == 0)
                         perf_session__set_id_hdr_size(session);
                 return err;
-        case PERF_RECORD_HEADER_EVENT_TYPE:
-                return tool->event_type(tool, event);
         case PERF_RECORD_HEADER_TRACING_DATA:
                 /* setup for reading amidst mmap */
                 lseek(session->fd, file_offset, SEEK_SET);
-                return tool->tracing_data(event, session);
+                return tool->tracing_data(tool, event, session);
         case PERF_RECORD_HEADER_BUILD_ID:
                 return tool->build_id(tool, event, session);
         case PERF_RECORD_FINISHED_ROUND:
@@ -975,10 +1088,6 @@ static int perf_session__process_event(struct perf_session *session,
         if (ret)
                 return ret;
 
-        /* Preprocess sample records - precheck callchains */
-        if (perf_session__preprocess_sample(session, event, &sample))
-                return 0;
-
         if (tool->ordered_samples) {
                 ret = perf_session_queue_event(session, event, &sample,
                                                file_offset);
@@ -999,7 +1108,7 @@ void perf_event_header__bswap(struct perf_event_header *self)
 
 struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
 {
-        return machine__findnew_thread(&session->machines.host, pid);
+        return machine__findnew_thread(&session->machines.host, 0, pid);
 }
 
 static struct thread *perf_session__register_idle_thread(struct perf_session *self)
@@ -1054,7 +1163,6 @@ static void perf_session__warn_about_errors(const struct perf_session *session,
         }
 }
 
-#define session_done()  (*(volatile int *)(&session_done))
 volatile int session_done;
 
 static int __perf_session__process_pipe_events(struct perf_session *self,
@@ -1091,8 +1199,10 @@ more:
                 perf_event_header__bswap(&event->header);
 
         size = event->header.size;
-        if (size == 0)
-                size = 8;
+        if (size < sizeof(struct perf_event_header)) {
+                pr_err("bad event header size\n");
+                goto out_err;
+        }
 
         if (size > cur_size) {
                 void *new = realloc(buf, size);
@@ -1161,8 +1271,12 @@ fetch_mmaped_event(struct perf_session *session,
         if (session->header.needs_swap)
                 perf_event_header__bswap(&event->header);
 
-        if (head + event->header.size > mmap_size)
+        if (head + event->header.size > mmap_size) {
+                /* We're not fetching the event so swap back again */
+                if (session->header.needs_swap)
+                        perf_event_header__bswap(&event->header);
                 return NULL;
+        }
 
         return event;
 }
@@ -1242,7 +1356,7 @@ more:
 
         size = event->header.size;
 
-        if (size == 0 ||
+        if (size < sizeof(struct perf_event_header) ||
             perf_session__process_event(session, event, tool, file_pos) < 0) {
                 pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
                        file_offset + head, event->header.size,
@@ -1260,10 +1374,13 @@ more:
                                     "Processing events...");
         }
 
+        err = 0;
+        if (session_done())
+                goto out_err;
+
         if (file_pos < file_size)
                 goto more;
 
-        err = 0;
         /* do the final flush for ordered samples */
         session->ordered_samples.next_flush = ULLONG_MAX;
         err = flush_sample_queue(session, tool);
@@ -1295,12 +1412,15 @@ int perf_session__process_events(struct perf_session *self,
 
 bool perf_session__has_traces(struct perf_session *session, const char *msg)
 {
-        if (!(perf_evlist__sample_type(session->evlist) & PERF_SAMPLE_RAW)) {
-                pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
-                return false;
+        struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, &session->evlist->entries, node) {
+                if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
+                        return true;
         }
 
-        return true;
+        pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
+        return false;
 }
 
 int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
@@ -1383,13 +1503,18 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
 
 void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
                           struct perf_sample *sample, struct machine *machine,
-                          int print_sym, int print_dso, int print_symoffset)
+                          unsigned int print_opts, unsigned int stack_depth)
 {
         struct addr_location al;
         struct callchain_cursor_node *node;
-
-        if (perf_event__preprocess_sample(event, machine, &al, sample,
-                                          NULL) < 0) {
+        int print_ip = print_opts & PRINT_IP_OPT_IP;
+        int print_sym = print_opts & PRINT_IP_OPT_SYM;
+        int print_dso = print_opts & PRINT_IP_OPT_DSO;
+        int print_symoffset = print_opts & PRINT_IP_OPT_SYMOFFSET;
+        int print_oneline = print_opts & PRINT_IP_OPT_ONELINE;
+        char s = print_oneline ? ' ' : '\t';
+
+        if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
                 error("problem processing %d event, skipping it.\n",
                         event->header.type);
                 return;
@@ -1397,37 +1522,50 @@ void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
 
         if (symbol_conf.use_callchain && sample->callchain) {
 
-
                 if (machine__resolve_callchain(machine, evsel, al.thread,
-                                               sample, NULL) != 0) {
+                                               sample, NULL, NULL) != 0) {
                         if (verbose)
                                 error("Failed to resolve callchain. Skipping\n");
                         return;
                 }
                 callchain_cursor_commit(&callchain_cursor);
 
-                while (1) {
+                while (stack_depth) {
                         node = callchain_cursor_current(&callchain_cursor);
                         if (!node)
                                 break;
 
-                        printf("\t%16" PRIx64, node->ip);
+                        if (print_ip)
+                                printf("%c%16" PRIx64, s, node->ip);
+
                         if (print_sym) {
                                 printf(" ");
-                                symbol__fprintf_symname(node->sym, stdout);
+                                if (print_symoffset) {
+                                        al.addr = node->ip;
+                                        al.map  = node->map;
+                                        symbol__fprintf_symname_offs(node->sym, &al, stdout);
+                                } else
+                                        symbol__fprintf_symname(node->sym, stdout);
                         }
+
                         if (print_dso) {
                                 printf(" (");
                                 map__fprintf_dsoname(node->map, stdout);
                                 printf(")");
                         }
-                        printf("\n");
+
+                        if (!print_oneline)
+                                printf("\n");
 
                         callchain_cursor_advance(&callchain_cursor);
+
+                        stack_depth--;
                 }
 
         } else {
-                printf("%16" PRIx64, sample->ip);
+                if (print_ip)
+                        printf("%16" PRIx64, sample->ip);
+
                 if (print_sym) {
                         printf(" ");
                         if (print_symoffset)
@@ -1510,52 +1648,26 @@ int __perf_session__set_tracepoints_handlers(struct perf_session *session,
                                              const struct perf_evsel_str_handler *assocs,
                                              size_t nr_assocs)
 {
-        struct perf_evlist *evlist = session->evlist;
-        struct event_format *format;
         struct perf_evsel *evsel;
-        char *tracepoint, *name;
         size_t i;
         int err;
 
         for (i = 0; i < nr_assocs; i++) {
-                err = -ENOMEM;
-                tracepoint = strdup(assocs[i].name);
-                if (tracepoint == NULL)
-                        goto out;
-
-                err = -ENOENT;
-                name = strchr(tracepoint, ':');
-                if (name == NULL)
-                        goto out_free;
-
-                *name++ = '\0';
-                format = pevent_find_event_by_name(session->pevent,
-                                                   tracepoint, name);
-                if (format == NULL) {
-                        /*
-                         * Adding a handler for an event not in the session,
-                         * just ignore it.
-                         */
-                        goto next;
-                }
-
-                evsel = perf_evlist__find_tracepoint_by_id(evlist, format->id);
+                /*
+                 * Adding a handler for an event not in the session,
+                 * just ignore it.
+                 */
+                evsel = perf_evlist__find_tracepoint_by_name(session->evlist, assocs[i].name);
                 if (evsel == NULL)
-                        goto next;
+                        continue;
 
                 err = -EEXIST;
                 if (evsel->handler.func != NULL)
-                        goto out_free;
+                        goto out;
                 evsel->handler.func = assocs[i].handler;
-next:
-                free(tracepoint);
         }
 
         err = 0;
 out:
         return err;
-
-out_free:
-        free(tracepoint);
-        goto out;
 }
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 6b51d47acdba..04bf7373a7e5 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -37,12 +37,16 @@ struct perf_session {
         int                     fd;
         bool                    fd_pipe;
         bool                    repipe;
-        int                     cwdlen;
-        char                    *cwd;
         struct ordered_samples  ordered_samples;
         char                    filename[1];
 };
 
+#define PRINT_IP_OPT_IP         (1<<0)
+#define PRINT_IP_OPT_SYM                (1<<1)
+#define PRINT_IP_OPT_DSO                (1<<2)
+#define PRINT_IP_OPT_SYMOFFSET  (1<<3)
+#define PRINT_IP_OPT_ONELINE    (1<<4)
+
 struct perf_tool;
 
 struct perf_session *perf_session__new(const char *filename, int mode,
@@ -58,6 +62,11 @@ int __perf_session__process_events(struct perf_session *self,
 int perf_session__process_events(struct perf_session *self,
                                  struct perf_tool *tool);
 
+int perf_session_queue_event(struct perf_session *s, union perf_event *event,
+                             struct perf_sample *sample, u64 file_offset);
+
+void perf_tool__fill_defaults(struct perf_tool *tool);
+
 int perf_session__resolve_callchain(struct perf_session *self, struct perf_evsel *evsel,
                                     struct thread *thread,
                                     struct ip_callchain *chain,
@@ -100,7 +109,7 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
 
 void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
                           struct perf_sample *sample, struct machine *machine,
-                          int print_sym, int print_dso, int print_symoffset);
+                          unsigned int print_opts, unsigned int stack_depth);
 
 int perf_session__cpu_bitmap(struct perf_session *session,
                              const char *cpu_list, unsigned long *cpu_bitmap);
@@ -115,4 +124,8 @@ int __perf_session__set_tracepoints_handlers(struct perf_session *session,
 
 #define perf_session__set_tracepoints_handlers(session, array) \
         __perf_session__set_tracepoints_handlers(session, array, ARRAY_SIZE(array))
+
+extern volatile int session_done;
+
+#define session_done()  (*(volatile int *)(&session_done))
 #endif /* __PERF_SESSION_H */
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index 6b0ed322907e..58ea5ca6c255 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -18,8 +18,9 @@ class install_lib(_install_lib):
         self.build_dir = build_lib
 
 
-cflags = ['-fno-strict-aliasing', '-Wno-write-strings']
-cflags += getenv('CFLAGS', '').split()
+cflags = getenv('CFLAGS', '').split()
+# switch off several checks (need to be at the end of cflags list)
+cflags += ['-fno-strict-aliasing', '-Wno-write-strings', '-Wno-unused-parameter' ]
 
 build_lib = getenv('PYTHON_EXTBUILD_LIB')
 build_tmp = getenv('PYTHON_EXTBUILD_TMP')
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 5f52d492590c..5f118a089519 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1,15 +1,18 @@
 #include "sort.h"
 #include "hist.h"
+#include "symbol.h"
 
 regex_t         parent_regex;
 const char      default_parent_pattern[] = "^sys_|^do_page_fault";
 const char      *parent_pattern = default_parent_pattern;
 const char      default_sort_order[] = "comm,dso,symbol";
 const char      *sort_order = default_sort_order;
+regex_t         ignore_callees_regex;
+int             have_ignore_callees = 0;
 int             sort__need_collapse = 0;
 int             sort__has_parent = 0;
 int             sort__has_sym = 0;
-int             sort__branch_mode = -1; /* -1 = means not set */
+enum sort_mode  sort__mode = SORT_MODE__NORMAL;
 
 enum sort_type  sort__first_dimension;
 
@@ -54,14 +57,14 @@ static int64_t cmp_null(void *l, void *r)
 static int64_t
 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
 {
-        return right->thread->pid - left->thread->pid;
+        return right->thread->tid - left->thread->tid;
 }
 
 static int hist_entry__thread_snprintf(struct hist_entry *self, char *bf,
                                        size_t size, unsigned int width)
 {
         return repsep_snprintf(bf, size, "%*s:%5d", width - 6,
-                              self->thread->comm ?: "", self->thread->pid);
+                              self->thread->comm ?: "", self->thread->tid);
 }
 
 struct sort_entry sort_thread = {
@@ -76,7 +79,7 @@ struct sort_entry sort_thread = {
 static int64_t
 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
 {
-        return right->thread->pid - left->thread->pid;
+        return right->thread->tid - left->thread->tid;
 }
 
 static int64_t
@@ -194,7 +197,7 @@ static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
         if (verbose) {
                 char o = map ? dso__symtab_origin(map->dso) : '!';
                 ret += repsep_snprintf(bf, size, "%-#*llx %c ",
-                                       BITS_PER_LONG / 4, ip, o);
+                                       BITS_PER_LONG / 4 + 2, ip, o);
         }
 
         ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
@@ -873,12 +876,6 @@ static struct sort_dimension common_sort_dimensions[] = {
         DIM(SORT_SRCLINE, "srcline", sort_srcline),
         DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
         DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
-        DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
-        DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
-        DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
-        DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
-        DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
-        DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
 };
 
 #undef DIM
@@ -895,6 +892,34 @@ static struct sort_dimension bstack_sort_dimensions[] = {
 
 #undef DIM
 
+#define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
+
+static struct sort_dimension memory_sort_dimensions[] = {
+        DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
+        DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
+        DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
+        DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
+        DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
+        DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
+};
+
+#undef DIM
+
+static void __sort_dimension__add(struct sort_dimension *sd, enum sort_type idx)
+{
+        if (sd->taken)
+                return;
+
+        if (sd->entry->se_collapse)
+                sort__need_collapse = 1;
+
+        if (list_empty(&hist_entry__sort_list))
+                sort__first_dimension = idx;
+
+        list_add_tail(&sd->entry->list, &hist_entry__sort_list);
+        sd->taken = 1;
+}
+
 int sort_dimension__add(const char *tok)
 {
         unsigned int i;
@@ -915,25 +940,11 @@ int sort_dimension__add(const char *tok)
                                 return -EINVAL;
                         }
                         sort__has_parent = 1;
-                } else if (sd->entry == &sort_sym ||
-                           sd->entry == &sort_sym_from ||
-                           sd->entry == &sort_sym_to ||
-                           sd->entry == &sort_mem_daddr_sym) {
+                } else if (sd->entry == &sort_sym) {
                         sort__has_sym = 1;
                 }
 
-                if (sd->taken)
-                        return 0;
-
-                if (sd->entry->se_collapse)
-                        sort__need_collapse = 1;
-
-                if (list_empty(&hist_entry__sort_list))
-                        sort__first_dimension = i;
-
-                list_add_tail(&sd->entry->list, &hist_entry__sort_list);
-                sd->taken = 1;
-
+                __sort_dimension__add(sd, i);
                 return 0;
         }
 
@@ -943,24 +954,29 @@ int sort_dimension__add(const char *tok)
                 if (strncasecmp(tok, sd->name, strlen(tok)))
                         continue;
 
-                if (sort__branch_mode != 1)
+                if (sort__mode != SORT_MODE__BRANCH)
                         return -EINVAL;
 
                 if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
                         sort__has_sym = 1;
 
-                if (sd->taken)
-                        return 0;
+                __sort_dimension__add(sd, i + __SORT_BRANCH_STACK);
+                return 0;
+        }
 
-                if (sd->entry->se_collapse)
-                        sort__need_collapse = 1;
+        for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
+                struct sort_dimension *sd = &memory_sort_dimensions[i];
 
-                if (list_empty(&hist_entry__sort_list))
-                        sort__first_dimension = i + __SORT_BRANCH_STACK;
+                if (strncasecmp(tok, sd->name, strlen(tok)))
+                        continue;
 
-                list_add_tail(&sd->entry->list, &hist_entry__sort_list);
-                sd->taken = 1;
+                if (sort__mode != SORT_MODE__MEMORY)
+                        return -EINVAL;
 
+                if (sd->entry == &sort_mem_daddr_sym)
+                        sort__has_sym = 1;
+
+                __sort_dimension__add(sd, i + __SORT_MEMORY_MODE);
                 return 0;
         }
 
@@ -993,8 +1009,9 @@ int setup_sorting(void)
         return ret;
 }
 
-void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
-                             const char *list_name, FILE *fp)
+static void sort_entry__setup_elide(struct sort_entry *self,
+                                    struct strlist *list,
+                                    const char *list_name, FILE *fp)
 {
         if (list && strlist__nr_entries(list) == 1) {
                 if (fp != NULL)
@@ -1003,3 +1020,42 @@ void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
                 self->elide = true;
         }
 }
+
+void sort__setup_elide(FILE *output)
+{
+        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                "dso", output);
+        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list,
+                                "comm", output);
+        sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list,
+                                "symbol", output);
+
+        if (sort__mode == SORT_MODE__BRANCH) {
+                sort_entry__setup_elide(&sort_dso_from,
+                                        symbol_conf.dso_from_list,
+                                        "dso_from", output);
+                sort_entry__setup_elide(&sort_dso_to,
+                                        symbol_conf.dso_to_list,
+                                        "dso_to", output);
+                sort_entry__setup_elide(&sort_sym_from,
+                                        symbol_conf.sym_from_list,
+                                        "sym_from", output);
+                sort_entry__setup_elide(&sort_sym_to,
+                                        symbol_conf.sym_to_list,
+                                        "sym_to", output);
+        } else if (sort__mode == SORT_MODE__MEMORY) {
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "symbol_daddr", output);
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "dso_daddr", output);
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "mem", output);
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "local_weight", output);
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "tlb", output);
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list,
+                                        "snoop", output);
+        }
+
+}
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index f24bdf64238c..4e80dbd271e7 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -29,10 +29,12 @@ extern const char *sort_order;
 extern const char default_parent_pattern[];
 extern const char *parent_pattern;
 extern const char default_sort_order[];
+extern regex_t ignore_callees_regex;
+extern int have_ignore_callees;
 extern int sort__need_collapse;
 extern int sort__has_parent;
 extern int sort__has_sym;
-extern int sort__branch_mode;
+extern enum sort_mode sort__mode;
 extern struct sort_entry sort_comm;
 extern struct sort_entry sort_dso;
 extern struct sort_entry sort_sym;
@@ -87,6 +89,9 @@ struct hist_entry {
 
         struct hist_entry_diff  diff;
 
+        /* We are added by hists__add_dummy_entry. */
+        bool                    dummy;
+
         /* XXX These two should move to some tree widget lib */
         u16                     row_offset;
         u16                     nr_rows;
@@ -117,12 +122,18 @@ static inline struct hist_entry *hist_entry__next_pair(struct hist_entry *he)
         return NULL;
 }
 
-static inline void hist_entry__add_pair(struct hist_entry *he,
-                                        struct hist_entry *pair)
+static inline void hist_entry__add_pair(struct hist_entry *pair,
+                                        struct hist_entry *he)
 {
-        list_add_tail(&he->pairs.head, &pair->pairs.node);
+        list_add_tail(&pair->pairs.node, &he->pairs.head);
 }
 
+enum sort_mode {
+        SORT_MODE__NORMAL,
+        SORT_MODE__BRANCH,
+        SORT_MODE__MEMORY,
+};
+
 enum sort_type {
         /* common sort keys */
         SORT_PID,
@@ -134,12 +145,6 @@ enum sort_type {
         SORT_SRCLINE,
         SORT_LOCAL_WEIGHT,
         SORT_GLOBAL_WEIGHT,
-        SORT_MEM_DADDR_SYMBOL,
-        SORT_MEM_DADDR_DSO,
-        SORT_MEM_LOCKED,
-        SORT_MEM_TLB,
-        SORT_MEM_LVL,
-        SORT_MEM_SNOOP,
 
         /* branch stack specific sort keys */
         __SORT_BRANCH_STACK,
@@ -148,6 +153,15 @@ enum sort_type {
         SORT_SYM_FROM,
         SORT_SYM_TO,
         SORT_MISPREDICT,
+
+        /* memory mode specific sort keys */
+        __SORT_MEMORY_MODE,
+        SORT_MEM_DADDR_SYMBOL = __SORT_MEMORY_MODE,
+        SORT_MEM_DADDR_DSO,
+        SORT_MEM_LOCKED,
+        SORT_MEM_TLB,
+        SORT_MEM_LVL,
+        SORT_MEM_SNOOP,
 };
 
 /*
@@ -172,7 +186,8 @@ extern struct list_head hist_entry__sort_list;
 
 int setup_sorting(void);
 extern int sort_dimension__add(const char *);
-void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
-                             const char *list_name, FILE *fp);
+void sort__setup_elide(FILE *fp);
+
+int report_parse_ignore_callees_opt(const struct option *opt, const char *arg, int unset);
 
 #endif  /* __PERF_SORT_H */
diff --git a/tools/perf/util/stat.c b/tools/perf/util/stat.c
index 23742126f47c..6506b3dfb605 100644
--- a/tools/perf/util/stat.c
+++ b/tools/perf/util/stat.c
@@ -10,6 +10,12 @@ void update_stats(struct stats *stats, u64 val)
         delta = val - stats->mean;
         stats->mean += delta / stats->n;
         stats->M2 += delta*(val - stats->mean);
+
+        if (val > stats->max)
+                stats->max = val;
+
+        if (val < stats->min)
+                stats->min = val;
 }
 
 double avg_stats(struct stats *stats)
@@ -37,7 +43,7 @@ double stddev_stats(struct stats *stats)
 {
         double variance, variance_mean;
 
-        if (!stats->n)
+        if (stats->n < 2)
                 return 0.0;
 
         variance = stats->M2 / (stats->n - 1);
diff --git a/tools/perf/util/stat.h b/tools/perf/util/stat.h
index 588367c3c767..ae8ccd7227cf 100644
--- a/tools/perf/util/stat.h
+++ b/tools/perf/util/stat.h
@@ -6,6 +6,7 @@
 struct stats
 {
         double n, mean, M2;
+        u64 max, min;
 };
 
 void update_stats(struct stats *stats, u64 val);
@@ -13,4 +14,12 @@ double avg_stats(struct stats *stats);
 double stddev_stats(struct stats *stats);
 double rel_stddev_stats(double stddev, double avg);
 
+static inline void init_stats(struct stats *stats)
+{
+        stats->n    = 0.0;
+        stats->mean = 0.0;
+        stats->M2   = 0.0;
+        stats->min  = (u64) -1;
+        stats->max  = 0;
+}
 #endif
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index 29c7b2cb2521..f0b0c008c507 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -387,3 +387,27 @@ void *memdup(const void *src, size_t len)
 
         return p;
 }
+
+/**
+ * str_append - reallocate string and append another
+ * @s: pointer to string pointer
+ * @len: pointer to len (initialized)
+ * @a: string to append.
+ */
+int str_append(char **s, int *len, const char *a)
+{
+        int olen = *s ? strlen(*s) : 0;
+        int nlen = olen + strlen(a) + 1;
+        if (*len < nlen) {
+                *len = *len * 2;
+                if (*len < nlen)
+                        *len = nlen;
+                *s = realloc(*s, *len);
+                if (!*s)
+                        return -ENOMEM;
+                if (olen == 0)
+                        **s = 0;
+        }
+        strcat(*s, a);
+        return 0;
+}
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 4b12bf850325..a9c829be5216 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -8,6 +8,22 @@
 #include "symbol.h"
 #include "debug.h"
 
+#ifndef HAVE_ELF_GETPHDRNUM
+static int elf_getphdrnum(Elf *elf, size_t *dst)
+{
+        GElf_Ehdr gehdr;
+        GElf_Ehdr *ehdr;
+
+        ehdr = gelf_getehdr(elf, &gehdr);
+        if (!ehdr)
+                return -1;
+
+        *dst = ehdr->e_phnum;
+
+        return 0;
+}
+#endif
+
 #ifndef NT_GNU_BUILD_ID
 #define NT_GNU_BUILD_ID 3
 #endif
@@ -599,11 +615,13 @@ int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
         if (dso->kernel == DSO_TYPE_USER) {
                 GElf_Shdr shdr;
                 ss->adjust_symbols = (ehdr.e_type == ET_EXEC ||
+                                ehdr.e_type == ET_REL ||
                                 elf_section_by_name(elf, &ehdr, &shdr,
                                                      ".gnu.prelink_undo",
                                                      NULL) != NULL);
         } else {
-                ss->adjust_symbols = 0;
+                ss->adjust_symbols = ehdr.e_type == ET_EXEC ||
+                                     ehdr.e_type == ET_REL;
         }
 
         ss->name   = strdup(name);
@@ -624,6 +642,37 @@ out_close:
         return err;
 }
 
+/**
+ * ref_reloc_sym_not_found - has kernel relocation symbol been found.
+ * @kmap: kernel maps and relocation reference symbol
+ *
+ * This function returns %true if we are dealing with the kernel maps and the
+ * relocation reference symbol has not yet been found.  Otherwise %false is
+ * returned.
+ */
+static bool ref_reloc_sym_not_found(struct kmap *kmap)
+{
+        return kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
+               !kmap->ref_reloc_sym->unrelocated_addr;
+}
+
+/**
+ * ref_reloc - kernel relocation offset.
+ * @kmap: kernel maps and relocation reference symbol
+ *
+ * This function returns the offset of kernel addresses as determined by using
+ * the relocation reference symbol i.e. if the kernel has not been relocated
+ * then the return value is zero.
+ */
+static u64 ref_reloc(struct kmap *kmap)
+{
+        if (kmap && kmap->ref_reloc_sym &&
+            kmap->ref_reloc_sym->unrelocated_addr)
+                return kmap->ref_reloc_sym->addr -
+                       kmap->ref_reloc_sym->unrelocated_addr;
+        return 0;
+}
+
 int dso__load_sym(struct dso *dso, struct map *map,
                   struct symsrc *syms_ss, struct symsrc *runtime_ss,
                   symbol_filter_t filter, int kmodule)
@@ -642,8 +691,17 @@ int dso__load_sym(struct dso *dso, struct map *map,
         Elf_Scn *sec, *sec_strndx;
         Elf *elf;
         int nr = 0;
+        bool remap_kernel = false, adjust_kernel_syms = false;
 
         dso->symtab_type = syms_ss->type;
+        dso->rel = syms_ss->ehdr.e_type == ET_REL;
+
+        /*
+         * Modules may already have symbols from kallsyms, but those symbols
+         * have the wrong values for the dso maps, so remove them.
+         */
+        if (kmodule && syms_ss->symtab)
+                symbols__delete(&dso->symbols[map->type]);
 
         if (!syms_ss->symtab) {
                 syms_ss->symtab  = syms_ss->dynsym;
@@ -681,7 +739,31 @@ int dso__load_sym(struct dso *dso, struct map *map,
         nr_syms = shdr.sh_size / shdr.sh_entsize;
 
         memset(&sym, 0, sizeof(sym));
-        dso->adjust_symbols = runtime_ss->adjust_symbols;
+
+        /*
+         * The kernel relocation symbol is needed in advance in order to adjust
+         * kernel maps correctly.
+         */
+        if (ref_reloc_sym_not_found(kmap)) {
+                elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
+                        const char *elf_name = elf_sym__name(&sym, symstrs);
+
+                        if (strcmp(elf_name, kmap->ref_reloc_sym->name))
+                                continue;
+                        kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
+                        break;
+                }
+        }
+
+        dso->adjust_symbols = runtime_ss->adjust_symbols || ref_reloc(kmap);
+        /*
+         * Initial kernel and module mappings do not map to the dso.  For
+         * function mappings, flag the fixups.
+         */
+        if (map->type == MAP__FUNCTION && (dso->kernel || kmodule)) {
+                remap_kernel = true;
+                adjust_kernel_syms = dso->adjust_symbols;
+        }
         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
                 struct symbol *f;
                 const char *elf_name = elf_sym__name(&sym, symstrs);
@@ -690,10 +772,6 @@ int dso__load_sym(struct dso *dso, struct map *map,
                 const char *section_name;
                 bool used_opd = false;
 
-                if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
-                    strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
-                        kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
-
                 if (!is_label && !elf_sym__is_a(&sym, map->type))
                         continue;
 
@@ -745,20 +823,55 @@ int dso__load_sym(struct dso *dso, struct map *map,
                     (sym.st_value & 1))
                         --sym.st_value;
 
-                if (dso->kernel != DSO_TYPE_USER || kmodule) {
+                if (dso->kernel || kmodule) {
                         char dso_name[PATH_MAX];
 
+                        /* Adjust symbol to map to file offset */
+                        if (adjust_kernel_syms)
+                                sym.st_value -= shdr.sh_addr - shdr.sh_offset;
+
                         if (strcmp(section_name,
                                    (curr_dso->short_name +
                                     dso->short_name_len)) == 0)
                                 goto new_symbol;
 
                         if (strcmp(section_name, ".text") == 0) {
+                                /*
+                                 * The initial kernel mapping is based on
+                                 * kallsyms and identity maps.  Overwrite it to
+                                 * map to the kernel dso.
+                                 */
+                                if (remap_kernel && dso->kernel) {
+                                        remap_kernel = false;
+                                        map->start = shdr.sh_addr +
+                                                     ref_reloc(kmap);
+                                        map->end = map->start + shdr.sh_size;
+                                        map->pgoff = shdr.sh_offset;
+                                        map->map_ip = map__map_ip;
+                                        map->unmap_ip = map__unmap_ip;
+                                        /* Ensure maps are correctly ordered */
+                                        map_groups__remove(kmap->kmaps, map);
+                                        map_groups__insert(kmap->kmaps, map);
+                                }
+
+                                /*
+                                 * The initial module mapping is based on
+                                 * /proc/modules mapped to offset zero.
+                                 * Overwrite it to map to the module dso.
+                                 */
+                                if (remap_kernel && kmodule) {
+                                        remap_kernel = false;
+                                        map->pgoff = shdr.sh_offset;
+                                }
+
                                 curr_map = map;
                                 curr_dso = dso;
                                 goto new_symbol;
                         }
 
+                        if (!kmap)
+                                goto new_symbol;
+
                         snprintf(dso_name, sizeof(dso_name),
                                  "%s%s", dso->short_name, section_name);
 
@@ -781,8 +894,16 @@ int dso__load_sym(struct dso *dso, struct map *map,
                                         dso__delete(curr_dso);
                                         goto out_elf_end;
                                 }
-                                curr_map->map_ip = identity__map_ip;
-                                curr_map->unmap_ip = identity__map_ip;
+                                if (adjust_kernel_syms) {
+                                        curr_map->start = shdr.sh_addr +
+                                                          ref_reloc(kmap);
+                                        curr_map->end = curr_map->start +
+                                                        shdr.sh_size;
+                                        curr_map->pgoff = shdr.sh_offset;
+                                } else {
+                                        curr_map->map_ip = identity__map_ip;
+                                        curr_map->unmap_ip = identity__map_ip;
+                                }
                                 curr_dso->symtab_type = dso->symtab_type;
                                 map_groups__insert(kmap->kmaps, curr_map);
                                 dsos__add(&dso->node, curr_dso);
@@ -846,6 +967,57 @@ out_elf_end:
         return err;
 }
 
+static int elf_read_maps(Elf *elf, bool exe, mapfn_t mapfn, void *data)
+{
+        GElf_Phdr phdr;
+        size_t i, phdrnum;
+        int err;
+        u64 sz;
+
+        if (elf_getphdrnum(elf, &phdrnum))
+                return -1;
+
+        for (i = 0; i < phdrnum; i++) {
+                if (gelf_getphdr(elf, i, &phdr) == NULL)
+                        return -1;
+                if (phdr.p_type != PT_LOAD)
+                        continue;
+                if (exe) {
+                        if (!(phdr.p_flags & PF_X))
+                                continue;
+                } else {
+                        if (!(phdr.p_flags & PF_R))
+                                continue;
+                }
+                sz = min(phdr.p_memsz, phdr.p_filesz);
+                if (!sz)
+                        continue;
+                err = mapfn(phdr.p_vaddr, sz, phdr.p_offset, data);
+                if (err)
+                        return err;
+        }
+        return 0;
+}
+
+int file__read_maps(int fd, bool exe, mapfn_t mapfn, void *data,
+                    bool *is_64_bit)
+{
+        int err;
+        Elf *elf;
+
+        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+        if (elf == NULL)
+                return -1;
+
+        if (is_64_bit)
+                *is_64_bit = (gelf_getclass(elf) == ELFCLASS64);
+
+        err = elf_read_maps(elf, exe, mapfn, data);
+
+        elf_end(elf);
+        return err;
+}
+
 void symbol__elf_init(void)
 {
         elf_version(EV_CURRENT);
diff --git a/tools/perf/util/symbol-minimal.c b/tools/perf/util/symbol-minimal.c
index a7390cde63bc..3a802c300fc5 100644
--- a/tools/perf/util/symbol-minimal.c
+++ b/tools/perf/util/symbol-minimal.c
@@ -301,6 +301,13 @@ int dso__load_sym(struct dso *dso, struct map *map __maybe_unused,
         return 0;
 }
 
+int file__read_maps(int fd __maybe_unused, bool exe __maybe_unused,
+                    mapfn_t mapfn __maybe_unused, void *data __maybe_unused,
+                    bool *is_64_bit __maybe_unused)
+{
+        return -1;
+}
+
 void symbol__elf_init(void)
 {
 }
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 8cf3b5426a9a..7eb0362f4ffd 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -32,7 +32,6 @@ int vmlinux_path__nr_entries;
 char **vmlinux_path;
 
 struct symbol_conf symbol_conf = {
-        .exclude_other    = true,
         .use_modules      = true,
         .try_vmlinux_path = true,
         .annotate_src     = true,
@@ -88,6 +87,7 @@ static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
 {
         s64 a;
         s64 b;
+        size_t na, nb;
 
         /* Prefer a symbol with non zero length */
         a = syma->end - syma->start;
@@ -121,11 +121,21 @@ static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
         else if (a > b)
                 return SYMBOL_B;
 
-        /* If all else fails, choose the symbol with the longest name */
-        if (strlen(syma->name) >= strlen(symb->name))
+        /* Choose the symbol with the longest name */
+        na = strlen(syma->name);
+        nb = strlen(symb->name);
+        if (na > nb)
                 return SYMBOL_A;
-        else
+        else if (na < nb)
+                return SYMBOL_B;
+
+        /* Avoid "SyS" kernel syscall aliases */
+        if (na >= 3 && !strncmp(syma->name, "SyS", 3))
+                return SYMBOL_B;
+        if (na >= 10 && !strncmp(syma->name, "compat_SyS", 10))
                 return SYMBOL_B;
+
+        return SYMBOL_A;
 }
 
 void symbols__fixup_duplicate(struct rb_root *symbols)
@@ -249,7 +259,10 @@ size_t symbol__fprintf_symname_offs(const struct symbol *sym,
         if (sym && sym->name) {
                 length = fprintf(fp, "%s", sym->name);
                 if (al) {
-                        offset = al->addr - sym->start;
+                        if (al->addr < sym->end)
+                                offset = al->addr - sym->start;
+                        else
+                                offset = al->addr - al->map->start - sym->start;
                         length += fprintf(fp, "+0x%lx", offset);
                 }
                 return length;
@@ -317,6 +330,16 @@ static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
         return NULL;
 }
 
+static struct symbol *symbols__first(struct rb_root *symbols)
+{
+        struct rb_node *n = rb_first(symbols);
+
+        if (n)
+                return rb_entry(n, struct symbol, rb_node);
+
+        return NULL;
+}
+
 struct symbol_name_rb_node {
         struct rb_node  rb_node;
         struct symbol   sym;
@@ -387,6 +410,11 @@ struct symbol *dso__find_symbol(struct dso *dso,
         return symbols__find(&dso->symbols[type], addr);
 }
 
+struct symbol *dso__first_symbol(struct dso *dso, enum map_type type)
+{
+        return symbols__first(&dso->symbols[type]);
+}
+
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
                                         const char *name)
 {
@@ -523,6 +551,53 @@ static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
         return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
 }
 
+static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map,
+                                         symbol_filter_t filter)
+{
+        struct map_groups *kmaps = map__kmap(map)->kmaps;
+        struct map *curr_map;
+        struct symbol *pos;
+        int count = 0, moved = 0;
+        struct rb_root *root = &dso->symbols[map->type];
+        struct rb_node *next = rb_first(root);
+
+        while (next) {
+                char *module;
+
+                pos = rb_entry(next, struct symbol, rb_node);
+                next = rb_next(&pos->rb_node);
+
+                module = strchr(pos->name, '\t');
+                if (module)
+                        *module = '\0';
+
+                curr_map = map_groups__find(kmaps, map->type, pos->start);
+
+                if (!curr_map || (filter && filter(curr_map, pos))) {
+                        rb_erase(&pos->rb_node, root);
+                        symbol__delete(pos);
+                } else {
+                        pos->start -= curr_map->start - curr_map->pgoff;
+                        if (pos->end)
+                                pos->end -= curr_map->start - curr_map->pgoff;
+                        if (curr_map != map) {
+                                rb_erase(&pos->rb_node, root);
+                                symbols__insert(
+                                        &curr_map->dso->symbols[curr_map->type],
+                                        pos);
+                                ++moved;
+                        } else {
+                                ++count;
+                        }
+                }
+        }
+
+        /* Symbols have been adjusted */
+        dso->adjust_symbols = 1;
+
+        return count + moved;
+}
+
 /*
  * Split the symbols into maps, making sure there are no overlaps, i.e. the
  * kernel range is broken in several maps, named [kernel].N, as we don't have
@@ -664,6 +739,161 @@ bool symbol__restricted_filename(const char *filename,
         return restricted;
 }
 
+struct kcore_mapfn_data {
+        struct dso *dso;
+        enum map_type type;
+        struct list_head maps;
+};
+
+static int kcore_mapfn(u64 start, u64 len, u64 pgoff, void *data)
+{
+        struct kcore_mapfn_data *md = data;
+        struct map *map;
+
+        map = map__new2(start, md->dso, md->type);
+        if (map == NULL)
+                return -ENOMEM;
+
+        map->end = map->start + len;
+        map->pgoff = pgoff;
+
+        list_add(&map->node, &md->maps);
+
+        return 0;
+}
+
+/*
+ * If kallsyms is referenced by name then we look for kcore in the same
+ * directory.
+ */
+static bool kcore_filename_from_kallsyms_filename(char *kcore_filename,
+                                                  const char *kallsyms_filename)
+{
+        char *name;
+
+        strcpy(kcore_filename, kallsyms_filename);
+        name = strrchr(kcore_filename, '/');
+        if (!name)
+                return false;
+
+        if (!strcmp(name, "/kallsyms")) {
+                strcpy(name, "/kcore");
+                return true;
+        }
+
+        return false;
+}
+
+static int dso__load_kcore(struct dso *dso, struct map *map,
+                           const char *kallsyms_filename)
+{
+        struct map_groups *kmaps = map__kmap(map)->kmaps;
+        struct machine *machine = kmaps->machine;
+        struct kcore_mapfn_data md;
+        struct map *old_map, *new_map, *replacement_map = NULL;
+        bool is_64_bit;
+        int err, fd;
+        char kcore_filename[PATH_MAX];
+        struct symbol *sym;
+
+        /* This function requires that the map is the kernel map */
+        if (map != machine->vmlinux_maps[map->type])
+                return -EINVAL;
+
+        if (!kcore_filename_from_kallsyms_filename(kcore_filename,
+                                                   kallsyms_filename))
+                return -EINVAL;
+
+        md.dso = dso;
+        md.type = map->type;
+        INIT_LIST_HEAD(&md.maps);
+
+        fd = open(kcore_filename, O_RDONLY);
+        if (fd < 0)
+                return -EINVAL;
+
+        /* Read new maps into temporary lists */
+        err = file__read_maps(fd, md.type == MAP__FUNCTION, kcore_mapfn, &md,
+                              &is_64_bit);
+        if (err)
+                goto out_err;
+
+        if (list_empty(&md.maps)) {
+                err = -EINVAL;
+                goto out_err;
+        }
+
+        /* Remove old maps */
+        old_map = map_groups__first(kmaps, map->type);
+        while (old_map) {
+                struct map *next = map_groups__next(old_map);
+
+                if (old_map != map)
+                        map_groups__remove(kmaps, old_map);
+                old_map = next;
+        }
+
+        /* Find the kernel map using the first symbol */
+        sym = dso__first_symbol(dso, map->type);
+        list_for_each_entry(new_map, &md.maps, node) {
+                if (sym && sym->start >= new_map->start &&
+                    sym->start < new_map->end) {
+                        replacement_map = new_map;
+                        break;
+                }
+        }
+
+        if (!replacement_map)
+                replacement_map = list_entry(md.maps.next, struct map, node);
+
+        /* Add new maps */
+        while (!list_empty(&md.maps)) {
+                new_map = list_entry(md.maps.next, struct map, node);
+                list_del(&new_map->node);
+                if (new_map == replacement_map) {
+                        map->start      = new_map->start;
+                        map->end        = new_map->end;
+                        map->pgoff      = new_map->pgoff;
+                        map->map_ip     = new_map->map_ip;
+                        map->unmap_ip   = new_map->unmap_ip;
+                        map__delete(new_map);
+                        /* Ensure maps are correctly ordered */
+                        map_groups__remove(kmaps, map);
+                        map_groups__insert(kmaps, map);
+                } else {
+                        map_groups__insert(kmaps, new_map);
+                }
+        }
+
+        /*
+         * Set the data type and long name so that kcore can be read via
+         * dso__data_read_addr().
+         */
+        if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
+                dso->data_type = DSO_BINARY_TYPE__GUEST_KCORE;
+        else
+                dso->data_type = DSO_BINARY_TYPE__KCORE;
+        dso__set_long_name(dso, strdup(kcore_filename));
+
+        close(fd);
+
+        if (map->type == MAP__FUNCTION)
+                pr_debug("Using %s for kernel object code\n", kcore_filename);
+        else
+                pr_debug("Using %s for kernel data\n", kcore_filename);
+
+        return 0;
+
+out_err:
+        while (!list_empty(&md.maps)) {
+                map = list_entry(md.maps.next, struct map, node);
+                list_del(&map->node);
+                map__delete(map);
+        }
+        close(fd);
+        return -EINVAL;
+}
+
 int dso__load_kallsyms(struct dso *dso, const char *filename,
                        struct map *map, symbol_filter_t filter)
 {
@@ -681,7 +911,10 @@ int dso__load_kallsyms(struct dso *dso, const char *filename,
         else
                 dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
 
-        return dso__split_kallsyms(dso, map, filter);
+        if (!dso__load_kcore(dso, map, filename))
+                return dso__split_kallsyms_for_kcore(dso, map, filter);
+        else
+                return dso__split_kallsyms(dso, map, filter);
 }
 
 static int dso__load_perf_map(struct dso *dso, struct map *map,
@@ -844,10 +1077,15 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
         if (!runtime_ss && syms_ss)
                 runtime_ss = syms_ss;
 
-        if (syms_ss)
-                ret = dso__load_sym(dso, map, syms_ss, runtime_ss, filter, 0);
-        else
+        if (syms_ss) {
+                int km;
+
+                km = dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
+                     dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE;
+                ret = dso__load_sym(dso, map, syms_ss, runtime_ss, filter, km);
+        } else {
                 ret = -1;
+        }
 
         if (ret > 0) {
                 int nr_plt;
@@ -889,8 +1127,11 @@ int dso__load_vmlinux(struct dso *dso, struct map *map,
         char symfs_vmlinux[PATH_MAX];
         enum dso_binary_type symtab_type;
 
-        snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
-                 symbol_conf.symfs, vmlinux);
+        if (vmlinux[0] == '/')
+                snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s", vmlinux);
+        else
+                snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
+                         symbol_conf.symfs, vmlinux);
 
         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
                 symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
@@ -904,6 +1145,10 @@ int dso__load_vmlinux(struct dso *dso, struct map *map,
         symsrc__destroy(&ss);
 
         if (err > 0) {
+                if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
+                        dso->data_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
+                else
+                        dso->data_type = DSO_BINARY_TYPE__VMLINUX;
                 dso__set_long_name(dso, (char *)vmlinux);
                 dso__set_loaded(dso, map->type);
                 pr_debug("Using %s for symbols\n", symfs_vmlinux);
@@ -976,7 +1221,7 @@ static int dso__load_kernel_sym(struct dso *dso, struct map *map,
                         dso__set_long_name(dso,
                                            strdup(symbol_conf.vmlinux_name));
                         dso->lname_alloc = 1;
-                        goto out_fixup;
+                        return err;
                 }
                 return err;
         }
@@ -984,7 +1229,7 @@ static int dso__load_kernel_sym(struct dso *dso, struct map *map,
         if (vmlinux_path != NULL) {
                 err = dso__load_vmlinux_path(dso, map, filter);
                 if (err > 0)
-                        goto out_fixup;
+                        return err;
         }
 
         /* do not try local files if a symfs was given */
@@ -1043,9 +1288,8 @@ do_kallsyms:
                 pr_debug("Using %s for symbols\n", kallsyms_filename);
         free(kallsyms_allocated_filename);
 
-        if (err > 0) {
+        if (err > 0 && !dso__is_kcore(dso)) {
                 dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
-out_fixup:
                 map__fixup_start(map);
                 map__fixup_end(map);
         }
@@ -1076,7 +1320,7 @@ static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
                 if (symbol_conf.default_guest_vmlinux_name != NULL) {
                         err = dso__load_vmlinux(dso, map,
                                 symbol_conf.default_guest_vmlinux_name, filter);
-                        goto out_try_fixup;
+                        return err;
                 }
 
                 kallsyms_filename = symbol_conf.default_guest_kallsyms;
@@ -1090,13 +1334,9 @@ static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
         err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
         if (err > 0)
                 pr_debug("Using %s for symbols\n", kallsyms_filename);
-
-out_try_fixup:
-        if (err > 0) {
-                if (kallsyms_filename != NULL) {
-                        machine__mmap_name(machine, path, sizeof(path));
-                        dso__set_long_name(dso, strdup(path));
-                }
+        if (err > 0 && !dso__is_kcore(dso)) {
+                machine__mmap_name(machine, path, sizeof(path));
+                dso__set_long_name(dso, strdup(path));
                 map__fixup_start(map);
                 map__fixup_end(map);
         }
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 5f720dc076da..fd5b70ea2981 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -215,6 +215,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 *dso__first_symbol(struct dso *dso, enum map_type type);
 
 int filename__read_build_id(const char *filename, void *bf, size_t size);
 int sysfs__read_build_id(const char *filename, void *bf, size_t size);
@@ -247,4 +248,8 @@ void symbols__fixup_duplicate(struct rb_root *symbols);
 void symbols__fixup_end(struct rb_root *symbols);
 void __map_groups__fixup_end(struct map_groups *mg, enum map_type type);
 
+typedef int (*mapfn_t)(u64 start, u64 len, u64 pgoff, void *data);
+int file__read_maps(int fd, bool exe, mapfn_t mapfn, void *data,
+                    bool *is_64_bit);
+
 #endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 632e40e5ceca..e3d4a550a703 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -7,16 +7,18 @@
 #include "util.h"
 #include "debug.h"
 
-struct thread *thread__new(pid_t pid)
+struct thread *thread__new(pid_t pid, pid_t tid)
 {
         struct thread *self = zalloc(sizeof(*self));
 
         if (self != NULL) {
                 map_groups__init(&self->mg);
-                self->pid = pid;
+                self->pid_ = pid;
+                self->tid = tid;
+                self->ppid = -1;
                 self->comm = malloc(32);
                 if (self->comm)
-                        snprintf(self->comm, 32, ":%d", self->pid);
+                        snprintf(self->comm, 32, ":%d", self->tid);
         }
 
         return self;
@@ -56,7 +58,7 @@ int thread__comm_len(struct thread *self)
 
 size_t thread__fprintf(struct thread *thread, FILE *fp)
 {
-        return fprintf(fp, "Thread %d %s\n", thread->pid, thread->comm) +
+        return fprintf(fp, "Thread %d %s\n", thread->tid, thread->comm) +
                map_groups__fprintf(&thread->mg, verbose, fp);
 }
 
@@ -82,5 +84,8 @@ int thread__fork(struct thread *self, struct thread *parent)
         for (i = 0; i < MAP__NR_TYPES; ++i)
                 if (map_groups__clone(&self->mg, &parent->mg, i) < 0)
                         return -ENOMEM;
+
+        self->ppid = parent->tid;
+
         return 0;
 }
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 5ad266403098..4ebbb40d46d4 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -12,9 +12,12 @@ struct thread {
                 struct list_head node;
         };
         struct map_groups       mg;
-        pid_t                   pid;
+        pid_t                   pid_; /* Not all tools update this */
+        pid_t                   tid;
+        pid_t                   ppid;
         char                    shortname[3];
         bool                    comm_set;
+        bool                    dead; /* if set thread has exited */
         char                    *comm;
         int                     comm_len;
 
@@ -23,8 +26,12 @@ struct thread {
 
 struct machine;
 
-struct thread *thread__new(pid_t pid);
+struct thread *thread__new(pid_t pid, pid_t tid);
 void thread__delete(struct thread *self);
+static inline void thread__exited(struct thread *thread)
+{
+        thread->dead = true;
+}
 
 int thread__set_comm(struct thread *self, const char *comm);
 int thread__comm_len(struct thread *self);
@@ -44,6 +51,15 @@ void thread__find_addr_map(struct thread *thread, struct machine *machine,
 
 void thread__find_addr_location(struct thread *thread, struct machine *machine,
                                 u8 cpumode, enum map_type type, u64 addr,
-                                struct addr_location *al,
-                                symbol_filter_t filter);
+                                struct addr_location *al);
+
+static inline void *thread__priv(struct thread *thread)
+{
+        return thread->priv;
+}
+
+static inline void thread__set_priv(struct thread *thread, void *p)
+{
+        thread->priv = p;
+}
 #endif  /* __PERF_THREAD_H */
diff --git a/tools/perf/util/tool.h b/tools/perf/util/tool.h
index b0e1aadba8d5..4385816d3d49 100644
--- a/tools/perf/util/tool.h
+++ b/tools/perf/util/tool.h
@@ -18,12 +18,9 @@ typedef int (*event_sample)(struct perf_tool *tool, union perf_event *event,
 typedef int (*event_op)(struct perf_tool *tool, union perf_event *event,
                         struct perf_sample *sample, struct machine *machine);
 
-typedef int (*event_attr_op)(union perf_event *event,
+typedef int (*event_attr_op)(struct perf_tool *tool,
+                             union perf_event *event,
                              struct perf_evlist **pevlist);
-typedef int (*event_simple_op)(struct perf_tool *tool, union perf_event *event);
-
-typedef int (*event_synth_op)(union perf_event *event,
-                              struct perf_session *session);
 
 typedef int (*event_op2)(struct perf_tool *tool, union perf_event *event,
                          struct perf_session *session);
@@ -32,6 +29,7 @@ struct perf_tool {
         event_sample    sample,
                         read;
         event_op        mmap,
+                        mmap2,
                         comm,
                         fork,
                         exit,
@@ -39,8 +37,7 @@ struct perf_tool {
                         throttle,
                         unthrottle;
         event_attr_op   attr;
-        event_synth_op  tracing_data;
-        event_simple_op event_type;
+        event_op2       tracing_data;
         event_op2       finished_round,
                         build_id;
         bool            ordered_samples;
diff --git a/tools/perf/util/top.c b/tools/perf/util/top.c
index 54d37a4753c5..f857b51b6bde 100644
--- a/tools/perf/util/top.c
+++ b/tools/perf/util/top.c
@@ -23,20 +23,31 @@
 
 size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
 {
-        float samples_per_sec = top->samples / top->delay_secs;
-        float ksamples_per_sec = top->kernel_samples / top->delay_secs;
-        float esamples_percent = (100.0 * top->exact_samples) / top->samples;
+        float samples_per_sec;
+        float ksamples_per_sec;
+        float esamples_percent;
         struct perf_record_opts *opts = &top->record_opts;
         struct perf_target *target = &opts->target;
         size_t ret = 0;
 
+        if (top->samples) {
+                samples_per_sec = top->samples / top->delay_secs;
+                ksamples_per_sec = top->kernel_samples / top->delay_secs;
+                esamples_percent = (100.0 * top->exact_samples) / top->samples;
+        } else {
+                samples_per_sec = ksamples_per_sec = esamples_percent = 0.0;
+        }
+
         if (!perf_guest) {
+                float ksamples_percent = 0.0;
+
+                if (samples_per_sec)
+                        ksamples_percent = (100.0 * ksamples_per_sec) /
+                                                        samples_per_sec;
                 ret = SNPRINTF(bf, size,
                                "   PerfTop:%8.0f irqs/sec  kernel:%4.1f%%"
                                "  exact: %4.1f%% [", samples_per_sec,
-                               100.0 - (100.0 * ((samples_per_sec - ksamples_per_sec) /
-                                        samples_per_sec)),
-                                esamples_percent);
+                               ksamples_percent, esamples_percent);
         } else {
                 float us_samples_per_sec = top->us_samples / top->delay_secs;
                 float guest_kernel_samples_per_sec = top->guest_kernel_samples / top->delay_secs;
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index 7ebf357dc9e1..b554ffc462b6 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -26,7 +26,6 @@ struct perf_top {
         int                print_entries, count_filter, delay_secs;
         bool               hide_kernel_symbols, hide_user_symbols, zero;
         bool               use_tui, use_stdio;
-        bool               sort_has_symbols;
         bool               kptr_restrict_warned;
         bool               vmlinux_warned;
         bool               dump_symtab;
@@ -37,8 +36,11 @@ struct perf_top {
         int                realtime_prio;
         int                sym_pcnt_filter;
         const char         *sym_filter;
+        float              min_percent;
 };
 
+#define CONSOLE_CLEAR ""
+
 size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size);
 void perf_top__reset_sample_counters(struct perf_top *top);
 #endif /* __PERF_TOP_H */
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 3917eb9a8479..f3c9e551bd35 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -46,65 +46,6 @@
 static int output_fd;
 
 
-static const char *find_debugfs(void)
-{
-        const char *path = perf_debugfs_mount(NULL);
-
-        if (!path)
-                pr_debug("Your kernel does not support the debugfs filesystem");
-
-        return path;
-}
-
-/*
- * Finds the path to the debugfs/tracing
- * Allocates the string and stores it.
- */
-static const char *find_tracing_dir(void)
-{
-        static char *tracing;
-        static int tracing_found;
-        const char *debugfs;
-
-        if (tracing_found)
-                return tracing;
-
-        debugfs = find_debugfs();
-        if (!debugfs)
-                return NULL;
-
-        tracing = malloc(strlen(debugfs) + 9);
-        if (!tracing)
-                return NULL;
-
-        sprintf(tracing, "%s/tracing", debugfs);
-
-        tracing_found = 1;
-        return tracing;
-}
-
-static char *get_tracing_file(const char *name)
-{
-        const char *tracing;
-        char *file;
-
-        tracing = find_tracing_dir();
-        if (!tracing)
-                return NULL;
-
-        file = malloc(strlen(tracing) + strlen(name) + 2);
-        if (!file)
-                return NULL;
-
-        sprintf(file, "%s/%s", tracing, name);
-        return file;
-}
-
-static void put_tracing_file(char *file)
-{
-        free(file);
-}
-
 int bigendian(void)
 {
         unsigned char str[] = { 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0};
@@ -160,7 +101,7 @@ out:
         return err;
 }
 
-static int read_header_files(void)
+static int record_header_files(void)
 {
         char *path;
         struct stat st;
@@ -299,7 +240,7 @@ out:
         return err;
 }
 
-static int read_ftrace_files(struct tracepoint_path *tps)
+static int record_ftrace_files(struct tracepoint_path *tps)
 {
         char *path;
         int ret;
@@ -328,7 +269,7 @@ static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
         return false;
 }
 
-static int read_event_files(struct tracepoint_path *tps)
+static int record_event_files(struct tracepoint_path *tps)
 {
         struct dirent *dent;
         struct stat st;
@@ -403,7 +344,7 @@ out:
         return err;
 }
 
-static int read_proc_kallsyms(void)
+static int record_proc_kallsyms(void)
 {
         unsigned int size;
         const char *path = "/proc/kallsyms";
@@ -421,7 +362,7 @@ static int read_proc_kallsyms(void)
         return record_file(path, 4);
 }
 
-static int read_ftrace_printk(void)
+static int record_ftrace_printk(void)
 {
         unsigned int size;
         char *path;
@@ -473,12 +414,27 @@ get_tracepoints_path(struct list_head *pattrs)
                 if (pos->attr.type != PERF_TYPE_TRACEPOINT)
                         continue;
                 ++nr_tracepoints;
+
+                if (pos->name) {
+                        ppath->next = tracepoint_name_to_path(pos->name);
+                        if (ppath->next)
+                                goto next;
+
+                        if (strchr(pos->name, ':') == NULL)
+                                goto try_id;
+
+                        goto error;
+                }
+
+try_id:
                 ppath->next = tracepoint_id_to_path(pos->attr.config);
                 if (!ppath->next) {
+error:
                         pr_debug("No memory to alloc tracepoints list\n");
                         put_tracepoints_path(&path);
                         return NULL;
                 }
+next:
                 ppath = ppath->next;
         }
 
@@ -520,8 +476,6 @@ static int tracing_data_header(void)
         else
                 buf[0] = 0;
 
-        read_trace_init(buf[0], buf[0]);
-
         if (write(output_fd, buf, 1) != 1)
                 return -1;
 
@@ -583,19 +537,19 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
         err = tracing_data_header();
         if (err)
                 goto out;
-        err = read_header_files();
+        err = record_header_files();
         if (err)
                 goto out;
-        err = read_ftrace_files(tps);
+        err = record_ftrace_files(tps);
         if (err)
                 goto out;
-        err = read_event_files(tps);
+        err = record_event_files(tps);
         if (err)
                 goto out;
-        err = read_proc_kallsyms();
+        err = record_proc_kallsyms();
         if (err)
                 goto out;
-        err = read_ftrace_printk();
+        err = record_ftrace_printk();
 
 out:
         /*
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 4454835a9ebc..e9e1c03f927d 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -28,12 +28,6 @@
 #include "util.h"
 #include "trace-event.h"
 
-int header_page_size_size;
-int header_page_ts_size;
-int header_page_data_offset;
-
-bool latency_format;
-
 struct pevent *read_trace_init(int file_bigendian, int host_bigendian)
 {
         struct pevent *pevent = pevent_alloc();
@@ -192,7 +186,7 @@ void parse_proc_kallsyms(struct pevent *pevent,
         char *next = NULL;
         char *addr_str;
         char *mod;
-        char *fmt;
+        char *fmt = NULL;
 
         line = strtok_r(file, "\n", &next);
         while (line) {
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index af215c0d2379..f2112270c663 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -39,10 +39,6 @@
 
 static int input_fd;
 
-int file_bigendian;
-int host_bigendian;
-static int long_size;
-
 static ssize_t trace_data_size;
 static bool repipe;
 
@@ -216,7 +212,7 @@ static int read_ftrace_printk(struct pevent *pevent)
 static int read_header_files(struct pevent *pevent)
 {
         unsigned long long size;
-        char *header_event;
+        char *header_page;
         char buf[BUFSIZ];
         int ret = 0;
 
@@ -229,13 +225,26 @@ static int read_header_files(struct pevent *pevent)
         }
 
         size = read8(pevent);
-        skip(size);
 
-        /*
-         * The size field in the page is of type long,
-         * use that instead, since it represents the kernel.
-         */
-        long_size = header_page_size_size;
+        header_page = malloc(size);
+        if (header_page == NULL)
+                return -1;
+
+        if (do_read(header_page, size) < 0) {
+                pr_debug("did not read header page");
+                free(header_page);
+                return -1;
+        }
+
+        if (!pevent_parse_header_page(pevent, header_page, size,
+                                      pevent_get_long_size(pevent))) {
+                /*
+                 * The commit field in the page is of type long,
+                 * use that instead, since it represents the kernel.
+                 */
+                pevent_set_long_size(pevent, pevent->header_page_size_size);
+        }
+        free(header_page);
 
         if (do_read(buf, 13) < 0)
                 return -1;
@@ -246,14 +255,8 @@ static int read_header_files(struct pevent *pevent)
         }
 
         size = read8(pevent);
-        header_event = malloc(size);
-        if (header_event == NULL)
-                return -1;
-
-        if (do_read(header_event, size) < 0)
-                ret = -1;
+        skip(size);
 
-        free(header_event);
         return ret;
 }
 
@@ -349,6 +352,10 @@ ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
         int show_funcs = 0;
         int show_printk = 0;
         ssize_t size = -1;
+        int file_bigendian;
+        int host_bigendian;
+        int file_long_size;
+        int file_page_size;
         struct pevent *pevent;
         int err;
 
@@ -391,12 +398,15 @@ ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
 
         if (do_read(buf, 1) < 0)
                 goto out;
-        long_size = buf[0];
+        file_long_size = buf[0];
 
-        page_size = read4(pevent);
-        if (!page_size)
+        file_page_size = read4(pevent);
+        if (!file_page_size)
                 goto out;
 
+        pevent_set_long_size(pevent, file_long_size);
+        pevent_set_page_size(pevent, file_page_size);
+
         err = read_header_files(pevent);
         if (err)
                 goto out;
diff --git a/tools/perf/util/trace-event-scripting.c b/tools/perf/util/trace-event-scripting.c
index 8715a1006d00..95199e4eea97 100644
--- a/tools/perf/util/trace-event-scripting.c
+++ b/tools/perf/util/trace-event-scripting.c
@@ -39,7 +39,8 @@ static void process_event_unsupported(union perf_event *event __maybe_unused,
                                       struct perf_sample *sample __maybe_unused,
                                       struct perf_evsel *evsel __maybe_unused,
                                       struct machine *machine __maybe_unused,
-                                      struct addr_location *al __maybe_unused)
+                                      struct thread *thread __maybe_unused,
+                                          struct addr_location *al __maybe_unused)
 {
 }
 
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 1978c398ad87..fafe1a40444a 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -1,32 +1,18 @@
 #ifndef _PERF_UTIL_TRACE_EVENT_H
 #define _PERF_UTIL_TRACE_EVENT_H
 
+#include <traceevent/event-parse.h>
 #include "parse-events.h"
-#include "event-parse.h"
 #include "session.h"
 
 struct machine;
 struct perf_sample;
 union perf_event;
 struct perf_tool;
+struct thread;
 
-extern int header_page_size_size;
-extern int header_page_ts_size;
-extern int header_page_data_offset;
-
-extern bool latency_format;
 extern struct pevent *perf_pevent;
 
-enum {
-        RINGBUF_TYPE_PADDING            = 29,
-        RINGBUF_TYPE_TIME_EXTEND        = 30,
-        RINGBUF_TYPE_TIME_STAMP         = 31,
-};
-
-#ifndef TS_SHIFT
-#define TS_SHIFT                27
-#endif
-
 int bigendian(void);
 
 struct pevent *read_trace_init(int file_bigendian, int host_bigendian);
@@ -83,7 +69,8 @@ struct scripting_ops {
                                struct perf_sample *sample,
                                struct perf_evsel *evsel,
                                struct machine *machine,
-                               struct addr_location *al);
+                               struct thread *thread,
+                                   struct addr_location *al);
         int (*generate_script) (struct pevent *pevent, const char *outfile);
 };
 
diff --git a/tools/perf/util/unwind.c b/tools/perf/util/unwind.c
index 958723ba3d2e..2f891f7e70bf 100644
--- a/tools/perf/util/unwind.c
+++ b/tools/perf/util/unwind.c
@@ -473,7 +473,7 @@ static int entry(u64 ip, struct thread *thread, struct machine *machine,
 
         thread__find_addr_location(thread, machine,
                                    PERF_RECORD_MISC_USER,
-                                   MAP__FUNCTION, ip, &al, NULL);
+                                   MAP__FUNCTION, ip, &al);
 
         e.ip = ip;
         e.map = al.map;
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 59d868add275..6d17b18e915d 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -269,3 +269,95 @@ void perf_debugfs_set_path(const char *mntpt)
         snprintf(debugfs_mountpoint, strlen(debugfs_mountpoint), "%s", mntpt);
         set_tracing_events_path(mntpt);
 }
+
+static const char *find_debugfs(void)
+{
+        const char *path = perf_debugfs_mount(NULL);
+
+        if (!path)
+                fprintf(stderr, "Your kernel does not support the debugfs filesystem");
+
+        return path;
+}
+
+/*
+ * Finds the path to the debugfs/tracing
+ * Allocates the string and stores it.
+ */
+const char *find_tracing_dir(void)
+{
+        static char *tracing;
+        static int tracing_found;
+        const char *debugfs;
+
+        if (tracing_found)
+                return tracing;
+
+        debugfs = find_debugfs();
+        if (!debugfs)
+                return NULL;
+
+        tracing = malloc(strlen(debugfs) + 9);
+        if (!tracing)
+                return NULL;
+
+        sprintf(tracing, "%s/tracing", debugfs);
+
+        tracing_found = 1;
+        return tracing;
+}
+
+char *get_tracing_file(const char *name)
+{
+        const char *tracing;
+        char *file;
+
+        tracing = find_tracing_dir();
+        if (!tracing)
+                return NULL;
+
+        file = malloc(strlen(tracing) + strlen(name) + 2);
+        if (!file)
+                return NULL;
+
+        sprintf(file, "%s/%s", tracing, name);
+        return file;
+}
+
+void put_tracing_file(char *file)
+{
+        free(file);
+}
+
+int parse_nsec_time(const char *str, u64 *ptime)
+{
+        u64 time_sec, time_nsec;
+        char *end;
+
+        time_sec = strtoul(str, &end, 10);
+        if (*end != '.' && *end != '\0')
+                return -1;
+
+        if (*end == '.') {
+                int i;
+                char nsec_buf[10];
+
+                if (strlen(++end) > 9)
+                        return -1;
+
+                strncpy(nsec_buf, end, 9);
+                nsec_buf[9] = '\0';
+
+                /* make it nsec precision */
+                for (i = strlen(nsec_buf); i < 9; i++)
+                        nsec_buf[i] = '0';
+
+                time_nsec = strtoul(nsec_buf, &end, 10);
+                if (*end != '\0')
+                        return -1;
+        } else
+                time_nsec = 0;
+
+        *ptime = time_sec * NSEC_PER_SEC + time_nsec;
+        return 0;
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index a45710b70a55..a53535949043 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -72,6 +72,7 @@
 #include "types.h"
 #include <sys/ttydefaults.h>
 #include <lk/debugfs.h>
+#include <termios.h>
 
 extern const char *graph_line;
 extern const char *graph_dotted_line;
@@ -79,6 +80,9 @@ extern char buildid_dir[];
 extern char tracing_events_path[];
 extern void perf_debugfs_set_path(const char *mountpoint);
 const char *perf_debugfs_mount(const char *mountpoint);
+const char *find_tracing_dir(void);
+char *get_tracing_file(const char *name);
+void put_tracing_file(char *file);
 
 /* On most systems <limits.h> would have given us this, but
  * not on some systems (e.g. GNU/Hurd).
@@ -204,6 +208,8 @@ static inline int has_extension(const char *filename, const char *ext)
 #define NSEC_PER_MSEC   1000000L
 #endif
 
+int parse_nsec_time(const char *str, u64 *ptime);
+
 extern unsigned char sane_ctype[256];
 #define GIT_SPACE               0x01
 #define GIT_DIGIT               0x02
@@ -221,8 +227,8 @@ extern unsigned char sane_ctype[256];
 #define isalpha(x) sane_istest(x,GIT_ALPHA)
 #define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
 #define isprint(x) sane_istest(x,GIT_PRINT)
-#define islower(x) (sane_istest(x,GIT_ALPHA) && sane_istest(x,0x20))
-#define isupper(x) (sane_istest(x,GIT_ALPHA) && !sane_istest(x,0x20))
+#define islower(x) (sane_istest(x,GIT_ALPHA) && (x & 0x20))
+#define isupper(x) (sane_istest(x,GIT_ALPHA) && !(x & 0x20))
 #define tolower(x) sane_case((unsigned char)(x), 0x20)
 #define toupper(x) sane_case((unsigned char)(x), 0)
 
@@ -274,6 +280,5 @@ void dump_stack(void);
 
 extern unsigned int page_size;
 
-struct winsize;
 void get_term_dimensions(struct winsize *ws);
 #endif /* GIT_COMPAT_UTIL_H */
diff --git a/tools/perf/util/vdso.c b/tools/perf/util/vdso.c
index e60951fcdb12..39159822d58f 100644
--- a/tools/perf/util/vdso.c
+++ b/tools/perf/util/vdso.c
@@ -91,7 +91,7 @@ void vdso__exit(void)
 
 struct dso *vdso__dso_findnew(struct list_head *head)
 {
-        struct dso *dso = dsos__find(head, VDSO__MAP_NAME);
+        struct dso *dso = dsos__find(head, VDSO__MAP_NAME, true);
 
         if (!dso) {
                 char *file;
diff --git a/tools/power/cpupower/Makefile b/tools/power/cpupower/Makefile
index d875a74a3bdf..cbfec92af327 100644
--- a/tools/power/cpupower/Makefile
+++ b/tools/power/cpupower/Makefile
@@ -128,10 +128,12 @@ UTIL_OBJS =  utils/helpers/amd.o utils/helpers/topology.o utils/helpers/msr.o \
         utils/helpers/sysfs.o utils/helpers/misc.o utils/helpers/cpuid.o \
         utils/helpers/pci.o utils/helpers/bitmask.o \
         utils/idle_monitor/nhm_idle.o utils/idle_monitor/snb_idle.o \
+        utils/idle_monitor/hsw_ext_idle.o \
         utils/idle_monitor/amd_fam14h_idle.o utils/idle_monitor/cpuidle_sysfs.o \
         utils/idle_monitor/mperf_monitor.o utils/idle_monitor/cpupower-monitor.o \
         utils/cpupower.o utils/cpufreq-info.o utils/cpufreq-set.o \
-        utils/cpupower-set.o utils/cpupower-info.o utils/cpuidle-info.o
+        utils/cpupower-set.o utils/cpupower-info.o utils/cpuidle-info.o \
+        utils/cpuidle-set.o
 
 UTIL_SRC := $(UTIL_OBJS:.o=.c)
 
diff --git a/tools/power/cpupower/man/cpupower-monitor.1 b/tools/power/cpupower/man/cpupower-monitor.1
index e01c35d13b6e..914cbb9d9cd0 100644
--- a/tools/power/cpupower/man/cpupower-monitor.1
+++ b/tools/power/cpupower/man/cpupower-monitor.1
@@ -110,13 +110,21 @@ May work poorly on Linux-2.6.20 through 2.6.29, as the \fBacpi-cpufreq \fP
 kernel frequency driver periodically cleared aperf/mperf registers in those
 kernels.
 
-.SS "Nehalem" "SandyBridge"
+.SS "Nehalem" "SandyBridge" "HaswellExtended"
 Intel Core and Package sleep state counters.
 Threads (hyperthreaded cores) may not be able to enter deeper core states if
 its sibling is utilized.
 Deepest package sleep states may in reality show up as machine/platform wide
 sleep states and can only be entered if all cores are idle. Look up Intel
 manuals (some are provided in the References section) for further details.
+The monitors are named after the CPU family where the sleep state capabilities
+got introduced and may not match exactly the CPU name of the platform.
+For example an IvyBridge processor has sleep state capabilities which got
+introduced in Nehalem and SandyBridge processor families.
+Thus on an IvyBridge processor one will get Nehalem and SandyBridge sleep
+state monitors.
+HaswellExtended extra package sleep state capabilities are available only in a
+specific Haswell (family 0x45) and probably also other future processors.
 
 .SS "Fam_12h" "Fam_14h"
 AMD laptop and desktop processor (family 12h and 14h) sleep state counters.
diff --git a/tools/power/cpupower/utils/builtin.h b/tools/power/cpupower/utils/builtin.h
index c10496fbe3c6..2284c8ea4e2a 100644
--- a/tools/power/cpupower/utils/builtin.h
+++ b/tools/power/cpupower/utils/builtin.h
@@ -5,6 +5,7 @@ extern int cmd_set(int argc, const char **argv);
 extern int cmd_info(int argc, const char **argv);
 extern int cmd_freq_set(int argc, const char **argv);
 extern int cmd_freq_info(int argc, const char **argv);
+extern int cmd_idle_set(int argc, const char **argv);
 extern int cmd_idle_info(int argc, const char **argv);
 extern int cmd_monitor(int argc, const char **argv);
 
diff --git a/tools/power/cpupower/utils/cpuidle-info.c b/tools/power/cpupower/utils/cpuidle-info.c
index 8145af5f93a6..75e66de7e7a7 100644
--- a/tools/power/cpupower/utils/cpuidle-info.c
+++ b/tools/power/cpupower/utils/cpuidle-info.c
@@ -22,7 +22,7 @@
 
 static void cpuidle_cpu_output(unsigned int cpu, int verbose)
 {
-        int idlestates, idlestate;
+        unsigned int idlestates, idlestate;
         char *tmp;
 
         printf(_ ("Analyzing CPU %d:\n"), cpu);
@@ -31,10 +31,8 @@ static void cpuidle_cpu_output(unsigned int cpu, int verbose)
         if (idlestates == 0) {
                 printf(_("CPU %u: No idle states\n"), cpu);
                 return;
-        } else if (idlestates <= 0) {
-                printf(_("CPU %u: Can't read idle state info\n"), cpu);
-                return;
         }
+
         printf(_("Number of idle states: %d\n"), idlestates);
         printf(_("Available idle states:"));
         for (idlestate = 0; idlestate < idlestates; idlestate++) {
@@ -50,10 +48,14 @@ static void cpuidle_cpu_output(unsigned int cpu, int verbose)
                 return;
 
         for (idlestate = 0; idlestate < idlestates; idlestate++) {
+                int disabled = sysfs_is_idlestate_disabled(cpu, idlestate);
+                /* Disabled interface not supported on older kernels */
+                if (disabled < 0)
+                        disabled = 0;
                 tmp = sysfs_get_idlestate_name(cpu, idlestate);
                 if (!tmp)
                         continue;
-                printf("%s:\n", tmp);
+                printf("%s%s:\n", tmp, (disabled) ? " (DISABLED) " : "");
                 free(tmp);
 
                 tmp = sysfs_get_idlestate_desc(cpu, idlestate);
@@ -98,21 +100,13 @@ static void cpuidle_general_output(void)
 static void proc_cpuidle_cpu_output(unsigned int cpu)
 {
         long max_allowed_cstate = 2000000000;
-        int cstates, cstate;
+        unsigned int cstate, cstates;
 
         cstates = sysfs_get_idlestate_count(cpu);
         if (cstates == 0) {
-                /*
-                 * Go on and print same useless info as you'd see with
-                 * cat /proc/acpi/processor/../power
-                 *      printf(_("CPU %u: No C-states available\n"), cpu);
-                 *      return;
-                 */
-        } else if (cstates <= 0) {
-                printf(_("CPU %u: Can't read C-state info\n"), cpu);
+                printf(_("CPU %u: No C-states info\n"), cpu);
                 return;
         }
-        /* printf("Cstates: %d\n", cstates); */
 
         printf(_("active state:            C0\n"));
         printf(_("max_cstate:              C%u\n"), cstates-1);
diff --git a/tools/power/cpupower/utils/cpuidle-set.c b/tools/power/cpupower/utils/cpuidle-set.c
new file mode 100644
index 000000000000..c78141c5dfac
--- /dev/null
+++ b/tools/power/cpupower/utils/cpuidle-set.c
@@ -0,0 +1,118 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <getopt.h>
+
+#include "cpufreq.h"
+#include "helpers/helpers.h"
+#include "helpers/sysfs.h"
+
+static struct option info_opts[] = {
+        { .name = "disable",    .has_arg = required_argument,   .flag = NULL,   .val = 'd'},
+        { .name = "enable",     .has_arg = required_argument,   .flag = NULL,   .val = 'e'},
+        { },
+};
+
+
+int cmd_idle_set(int argc, char **argv)
+{
+        extern char *optarg;
+        extern int optind, opterr, optopt;
+        int ret = 0, cont = 1, param = 0, idlestate = 0;
+        unsigned int cpu = 0;
+
+        do {
+                ret = getopt_long(argc, argv, "d:e:", info_opts, NULL);
+                if (ret == -1)
+                        break;
+                switch (ret) {
+                case '?':
+                        param = '?';
+                        cont = 0;
+                        break;
+                case 'd':
+                        if (param) {
+                                param = -1;
+                                cont = 0;
+                                break;
+                        }
+                        param = ret;
+                        idlestate = atoi(optarg);
+                        break;
+                case 'e':
+                        if (param) {
+                                param = -1;
+                                cont = 0;
+                                break;
+                        }
+                        param = ret;
+                        idlestate = atoi(optarg);
+                        break;
+                case -1:
+                        cont = 0;
+                        break;
+                }
+        } while (cont);
+
+        switch (param) {
+        case -1:
+                printf(_("You can't specify more than one "
+                         "output-specific argument\n"));
+                exit(EXIT_FAILURE);
+        case '?':
+                printf(_("invalid or unknown argument\n"));
+                exit(EXIT_FAILURE);
+        }
+
+        /* Default is: set all CPUs */
+        if (bitmask_isallclear(cpus_chosen))
+                bitmask_setall(cpus_chosen);
+
+        for (cpu = bitmask_first(cpus_chosen);
+             cpu <= bitmask_last(cpus_chosen); cpu++) {
+
+                if (!bitmask_isbitset(cpus_chosen, cpu))
+                        continue;
+
+                switch (param) {
+
+                case 'd':
+                        ret = sysfs_idlestate_disable(cpu, idlestate, 1);
+                        if (ret == 0)
+                printf(_("Idlestate %u disabled on CPU %u\n"),  idlestate, cpu);
+                        else if (ret == -1)
+                printf(_("Idlestate %u not available on CPU %u\n"),
+                       idlestate, cpu);
+                        else if (ret == -2)
+                printf(_("Idlestate disabling not supported by kernel\n"));
+                        else
+                printf(_("Idlestate %u not disabled on CPU %u\n"),
+                       idlestate, cpu);
+                        break;
+                case 'e':
+                        ret = sysfs_idlestate_disable(cpu, idlestate, 0);
+                        if (ret == 0)
+                printf(_("Idlestate %u enabled on CPU %u\n"),  idlestate, cpu);
+                        else if (ret == -1)
+                printf(_("Idlestate %u not available on CPU %u\n"),
+                       idlestate, cpu);
+                        else if (ret == -2)
+                printf(_("Idlestate enabling not supported by kernel\n"));
+                        else
+                printf(_("Idlestate %u not enabled on CPU %u\n"),
+                       idlestate, cpu);
+                        break;
+                default:
+                        /* Not reachable with proper args checking */
+                        printf(_("Invalid or unknown argument\n"));
+                        exit(EXIT_FAILURE);
+                        break;
+                }
+        }
+        return EXIT_SUCCESS;
+}
diff --git a/tools/power/cpupower/utils/cpupower.c b/tools/power/cpupower/utils/cpupower.c
index 52bee591c1c5..7efc570ffbaa 100644
--- a/tools/power/cpupower/utils/cpupower.c
+++ b/tools/power/cpupower/utils/cpupower.c
@@ -17,12 +17,6 @@
 #include "helpers/helpers.h"
 #include "helpers/bitmask.h"
 
-struct cmd_struct {
-        const char *cmd;
-        int (*main)(int, const char **);
-        int needs_root;
-};
-
 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
 
 static int cmd_help(int argc, const char **argv);
@@ -43,10 +37,17 @@ int be_verbose;
 
 static void print_help(void);
 
+struct cmd_struct {
+        const char *cmd;
+        int (*main)(int, const char **);
+        int needs_root;
+};
+
 static struct cmd_struct commands[] = {
         { "frequency-info",     cmd_freq_info,  0       },
         { "frequency-set",      cmd_freq_set,   1       },
         { "idle-info",          cmd_idle_info,  0       },
+        { "idle-set",           cmd_idle_set,   1       },
         { "set",                cmd_set,        1       },
         { "info",               cmd_info,       0       },
         { "monitor",            cmd_monitor,    0       },
diff --git a/tools/power/cpupower/utils/helpers/sysfs.c b/tools/power/cpupower/utils/helpers/sysfs.c
index 38ab91629463..5cdc600e8152 100644
--- a/tools/power/cpupower/utils/helpers/sysfs.c
+++ b/tools/power/cpupower/utils/helpers/sysfs.c
@@ -89,6 +89,33 @@ int sysfs_is_cpu_online(unsigned int cpu)
 
 /* CPUidle idlestate specific /sys/devices/system/cpu/cpuX/cpuidle/ access */
 
+
+/* CPUidle idlestate specific /sys/devices/system/cpu/cpuX/cpuidle/ access */
+
+/*
+ * helper function to check whether a file under "../cpuX/cpuidle/stateX/" dir
+ * exists.
+ * For example the functionality to disable c-states was introduced in later
+ * kernel versions, this function can be used to explicitly check for this
+ * feature.
+ *
+ * returns 1 if the file exists, 0 otherwise.
+ */
+unsigned int sysfs_idlestate_file_exists(unsigned int cpu,
+                                         unsigned int idlestate,
+                                         const char *fname)
+{
+        char path[SYSFS_PATH_MAX];
+        struct stat statbuf;
+
+
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpuidle/state%u/%s",
+                 cpu, idlestate, fname);
+        if (stat(path, &statbuf) != 0)
+                return 0;
+        return 1;
+}
+
 /*
  * helper function to read file from /sys into given buffer
  * fname is a relative path under "cpuX/cpuidle/stateX/" dir
@@ -121,6 +148,40 @@ unsigned int sysfs_idlestate_read_file(unsigned int cpu, unsigned int idlestate,
         return (unsigned int) numread;
 }
 
+/* 
+ * helper function to write a new value to a /sys file
+ * fname is a relative path under "../cpuX/cpuidle/cstateY/" dir
+ *
+ * Returns the number of bytes written or 0 on error
+ */
+static
+unsigned int sysfs_idlestate_write_file(unsigned int cpu,
+                                        unsigned int idlestate,
+                                        const char *fname,
+                                        const char *value, size_t len)
+{
+        char path[SYSFS_PATH_MAX];
+        int fd;
+        ssize_t numwrite;
+
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpuidle/state%u/%s",
+                 cpu, idlestate, fname);
+
+        fd = open(path, O_WRONLY);
+        if (fd == -1)
+                return 0;
+
+        numwrite = write(fd, value, len);
+        if (numwrite < 1) {
+                close(fd);
+                return 0;
+        }
+
+        close(fd);
+
+        return (unsigned int) numwrite;
+}
+
 /* read access to files which contain one numeric value */
 
 enum idlestate_value {
@@ -128,6 +189,7 @@ enum idlestate_value {
         IDLESTATE_POWER,
         IDLESTATE_LATENCY,
         IDLESTATE_TIME,
+        IDLESTATE_DISABLE,
         MAX_IDLESTATE_VALUE_FILES
 };
 
@@ -136,6 +198,7 @@ static const char *idlestate_value_files[MAX_IDLESTATE_VALUE_FILES] = {
         [IDLESTATE_POWER] = "power",
         [IDLESTATE_LATENCY] = "latency",
         [IDLESTATE_TIME]  = "time",
+        [IDLESTATE_DISABLE]  = "disable",
 };
 
 static unsigned long long sysfs_idlestate_get_one_value(unsigned int cpu,
@@ -205,8 +268,59 @@ static char *sysfs_idlestate_get_one_string(unsigned int cpu,
         return result;
 }
 
+/*
+ * Returns:
+ *    1  if disabled
+ *    0  if enabled
+ *    -1 if idlestate is not available
+ *    -2 if disabling is not supported by the kernel
+ */
+int sysfs_is_idlestate_disabled(unsigned int cpu,
+                                unsigned int idlestate)
+{
+        if (sysfs_get_idlestate_count(cpu) < idlestate)
+                return -1;
+
+        if (!sysfs_idlestate_file_exists(cpu, idlestate,
+                                 idlestate_value_files[IDLESTATE_DISABLE]))
+                return -2;
+        return sysfs_idlestate_get_one_value(cpu, idlestate, IDLESTATE_DISABLE);
+}
+
+/*
+ * Pass 1 as last argument to disable or 0 to enable the state
+ * Returns:
+ *    0  on success
+ *    negative values on error, for example:
+ *      -1 if idlestate is not available
+ *      -2 if disabling is not supported by the kernel
+ *      -3 No write access to disable/enable C-states
+ */
+int sysfs_idlestate_disable(unsigned int cpu,
+                            unsigned int idlestate,
+                            unsigned int disable)
+{
+        char value[SYSFS_PATH_MAX];
+        int bytes_written;
+
+        if (sysfs_get_idlestate_count(cpu) < idlestate)
+                return -1;
+
+        if (!sysfs_idlestate_file_exists(cpu, idlestate,
+                                 idlestate_value_files[IDLESTATE_DISABLE]))
+                return -2;
+
+        snprintf(value, SYSFS_PATH_MAX, "%u", disable);
+
+        bytes_written = sysfs_idlestate_write_file(cpu, idlestate, "disable",
+                                                   value, sizeof(disable));
+        if (bytes_written)
+                return 0;
+        return -3;
+}
+
 unsigned long sysfs_get_idlestate_latency(unsigned int cpu,
-                                        unsigned int idlestate)
+                                          unsigned int idlestate)
 {
         return sysfs_idlestate_get_one_value(cpu, idlestate, IDLESTATE_LATENCY);
 }
@@ -238,7 +352,7 @@ char *sysfs_get_idlestate_desc(unsigned int cpu, unsigned int idlestate)
  * Negativ in error case
  * Zero if cpuidle does not export any C-states
  */
-int sysfs_get_idlestate_count(unsigned int cpu)
+unsigned int sysfs_get_idlestate_count(unsigned int cpu)
 {
         char file[SYSFS_PATH_MAX];
         struct stat statbuf;
diff --git a/tools/power/cpupower/utils/helpers/sysfs.h b/tools/power/cpupower/utils/helpers/sysfs.h
index 8cb797bbceb0..d28f11fedbda 100644
--- a/tools/power/cpupower/utils/helpers/sysfs.h
+++ b/tools/power/cpupower/utils/helpers/sysfs.h
@@ -7,8 +7,16 @@
 
 extern unsigned int sysfs_read_file(const char *path, char *buf, size_t buflen);
 
+extern unsigned int sysfs_idlestate_file_exists(unsigned int cpu,
+                                                unsigned int idlestate,
+                                                const char *fname);
+
 extern int sysfs_is_cpu_online(unsigned int cpu);
 
+extern int sysfs_is_idlestate_disabled(unsigned int cpu,
+                                       unsigned int idlestate);
+extern int sysfs_idlestate_disable(unsigned int cpu, unsigned int idlestate,
+                                   unsigned int disable);
 extern unsigned long sysfs_get_idlestate_latency(unsigned int cpu,
                                                 unsigned int idlestate);
 extern unsigned long sysfs_get_idlestate_usage(unsigned int cpu,
@@ -19,7 +27,7 @@ extern char *sysfs_get_idlestate_name(unsigned int cpu,
                                 unsigned int idlestate);
 extern char *sysfs_get_idlestate_desc(unsigned int cpu,
                                 unsigned int idlestate);
-extern int sysfs_get_idlestate_count(unsigned int cpu);
+extern unsigned int sysfs_get_idlestate_count(unsigned int cpu);
 
 extern char *sysfs_get_cpuidle_governor(void);
 extern char *sysfs_get_cpuidle_driver(void);
diff --git a/tools/power/cpupower/utils/idle_monitor/hsw_ext_idle.c b/tools/power/cpupower/utils/idle_monitor/hsw_ext_idle.c
new file mode 100644
index 000000000000..ebeaba6571a3
--- /dev/null
+++ b/tools/power/cpupower/utils/idle_monitor/hsw_ext_idle.c
@@ -0,0 +1,196 @@
+/*
+ *  (C) 2010,2011       Thomas Renninger <trenn@suse.de>, Novell Inc.
+ *
+ *  Licensed under the terms of the GNU GPL License version 2.
+ *
+ *  Based on SandyBridge monitor. Implements the new package C-states
+ *  (PC8, PC9, PC10) coming with a specific Haswell (family 0x45) CPU.
+ */
+
+#if defined(__i386__) || defined(__x86_64__)
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "helpers/helpers.h"
+#include "idle_monitor/cpupower-monitor.h"
+
+#define MSR_PKG_C8_RESIDENCY           0x00000630
+#define MSR_PKG_C9_RESIDENCY           0x00000631
+#define MSR_PKG_C10_RESIDENCY          0x00000632
+
+#define MSR_TSC 0x10
+
+enum intel_hsw_ext_id { PC8 = 0, PC9, PC10, HSW_EXT_CSTATE_COUNT,
+                        TSC = 0xFFFF };
+
+static int hsw_ext_get_count_percent(unsigned int self_id, double *percent,
+                                 unsigned int cpu);
+
+static cstate_t hsw_ext_cstates[HSW_EXT_CSTATE_COUNT] = {
+        {
+                .name                   = "PC8",
+                .desc                   = N_("Processor Package C8"),
+                .id                     = PC8,
+                .range                  = RANGE_PACKAGE,
+                .get_count_percent      = hsw_ext_get_count_percent,
+        },
+        {
+                .name                   = "PC9",
+                .desc                   = N_("Processor Package C9"),
+                .desc                   = N_("Processor Package C2"),
+                .id                     = PC9,
+                .range                  = RANGE_PACKAGE,
+                .get_count_percent      = hsw_ext_get_count_percent,
+        },
+        {
+                .name                   = "PC10",
+                .desc                   = N_("Processor Package C10"),
+                .id                     = PC10,
+                .range                  = RANGE_PACKAGE,
+                .get_count_percent      = hsw_ext_get_count_percent,
+        },
+};
+
+static unsigned long long tsc_at_measure_start;
+static unsigned long long tsc_at_measure_end;
+static unsigned long long *previous_count[HSW_EXT_CSTATE_COUNT];
+static unsigned long long *current_count[HSW_EXT_CSTATE_COUNT];
+/* valid flag for all CPUs. If a MSR read failed it will be zero */
+static int *is_valid;
+
+static int hsw_ext_get_count(enum intel_hsw_ext_id id, unsigned long long *val,
+                        unsigned int cpu)
+{
+        int msr;
+
+        switch (id) {
+        case PC8:
+                msr = MSR_PKG_C8_RESIDENCY;
+                break;
+        case PC9:
+                msr = MSR_PKG_C9_RESIDENCY;
+                break;
+        case PC10:
+                msr = MSR_PKG_C10_RESIDENCY;
+                break;
+        case TSC:
+                msr = MSR_TSC;
+                break;
+        default:
+                return -1;
+        };
+        if (read_msr(cpu, msr, val))
+                return -1;
+        return 0;
+}
+
+static int hsw_ext_get_count_percent(unsigned int id, double *percent,
+                                 unsigned int cpu)
+{
+        *percent = 0.0;
+
+        if (!is_valid[cpu])
+                return -1;
+
+        *percent = (100.0 *
+                (current_count[id][cpu] - previous_count[id][cpu])) /
+                (tsc_at_measure_end - tsc_at_measure_start);
+
+        dprint("%s: previous: %llu - current: %llu - (%u)\n",
+                hsw_ext_cstates[id].name, previous_count[id][cpu],
+                current_count[id][cpu], cpu);
+
+        dprint("%s: tsc_diff: %llu - count_diff: %llu - percent: %2.f (%u)\n",
+               hsw_ext_cstates[id].name,
+               (unsigned long long) tsc_at_measure_end - tsc_at_measure_start,
+               current_count[id][cpu] - previous_count[id][cpu],
+               *percent, cpu);
+
+        return 0;
+}
+
+static int hsw_ext_start(void)
+{
+        int num, cpu;
+        unsigned long long val;
+
+        for (num = 0; num < HSW_EXT_CSTATE_COUNT; num++) {
+                for (cpu = 0; cpu < cpu_count; cpu++) {
+                        hsw_ext_get_count(num, &val, cpu);
+                        previous_count[num][cpu] = val;
+                }
+        }
+        hsw_ext_get_count(TSC, &tsc_at_measure_start, 0);
+        return 0;
+}
+
+static int hsw_ext_stop(void)
+{
+        unsigned long long val;
+        int num, cpu;
+
+        hsw_ext_get_count(TSC, &tsc_at_measure_end, 0);
+
+        for (num = 0; num < HSW_EXT_CSTATE_COUNT; num++) {
+                for (cpu = 0; cpu < cpu_count; cpu++) {
+                        is_valid[cpu] = !hsw_ext_get_count(num, &val, cpu);
+                        current_count[num][cpu] = val;
+                }
+        }
+        return 0;
+}
+
+struct cpuidle_monitor intel_hsw_ext_monitor;
+
+static struct cpuidle_monitor *hsw_ext_register(void)
+{
+        int num;
+
+        if (cpupower_cpu_info.vendor != X86_VENDOR_INTEL
+            || cpupower_cpu_info.family != 6)
+                return NULL;
+
+        switch (cpupower_cpu_info.model) {
+        case 0x45: /* HSW */
+                break;
+        default:
+                return NULL;
+        }
+
+        is_valid = calloc(cpu_count, sizeof(int));
+        for (num = 0; num < HSW_EXT_CSTATE_COUNT; num++) {
+                previous_count[num] = calloc(cpu_count,
+                                        sizeof(unsigned long long));
+                current_count[num]  = calloc(cpu_count,
+                                        sizeof(unsigned long long));
+        }
+        intel_hsw_ext_monitor.name_len = strlen(intel_hsw_ext_monitor.name);
+        return &intel_hsw_ext_monitor;
+}
+
+void hsw_ext_unregister(void)
+{
+        int num;
+        free(is_valid);
+        for (num = 0; num < HSW_EXT_CSTATE_COUNT; num++) {
+                free(previous_count[num]);
+                free(current_count[num]);
+        }
+}
+
+struct cpuidle_monitor intel_hsw_ext_monitor = {
+        .name                   = "HaswellExtended",
+        .hw_states              = hsw_ext_cstates,
+        .hw_states_num          = HSW_EXT_CSTATE_COUNT,
+        .start                  = hsw_ext_start,
+        .stop                   = hsw_ext_stop,
+        .do_register            = hsw_ext_register,
+        .unregister             = hsw_ext_unregister,
+        .needs_root             = 1,
+        .overflow_s             = 922000000 /* 922337203 seconds TSC overflow
+                                               at 20GHz */
+};
+#endif /* defined(__i386__) || defined(__x86_64__) */
diff --git a/tools/power/cpupower/utils/idle_monitor/idle_monitors.def b/tools/power/cpupower/utils/idle_monitor/idle_monitors.def
index e3f8d9b2b18f..0d6ba4dbb9c7 100644
--- a/tools/power/cpupower/utils/idle_monitor/idle_monitors.def
+++ b/tools/power/cpupower/utils/idle_monitor/idle_monitors.def
@@ -2,6 +2,7 @@
 DEF(amd_fam14h)
 DEF(intel_nhm)
 DEF(intel_snb)
+DEF(intel_hsw_ext)
 DEF(mperf)
 #endif
 DEF(cpuidle_sysfs)
diff --git a/tools/power/cpupower/utils/idle_monitor/snb_idle.c b/tools/power/cpupower/utils/idle_monitor/snb_idle.c
index a99b43b97d6d..efc8a69c9aba 100644
--- a/tools/power/cpupower/utils/idle_monitor/snb_idle.c
+++ b/tools/power/cpupower/utils/idle_monitor/snb_idle.c
@@ -155,6 +155,10 @@ static struct cpuidle_monitor *snb_register(void)
         case 0x2D: /* SNB Xeon */
         case 0x3A: /* IVB */
         case 0x3E: /* IVB Xeon */
+        case 0x3C: /* HSW */
+        case 0x3F: /* HSW */
+        case 0x45: /* HSW */
+        case 0x46: /* HSW */
                 break;
         default:
                 return NULL;
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index 9e9d34871195..fe702076ca46 100644
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -2191,7 +2191,7 @@ int initialize_counters(int cpu_id)
 
 void allocate_output_buffer()
 {
-        output_buffer = calloc(1, (1 + topo.num_cpus) * 128);
+        output_buffer = calloc(1, (1 + topo.num_cpus) * 256);
         outp = output_buffer;
         if (outp == NULL) {
                 perror("calloc");
diff --git a/tools/scripts/Makefile.include b/tools/scripts/Makefile.include
index f03e681f8891..0d0506d55c71 100644
--- a/tools/scripts/Makefile.include
+++ b/tools/scripts/Makefile.include
@@ -59,7 +59,7 @@ QUIET_SUBDIR0  = +$(MAKE) $(COMMAND_O) -C # space to separate -C and subdir
 QUIET_SUBDIR1  =
 
 ifneq ($(findstring $(MAKEFLAGS),s),s)
-ifndef V
+ifneq ($(V),1)
         QUIET_CC       = @echo '   ' CC $@;
         QUIET_AR       = @echo '   ' AR $@;
         QUIET_LINK     = @echo '   ' LINK $@;
diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl
index 0d7fd8b51544..999eab1bc64f 100755
--- a/tools/testing/ktest/ktest.pl
+++ b/tools/testing/ktest/ktest.pl
@@ -1796,7 +1796,7 @@ sub monitor {
                 # We already booted into the kernel we are testing,
                 # but now we booted into another kernel?
                 # Consider this a triple fault.
-                doprint "Aleady booted in Linux kernel $version, but now\n";
+                doprint "Already booted in Linux kernel $version, but now\n";
                 doprint "we booted into Linux kernel $1.\n";
                 doprint "Assuming that this is a triple fault.\n";
                 doprint "To disable this: set DETECT_TRIPLE_FAULT to 0\n";
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 0a63658065f0..9f3eae290900 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -6,7 +6,9 @@ TARGETS += memory-hotplug
 TARGETS += mqueue
 TARGETS += net
 TARGETS += ptrace
+TARGETS += timers
 TARGETS += vm
+TARGETS += powerpc
 
 all:
         for TARGET in $(TARGETS); do \
diff --git a/tools/testing/selftests/cpu-hotplug/Makefile b/tools/testing/selftests/cpu-hotplug/Makefile
index 12657a5e4bf9..ae5faf9aade2 100644
--- a/tools/testing/selftests/cpu-hotplug/Makefile
+++ b/tools/testing/selftests/cpu-hotplug/Makefile
@@ -1,6 +1,6 @@
 all:
 
 run_tests:
-        @./on-off-test.sh || echo "cpu-hotplug selftests: [FAIL]"
+        @/bin/sh ./on-off-test.sh || echo "cpu-hotplug selftests: [FAIL]"
 
 clean:
diff --git a/tools/testing/selftests/kcmp/.gitignore b/tools/testing/selftests/kcmp/.gitignore
new file mode 100644
index 000000000000..5a9b3732b2de
--- /dev/null
+++ b/tools/testing/selftests/kcmp/.gitignore
@@ -0,0 +1,2 @@
+kcmp_test
+kcmp-test-file
diff --git a/tools/testing/selftests/kcmp/Makefile b/tools/testing/selftests/kcmp/Makefile
index 56eb5523dbb8..d7d6bbeeff2f 100644
--- a/tools/testing/selftests/kcmp/Makefile
+++ b/tools/testing/selftests/kcmp/Makefile
@@ -25,5 +25,4 @@ run_tests: all
         @./kcmp_test || echo "kcmp_test: [FAIL]"
 
 clean:
-        rm -fr ./run_test
-        rm -fr ./test-file
+        $(RM) kcmp_test kcmp-test-file
diff --git a/tools/testing/selftests/memory-hotplug/Makefile b/tools/testing/selftests/memory-hotplug/Makefile
index 0f49c3f5f58d..350bfeda3aa8 100644
--- a/tools/testing/selftests/memory-hotplug/Makefile
+++ b/tools/testing/selftests/memory-hotplug/Makefile
@@ -1,6 +1,6 @@
 all:
 
 run_tests:
-        @./on-off-test.sh || echo "memory-hotplug selftests: [FAIL]"
+        @/bin/sh ./on-off-test.sh || echo "memory-hotplug selftests: [FAIL]"
 
 clean:
diff --git a/tools/testing/selftests/net/psock_tpacket.c b/tools/testing/selftests/net/psock_tpacket.c
index c41b58640a05..24adf709bd9d 100644
--- a/tools/testing/selftests/net/psock_tpacket.c
+++ b/tools/testing/selftests/net/psock_tpacket.c
@@ -1,6 +1,7 @@
 /*
  * Copyright 2013 Red Hat, Inc.
  * Author: Daniel Borkmann <dborkman@redhat.com>
+ *         Chetan Loke <loke.chetan@gmail.com> (TPACKET_V3 usage example)
  *
  * A basic test of packet socket's TPACKET_V1/TPACKET_V2/TPACKET_V3 behavior.
  *
@@ -71,18 +72,8 @@
 # define __align_tpacket(x)     __attribute__((aligned(TPACKET_ALIGN(x))))
 #endif
 
-#define BLOCK_STATUS(x)         ((x)->h1.block_status)
-#define BLOCK_NUM_PKTS(x)       ((x)->h1.num_pkts)
-#define BLOCK_O2FP(x)           ((x)->h1.offset_to_first_pkt)
-#define BLOCK_LEN(x)            ((x)->h1.blk_len)
-#define BLOCK_SNUM(x)           ((x)->h1.seq_num)
-#define BLOCK_O2PRIV(x)         ((x)->offset_to_priv)
-#define BLOCK_PRIV(x)           ((void *) ((uint8_t *) (x) + BLOCK_O2PRIV(x)))
-#define BLOCK_HDR_LEN           (ALIGN_8(sizeof(struct block_desc)))
-#define ALIGN_8(x)              (((x) + 8 - 1) & ~(8 - 1))
-#define BLOCK_PLUS_PRIV(sz_pri) (BLOCK_HDR_LEN + ALIGN_8((sz_pri)))
-
 #define NUM_PACKETS             100
+#define ALIGN_8(x)              (((x) + 8 - 1) & ~(8 - 1))
 
 struct ring {
         struct iovec *rd;
@@ -476,41 +467,30 @@ static uint64_t __v3_prev_block_seq_num = 0;
 
 void __v3_test_block_seq_num(struct block_desc *pbd)
 {
-        if (__v3_prev_block_seq_num + 1 != BLOCK_SNUM(pbd)) {
+        if (__v3_prev_block_seq_num + 1 != pbd->h1.seq_num) {
                 fprintf(stderr, "\nprev_block_seq_num:%"PRIu64", expected "
                         "seq:%"PRIu64" != actual seq:%"PRIu64"\n",
                         __v3_prev_block_seq_num, __v3_prev_block_seq_num + 1,
-                        (uint64_t) BLOCK_SNUM(pbd));
+                        (uint64_t) pbd->h1.seq_num);
                 exit(1);
         }
 
-        __v3_prev_block_seq_num = BLOCK_SNUM(pbd);
+        __v3_prev_block_seq_num = pbd->h1.seq_num;
 }
 
 static void __v3_test_block_len(struct block_desc *pbd, uint32_t bytes, int block_num)
 {
-        if (BLOCK_NUM_PKTS(pbd)) {
-                if (bytes != BLOCK_LEN(pbd)) {
-                        fprintf(stderr, "\nblock:%u with %upackets, expected "
-                                "len:%u != actual len:%u\n", block_num,
-                                BLOCK_NUM_PKTS(pbd), bytes, BLOCK_LEN(pbd));
-                        exit(1);
-                }
-        } else {
-                if (BLOCK_LEN(pbd) != BLOCK_PLUS_PRIV(13)) {
-                        fprintf(stderr, "\nblock:%u, expected len:%lu != "
-                                "actual len:%u\n", block_num, BLOCK_HDR_LEN,
-                                BLOCK_LEN(pbd));
-                        exit(1);
-                }
+        if (pbd->h1.num_pkts && bytes != pbd->h1.blk_len) {
+                fprintf(stderr, "\nblock:%u with %upackets, expected "
+                        "len:%u != actual len:%u\n", block_num,
+                        pbd->h1.num_pkts, bytes, pbd->h1.blk_len);
+                exit(1);
         }
 }
 
 static void __v3_test_block_header(struct block_desc *pbd, const int block_num)
 {
-        uint32_t block_status = BLOCK_STATUS(pbd);
-
-        if ((block_status & TP_STATUS_USER) == 0) {
+        if ((pbd->h1.block_status & TP_STATUS_USER) == 0) {
                 fprintf(stderr, "\nblock %u: not in TP_STATUS_USER\n", block_num);
                 exit(1);
         }
@@ -520,14 +500,15 @@ static void __v3_test_block_header(struct block_desc *pbd, const int block_num)
 
 static void __v3_walk_block(struct block_desc *pbd, const int block_num)
 {
-        int num_pkts = BLOCK_NUM_PKTS(pbd), i;
-        unsigned long bytes = 0;
-        unsigned long bytes_with_padding = BLOCK_PLUS_PRIV(13);
+        int num_pkts = pbd->h1.num_pkts, i;
+        unsigned long bytes = 0, bytes_with_padding = ALIGN_8(sizeof(*pbd));
         struct tpacket3_hdr *ppd;
 
         __v3_test_block_header(pbd, block_num);
 
-        ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd + BLOCK_O2FP(pbd));
+        ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd +
+                                       pbd->h1.offset_to_first_pkt);
+
         for (i = 0; i < num_pkts; ++i) {
                 bytes += ppd->tp_snaplen;
 
@@ -551,7 +532,7 @@ static void __v3_walk_block(struct block_desc *pbd, const int block_num)
 
 void __v3_flush_block(struct block_desc *pbd)
 {
-        BLOCK_STATUS(pbd) = TP_STATUS_KERNEL;
+        pbd->h1.block_status = TP_STATUS_KERNEL;
         __sync_synchronize();
 }
 
@@ -577,7 +558,7 @@ static void walk_v3_rx(int sock, struct ring *ring)
         while (total_packets < NUM_PACKETS * 2) {
                 pbd = (struct block_desc *) ring->rd[block_num].iov_base;
 
-                while ((BLOCK_STATUS(pbd) & TP_STATUS_USER) == 0)
+                while ((pbd->h1.block_status & TP_STATUS_USER) == 0)
                         poll(&pfd, 1, 1);
 
                 __v3_walk_block(pbd, block_num);
@@ -624,8 +605,8 @@ static void __v1_v2_fill(struct ring *ring, unsigned int blocks)
 static void __v3_fill(struct ring *ring, unsigned int blocks)
 {
         ring->req3.tp_retire_blk_tov = 64;
-        ring->req3.tp_sizeof_priv = 13;
-        ring->req3.tp_feature_req_word |= TP_FT_REQ_FILL_RXHASH;
+        ring->req3.tp_sizeof_priv = 0;
+        ring->req3.tp_feature_req_word = TP_FT_REQ_FILL_RXHASH;
 
         ring->req3.tp_block_size = getpagesize() << 2;
         ring->req3.tp_frame_size = TPACKET_ALIGNMENT << 7;
diff --git a/tools/testing/selftests/powerpc/Makefile b/tools/testing/selftests/powerpc/Makefile
new file mode 100644
index 000000000000..bd24ae5aaeab
--- /dev/null
+++ b/tools/testing/selftests/powerpc/Makefile
@@ -0,0 +1,39 @@
+# Makefile for powerpc selftests
+
+# ARCH can be overridden by the user for cross compiling
+ARCH ?= $(shell uname -m)
+ARCH := $(shell echo $(ARCH) | sed -e s/ppc.*/powerpc/)
+
+ifeq ($(ARCH),powerpc)
+
+GIT_VERSION = $(shell git describe --always --long --dirty || echo "unknown")
+
+CC := $(CROSS_COMPILE)$(CC)
+CFLAGS := -Wall -O2 -flto -Wall -Werror -DGIT_VERSION='"$(GIT_VERSION)"' -I$(CURDIR) $(CFLAGS)
+
+export CC CFLAGS
+
+TARGETS = pmu
+
+endif
+
+all:
+        @for TARGET in $(TARGETS); do \
+                $(MAKE) -C $$TARGET all; \
+        done;
+
+run_tests: all
+        @for TARGET in $(TARGETS); do \
+                $(MAKE) -C $$TARGET run_tests; \
+        done;
+
+clean:
+        @for TARGET in $(TARGETS); do \
+                $(MAKE) -C $$TARGET clean; \
+        done;
+        rm -f tags
+
+tags:
+        find . -name '*.c' -o -name '*.h' | xargs ctags
+
+.PHONY: all run_tests clean tags
diff --git a/tools/testing/selftests/powerpc/harness.c b/tools/testing/selftests/powerpc/harness.c
new file mode 100644
index 000000000000..e80c42a584fe
--- /dev/null
+++ b/tools/testing/selftests/powerpc/harness.c
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2013, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#include <errno.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "subunit.h"
+#include "utils.h"
+
+#define TIMEOUT         120
+#define KILL_TIMEOUT    5
+
+
+int run_test(int (test_function)(void), char *name)
+{
+        bool terminated;
+        int rc, status;
+        pid_t pid;
+
+        /* Make sure output is flushed before forking */
+        fflush(stdout);
+
+        pid = fork();
+        if (pid == 0) {
+                exit(test_function());
+        } else if (pid == -1) {
+                perror("fork");
+                return 1;
+        }
+
+        /* Wake us up in timeout seconds */
+        alarm(TIMEOUT);
+        terminated = false;
+
+wait:
+        rc = waitpid(pid, &status, 0);
+        if (rc == -1) {
+                if (errno != EINTR) {
+                        printf("unknown error from waitpid\n");
+                        return 1;
+                }
+
+                if (terminated) {
+                        printf("!! force killing %s\n", name);
+                        kill(pid, SIGKILL);
+                        return 1;
+                } else {
+                        printf("!! killing %s\n", name);
+                        kill(pid, SIGTERM);
+                        terminated = true;
+                        alarm(KILL_TIMEOUT);
+                        goto wait;
+                }
+        }
+
+        if (WIFEXITED(status))
+                status = WEXITSTATUS(status);
+        else {
+                if (WIFSIGNALED(status))
+                        printf("!! child died by signal %d\n", WTERMSIG(status));
+                else
+                        printf("!! child died by unknown cause\n");
+
+                status = 1; /* Signal or other */
+        }
+
+        return status;
+}
+
+static void alarm_handler(int signum)
+{
+        /* Jut wake us up from waitpid */
+}
+
+static struct sigaction alarm_action = {
+        .sa_handler = alarm_handler,
+};
+
+int test_harness(int (test_function)(void), char *name)
+{
+        int rc;
+
+        test_start(name);
+        test_set_git_version(GIT_VERSION);
+
+        if (sigaction(SIGALRM, &alarm_action, NULL)) {
+                perror("sigaction");
+                test_error(name);
+                return 1;
+        }
+
+        rc = run_test(test_function, name);
+
+        test_finish(name, rc);
+
+        return rc;
+}
diff --git a/tools/testing/selftests/powerpc/pmu/Makefile b/tools/testing/selftests/powerpc/pmu/Makefile
new file mode 100644
index 000000000000..7216f0091655
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/Makefile
@@ -0,0 +1,23 @@
+noarg:
+        $(MAKE) -C ../
+
+PROGS := count_instructions
+EXTRA_SOURCES := ../harness.c event.c
+
+all: $(PROGS)
+
+$(PROGS): $(EXTRA_SOURCES)
+
+# loop.S can only be built 64-bit
+count_instructions: loop.S count_instructions.c $(EXTRA_SOURCES)
+        $(CC) $(CFLAGS) -m64 -o $@ $^
+
+run_tests: all
+        @-for PROG in $(PROGS); do \
+                ./$$PROG; \
+        done;
+
+clean:
+        rm -f $(PROGS) loop.o
+
+.PHONY: all run_tests clean
diff --git a/tools/testing/selftests/powerpc/pmu/count_instructions.c b/tools/testing/selftests/powerpc/pmu/count_instructions.c
new file mode 100644
index 000000000000..312b4f0fd27c
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/count_instructions.c
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2013, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/prctl.h>
+
+#include "event.h"
+#include "utils.h"
+
+extern void thirty_two_instruction_loop(u64 loops);
+
+static void setup_event(struct event *e, u64 config, char *name)
+{
+        event_init_opts(e, config, PERF_TYPE_HARDWARE, name);
+
+        e->attr.disabled = 1;
+        e->attr.exclude_kernel = 1;
+        e->attr.exclude_hv = 1;
+        e->attr.exclude_idle = 1;
+}
+
+static int do_count_loop(struct event *events, u64 instructions,
+                         u64 overhead, bool report)
+{
+        s64 difference, expected;
+        double percentage;
+
+        prctl(PR_TASK_PERF_EVENTS_ENABLE);
+
+        /* Run for 1M instructions */
+        thirty_two_instruction_loop(instructions >> 5);
+
+        prctl(PR_TASK_PERF_EVENTS_DISABLE);
+
+        event_read(&events[0]);
+        event_read(&events[1]);
+
+        expected = instructions + overhead;
+        difference = events[0].result.value - expected;
+        percentage = (double)difference / events[0].result.value * 100;
+
+        if (report) {
+                event_report(&events[0]);
+                event_report(&events[1]);
+
+                printf("Looped for %llu instructions, overhead %llu\n", instructions, overhead);
+                printf("Expected %llu\n", expected);
+                printf("Actual   %llu\n", events[0].result.value);
+                printf("Delta    %lld, %f%%\n", difference, percentage);
+        }
+
+        event_reset(&events[0]);
+        event_reset(&events[1]);
+
+        if (difference < 0)
+                difference = -difference;
+
+        /* Tolerate a difference below 0.0001 % */
+        difference *= 10000 * 100;
+        if (difference / events[0].result.value)
+                return -1;
+
+        return 0;
+}
+
+/* Count how many instructions it takes to do a null loop */
+static u64 determine_overhead(struct event *events)
+{
+        u64 current, overhead;
+        int i;
+
+        do_count_loop(events, 0, 0, false);
+        overhead = events[0].result.value;
+
+        for (i = 0; i < 100; i++) {
+                do_count_loop(events, 0, 0, false);
+                current = events[0].result.value;
+                if (current < overhead) {
+                        printf("Replacing overhead %llu with %llu\n", overhead, current);
+                        overhead = current;
+                }
+        }
+
+        return overhead;
+}
+
+static int count_instructions(void)
+{
+        struct event events[2];
+        u64 overhead;
+
+        setup_event(&events[0], PERF_COUNT_HW_INSTRUCTIONS, "instructions");
+        setup_event(&events[1], PERF_COUNT_HW_CPU_CYCLES, "cycles");
+
+        if (event_open(&events[0])) {
+                perror("perf_event_open");
+                return -1;
+        }
+
+        if (event_open_with_group(&events[1], events[0].fd)) {
+                perror("perf_event_open");
+                return -1;
+        }
+
+        overhead = determine_overhead(events);
+        printf("Overhead of null loop: %llu instructions\n", overhead);
+
+        /* Run for 1M instructions */
+        FAIL_IF(do_count_loop(events, 0x100000, overhead, true));
+
+        /* Run for 10M instructions */
+        FAIL_IF(do_count_loop(events, 0xa00000, overhead, true));
+
+        /* Run for 100M instructions */
+        FAIL_IF(do_count_loop(events, 0x6400000, overhead, true));
+
+        /* Run for 1G instructions */
+        FAIL_IF(do_count_loop(events, 0x40000000, overhead, true));
+
+        event_close(&events[0]);
+        event_close(&events[1]);
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(count_instructions, "count_instructions");
+}
diff --git a/tools/testing/selftests/powerpc/pmu/event.c b/tools/testing/selftests/powerpc/pmu/event.c
new file mode 100644
index 000000000000..2b2d11df2450
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/event.c
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2013, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#define _GNU_SOURCE
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+
+#include "event.h"
+
+
+int perf_event_open(struct perf_event_attr *attr, pid_t pid, int cpu,
+                int group_fd, unsigned long flags)
+{
+        return syscall(__NR_perf_event_open, attr, pid, cpu,
+                           group_fd, flags);
+}
+
+void event_init_opts(struct event *e, u64 config, int type, char *name)
+{
+        memset(e, 0, sizeof(*e));
+
+        e->name = name;
+
+        e->attr.type = type;
+        e->attr.config = config;
+        e->attr.size = sizeof(e->attr);
+        /* This has to match the structure layout in the header */
+        e->attr.read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | \
+                                  PERF_FORMAT_TOTAL_TIME_RUNNING;
+}
+
+void event_init_named(struct event *e, u64 config, char *name)
+{
+        event_init_opts(e, config, PERF_TYPE_RAW, name);
+}
+
+#define PERF_CURRENT_PID        0
+#define PERF_NO_CPU             -1
+#define PERF_NO_GROUP           -1
+
+int event_open_with_options(struct event *e, pid_t pid, int cpu, int group_fd)
+{
+        e->fd = perf_event_open(&e->attr, pid, cpu, group_fd, 0);
+        if (e->fd == -1) {
+                perror("perf_event_open");
+                return -1;
+        }
+
+        return 0;
+}
+
+int event_open_with_group(struct event *e, int group_fd)
+{
+        return event_open_with_options(e, PERF_CURRENT_PID, PERF_NO_CPU, group_fd);
+}
+
+int event_open(struct event *e)
+{
+        return event_open_with_options(e, PERF_CURRENT_PID, PERF_NO_CPU, PERF_NO_GROUP);
+}
+
+void event_close(struct event *e)
+{
+        close(e->fd);
+}
+
+int event_reset(struct event *e)
+{
+        return ioctl(e->fd, PERF_EVENT_IOC_RESET);
+}
+
+int event_read(struct event *e)
+{
+        int rc;
+
+        rc = read(e->fd, &e->result, sizeof(e->result));
+        if (rc != sizeof(e->result)) {
+                fprintf(stderr, "read error on event %p!\n", e);
+                return -1;
+        }
+
+        return 0;
+}
+
+void event_report_justified(struct event *e, int name_width, int result_width)
+{
+        printf("%*s: result %*llu ", name_width, e->name, result_width,
+               e->result.value);
+
+        if (e->result.running == e->result.enabled)
+                printf("running/enabled %llu\n", e->result.running);
+        else
+                printf("running %llu enabled %llu\n", e->result.running,
+                        e->result.enabled);
+}
+
+void event_report(struct event *e)
+{
+        event_report_justified(e, 0, 0);
+}
diff --git a/tools/testing/selftests/powerpc/pmu/event.h b/tools/testing/selftests/powerpc/pmu/event.h
new file mode 100644
index 000000000000..e6993192ff34
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/event.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2013, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#ifndef _SELFTESTS_POWERPC_PMU_EVENT_H
+#define _SELFTESTS_POWERPC_PMU_EVENT_H
+
+#include <unistd.h>
+#include <linux/perf_event.h>
+
+#include "utils.h"
+
+
+struct event {
+        struct perf_event_attr attr;
+        char *name;
+        int fd;
+        /* This must match the read_format we use */
+        struct {
+                u64 value;
+                u64 running;
+                u64 enabled;
+        } result;
+};
+
+void event_init(struct event *e, u64 config);
+void event_init_named(struct event *e, u64 config, char *name);
+void event_init_opts(struct event *e, u64 config, int type, char *name);
+int event_open_with_options(struct event *e, pid_t pid, int cpu, int group_fd);
+int event_open_with_group(struct event *e, int group_fd);
+int event_open(struct event *e);
+void event_close(struct event *e);
+int event_reset(struct event *e);
+int event_read(struct event *e);
+void event_report_justified(struct event *e, int name_width, int result_width);
+void event_report(struct event *e);
+
+#endif /* _SELFTESTS_POWERPC_PMU_EVENT_H */
diff --git a/tools/testing/selftests/powerpc/pmu/loop.S b/tools/testing/selftests/powerpc/pmu/loop.S
new file mode 100644
index 000000000000..8820e3df1444
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/loop.S
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2013, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+        .text
+
+        .global thirty_two_instruction_loop
+        .type .thirty_two_instruction_loop,@function
+        .section ".opd","aw",@progbits
+thirty_two_instruction_loop:
+        .quad .thirty_two_instruction_loop, .TOC.@tocbase, 0
+        .previous
+.thirty_two_instruction_loop:
+        cmpwi   %r3,0
+        beqlr
+        addi    %r4,%r3,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1
+        addi    %r4,%r4,1       # 28 addi's
+        subi    %r3,%r3,1
+        b       .thirty_two_instruction_loop
diff --git a/tools/testing/selftests/powerpc/subunit.h b/tools/testing/selftests/powerpc/subunit.h
new file mode 100644
index 000000000000..98a22920792d
--- /dev/null
+++ b/tools/testing/selftests/powerpc/subunit.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2013, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#ifndef _SELFTESTS_POWERPC_SUBUNIT_H
+#define _SELFTESTS_POWERPC_SUBUNIT_H
+
+static inline void test_start(char *name)
+{
+        printf("test: %s\n", name);
+}
+
+static inline void test_failure_detail(char *name, char *detail)
+{
+        printf("failure: %s [%s]\n", name, detail);
+}
+
+static inline void test_failure(char *name)
+{
+        printf("failure: %s\n", name);
+}
+
+static inline void test_error(char *name)
+{
+        printf("error: %s\n", name);
+}
+
+static inline void test_success(char *name)
+{
+        printf("success: %s\n", name);
+}
+
+static inline void test_finish(char *name, int status)
+{
+        if (status)
+                test_failure(name);
+        else
+                test_success(name);
+}
+
+static inline void test_set_git_version(char *value)
+{
+        printf("tags: git_version:%s\n", value);
+}
+
+#endif /* _SELFTESTS_POWERPC_SUBUNIT_H */
diff --git a/tools/testing/selftests/powerpc/utils.h b/tools/testing/selftests/powerpc/utils.h
new file mode 100644
index 000000000000..5851c4b0f553
--- /dev/null
+++ b/tools/testing/selftests/powerpc/utils.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2013, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#ifndef _SELFTESTS_POWERPC_UTILS_H
+#define _SELFTESTS_POWERPC_UTILS_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/* Avoid headaches with PRI?64 - just use %ll? always */
+typedef unsigned long long u64;
+typedef   signed long long s64;
+
+/* Just for familiarity */
+typedef uint32_t u32;
+typedef uint8_t u8;
+
+
+int test_harness(int (test_function)(void), char *name);
+
+
+/* Yes, this is evil */
+#define FAIL_IF(x)                                              \
+do {                                                            \
+        if ((x)) {                                              \
+                fprintf(stderr,                                 \
+                "[FAIL] Test FAILED on line %d\n", __LINE__);   \
+                return 1;                                       \
+        }                                                       \
+} while (0)
+
+#endif /* _SELFTESTS_POWERPC_UTILS_H */
diff --git a/tools/testing/selftests/timers/Makefile b/tools/testing/selftests/timers/Makefile
new file mode 100644
index 000000000000..eb2859f4ad21
--- /dev/null
+++ b/tools/testing/selftests/timers/Makefile
@@ -0,0 +1,8 @@
+all:
+        gcc posix_timers.c -o posix_timers -lrt
+
+run_tests: all
+        ./posix_timers
+
+clean:
+        rm -f ./posix_timers
diff --git a/tools/testing/selftests/timers/posix_timers.c b/tools/testing/selftests/timers/posix_timers.c
new file mode 100644
index 000000000000..4fa655d68a81
--- /dev/null
+++ b/tools/testing/selftests/timers/posix_timers.c
@@ -0,0 +1,221 @@
+/*
+ * Copyright (C) 2013 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com>
+ *
+ * Licensed under the terms of the GNU GPL License version 2
+ *
+ * Selftests for a few posix timers interface.
+ *
+ * Kernel loop code stolen from Steven Rostedt <srostedt@redhat.com>
+ */
+
+#include <sys/time.h>
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+#include <time.h>
+#include <pthread.h>
+
+#define DELAY 2
+#define USECS_PER_SEC 1000000
+
+static volatile int done;
+
+/* Busy loop in userspace to elapse ITIMER_VIRTUAL */
+static void user_loop(void)
+{
+        while (!done);
+}
+
+/*
+ * Try to spend as much time as possible in kernelspace
+ * to elapse ITIMER_PROF.
+ */
+static void kernel_loop(void)
+{
+        void *addr = sbrk(0);
+
+        while (!done) {
+                brk(addr + 4096);
+                brk(addr);
+        }
+}
+
+/*
+ * Sleep until ITIMER_REAL expiration.
+ */
+static void idle_loop(void)
+{
+        pause();
+}
+
+static void sig_handler(int nr)
+{
+        done = 1;
+}
+
+/*
+ * Check the expected timer expiration matches the GTOD elapsed delta since
+ * we armed the timer. Keep a 0.5 sec error margin due to various jitter.
+ */
+static int check_diff(struct timeval start, struct timeval end)
+{
+        long long diff;
+
+        diff = end.tv_usec - start.tv_usec;
+        diff += (end.tv_sec - start.tv_sec) * USECS_PER_SEC;
+
+        if (abs(diff - DELAY * USECS_PER_SEC) > USECS_PER_SEC / 2) {
+                printf("Diff too high: %lld..", diff);
+                return -1;
+        }
+
+        return 0;
+}
+
+static int check_itimer(int which)
+{
+        int err;
+        struct timeval start, end;
+        struct itimerval val = {
+                .it_value.tv_sec = DELAY,
+        };
+
+        printf("Check itimer ");
+
+        if (which == ITIMER_VIRTUAL)
+                printf("virtual... ");
+        else if (which == ITIMER_PROF)
+                printf("prof... ");
+        else if (which == ITIMER_REAL)
+                printf("real... ");
+
+        fflush(stdout);
+
+        done = 0;
+
+        if (which == ITIMER_VIRTUAL)
+                signal(SIGVTALRM, sig_handler);
+        else if (which == ITIMER_PROF)
+                signal(SIGPROF, sig_handler);
+        else if (which == ITIMER_REAL)
+                signal(SIGALRM, sig_handler);
+
+        err = gettimeofday(&start, NULL);
+        if (err < 0) {
+                perror("Can't call gettimeofday()\n");
+                return -1;
+        }
+
+        err = setitimer(which, &val, NULL);
+        if (err < 0) {
+                perror("Can't set timer\n");
+                return -1;
+        }
+
+        if (which == ITIMER_VIRTUAL)
+                user_loop();
+        else if (which == ITIMER_PROF)
+                kernel_loop();
+        else if (which == ITIMER_REAL)
+                idle_loop();
+
+        gettimeofday(&end, NULL);
+        if (err < 0) {
+                perror("Can't call gettimeofday()\n");
+                return -1;
+        }
+
+        if (!check_diff(start, end))
+                printf("[OK]\n");
+        else
+                printf("[FAIL]\n");
+
+        return 0;
+}
+
+static int check_timer_create(int which)
+{
+        int err;
+        timer_t id;
+        struct timeval start, end;
+        struct itimerspec val = {
+                .it_value.tv_sec = DELAY,
+        };
+
+        printf("Check timer_create() ");
+        if (which == CLOCK_THREAD_CPUTIME_ID) {
+                printf("per thread... ");
+        } else if (which == CLOCK_PROCESS_CPUTIME_ID) {
+                printf("per process... ");
+        }
+        fflush(stdout);
+
+        done = 0;
+        timer_create(which, NULL, &id);
+        if (err < 0) {
+                perror("Can't create timer\n");
+                return -1;
+        }
+        signal(SIGALRM, sig_handler);
+
+        err = gettimeofday(&start, NULL);
+        if (err < 0) {
+                perror("Can't call gettimeofday()\n");
+                return -1;
+        }
+
+        err = timer_settime(id, 0, &val, NULL);
+        if (err < 0) {
+                perror("Can't set timer\n");
+                return -1;
+        }
+
+        user_loop();
+
+        gettimeofday(&end, NULL);
+        if (err < 0) {
+                perror("Can't call gettimeofday()\n");
+                return -1;
+        }
+
+        if (!check_diff(start, end))
+                printf("[OK]\n");
+        else
+                printf("[FAIL]\n");
+
+        return 0;
+}
+
+int main(int argc, char **argv)
+{
+        int err;
+
+        printf("Testing posix timers. False negative may happen on CPU execution \n");
+        printf("based timers if other threads run on the CPU...\n");
+
+        if (check_itimer(ITIMER_VIRTUAL) < 0)
+                return -1;
+
+        if (check_itimer(ITIMER_PROF) < 0)
+                return -1;
+
+        if (check_itimer(ITIMER_REAL) < 0)
+                return -1;
+
+        if (check_timer_create(CLOCK_THREAD_CPUTIME_ID) < 0)
+                return -1;
+
+        /*
+         * It's unfortunately hard to reliably test a timer expiration
+         * on parallel multithread cputime. We could arm it to expire
+         * on DELAY * nr_threads, with nr_threads busy looping, then wait
+         * the normal DELAY since the time is elapsing nr_threads faster.
+         * But for that we need to ensure we have real physical free CPUs
+         * to ensure true parallelism. So test only one thread until we
+         * find a better solution.
+         */
+        if (check_timer_create(CLOCK_PROCESS_CPUTIME_ID) < 0)
+                return -1;
+
+        return 0;
+}
diff --git a/tools/testing/selftests/vm/.gitignore b/tools/testing/selftests/vm/.gitignore
new file mode 100644
index 000000000000..ff1bb16cec4f
--- /dev/null
+++ b/tools/testing/selftests/vm/.gitignore
@@ -0,0 +1,4 @@
+hugepage-mmap
+hugepage-shm
+map_hugetlb
+thuge-gen
diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/vm/Makefile
index 436d2e81868b..3f94e1afd6cf 100644
--- a/tools/testing/selftests/vm/Makefile
+++ b/tools/testing/selftests/vm/Makefile
@@ -2,13 +2,14 @@
 
 CC = $(CROSS_COMPILE)gcc
 CFLAGS = -Wall
+BINARIES = hugepage-mmap hugepage-shm map_hugetlb thuge-gen hugetlbfstest
 
-all: hugepage-mmap hugepage-shm  map_hugetlb thuge-gen
+all: $(BINARIES)
 %: %.c
         $(CC) $(CFLAGS) -o $@ $^
 
 run_tests: all
-        @/bin/sh ./run_vmtests || echo "vmtests: [FAIL]"
+        @/bin/sh ./run_vmtests || (echo "vmtests: [FAIL]"; exit 1)
 
 clean:
-        $(RM) hugepage-mmap hugepage-shm  map_hugetlb
+        $(RM) $(BINARIES)
diff --git a/tools/testing/selftests/vm/hugetlbfstest.c b/tools/testing/selftests/vm/hugetlbfstest.c
new file mode 100644
index 000000000000..ea40ff8c2391
--- /dev/null
+++ b/tools/testing/selftests/vm/hugetlbfstest.c
@@ -0,0 +1,84 @@
+#define _GNU_SOURCE
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+typedef unsigned long long u64;
+
+static size_t length = 1 << 24;
+
+static u64 read_rss(void)
+{
+        char buf[4096], *s = buf;
+        int i, fd;
+        u64 rss;
+
+        fd = open("/proc/self/statm", O_RDONLY);
+        assert(fd > 2);
+        memset(buf, 0, sizeof(buf));
+        read(fd, buf, sizeof(buf) - 1);
+        for (i = 0; i < 1; i++)
+                s = strchr(s, ' ') + 1;
+        rss = strtoull(s, NULL, 10);
+        return rss << 12; /* assumes 4k pagesize */
+}
+
+static void do_mmap(int fd, int extra_flags, int unmap)
+{
+        int *p;
+        int flags = MAP_PRIVATE | MAP_POPULATE | extra_flags;
+        u64 before, after;
+
+        before = read_rss();
+        p = mmap(NULL, length, PROT_READ | PROT_WRITE, flags, fd, 0);
+        assert(p != MAP_FAILED ||
+                        !"mmap returned an unexpected error");
+        after = read_rss();
+        assert(llabs(after - before - length) < 0x40000 ||
+                        !"rss didn't grow as expected");
+        if (!unmap)
+                return;
+        munmap(p, length);
+        after = read_rss();
+        assert(llabs(after - before) < 0x40000 ||
+                        !"rss didn't shrink as expected");
+}
+
+static int open_file(const char *path)
+{
+        int fd, err;
+
+        unlink(path);
+        fd = open(path, O_CREAT | O_RDWR | O_TRUNC | O_EXCL
+                        | O_LARGEFILE | O_CLOEXEC, 0600);
+        assert(fd > 2);
+        unlink(path);
+        err = ftruncate(fd, length);
+        assert(!err);
+        return fd;
+}
+
+int main(void)
+{
+        int hugefd, fd;
+
+        fd = open_file("/dev/shm/hugetlbhog");
+        hugefd = open_file("/hugepages/hugetlbhog");
+
+        system("echo 100 > /proc/sys/vm/nr_hugepages");
+        do_mmap(-1, MAP_ANONYMOUS, 1);
+        do_mmap(fd, 0, 1);
+        do_mmap(-1, MAP_ANONYMOUS | MAP_HUGETLB, 1);
+        do_mmap(hugefd, 0, 1);
+        do_mmap(hugefd, MAP_HUGETLB, 1);
+        /* Leak the last one to test do_exit() */
+        do_mmap(-1, MAP_ANONYMOUS | MAP_HUGETLB, 0);
+        printf("oll korrekt.\n");
+        return 0;
+}
diff --git a/tools/testing/selftests/vm/run_vmtests b/tools/testing/selftests/vm/run_vmtests
index 4c53cae6c273..c87b6812300d 100644
--- a/tools/testing/selftests/vm/run_vmtests
+++ b/tools/testing/selftests/vm/run_vmtests
@@ -4,6 +4,7 @@
 #we need 256M, below is the size in kB
 needmem=262144
 mnt=./huge
+exitcode=0
 
 #get pagesize and freepages from /proc/meminfo
 while read name size unit; do
@@ -41,6 +42,7 @@ echo "--------------------"
 ./hugepage-mmap
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
+        exitcode=1
 else
         echo "[PASS]"
 fi
@@ -55,6 +57,7 @@ echo "--------------------"
 ./hugepage-shm
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
+        exitcode=1
 else
         echo "[PASS]"
 fi
@@ -67,6 +70,18 @@ echo "--------------------"
 ./map_hugetlb
 if [ $? -ne 0 ]; then
         echo "[FAIL]"
+        exitcode=1
+else
+        echo "[PASS]"
+fi
+
+echo "--------------------"
+echo "running hugetlbfstest"
+echo "--------------------"
+./hugetlbfstest
+if [ $? -ne 0 ]; then
+        echo "[FAIL]"
+        exitcode=1
 else
         echo "[PASS]"
 fi
@@ -75,3 +90,4 @@ fi
 umount $mnt
 rm -rf $mnt
 echo $nr_hugepgs > /proc/sys/vm/nr_hugepages
+exit $exitcode
diff --git a/tools/virtio/.gitignore b/tools/virtio/.gitignore
new file mode 100644
index 000000000000..1cfbb0157a46
--- /dev/null
+++ b/tools/virtio/.gitignore
@@ -0,0 +1,3 @@
+*.d
+virtio_test
+vringh_test
diff --git a/tools/virtio/linux/module.h b/tools/virtio/linux/module.h
index 3039a7e972b6..28ce95a05997 100644
--- a/tools/virtio/linux/module.h
+++ b/tools/virtio/linux/module.h
@@ -1 +1,6 @@
 #include <linux/export.h>
+
+#define MODULE_LICENSE(__MODULE_LICENSE_value) \
+        static __attribute__((unused)) const char *__MODULE_LICENSE_name = \
+                __MODULE_LICENSE_value
+
diff --git a/tools/virtio/linux/virtio.h b/tools/virtio/linux/virtio.h
index cd801838156f..844783040703 100644
--- a/tools/virtio/linux/virtio.h
+++ b/tools/virtio/linux/virtio.h
@@ -45,9 +45,6 @@ struct virtqueue {
         void *priv;
 };
 
-#define MODULE_LICENSE(__MODULE_LICENSE_value) \
-        const char *__MODULE_LICENSE_name = __MODULE_LICENSE_value
-
 /* Interfaces exported by virtio_ring. */
 int virtqueue_add_sgs(struct virtqueue *vq,
                       struct scatterlist *sgs[],